@danielx/civet 0.5.65 → 0.5.67
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 +858 -618
- package/dist/civet +0 -0
- package/dist/main.js +858 -618
- package/dist/main.mjs +858 -618
- package/package.json +1 -1
package/dist/main.mjs
CHANGED
|
@@ -441,11 +441,12 @@ ${input.slice(result.pos)}
|
|
|
441
441
|
NonSuppressedTrailingMemberExpressions,
|
|
442
442
|
CommaDelimiter,
|
|
443
443
|
ArgumentList,
|
|
444
|
+
NonPipelineArgumentList,
|
|
444
445
|
NestedArgumentList,
|
|
445
446
|
NestedArgument,
|
|
446
|
-
InlineArgumentExpressions,
|
|
447
447
|
SingleLineArgumentExpressions,
|
|
448
448
|
ArgumentPart,
|
|
449
|
+
NonPipelineArgumentPart,
|
|
449
450
|
BinaryOpExpression,
|
|
450
451
|
BinaryOpRHS,
|
|
451
452
|
RHS,
|
|
@@ -623,6 +624,8 @@ ${input.slice(result.pos)}
|
|
|
623
624
|
CoffeeWordAssignmentOp,
|
|
624
625
|
BinaryOp,
|
|
625
626
|
BinaryOpSymbol,
|
|
627
|
+
Xor,
|
|
628
|
+
Xnor,
|
|
626
629
|
UnaryOp,
|
|
627
630
|
ModuleItem,
|
|
628
631
|
StatementListItem,
|
|
@@ -1019,225 +1022,231 @@ ${input.slice(result.pos)}
|
|
|
1019
1022
|
var $L12 = $L("super");
|
|
1020
1023
|
var $L13 = $L("import");
|
|
1021
1024
|
var $L14 = $L("!");
|
|
1022
|
-
var $L15 = $L("
|
|
1023
|
-
var $L16 = $L("
|
|
1024
|
-
var $L17 = $L("");
|
|
1025
|
-
var $L18 = $L("
|
|
1026
|
-
var $L19 = $L("
|
|
1027
|
-
var $L20 = $L("
|
|
1028
|
-
var $L21 = $L("
|
|
1029
|
-
var $L22 = $L("
|
|
1030
|
-
var $L23 = $L("
|
|
1031
|
-
var $L24 = $L("
|
|
1032
|
-
var $L25 = $L("
|
|
1033
|
-
var $L26 = $L("
|
|
1034
|
-
var $L27 = $L("
|
|
1035
|
-
var $L28 = $L("
|
|
1036
|
-
var $L29 = $L("
|
|
1037
|
-
var $L30 = $L("
|
|
1038
|
-
var $L31 = $L("
|
|
1039
|
-
var $L32 = $L("
|
|
1040
|
-
var $L33 = $L("
|
|
1041
|
-
var $L34 = $L("
|
|
1042
|
-
var $L35 = $L("
|
|
1043
|
-
var $L36 = $L("
|
|
1044
|
-
var $L37 = $L("
|
|
1045
|
-
var $L38 = $L("
|
|
1046
|
-
var $L39 = $L("
|
|
1047
|
-
var $L40 = $L("
|
|
1048
|
-
var $L41 = $L("
|
|
1049
|
-
var $L42 = $L("
|
|
1050
|
-
var $L43 = $L("
|
|
1051
|
-
var $L44 = $L("
|
|
1052
|
-
var $L45 = $L("
|
|
1053
|
-
var $L46 = $L("
|
|
1054
|
-
var $L47 = $L("
|
|
1055
|
-
var $L48 = $L("
|
|
1056
|
-
var $L49 = $L("
|
|
1057
|
-
var $L50 = $L("
|
|
1058
|
-
var $L51 = $L("
|
|
1059
|
-
var $L52 = $L("
|
|
1060
|
-
var $L53 = $L("
|
|
1061
|
-
var $L54 = $L("
|
|
1062
|
-
var $L55 = $L("
|
|
1063
|
-
var $L56 = $L("
|
|
1064
|
-
var $L57 = $L("
|
|
1065
|
-
var $L58 = $L("
|
|
1066
|
-
var $L59 = $L("
|
|
1067
|
-
var $L60 = $L("
|
|
1068
|
-
var $L61 = $L("
|
|
1069
|
-
var $L62 = $L("
|
|
1070
|
-
var $L63 = $L("
|
|
1071
|
-
var $L64 = $L("
|
|
1072
|
-
var $L65 = $L("
|
|
1073
|
-
var $L66 = $L("
|
|
1074
|
-
var $L67 = $L("
|
|
1075
|
-
var $L68 = $L("
|
|
1076
|
-
var $L69 = $L("
|
|
1077
|
-
var $L70 = $L("
|
|
1078
|
-
var $L71 = $L("
|
|
1079
|
-
var $L72 = $L("
|
|
1080
|
-
var $L73 = $L("
|
|
1081
|
-
var $L74 = $L("
|
|
1082
|
-
var $L75 = $L("
|
|
1083
|
-
var $L76 = $L("
|
|
1084
|
-
var $L77 = $L("
|
|
1085
|
-
var $L78 = $L("
|
|
1086
|
-
var $L79 = $L("
|
|
1087
|
-
var $L80 = $L("
|
|
1088
|
-
var $L81 = $L("
|
|
1089
|
-
var $L82 = $L("
|
|
1090
|
-
var $L83 = $L("
|
|
1091
|
-
var $L84 = $L("
|
|
1092
|
-
var $L85 = $L("
|
|
1093
|
-
var $L86 = $L("
|
|
1094
|
-
var $L87 = $L("
|
|
1095
|
-
var $L88 = $L("
|
|
1096
|
-
var $L89 = $L("
|
|
1097
|
-
var $L90 = $L("
|
|
1098
|
-
var $L91 = $L("
|
|
1099
|
-
var $L92 = $L("
|
|
1100
|
-
var $L93 = $L("
|
|
1101
|
-
var $L94 = $L("
|
|
1102
|
-
var $L95 = $L("
|
|
1103
|
-
var $L96 = $L("
|
|
1104
|
-
var $L97 = $L("
|
|
1105
|
-
var $L98 = $L("
|
|
1106
|
-
var $L99 = $L("
|
|
1107
|
-
var $L100 = $L("
|
|
1108
|
-
var $L101 = $L("
|
|
1109
|
-
var $L102 = $L("
|
|
1110
|
-
var $L103 = $L("
|
|
1111
|
-
var $L104 = $L("
|
|
1112
|
-
var $L105 = $L("
|
|
1113
|
-
var $L106 = $L("
|
|
1114
|
-
var $L107 = $L("
|
|
1115
|
-
var $L108 = $L("
|
|
1116
|
-
var $L109 = $L("
|
|
1117
|
-
var $L110 = $L("
|
|
1118
|
-
var $L111 = $L("
|
|
1119
|
-
var $L112 = $L(
|
|
1120
|
-
var $L113 = $L("
|
|
1121
|
-
var $L114 = $L("
|
|
1122
|
-
var $L115 = $L("
|
|
1123
|
-
var $L116 = $L("
|
|
1124
|
-
var $L117 = $L("
|
|
1125
|
-
var $L118 = $L("
|
|
1126
|
-
var $L119 = $L("
|
|
1127
|
-
var $L120 = $L("
|
|
1128
|
-
var $L121 = $L("
|
|
1129
|
-
var $L122 = $L("
|
|
1130
|
-
var $L123 = $L("
|
|
1131
|
-
var $L124 = $L("
|
|
1132
|
-
var $L125 = $L("
|
|
1133
|
-
var $L126 = $L("
|
|
1134
|
-
var $L127 = $L("
|
|
1135
|
-
var $L128 = $L("
|
|
1136
|
-
var $L129 = $L("
|
|
1137
|
-
var $L130 = $L("
|
|
1138
|
-
var $L131 = $L("
|
|
1139
|
-
var $L132 = $L("
|
|
1140
|
-
var $L133 = $L("
|
|
1141
|
-
var $L134 = $L("
|
|
1142
|
-
var $L135 = $L("
|
|
1143
|
-
var $L136 = $L("
|
|
1144
|
-
var $L137 = $L("
|
|
1145
|
-
var $L138 = $L("
|
|
1146
|
-
var $L139 = $L("
|
|
1147
|
-
var $L140 = $L("
|
|
1148
|
-
var $L141 = $L("
|
|
1149
|
-
var $L142 = $L("
|
|
1150
|
-
var $L143 = $L("
|
|
1151
|
-
var $L144 = $L("
|
|
1152
|
-
var $L145 = $L(
|
|
1153
|
-
var $L146 = $L("
|
|
1154
|
-
var $L147 = $L("
|
|
1155
|
-
var $L148 = $L("
|
|
1156
|
-
var $L149 = $L("
|
|
1157
|
-
var $L150 = $L("
|
|
1158
|
-
var $L151 = $L("
|
|
1159
|
-
var $L152 = $L("
|
|
1160
|
-
var $L153 = $L("
|
|
1161
|
-
var $L154 = $L("
|
|
1162
|
-
var $L155 = $L("
|
|
1163
|
-
var $L156 = $L("
|
|
1164
|
-
var $L157 = $L("
|
|
1165
|
-
var $L158 = $L("
|
|
1166
|
-
var $L159 = $L("
|
|
1167
|
-
var $L160 = $L("
|
|
1168
|
-
var $L161 = $L("
|
|
1169
|
-
var $L162 = $L("
|
|
1170
|
-
var $L163 = $L("
|
|
1171
|
-
var $L164 = $L("
|
|
1172
|
-
var $L165 = $L("
|
|
1173
|
-
var $L166 = $L("
|
|
1174
|
-
var $L167 = $L("
|
|
1175
|
-
var $L168 = $L("
|
|
1176
|
-
var $L169 = $L("
|
|
1177
|
-
var $L170 = $L("
|
|
1178
|
-
var $L171 = $L("
|
|
1179
|
-
var $
|
|
1025
|
+
var $L15 = $L("^");
|
|
1026
|
+
var $L16 = $L("-");
|
|
1027
|
+
var $L17 = $L("import.meta");
|
|
1028
|
+
var $L18 = $L("");
|
|
1029
|
+
var $L19 = $L(")");
|
|
1030
|
+
var $L20 = $L(",");
|
|
1031
|
+
var $L21 = $L("->");
|
|
1032
|
+
var $L22 = $L("}");
|
|
1033
|
+
var $L23 = $L("null");
|
|
1034
|
+
var $L24 = $L("true");
|
|
1035
|
+
var $L25 = $L("false");
|
|
1036
|
+
var $L26 = $L("yes");
|
|
1037
|
+
var $L27 = $L("on");
|
|
1038
|
+
var $L28 = $L("no");
|
|
1039
|
+
var $L29 = $L("off");
|
|
1040
|
+
var $L30 = $L(">");
|
|
1041
|
+
var $L31 = $L("]");
|
|
1042
|
+
var $L32 = $L(":");
|
|
1043
|
+
var $L33 = $L("**=");
|
|
1044
|
+
var $L34 = $L("*=");
|
|
1045
|
+
var $L35 = $L("/=");
|
|
1046
|
+
var $L36 = $L("%=");
|
|
1047
|
+
var $L37 = $L("+=");
|
|
1048
|
+
var $L38 = $L("-=");
|
|
1049
|
+
var $L39 = $L("<<=");
|
|
1050
|
+
var $L40 = $L(">>>=");
|
|
1051
|
+
var $L41 = $L(">>=");
|
|
1052
|
+
var $L42 = $L("&&=");
|
|
1053
|
+
var $L43 = $L("&=");
|
|
1054
|
+
var $L44 = $L("^=");
|
|
1055
|
+
var $L45 = $L("||=");
|
|
1056
|
+
var $L46 = $L("|=");
|
|
1057
|
+
var $L47 = $L("??=");
|
|
1058
|
+
var $L48 = $L("?=");
|
|
1059
|
+
var $L49 = $L("and=");
|
|
1060
|
+
var $L50 = $L("or=");
|
|
1061
|
+
var $L51 = $L("not");
|
|
1062
|
+
var $L52 = $L("**");
|
|
1063
|
+
var $L53 = $L("*");
|
|
1064
|
+
var $L54 = $L("/");
|
|
1065
|
+
var $L55 = $L("%%");
|
|
1066
|
+
var $L56 = $L("%");
|
|
1067
|
+
var $L57 = $L("+");
|
|
1068
|
+
var $L58 = $L("<=");
|
|
1069
|
+
var $L59 = $L(">=");
|
|
1070
|
+
var $L60 = $L("<?");
|
|
1071
|
+
var $L61 = $L("!<?");
|
|
1072
|
+
var $L62 = $L("<<");
|
|
1073
|
+
var $L63 = $L(">>>");
|
|
1074
|
+
var $L64 = $L(">>");
|
|
1075
|
+
var $L65 = $L("!==");
|
|
1076
|
+
var $L66 = $L("!=");
|
|
1077
|
+
var $L67 = $L("isnt");
|
|
1078
|
+
var $L68 = $L("===");
|
|
1079
|
+
var $L69 = $L("==");
|
|
1080
|
+
var $L70 = $L("and");
|
|
1081
|
+
var $L71 = $L("&&");
|
|
1082
|
+
var $L72 = $L("of");
|
|
1083
|
+
var $L73 = $L("or");
|
|
1084
|
+
var $L74 = $L("||");
|
|
1085
|
+
var $L75 = $L("^^");
|
|
1086
|
+
var $L76 = $L("xor");
|
|
1087
|
+
var $L77 = $L("xnor");
|
|
1088
|
+
var $L78 = $L("??");
|
|
1089
|
+
var $L79 = $L("instanceof");
|
|
1090
|
+
var $L80 = $L("in");
|
|
1091
|
+
var $L81 = $L("is");
|
|
1092
|
+
var $L82 = $L("&");
|
|
1093
|
+
var $L83 = $L("|");
|
|
1094
|
+
var $L84 = $L(";");
|
|
1095
|
+
var $L85 = $L("own");
|
|
1096
|
+
var $L86 = $L("break");
|
|
1097
|
+
var $L87 = $L("continue");
|
|
1098
|
+
var $L88 = $L("debugger");
|
|
1099
|
+
var $L89 = $L("assert");
|
|
1100
|
+
var $L90 = $L(":=");
|
|
1101
|
+
var $L91 = $L(".=");
|
|
1102
|
+
var $L92 = $L("/*");
|
|
1103
|
+
var $L93 = $L("*/");
|
|
1104
|
+
var $L94 = $L("\\");
|
|
1105
|
+
var $L95 = $L("[");
|
|
1106
|
+
var $L96 = $L("`");
|
|
1107
|
+
var $L97 = $L("abstract");
|
|
1108
|
+
var $L98 = $L("as");
|
|
1109
|
+
var $L99 = $L("@");
|
|
1110
|
+
var $L100 = $L("@@");
|
|
1111
|
+
var $L101 = $L("async");
|
|
1112
|
+
var $L102 = $L("await");
|
|
1113
|
+
var $L103 = $L("by");
|
|
1114
|
+
var $L104 = $L("case");
|
|
1115
|
+
var $L105 = $L("catch");
|
|
1116
|
+
var $L106 = $L("class");
|
|
1117
|
+
var $L107 = $L("#{");
|
|
1118
|
+
var $L108 = $L("declare");
|
|
1119
|
+
var $L109 = $L("default");
|
|
1120
|
+
var $L110 = $L("delete");
|
|
1121
|
+
var $L111 = $L("do");
|
|
1122
|
+
var $L112 = $L("..");
|
|
1123
|
+
var $L113 = $L("...");
|
|
1124
|
+
var $L114 = $L("::");
|
|
1125
|
+
var $L115 = $L('"');
|
|
1126
|
+
var $L116 = $L("else");
|
|
1127
|
+
var $L117 = $L("export");
|
|
1128
|
+
var $L118 = $L("extends");
|
|
1129
|
+
var $L119 = $L("finally");
|
|
1130
|
+
var $L120 = $L("for");
|
|
1131
|
+
var $L121 = $L("from");
|
|
1132
|
+
var $L122 = $L("function");
|
|
1133
|
+
var $L123 = $L("get");
|
|
1134
|
+
var $L124 = $L("set");
|
|
1135
|
+
var $L125 = $L("if");
|
|
1136
|
+
var $L126 = $L("let");
|
|
1137
|
+
var $L127 = $L("const");
|
|
1138
|
+
var $L128 = $L("loop");
|
|
1139
|
+
var $L129 = $L("new");
|
|
1140
|
+
var $L130 = $L("<");
|
|
1141
|
+
var $L131 = $L("{");
|
|
1142
|
+
var $L132 = $L("operator");
|
|
1143
|
+
var $L133 = $L("public");
|
|
1144
|
+
var $L134 = $L("private");
|
|
1145
|
+
var $L135 = $L("protected");
|
|
1146
|
+
var $L136 = $L("||>");
|
|
1147
|
+
var $L137 = $L("|>=");
|
|
1148
|
+
var $L138 = $L("|>");
|
|
1149
|
+
var $L139 = $L("readonly");
|
|
1150
|
+
var $L140 = $L("return");
|
|
1151
|
+
var $L141 = $L("satisfies");
|
|
1152
|
+
var $L142 = $L("'");
|
|
1153
|
+
var $L143 = $L("static");
|
|
1154
|
+
var $L144 = $L("${");
|
|
1155
|
+
var $L145 = $L("switch");
|
|
1156
|
+
var $L146 = $L("target");
|
|
1157
|
+
var $L147 = $L("then");
|
|
1158
|
+
var $L148 = $L("this");
|
|
1159
|
+
var $L149 = $L("throw");
|
|
1160
|
+
var $L150 = $L('"""');
|
|
1161
|
+
var $L151 = $L("'''");
|
|
1162
|
+
var $L152 = $L("///");
|
|
1163
|
+
var $L153 = $L("```");
|
|
1164
|
+
var $L154 = $L("try");
|
|
1165
|
+
var $L155 = $L("typeof");
|
|
1166
|
+
var $L156 = $L("unless");
|
|
1167
|
+
var $L157 = $L("until");
|
|
1168
|
+
var $L158 = $L("var");
|
|
1169
|
+
var $L159 = $L("void");
|
|
1170
|
+
var $L160 = $L("when");
|
|
1171
|
+
var $L161 = $L("while");
|
|
1172
|
+
var $L162 = $L("yield");
|
|
1173
|
+
var $L163 = $L("/>");
|
|
1174
|
+
var $L164 = $L("</");
|
|
1175
|
+
var $L165 = $L("<>");
|
|
1176
|
+
var $L166 = $L("</>");
|
|
1177
|
+
var $L167 = $L("<!--");
|
|
1178
|
+
var $L168 = $L("-->");
|
|
1179
|
+
var $L169 = $L("type");
|
|
1180
|
+
var $L170 = $L("interface");
|
|
1181
|
+
var $L171 = $L("namespace");
|
|
1182
|
+
var $L172 = $L("asserts");
|
|
1183
|
+
var $L173 = $L("keyof");
|
|
1184
|
+
var $L174 = $L("infer");
|
|
1185
|
+
var $L175 = $L("[]");
|
|
1186
|
+
var $L176 = $L("civet");
|
|
1187
|
+
var $R0 = $R(new RegExp("(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1180
1188
|
var $R1 = $R(new RegExp("[0-9]", "suy"));
|
|
1181
1189
|
var $R2 = $R(new RegExp("[&]", "suy"));
|
|
1182
1190
|
var $R3 = $R(new RegExp("[!~+-]+", "suy"));
|
|
1183
1191
|
var $R4 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
1184
1192
|
var $R5 = $R(new RegExp("[!+-]", "suy"));
|
|
1185
1193
|
var $R6 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
|
|
1186
|
-
var $R7 = $R(new RegExp("
|
|
1187
|
-
var $R8 = $R(new RegExp("(
|
|
1188
|
-
var $R9 = $R(new RegExp(
|
|
1189
|
-
var $R10 = $R(new RegExp("
|
|
1190
|
-
var $R11 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)
|
|
1191
|
-
var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(
|
|
1192
|
-
var $R13 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1193
|
-
var $R14 = $R(new RegExp("(
|
|
1194
|
-
var $R15 = $R(new RegExp("
|
|
1195
|
-
var $R16 = $R(new RegExp("0[
|
|
1196
|
-
var $R17 = $R(new RegExp("0[
|
|
1197
|
-
var $R18 = $R(new RegExp("
|
|
1198
|
-
var $R19 = $R(new RegExp(
|
|
1199
|
-
var $R20 = $R(new RegExp(
|
|
1200
|
-
var $R21 = $R(new RegExp(
|
|
1201
|
-
var $R22 = $R(new RegExp(
|
|
1202
|
-
var $R23 = $R(new RegExp('(
|
|
1203
|
-
var $R24 = $R(new RegExp(
|
|
1204
|
-
var $R25 = $R(new RegExp("(
|
|
1205
|
-
var $R26 = $R(new RegExp("
|
|
1206
|
-
var $R27 = $R(new RegExp("
|
|
1207
|
-
var $R28 = $R(new RegExp("
|
|
1208
|
-
var $R29 = $R(new RegExp("[
|
|
1209
|
-
var $R30 = $R(new RegExp("
|
|
1210
|
-
var $R31 = $R(new RegExp("(
|
|
1211
|
-
var $R32 = $R(new RegExp("(
|
|
1212
|
-
var $R33 = $R(new RegExp("(?:\\$(?!\\{)
|
|
1213
|
-
var $R34 = $R(new RegExp("(
|
|
1214
|
-
var $R35 = $R(new RegExp("(?:
|
|
1215
|
-
var $R36 = $R(new RegExp("(?:
|
|
1216
|
-
var $R37 = $R(new RegExp("(?:
|
|
1217
|
-
var $R38 = $R(new RegExp("(?:
|
|
1218
|
-
var $R39 = $R(new RegExp("
|
|
1219
|
-
var $R40 = $R(new RegExp("
|
|
1220
|
-
var $R41 = $R(new RegExp("
|
|
1221
|
-
var $R42 = $R(new RegExp("[
|
|
1222
|
-
var $R43 = $R(new RegExp("
|
|
1223
|
-
var $R44 = $R(new RegExp("
|
|
1224
|
-
var $R45 = $R(new RegExp("[
|
|
1225
|
-
var $R46 = $R(new RegExp("
|
|
1226
|
-
var $R47 = $R(new RegExp("
|
|
1227
|
-
var $R48 = $R(new RegExp("
|
|
1228
|
-
var $R49 = $R(new RegExp("[\\
|
|
1229
|
-
var $R50 = $R(new RegExp("
|
|
1230
|
-
var $R51 = $R(new RegExp("[
|
|
1231
|
-
var $R52 = $R(new RegExp("
|
|
1232
|
-
var $R53 = $R(new RegExp("[
|
|
1233
|
-
var $R54 = $R(new RegExp("[
|
|
1234
|
-
var $R55 = $R(new RegExp("[+-]", "suy"));
|
|
1235
|
-
var $R56 = $R(new RegExp("
|
|
1236
|
-
var $R57 = $R(new RegExp("[\\
|
|
1237
|
-
var $R58 = $R(new RegExp("[\\
|
|
1238
|
-
var $R59 = $R(new RegExp("
|
|
1239
|
-
var $R60 = $R(new RegExp("\\
|
|
1240
|
-
var $R61 = $R(new RegExp("
|
|
1194
|
+
var $R7 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
1195
|
+
var $R8 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
1196
|
+
var $R9 = $R(new RegExp("(?=[\\s\\)])", "suy"));
|
|
1197
|
+
var $R10 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
1198
|
+
var $R11 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
1199
|
+
var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
1200
|
+
var $R13 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
1201
|
+
var $R14 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1202
|
+
var $R15 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
1203
|
+
var $R16 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
1204
|
+
var $R17 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
1205
|
+
var $R18 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
1206
|
+
var $R19 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1207
|
+
var $R20 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
1208
|
+
var $R21 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
1209
|
+
var $R22 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
1210
|
+
var $R23 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
1211
|
+
var $R24 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
1212
|
+
var $R25 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
1213
|
+
var $R26 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
1214
|
+
var $R27 = $R(new RegExp("[\\s]+", "suy"));
|
|
1215
|
+
var $R28 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
1216
|
+
var $R29 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
1217
|
+
var $R30 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
1218
|
+
var $R31 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
1219
|
+
var $R32 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
1220
|
+
var $R33 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
1221
|
+
var $R34 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
1222
|
+
var $R35 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
1223
|
+
var $R36 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
1224
|
+
var $R37 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
1225
|
+
var $R38 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
1226
|
+
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"));
|
|
1227
|
+
var $R40 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
1228
|
+
var $R41 = $R(new RegExp(".", "suy"));
|
|
1229
|
+
var $R42 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
1230
|
+
var $R43 = $R(new RegExp("[^]*?###", "suy"));
|
|
1231
|
+
var $R44 = $R(new RegExp("###(?!#)", "suy"));
|
|
1232
|
+
var $R45 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
1233
|
+
var $R46 = $R(new RegExp("[ \\t]+", "suy"));
|
|
1234
|
+
var $R47 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
1235
|
+
var $R48 = $R(new RegExp("\\s", "suy"));
|
|
1236
|
+
var $R49 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
1237
|
+
var $R50 = $R(new RegExp("[\\s>]", "suy"));
|
|
1238
|
+
var $R51 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
1239
|
+
var $R52 = $R(new RegExp("[<>]", "suy"));
|
|
1240
|
+
var $R53 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
1241
|
+
var $R54 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
1242
|
+
var $R55 = $R(new RegExp("[+-]?", "suy"));
|
|
1243
|
+
var $R56 = $R(new RegExp("[+-]", "suy"));
|
|
1244
|
+
var $R57 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
1245
|
+
var $R58 = $R(new RegExp("[\\t ]*", "suy"));
|
|
1246
|
+
var $R59 = $R(new RegExp("[\\s]*", "suy"));
|
|
1247
|
+
var $R60 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
1248
|
+
var $R61 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
1249
|
+
var $R62 = $R(new RegExp("[ \\t]*", "suy"));
|
|
1241
1250
|
var Program$0 = $TS($S(Reset, Init, __, $Q(TopLevelStatement), __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1242
1251
|
var statements = $4;
|
|
1243
1252
|
module.processProgram(statements);
|
|
@@ -1480,7 +1489,7 @@ ${input.slice(result.pos)}
|
|
|
1480
1489
|
return result;
|
|
1481
1490
|
}
|
|
1482
1491
|
}
|
|
1483
|
-
var ImplicitArguments$0 = $TS($S($E($S(TypeArguments, $N(ImplementsToken))), ApplicationStart, InsertOpenParen, $Q(_),
|
|
1492
|
+
var ImplicitArguments$0 = $TS($S($E($S(TypeArguments, $N(ImplementsToken))), ApplicationStart, InsertOpenParen, $Q(_), NonPipelineArgumentList, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
1484
1493
|
var ta = $1;
|
|
1485
1494
|
var open = $3;
|
|
1486
1495
|
var ws = $4;
|
|
@@ -1557,7 +1566,7 @@ ${input.slice(result.pos)}
|
|
|
1557
1566
|
return result;
|
|
1558
1567
|
}
|
|
1559
1568
|
}
|
|
1560
|
-
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|for|while|until|of|satisfies|then|when|implements)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
1569
|
+
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
1561
1570
|
var ForbiddenImplicitCalls$1 = $EXPECT($L0, fail, 'ForbiddenImplicitCalls "/ "');
|
|
1562
1571
|
var ForbiddenImplicitCalls$2 = AtAt;
|
|
1563
1572
|
var ForbiddenImplicitCalls$3 = $S(Identifier, $EXPECT($L1, fail, 'ForbiddenImplicitCalls "="'), Whitespace);
|
|
@@ -1698,7 +1707,9 @@ ${input.slice(result.pos)}
|
|
|
1698
1707
|
return module.insertTrimmingSpace($1, "");
|
|
1699
1708
|
});
|
|
1700
1709
|
var ArgumentList$2 = NestedArgumentList;
|
|
1701
|
-
var ArgumentList$3 =
|
|
1710
|
+
var ArgumentList$3 = $TS($S($Q(TrailingComment), ArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
|
|
1711
|
+
return [...$1, $2, ...$3];
|
|
1712
|
+
});
|
|
1702
1713
|
function ArgumentList(state) {
|
|
1703
1714
|
let eventData;
|
|
1704
1715
|
if (state.events) {
|
|
@@ -1721,6 +1732,36 @@ ${input.slice(result.pos)}
|
|
|
1721
1732
|
return result;
|
|
1722
1733
|
}
|
|
1723
1734
|
}
|
|
1735
|
+
var NonPipelineArgumentList$0 = $S(NonPipelineArgumentPart, $P($S(CommaDelimiter, $C(NestedImplicitObjectLiteral, NestedArgumentList))));
|
|
1736
|
+
var NonPipelineArgumentList$1 = $TS($S(NestedImplicitObjectLiteral), function($skip, $loc, $0, $1) {
|
|
1737
|
+
return module.insertTrimmingSpace($1, "");
|
|
1738
|
+
});
|
|
1739
|
+
var NonPipelineArgumentList$2 = NestedArgumentList;
|
|
1740
|
+
var NonPipelineArgumentList$3 = $TS($S($Q(TrailingComment), NonPipelineArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), NonPipelineArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
|
|
1741
|
+
return [...$1, $2, ...$3];
|
|
1742
|
+
});
|
|
1743
|
+
function NonPipelineArgumentList(state) {
|
|
1744
|
+
let eventData;
|
|
1745
|
+
if (state.events) {
|
|
1746
|
+
const result = state.events.enter?.("NonPipelineArgumentList", state);
|
|
1747
|
+
if (result) {
|
|
1748
|
+
if (result.cache)
|
|
1749
|
+
return result.cache;
|
|
1750
|
+
eventData = result.data;
|
|
1751
|
+
}
|
|
1752
|
+
}
|
|
1753
|
+
if (state.tokenize) {
|
|
1754
|
+
const result = $TOKEN("NonPipelineArgumentList", state, NonPipelineArgumentList$0(state) || NonPipelineArgumentList$1(state) || NonPipelineArgumentList$2(state) || NonPipelineArgumentList$3(state));
|
|
1755
|
+
if (state.events)
|
|
1756
|
+
state.events.exit?.("NonPipelineArgumentList", state, result, eventData);
|
|
1757
|
+
return result;
|
|
1758
|
+
} else {
|
|
1759
|
+
const result = NonPipelineArgumentList$0(state) || NonPipelineArgumentList$1(state) || NonPipelineArgumentList$2(state) || NonPipelineArgumentList$3(state);
|
|
1760
|
+
if (state.events)
|
|
1761
|
+
state.events.exit?.("NonPipelineArgumentList", state, result, eventData);
|
|
1762
|
+
return result;
|
|
1763
|
+
}
|
|
1764
|
+
}
|
|
1724
1765
|
var NestedArgumentList$0 = $TS($S(PushIndent, $Q(NestedArgument), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
1725
1766
|
var args = $2;
|
|
1726
1767
|
if (args.length)
|
|
@@ -1772,13 +1813,11 @@ ${input.slice(result.pos)}
|
|
|
1772
1813
|
return result;
|
|
1773
1814
|
}
|
|
1774
1815
|
}
|
|
1775
|
-
var
|
|
1776
|
-
|
|
1777
|
-
});
|
|
1778
|
-
function InlineArgumentExpressions(state) {
|
|
1816
|
+
var SingleLineArgumentExpressions$0 = $S($Q(TrailingComment), ArgumentPart, $Q($S($Q(TrailingComment), Comma, $Q(TrailingComment), ArgumentPart)));
|
|
1817
|
+
function SingleLineArgumentExpressions(state) {
|
|
1779
1818
|
let eventData;
|
|
1780
1819
|
if (state.events) {
|
|
1781
|
-
const result = state.events.enter?.("
|
|
1820
|
+
const result = state.events.enter?.("SingleLineArgumentExpressions", state);
|
|
1782
1821
|
if (result) {
|
|
1783
1822
|
if (result.cache)
|
|
1784
1823
|
return result.cache;
|
|
@@ -1786,22 +1825,28 @@ ${input.slice(result.pos)}
|
|
|
1786
1825
|
}
|
|
1787
1826
|
}
|
|
1788
1827
|
if (state.tokenize) {
|
|
1789
|
-
const result = $TOKEN("
|
|
1828
|
+
const result = $TOKEN("SingleLineArgumentExpressions", state, SingleLineArgumentExpressions$0(state));
|
|
1790
1829
|
if (state.events)
|
|
1791
|
-
state.events.exit?.("
|
|
1830
|
+
state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
|
|
1792
1831
|
return result;
|
|
1793
1832
|
} else {
|
|
1794
|
-
const result =
|
|
1833
|
+
const result = SingleLineArgumentExpressions$0(state);
|
|
1795
1834
|
if (state.events)
|
|
1796
|
-
state.events.exit?.("
|
|
1835
|
+
state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
|
|
1797
1836
|
return result;
|
|
1798
1837
|
}
|
|
1799
1838
|
}
|
|
1800
|
-
var
|
|
1801
|
-
|
|
1839
|
+
var ArgumentPart$0 = $S(DotDotDot, ExtendedExpression);
|
|
1840
|
+
var ArgumentPart$1 = $TS($S(ExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
|
|
1841
|
+
if ($2) {
|
|
1842
|
+
return [$2, $1];
|
|
1843
|
+
}
|
|
1844
|
+
return $1;
|
|
1845
|
+
});
|
|
1846
|
+
function ArgumentPart(state) {
|
|
1802
1847
|
let eventData;
|
|
1803
1848
|
if (state.events) {
|
|
1804
|
-
const result = state.events.enter?.("
|
|
1849
|
+
const result = state.events.enter?.("ArgumentPart", state);
|
|
1805
1850
|
if (result) {
|
|
1806
1851
|
if (result.cache)
|
|
1807
1852
|
return result.cache;
|
|
@@ -1809,28 +1854,28 @@ ${input.slice(result.pos)}
|
|
|
1809
1854
|
}
|
|
1810
1855
|
}
|
|
1811
1856
|
if (state.tokenize) {
|
|
1812
|
-
const result = $TOKEN("
|
|
1857
|
+
const result = $TOKEN("ArgumentPart", state, ArgumentPart$0(state) || ArgumentPart$1(state));
|
|
1813
1858
|
if (state.events)
|
|
1814
|
-
state.events.exit?.("
|
|
1859
|
+
state.events.exit?.("ArgumentPart", state, result, eventData);
|
|
1815
1860
|
return result;
|
|
1816
1861
|
} else {
|
|
1817
|
-
const result =
|
|
1862
|
+
const result = ArgumentPart$0(state) || ArgumentPart$1(state);
|
|
1818
1863
|
if (state.events)
|
|
1819
|
-
state.events.exit?.("
|
|
1864
|
+
state.events.exit?.("ArgumentPart", state, result, eventData);
|
|
1820
1865
|
return result;
|
|
1821
1866
|
}
|
|
1822
1867
|
}
|
|
1823
|
-
var
|
|
1824
|
-
var
|
|
1868
|
+
var NonPipelineArgumentPart$0 = $S(DotDotDot, NonPipelineExtendedExpression);
|
|
1869
|
+
var NonPipelineArgumentPart$1 = $TS($S(NonPipelineExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
|
|
1825
1870
|
if ($2) {
|
|
1826
1871
|
return [$2, $1];
|
|
1827
1872
|
}
|
|
1828
1873
|
return $1;
|
|
1829
1874
|
});
|
|
1830
|
-
function
|
|
1875
|
+
function NonPipelineArgumentPart(state) {
|
|
1831
1876
|
let eventData;
|
|
1832
1877
|
if (state.events) {
|
|
1833
|
-
const result = state.events.enter?.("
|
|
1878
|
+
const result = state.events.enter?.("NonPipelineArgumentPart", state);
|
|
1834
1879
|
if (result) {
|
|
1835
1880
|
if (result.cache)
|
|
1836
1881
|
return result.cache;
|
|
@@ -1838,14 +1883,14 @@ ${input.slice(result.pos)}
|
|
|
1838
1883
|
}
|
|
1839
1884
|
}
|
|
1840
1885
|
if (state.tokenize) {
|
|
1841
|
-
const result = $TOKEN("
|
|
1886
|
+
const result = $TOKEN("NonPipelineArgumentPart", state, NonPipelineArgumentPart$0(state) || NonPipelineArgumentPart$1(state));
|
|
1842
1887
|
if (state.events)
|
|
1843
|
-
state.events.exit?.("
|
|
1888
|
+
state.events.exit?.("NonPipelineArgumentPart", state, result, eventData);
|
|
1844
1889
|
return result;
|
|
1845
1890
|
} else {
|
|
1846
|
-
const result =
|
|
1891
|
+
const result = NonPipelineArgumentPart$0(state) || NonPipelineArgumentPart$1(state);
|
|
1847
1892
|
if (state.events)
|
|
1848
|
-
state.events.exit?.("
|
|
1893
|
+
state.events.exit?.("NonPipelineArgumentPart", state, result, eventData);
|
|
1849
1894
|
return result;
|
|
1850
1895
|
}
|
|
1851
1896
|
}
|
|
@@ -2094,7 +2139,6 @@ ${input.slice(result.pos)}
|
|
|
2094
2139
|
}
|
|
2095
2140
|
}
|
|
2096
2141
|
var NonPipelineAssignmentExpression$0 = SingleLineAssignmentExpression;
|
|
2097
|
-
var NonPipelineAssignmentExpression$1 = $S(__, AssignmentExpressionTail);
|
|
2098
2142
|
function NonPipelineAssignmentExpression(state) {
|
|
2099
2143
|
let eventData;
|
|
2100
2144
|
if (state.events) {
|
|
@@ -2106,12 +2150,12 @@ ${input.slice(result.pos)}
|
|
|
2106
2150
|
}
|
|
2107
2151
|
}
|
|
2108
2152
|
if (state.tokenize) {
|
|
2109
|
-
const result = $TOKEN("NonPipelineAssignmentExpression", state, NonPipelineAssignmentExpression$0(state)
|
|
2153
|
+
const result = $TOKEN("NonPipelineAssignmentExpression", state, NonPipelineAssignmentExpression$0(state));
|
|
2110
2154
|
if (state.events)
|
|
2111
2155
|
state.events.exit?.("NonPipelineAssignmentExpression", state, result, eventData);
|
|
2112
2156
|
return result;
|
|
2113
2157
|
} else {
|
|
2114
|
-
const result = NonPipelineAssignmentExpression$0(state)
|
|
2158
|
+
const result = NonPipelineAssignmentExpression$0(state);
|
|
2115
2159
|
if (state.events)
|
|
2116
2160
|
state.events.exit?.("NonPipelineAssignmentExpression", state, result, eventData);
|
|
2117
2161
|
return result;
|
|
@@ -2483,30 +2527,12 @@ ${input.slice(result.pos)}
|
|
|
2483
2527
|
return result;
|
|
2484
2528
|
}
|
|
2485
2529
|
}
|
|
2486
|
-
var PipelineExpression$0 = $TS($S(
|
|
2530
|
+
var PipelineExpression$0 = $TS($S(PipelineHeadItem, $P($S(__, Pipe, __, PipelineTailItem))), function($skip, $loc, $0, $1, $2) {
|
|
2487
2531
|
var head = $1;
|
|
2488
2532
|
var body = $2;
|
|
2489
|
-
var preTailWS = $3;
|
|
2490
|
-
var tail = $4;
|
|
2491
|
-
let children = head.slice(0, -1).map(module.skipIfOnlyWS);
|
|
2492
|
-
for (const [leadingComment, expr, trailingComment] of body) {
|
|
2493
|
-
children = module.constructPipeStep(
|
|
2494
|
-
{
|
|
2495
|
-
leadingComment: module.skipIfOnlyWS(leadingComment),
|
|
2496
|
-
trailingComment: module.skipIfOnlyWS(trailingComment),
|
|
2497
|
-
expr
|
|
2498
|
-
},
|
|
2499
|
-
{ expr: children }
|
|
2500
|
-
);
|
|
2501
|
-
}
|
|
2502
2533
|
return {
|
|
2503
|
-
|
|
2504
|
-
|
|
2505
|
-
leadingComment: module.skipIfOnlyWS(preTailWS),
|
|
2506
|
-
expr: tail
|
|
2507
|
-
},
|
|
2508
|
-
{ expr: children }
|
|
2509
|
-
)
|
|
2534
|
+
type: "PipelineExpression",
|
|
2535
|
+
children: [head, body]
|
|
2510
2536
|
};
|
|
2511
2537
|
});
|
|
2512
2538
|
function PipelineExpression(state) {
|
|
@@ -3365,8 +3391,8 @@ ${input.slice(result.pos)}
|
|
|
3365
3391
|
return result;
|
|
3366
3392
|
}
|
|
3367
3393
|
}
|
|
3368
|
-
var NonNullAssertion$0 = $T($EXPECT($L14, fail, 'NonNullAssertion "!"'), function(value) {
|
|
3369
|
-
return { "type": "NonNullAssertion", "ts": true, "children": value };
|
|
3394
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L14, fail, 'NonNullAssertion "!"'), $N($EXPECT($L15, fail, 'NonNullAssertion "^"'))), function(value) {
|
|
3395
|
+
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
3370
3396
|
});
|
|
3371
3397
|
function NonNullAssertion(state) {
|
|
3372
3398
|
let eventData;
|
|
@@ -3503,7 +3529,7 @@ ${input.slice(result.pos)}
|
|
|
3503
3529
|
]
|
|
3504
3530
|
};
|
|
3505
3531
|
});
|
|
3506
|
-
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($
|
|
3532
|
+
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($L16, fail, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
3507
3533
|
var dot = $1;
|
|
3508
3534
|
var neg = $2;
|
|
3509
3535
|
var num = $3;
|
|
@@ -3700,7 +3726,7 @@ ${input.slice(result.pos)}
|
|
|
3700
3726
|
}
|
|
3701
3727
|
}
|
|
3702
3728
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
3703
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
3729
|
+
var MetaProperty$1 = $TS($S($EXPECT($L17, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3704
3730
|
return { $loc, token: $1 };
|
|
3705
3731
|
});
|
|
3706
3732
|
function MetaProperty(state) {
|
|
@@ -3726,7 +3752,7 @@ ${input.slice(result.pos)}
|
|
|
3726
3752
|
}
|
|
3727
3753
|
}
|
|
3728
3754
|
var Parameters$0 = NonEmptyParameters;
|
|
3729
|
-
var Parameters$1 = $TV($EXPECT($
|
|
3755
|
+
var Parameters$1 = $TV($EXPECT($L18, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
3730
3756
|
return {
|
|
3731
3757
|
type: "Parameters",
|
|
3732
3758
|
children: [{ $loc, token: "()" }],
|
|
@@ -3887,7 +3913,7 @@ ${input.slice(result.pos)}
|
|
|
3887
3913
|
}
|
|
3888
3914
|
}
|
|
3889
3915
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
3890
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
3916
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L19, fail, 'ParameterElementDelimiter ")"')));
|
|
3891
3917
|
var ParameterElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
3892
3918
|
return value[1];
|
|
3893
3919
|
});
|
|
@@ -4507,7 +4533,7 @@ ${input.slice(result.pos)}
|
|
|
4507
4533
|
children: $0
|
|
4508
4534
|
};
|
|
4509
4535
|
});
|
|
4510
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
4536
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
4511
4537
|
return {
|
|
4512
4538
|
children: [{
|
|
4513
4539
|
type: "ElisionElement",
|
|
@@ -4580,7 +4606,7 @@ ${input.slice(result.pos)}
|
|
|
4580
4606
|
return result;
|
|
4581
4607
|
}
|
|
4582
4608
|
}
|
|
4583
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
4609
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L18, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
4584
4610
|
const ref = {
|
|
4585
4611
|
type: "Ref",
|
|
4586
4612
|
base: "ref",
|
|
@@ -5056,7 +5082,7 @@ ${input.slice(result.pos)}
|
|
|
5056
5082
|
children: [ws, binding]
|
|
5057
5083
|
};
|
|
5058
5084
|
});
|
|
5059
|
-
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($
|
|
5085
|
+
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'MatchingElement ","'))), function($skip, $loc, $0, $1) {
|
|
5060
5086
|
return {
|
|
5061
5087
|
children: [{
|
|
5062
5088
|
type: "ElisionElement",
|
|
@@ -5450,7 +5476,7 @@ ${input.slice(result.pos)}
|
|
|
5450
5476
|
return result;
|
|
5451
5477
|
}
|
|
5452
5478
|
}
|
|
5453
|
-
var Arrow$0 = $TV($EXPECT($
|
|
5479
|
+
var Arrow$0 = $TV($EXPECT($L21, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
5454
5480
|
return { $loc, token: $1 };
|
|
5455
5481
|
});
|
|
5456
5482
|
function Arrow(state) {
|
|
@@ -5684,7 +5710,7 @@ ${input.slice(result.pos)}
|
|
|
5684
5710
|
return result;
|
|
5685
5711
|
}
|
|
5686
5712
|
}
|
|
5687
|
-
var EmptyBareBlock$0 = $TV($EXPECT($
|
|
5713
|
+
var EmptyBareBlock$0 = $TV($EXPECT($L18, fail, 'EmptyBareBlock ""'), function($skip, $loc, $0, $1) {
|
|
5688
5714
|
const expressions = [];
|
|
5689
5715
|
return {
|
|
5690
5716
|
type: "BlockStatement",
|
|
@@ -5907,7 +5933,7 @@ ${input.slice(result.pos)}
|
|
|
5907
5933
|
children: [$1, expressions]
|
|
5908
5934
|
};
|
|
5909
5935
|
});
|
|
5910
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
5936
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L22, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
5911
5937
|
const expressions = [];
|
|
5912
5938
|
return {
|
|
5913
5939
|
type: "BlockStatement",
|
|
@@ -6052,7 +6078,7 @@ ${input.slice(result.pos)}
|
|
|
6052
6078
|
return result;
|
|
6053
6079
|
}
|
|
6054
6080
|
}
|
|
6055
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
6081
|
+
var NullLiteral$0 = $TS($S($EXPECT($L23, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6056
6082
|
return { $loc, token: $1 };
|
|
6057
6083
|
});
|
|
6058
6084
|
function NullLiteral(state) {
|
|
@@ -6080,7 +6106,7 @@ ${input.slice(result.pos)}
|
|
|
6080
6106
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
6081
6107
|
return value[1];
|
|
6082
6108
|
});
|
|
6083
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6109
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L24, fail, 'BooleanLiteral "true"'), $EXPECT($L25, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6084
6110
|
return { $loc, token: $1 };
|
|
6085
6111
|
});
|
|
6086
6112
|
function BooleanLiteral(state) {
|
|
@@ -6105,10 +6131,10 @@ ${input.slice(result.pos)}
|
|
|
6105
6131
|
return result;
|
|
6106
6132
|
}
|
|
6107
6133
|
}
|
|
6108
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
6134
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L26, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L27, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6109
6135
|
return { $loc, token: "true" };
|
|
6110
6136
|
});
|
|
6111
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6137
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L28, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L29, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6112
6138
|
return { $loc, token: "false" };
|
|
6113
6139
|
});
|
|
6114
6140
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -6214,7 +6240,7 @@ ${input.slice(result.pos)}
|
|
|
6214
6240
|
return result;
|
|
6215
6241
|
}
|
|
6216
6242
|
}
|
|
6217
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($
|
|
6243
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($L30, fail, 'UpcomingAssignment ">"')))));
|
|
6218
6244
|
function UpcomingAssignment(state) {
|
|
6219
6245
|
let eventData;
|
|
6220
6246
|
if (state.events) {
|
|
@@ -6294,17 +6320,8 @@ ${input.slice(result.pos)}
|
|
|
6294
6320
|
const inclusive = range.token === "..";
|
|
6295
6321
|
range.token = ",";
|
|
6296
6322
|
if (s.type === "Literal" && e.type === "Literal") {
|
|
6297
|
-
|
|
6298
|
-
|
|
6299
|
-
start = s.raw.match(/^'(.*)'$/)[1];
|
|
6300
|
-
} else {
|
|
6301
|
-
start = JSON.parse(s.raw);
|
|
6302
|
-
}
|
|
6303
|
-
if (e.raw[0] === "'") {
|
|
6304
|
-
end = e.raw.match(/^'(.*)'$/)[1];
|
|
6305
|
-
} else {
|
|
6306
|
-
end = JSON.parse(e.raw);
|
|
6307
|
-
}
|
|
6323
|
+
const start = module.literalValue(s);
|
|
6324
|
+
const end = module.literalValue(e);
|
|
6308
6325
|
if (typeof start !== typeof end) {
|
|
6309
6326
|
throw new Error("Range start and end must be of the same type");
|
|
6310
6327
|
}
|
|
@@ -6487,7 +6504,7 @@ ${input.slice(result.pos)}
|
|
|
6487
6504
|
}
|
|
6488
6505
|
}
|
|
6489
6506
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
6490
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6507
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L31, fail, 'ArrayElementDelimiter "]"')));
|
|
6491
6508
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6492
6509
|
return value[1];
|
|
6493
6510
|
});
|
|
@@ -6913,7 +6930,7 @@ ${input.slice(result.pos)}
|
|
|
6913
6930
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
|
|
6914
6931
|
return value[1];
|
|
6915
6932
|
});
|
|
6916
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
6933
|
+
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($L32, fail, 'ImplicitInlineObjectPropertyDelimiter ":"'), $EXPECT($L19, fail, 'ImplicitInlineObjectPropertyDelimiter ")"'), $EXPECT($L31, fail, 'ImplicitInlineObjectPropertyDelimiter "]"'), $EXPECT($L22, fail, 'ImplicitInlineObjectPropertyDelimiter "}"'), ReservedWord))), function(value) {
|
|
6917
6934
|
return "";
|
|
6918
6935
|
});
|
|
6919
6936
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -6942,7 +6959,7 @@ ${input.slice(result.pos)}
|
|
|
6942
6959
|
}
|
|
6943
6960
|
}
|
|
6944
6961
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
6945
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6962
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L22, fail, 'ObjectPropertyDelimiter "}"')));
|
|
6946
6963
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6947
6964
|
return value[1];
|
|
6948
6965
|
});
|
|
@@ -6972,6 +6989,7 @@ ${input.slice(result.pos)}
|
|
|
6972
6989
|
return $0.map(([prop, delim]) => {
|
|
6973
6990
|
return {
|
|
6974
6991
|
...prop,
|
|
6992
|
+
delim,
|
|
6975
6993
|
children: [...prop.children, delim]
|
|
6976
6994
|
};
|
|
6977
6995
|
});
|
|
@@ -7050,7 +7068,8 @@ ${input.slice(result.pos)}
|
|
|
7050
7068
|
type: "SpreadProperty",
|
|
7051
7069
|
children: [ws, dots, exp],
|
|
7052
7070
|
names: exp.names,
|
|
7053
|
-
|
|
7071
|
+
dots,
|
|
7072
|
+
value: exp
|
|
7054
7073
|
};
|
|
7055
7074
|
});
|
|
7056
7075
|
var PropertyDefinition$5 = $TS($S(__, CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
@@ -7217,7 +7236,7 @@ ${input.slice(result.pos)}
|
|
|
7217
7236
|
expression
|
|
7218
7237
|
};
|
|
7219
7238
|
});
|
|
7220
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7239
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L16, fail, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7221
7240
|
return {
|
|
7222
7241
|
type: "ComputedPropertyName",
|
|
7223
7242
|
children: $0
|
|
@@ -7523,7 +7542,21 @@ ${input.slice(result.pos)}
|
|
|
7523
7542
|
return result;
|
|
7524
7543
|
}
|
|
7525
7544
|
}
|
|
7526
|
-
var OperatorAssignmentOp$0 = $TS($S(
|
|
7545
|
+
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7546
|
+
return {
|
|
7547
|
+
special: true,
|
|
7548
|
+
call: module.getRef("xor"),
|
|
7549
|
+
children: [$2, ...$4]
|
|
7550
|
+
};
|
|
7551
|
+
});
|
|
7552
|
+
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7553
|
+
return {
|
|
7554
|
+
special: true,
|
|
7555
|
+
call: module.getRef("xnor"),
|
|
7556
|
+
children: [$2, ...$4]
|
|
7557
|
+
};
|
|
7558
|
+
});
|
|
7559
|
+
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7527
7560
|
return {
|
|
7528
7561
|
special: true,
|
|
7529
7562
|
call: $1,
|
|
@@ -7541,33 +7574,33 @@ ${input.slice(result.pos)}
|
|
|
7541
7574
|
}
|
|
7542
7575
|
}
|
|
7543
7576
|
if (state.tokenize) {
|
|
7544
|
-
const result = $TOKEN("OperatorAssignmentOp", state, OperatorAssignmentOp$0(state));
|
|
7577
|
+
const result = $TOKEN("OperatorAssignmentOp", state, OperatorAssignmentOp$0(state) || OperatorAssignmentOp$1(state) || OperatorAssignmentOp$2(state));
|
|
7545
7578
|
if (state.events)
|
|
7546
7579
|
state.events.exit?.("OperatorAssignmentOp", state, result, eventData);
|
|
7547
7580
|
return result;
|
|
7548
7581
|
} else {
|
|
7549
|
-
const result = OperatorAssignmentOp$0(state);
|
|
7582
|
+
const result = OperatorAssignmentOp$0(state) || OperatorAssignmentOp$1(state) || OperatorAssignmentOp$2(state);
|
|
7550
7583
|
if (state.events)
|
|
7551
7584
|
state.events.exit?.("OperatorAssignmentOp", state, result, eventData);
|
|
7552
7585
|
return result;
|
|
7553
7586
|
}
|
|
7554
7587
|
}
|
|
7555
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
7556
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
7557
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
7558
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
7559
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
7560
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
7561
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
7562
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
7563
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
7564
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
7565
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
7566
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
7567
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
7568
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
7569
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
7570
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
7588
|
+
var AssignmentOpSymbol$0 = $EXPECT($L33, fail, 'AssignmentOpSymbol "**="');
|
|
7589
|
+
var AssignmentOpSymbol$1 = $EXPECT($L34, fail, 'AssignmentOpSymbol "*="');
|
|
7590
|
+
var AssignmentOpSymbol$2 = $EXPECT($L35, fail, 'AssignmentOpSymbol "/="');
|
|
7591
|
+
var AssignmentOpSymbol$3 = $EXPECT($L36, fail, 'AssignmentOpSymbol "%="');
|
|
7592
|
+
var AssignmentOpSymbol$4 = $EXPECT($L37, fail, 'AssignmentOpSymbol "+="');
|
|
7593
|
+
var AssignmentOpSymbol$5 = $EXPECT($L38, fail, 'AssignmentOpSymbol "-="');
|
|
7594
|
+
var AssignmentOpSymbol$6 = $EXPECT($L39, fail, 'AssignmentOpSymbol "<<="');
|
|
7595
|
+
var AssignmentOpSymbol$7 = $EXPECT($L40, fail, 'AssignmentOpSymbol ">>>="');
|
|
7596
|
+
var AssignmentOpSymbol$8 = $EXPECT($L41, fail, 'AssignmentOpSymbol ">>="');
|
|
7597
|
+
var AssignmentOpSymbol$9 = $EXPECT($L42, fail, 'AssignmentOpSymbol "&&="');
|
|
7598
|
+
var AssignmentOpSymbol$10 = $EXPECT($L43, fail, 'AssignmentOpSymbol "&="');
|
|
7599
|
+
var AssignmentOpSymbol$11 = $EXPECT($L44, fail, 'AssignmentOpSymbol "^="');
|
|
7600
|
+
var AssignmentOpSymbol$12 = $EXPECT($L45, fail, 'AssignmentOpSymbol "||="');
|
|
7601
|
+
var AssignmentOpSymbol$13 = $EXPECT($L46, fail, 'AssignmentOpSymbol "|="');
|
|
7602
|
+
var AssignmentOpSymbol$14 = $EXPECT($L47, fail, 'AssignmentOpSymbol "??="');
|
|
7603
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L48, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
7571
7604
|
return "??=";
|
|
7572
7605
|
});
|
|
7573
7606
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L1, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L1, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -7598,10 +7631,10 @@ ${input.slice(result.pos)}
|
|
|
7598
7631
|
return result;
|
|
7599
7632
|
}
|
|
7600
7633
|
}
|
|
7601
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
7634
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L49, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
7602
7635
|
return "&&=";
|
|
7603
7636
|
});
|
|
7604
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
7637
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L50, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
7605
7638
|
return "||=";
|
|
7606
7639
|
});
|
|
7607
7640
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -7640,7 +7673,7 @@ ${input.slice(result.pos)}
|
|
|
7640
7673
|
special: true
|
|
7641
7674
|
};
|
|
7642
7675
|
});
|
|
7643
|
-
var BinaryOp$2 = $TS($S($EXPECT($
|
|
7676
|
+
var BinaryOp$2 = $TS($S($EXPECT($L51, fail, 'BinaryOp "not"'), NonIdContinue, __, Identifier), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7644
7677
|
var id = $4;
|
|
7645
7678
|
if (!module.operators.has(id.name))
|
|
7646
7679
|
return $skip;
|
|
@@ -7672,21 +7705,21 @@ ${input.slice(result.pos)}
|
|
|
7672
7705
|
return result;
|
|
7673
7706
|
}
|
|
7674
7707
|
}
|
|
7675
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
7676
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
7677
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
7678
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
7708
|
+
var BinaryOpSymbol$0 = $EXPECT($L52, fail, 'BinaryOpSymbol "**"');
|
|
7709
|
+
var BinaryOpSymbol$1 = $EXPECT($L53, fail, 'BinaryOpSymbol "*"');
|
|
7710
|
+
var BinaryOpSymbol$2 = $EXPECT($L54, fail, 'BinaryOpSymbol "/"');
|
|
7711
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L55, fail, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
7679
7712
|
return {
|
|
7680
7713
|
call: module.getRef("modulo"),
|
|
7681
7714
|
special: true
|
|
7682
7715
|
};
|
|
7683
7716
|
});
|
|
7684
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
7685
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
7686
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
7687
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
7688
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
7689
|
-
var BinaryOpSymbol$9 = $TV($EXPECT($
|
|
7717
|
+
var BinaryOpSymbol$4 = $EXPECT($L56, fail, 'BinaryOpSymbol "%"');
|
|
7718
|
+
var BinaryOpSymbol$5 = $EXPECT($L57, fail, 'BinaryOpSymbol "+"');
|
|
7719
|
+
var BinaryOpSymbol$6 = $EXPECT($L16, fail, 'BinaryOpSymbol "-"');
|
|
7720
|
+
var BinaryOpSymbol$7 = $EXPECT($L58, fail, 'BinaryOpSymbol "<="');
|
|
7721
|
+
var BinaryOpSymbol$8 = $EXPECT($L59, fail, 'BinaryOpSymbol ">="');
|
|
7722
|
+
var BinaryOpSymbol$9 = $TV($EXPECT($L60, fail, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
7690
7723
|
return {
|
|
7691
7724
|
$loc,
|
|
7692
7725
|
token: "instanceof",
|
|
@@ -7694,7 +7727,7 @@ ${input.slice(result.pos)}
|
|
|
7694
7727
|
special: true
|
|
7695
7728
|
};
|
|
7696
7729
|
});
|
|
7697
|
-
var BinaryOpSymbol$10 = $TV($EXPECT($
|
|
7730
|
+
var BinaryOpSymbol$10 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
7698
7731
|
return {
|
|
7699
7732
|
$loc,
|
|
7700
7733
|
token: "instanceof",
|
|
@@ -7703,46 +7736,58 @@ ${input.slice(result.pos)}
|
|
|
7703
7736
|
negated: true
|
|
7704
7737
|
};
|
|
7705
7738
|
});
|
|
7706
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
7739
|
+
var BinaryOpSymbol$11 = $EXPECT($L62, fail, 'BinaryOpSymbol "<<"');
|
|
7707
7740
|
var BinaryOpSymbol$12 = $TR($EXPECT($R6, fail, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7708
7741
|
return "<";
|
|
7709
7742
|
});
|
|
7710
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
7711
|
-
var BinaryOpSymbol$14 = $EXPECT($
|
|
7712
|
-
var BinaryOpSymbol$15 = $EXPECT($
|
|
7713
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
7714
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
7743
|
+
var BinaryOpSymbol$13 = $EXPECT($L63, fail, 'BinaryOpSymbol ">>>"');
|
|
7744
|
+
var BinaryOpSymbol$14 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>"');
|
|
7745
|
+
var BinaryOpSymbol$15 = $EXPECT($L30, fail, 'BinaryOpSymbol ">"');
|
|
7746
|
+
var BinaryOpSymbol$16 = $EXPECT($L65, fail, 'BinaryOpSymbol "!=="');
|
|
7747
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L66, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
7715
7748
|
if (module.config.coffeeEq)
|
|
7716
7749
|
return "!==";
|
|
7717
7750
|
return $1;
|
|
7718
7751
|
});
|
|
7719
|
-
var BinaryOpSymbol$18 = $TS($S($EXPECT($
|
|
7752
|
+
var BinaryOpSymbol$18 = $TS($S($EXPECT($L67, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7720
7753
|
if (module.config.coffeeIsnt)
|
|
7721
7754
|
return "!==";
|
|
7722
7755
|
return $skip;
|
|
7723
7756
|
});
|
|
7724
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
7725
|
-
var BinaryOpSymbol$20 = $TV($EXPECT($
|
|
7757
|
+
var BinaryOpSymbol$19 = $EXPECT($L68, fail, 'BinaryOpSymbol "==="');
|
|
7758
|
+
var BinaryOpSymbol$20 = $TV($EXPECT($L69, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
7726
7759
|
if (module.config.coffeeEq)
|
|
7727
7760
|
return "===";
|
|
7728
7761
|
return $1;
|
|
7729
7762
|
});
|
|
7730
|
-
var BinaryOpSymbol$21 = $T($S($EXPECT($
|
|
7763
|
+
var BinaryOpSymbol$21 = $T($S($EXPECT($L70, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
7731
7764
|
return "&&";
|
|
7732
7765
|
});
|
|
7733
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
7734
|
-
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
7766
|
+
var BinaryOpSymbol$22 = $EXPECT($L71, fail, 'BinaryOpSymbol "&&"');
|
|
7767
|
+
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($L72, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
7735
7768
|
return "in";
|
|
7736
7769
|
});
|
|
7737
|
-
var BinaryOpSymbol$24 = $T($S($EXPECT($
|
|
7770
|
+
var BinaryOpSymbol$24 = $T($S($EXPECT($L73, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
7738
7771
|
return "||";
|
|
7739
7772
|
});
|
|
7740
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
7741
|
-
var BinaryOpSymbol$26 = $EXPECT($
|
|
7742
|
-
|
|
7773
|
+
var BinaryOpSymbol$25 = $EXPECT($L74, fail, 'BinaryOpSymbol "||"');
|
|
7774
|
+
var BinaryOpSymbol$26 = $TV($C($EXPECT($L75, fail, 'BinaryOpSymbol "^^"'), $S($EXPECT($L76, fail, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7775
|
+
return {
|
|
7776
|
+
call: module.getRef("xor"),
|
|
7777
|
+
special: true
|
|
7778
|
+
};
|
|
7779
|
+
});
|
|
7780
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($R7, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L77, fail, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7781
|
+
return {
|
|
7782
|
+
call: module.getRef("xnor"),
|
|
7783
|
+
special: true
|
|
7784
|
+
};
|
|
7785
|
+
});
|
|
7786
|
+
var BinaryOpSymbol$28 = $EXPECT($L78, fail, 'BinaryOpSymbol "??"');
|
|
7787
|
+
var BinaryOpSymbol$29 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L3, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
7743
7788
|
return "??";
|
|
7744
7789
|
});
|
|
7745
|
-
var BinaryOpSymbol$
|
|
7790
|
+
var BinaryOpSymbol$30 = $TS($S($EXPECT($L79, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7746
7791
|
return {
|
|
7747
7792
|
$loc,
|
|
7748
7793
|
token: $1,
|
|
@@ -7750,7 +7795,7 @@ ${input.slice(result.pos)}
|
|
|
7750
7795
|
special: true
|
|
7751
7796
|
};
|
|
7752
7797
|
});
|
|
7753
|
-
var BinaryOpSymbol$
|
|
7798
|
+
var BinaryOpSymbol$31 = $TS($S($EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L79, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7754
7799
|
return {
|
|
7755
7800
|
$loc,
|
|
7756
7801
|
token: "instanceof",
|
|
@@ -7759,7 +7804,7 @@ ${input.slice(result.pos)}
|
|
|
7759
7804
|
negated: true
|
|
7760
7805
|
};
|
|
7761
7806
|
});
|
|
7762
|
-
var BinaryOpSymbol$
|
|
7807
|
+
var BinaryOpSymbol$32 = $TV($C($S($N(CoffeeOfEnabled), $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), $S(CoffeeOfEnabled, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L72, fail, 'BinaryOpSymbol "of"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7763
7808
|
return {
|
|
7764
7809
|
$loc,
|
|
7765
7810
|
token: "in",
|
|
@@ -7767,7 +7812,7 @@ ${input.slice(result.pos)}
|
|
|
7767
7812
|
negated: true
|
|
7768
7813
|
};
|
|
7769
7814
|
});
|
|
7770
|
-
var BinaryOpSymbol$
|
|
7815
|
+
var BinaryOpSymbol$33 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7771
7816
|
return {
|
|
7772
7817
|
method: "includes",
|
|
7773
7818
|
relational: true,
|
|
@@ -7775,7 +7820,7 @@ ${input.slice(result.pos)}
|
|
|
7775
7820
|
special: true
|
|
7776
7821
|
};
|
|
7777
7822
|
});
|
|
7778
|
-
var BinaryOpSymbol$
|
|
7823
|
+
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
7779
7824
|
return {
|
|
7780
7825
|
call: [module.getRef("indexOf"), ".call"],
|
|
7781
7826
|
relational: true,
|
|
@@ -7784,7 +7829,7 @@ ${input.slice(result.pos)}
|
|
|
7784
7829
|
special: true
|
|
7785
7830
|
};
|
|
7786
7831
|
});
|
|
7787
|
-
var BinaryOpSymbol$
|
|
7832
|
+
var BinaryOpSymbol$35 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
7788
7833
|
return {
|
|
7789
7834
|
method: "includes",
|
|
7790
7835
|
relational: true,
|
|
@@ -7793,7 +7838,7 @@ ${input.slice(result.pos)}
|
|
|
7793
7838
|
negated: true
|
|
7794
7839
|
};
|
|
7795
7840
|
});
|
|
7796
|
-
var BinaryOpSymbol$
|
|
7841
|
+
var BinaryOpSymbol$36 = $TS($S(CoffeeOfEnabled, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
7797
7842
|
return {
|
|
7798
7843
|
call: [module.getRef("indexOf"), ".call"],
|
|
7799
7844
|
relational: true,
|
|
@@ -7802,7 +7847,7 @@ ${input.slice(result.pos)}
|
|
|
7802
7847
|
special: true
|
|
7803
7848
|
};
|
|
7804
7849
|
});
|
|
7805
|
-
var BinaryOpSymbol$
|
|
7850
|
+
var BinaryOpSymbol$37 = $TS($S($N(CoffeeNotEnabled), $EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
7806
7851
|
if (module.config.objectIs) {
|
|
7807
7852
|
return {
|
|
7808
7853
|
call: module.getRef("is"),
|
|
@@ -7814,7 +7859,7 @@ ${input.slice(result.pos)}
|
|
|
7814
7859
|
}
|
|
7815
7860
|
return "!==";
|
|
7816
7861
|
});
|
|
7817
|
-
var BinaryOpSymbol$
|
|
7862
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7818
7863
|
if (module.config.objectIs) {
|
|
7819
7864
|
return {
|
|
7820
7865
|
call: module.getRef("is"),
|
|
@@ -7825,12 +7870,12 @@ ${input.slice(result.pos)}
|
|
|
7825
7870
|
}
|
|
7826
7871
|
return "===";
|
|
7827
7872
|
});
|
|
7828
|
-
var BinaryOpSymbol$
|
|
7873
|
+
var BinaryOpSymbol$39 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7829
7874
|
return $1;
|
|
7830
7875
|
});
|
|
7831
|
-
var BinaryOpSymbol$
|
|
7832
|
-
var BinaryOpSymbol$
|
|
7833
|
-
var BinaryOpSymbol$
|
|
7876
|
+
var BinaryOpSymbol$40 = $EXPECT($L82, fail, 'BinaryOpSymbol "&"');
|
|
7877
|
+
var BinaryOpSymbol$41 = $EXPECT($L15, fail, 'BinaryOpSymbol "^"');
|
|
7878
|
+
var BinaryOpSymbol$42 = $EXPECT($L83, fail, 'BinaryOpSymbol "|"');
|
|
7834
7879
|
function BinaryOpSymbol(state) {
|
|
7835
7880
|
let eventData;
|
|
7836
7881
|
if (state.events) {
|
|
@@ -7842,18 +7887,66 @@ ${input.slice(result.pos)}
|
|
|
7842
7887
|
}
|
|
7843
7888
|
}
|
|
7844
7889
|
if (state.tokenize) {
|
|
7845
|
-
const result = $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state) || BinaryOpSymbol$37(state) || BinaryOpSymbol$38(state) || BinaryOpSymbol$39(state) || BinaryOpSymbol$40(state));
|
|
7890
|
+
const result = $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state) || BinaryOpSymbol$37(state) || BinaryOpSymbol$38(state) || BinaryOpSymbol$39(state) || BinaryOpSymbol$40(state) || BinaryOpSymbol$41(state) || BinaryOpSymbol$42(state));
|
|
7846
7891
|
if (state.events)
|
|
7847
7892
|
state.events.exit?.("BinaryOpSymbol", state, result, eventData);
|
|
7848
7893
|
return result;
|
|
7849
7894
|
} else {
|
|
7850
|
-
const result = BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state) || BinaryOpSymbol$37(state) || BinaryOpSymbol$38(state) || BinaryOpSymbol$39(state) || BinaryOpSymbol$40(state);
|
|
7895
|
+
const result = BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state) || BinaryOpSymbol$37(state) || BinaryOpSymbol$38(state) || BinaryOpSymbol$39(state) || BinaryOpSymbol$40(state) || BinaryOpSymbol$41(state) || BinaryOpSymbol$42(state);
|
|
7851
7896
|
if (state.events)
|
|
7852
7897
|
state.events.exit?.("BinaryOpSymbol", state, result, eventData);
|
|
7853
7898
|
return result;
|
|
7854
7899
|
}
|
|
7855
7900
|
}
|
|
7856
|
-
var
|
|
7901
|
+
var Xor$0 = $EXPECT($L75, fail, 'Xor "^^"');
|
|
7902
|
+
var Xor$1 = $S($EXPECT($L76, fail, 'Xor "xor"'), NonIdContinue);
|
|
7903
|
+
function Xor(state) {
|
|
7904
|
+
let eventData;
|
|
7905
|
+
if (state.events) {
|
|
7906
|
+
const result = state.events.enter?.("Xor", state);
|
|
7907
|
+
if (result) {
|
|
7908
|
+
if (result.cache)
|
|
7909
|
+
return result.cache;
|
|
7910
|
+
eventData = result.data;
|
|
7911
|
+
}
|
|
7912
|
+
}
|
|
7913
|
+
if (state.tokenize) {
|
|
7914
|
+
const result = $TOKEN("Xor", state, Xor$0(state) || Xor$1(state));
|
|
7915
|
+
if (state.events)
|
|
7916
|
+
state.events.exit?.("Xor", state, result, eventData);
|
|
7917
|
+
return result;
|
|
7918
|
+
} else {
|
|
7919
|
+
const result = Xor$0(state) || Xor$1(state);
|
|
7920
|
+
if (state.events)
|
|
7921
|
+
state.events.exit?.("Xor", state, result, eventData);
|
|
7922
|
+
return result;
|
|
7923
|
+
}
|
|
7924
|
+
}
|
|
7925
|
+
var Xnor$0 = $R$0($EXPECT($R7, fail, "Xnor /!\\^\\^?/"));
|
|
7926
|
+
var Xnor$1 = $EXPECT($L77, fail, 'Xnor "xnor"');
|
|
7927
|
+
function Xnor(state) {
|
|
7928
|
+
let eventData;
|
|
7929
|
+
if (state.events) {
|
|
7930
|
+
const result = state.events.enter?.("Xnor", state);
|
|
7931
|
+
if (result) {
|
|
7932
|
+
if (result.cache)
|
|
7933
|
+
return result.cache;
|
|
7934
|
+
eventData = result.data;
|
|
7935
|
+
}
|
|
7936
|
+
}
|
|
7937
|
+
if (state.tokenize) {
|
|
7938
|
+
const result = $TOKEN("Xnor", state, Xnor$0(state) || Xnor$1(state));
|
|
7939
|
+
if (state.events)
|
|
7940
|
+
state.events.exit?.("Xnor", state, result, eventData);
|
|
7941
|
+
return result;
|
|
7942
|
+
} else {
|
|
7943
|
+
const result = Xnor$0(state) || Xnor$1(state);
|
|
7944
|
+
if (state.events)
|
|
7945
|
+
state.events.exit?.("Xnor", state, result, eventData);
|
|
7946
|
+
return result;
|
|
7947
|
+
}
|
|
7948
|
+
}
|
|
7949
|
+
var UnaryOp$0 = $TR($EXPECT($R8, fail, "UnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7857
7950
|
return { $loc, token: $0 };
|
|
7858
7951
|
});
|
|
7859
7952
|
var UnaryOp$1 = $S($C(Await, Delete, Void, Typeof), __);
|
|
@@ -8050,7 +8143,7 @@ ${input.slice(result.pos)}
|
|
|
8050
8143
|
return result;
|
|
8051
8144
|
}
|
|
8052
8145
|
}
|
|
8053
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
8146
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L84, fail, 'EmptyStatement ";"'))), function(value) {
|
|
8054
8147
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
8055
8148
|
});
|
|
8056
8149
|
function EmptyStatement(state) {
|
|
@@ -9005,7 +9098,7 @@ ${input.slice(result.pos)}
|
|
|
9005
9098
|
return result;
|
|
9006
9099
|
}
|
|
9007
9100
|
}
|
|
9008
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
9101
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L85, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
9009
9102
|
var own = $1;
|
|
9010
9103
|
var binding = $2;
|
|
9011
9104
|
return {
|
|
@@ -9128,7 +9221,7 @@ ${input.slice(result.pos)}
|
|
|
9128
9221
|
names: binding.names
|
|
9129
9222
|
};
|
|
9130
9223
|
});
|
|
9131
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
9224
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R9, fail, "ForDeclaration /(?=[\\s\\)])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
9132
9225
|
var c = $1;
|
|
9133
9226
|
var binding = $2;
|
|
9134
9227
|
return {
|
|
@@ -9486,7 +9579,7 @@ ${input.slice(result.pos)}
|
|
|
9486
9579
|
}
|
|
9487
9580
|
}
|
|
9488
9581
|
var ImpliedColon$0 = $S(__, Colon);
|
|
9489
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
9582
|
+
var ImpliedColon$1 = $TV($EXPECT($L18, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
9490
9583
|
return { $loc, token: ":" };
|
|
9491
9584
|
});
|
|
9492
9585
|
function ImpliedColon(state) {
|
|
@@ -9740,7 +9833,7 @@ ${input.slice(result.pos)}
|
|
|
9740
9833
|
return result;
|
|
9741
9834
|
}
|
|
9742
9835
|
}
|
|
9743
|
-
var SuppressIndentedApplication$0 = $TV($EXPECT($
|
|
9836
|
+
var SuppressIndentedApplication$0 = $TV($EXPECT($L18, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
9744
9837
|
module.suppressIndentedApplication = true;
|
|
9745
9838
|
});
|
|
9746
9839
|
function SuppressIndentedApplication(state) {
|
|
@@ -9765,7 +9858,7 @@ ${input.slice(result.pos)}
|
|
|
9765
9858
|
return result;
|
|
9766
9859
|
}
|
|
9767
9860
|
}
|
|
9768
|
-
var IndentedApplicationAllowed$0 = $TV($EXPECT($
|
|
9861
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L18, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
9769
9862
|
if (module.suppressIndentedApplication)
|
|
9770
9863
|
return $skip;
|
|
9771
9864
|
return;
|
|
@@ -9792,7 +9885,7 @@ ${input.slice(result.pos)}
|
|
|
9792
9885
|
return result;
|
|
9793
9886
|
}
|
|
9794
9887
|
}
|
|
9795
|
-
var SuppressTrailingMemberProperty$0 = $TV($EXPECT($
|
|
9888
|
+
var SuppressTrailingMemberProperty$0 = $TV($EXPECT($L18, fail, 'SuppressTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
9796
9889
|
module.suppressTrailingMemberProperty.push(true);
|
|
9797
9890
|
});
|
|
9798
9891
|
function SuppressTrailingMemberProperty(state) {
|
|
@@ -9817,7 +9910,7 @@ ${input.slice(result.pos)}
|
|
|
9817
9910
|
return result;
|
|
9818
9911
|
}
|
|
9819
9912
|
}
|
|
9820
|
-
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($
|
|
9913
|
+
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($L18, fail, 'TrailingMemberPropertyAllowed ""'), function($skip, $loc, $0, $1) {
|
|
9821
9914
|
if (module.trailingMemberPropertySuppressed)
|
|
9822
9915
|
return $skip;
|
|
9823
9916
|
});
|
|
@@ -9866,13 +9959,13 @@ ${input.slice(result.pos)}
|
|
|
9866
9959
|
return result;
|
|
9867
9960
|
}
|
|
9868
9961
|
}
|
|
9869
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
9962
|
+
var KeywordStatement$0 = $T($S($EXPECT($L86, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
9870
9963
|
return { "type": "BreakStatement", "children": value };
|
|
9871
9964
|
});
|
|
9872
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
9965
|
+
var KeywordStatement$1 = $T($S($EXPECT($L87, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
9873
9966
|
return { "type": "ContinueStatement", "children": value };
|
|
9874
9967
|
});
|
|
9875
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
9968
|
+
var KeywordStatement$2 = $T($S($EXPECT($L88, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
9876
9969
|
return { "type": "DebuggerStatement", "children": value };
|
|
9877
9970
|
});
|
|
9878
9971
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -9903,7 +9996,7 @@ ${input.slice(result.pos)}
|
|
|
9903
9996
|
return result;
|
|
9904
9997
|
}
|
|
9905
9998
|
}
|
|
9906
|
-
var DebuggerExpression$0 = $TS($S($EXPECT($
|
|
9999
|
+
var DebuggerExpression$0 = $TS($S($EXPECT($L88, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9907
10000
|
return {
|
|
9908
10001
|
type: "DebuggerExpression",
|
|
9909
10002
|
children: ["(()=>{", $1, "})()"]
|
|
@@ -10031,7 +10124,7 @@ ${input.slice(result.pos)}
|
|
|
10031
10124
|
return result;
|
|
10032
10125
|
}
|
|
10033
10126
|
}
|
|
10034
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
10127
|
+
var ImpliedImport$0 = $TV($EXPECT($L18, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
10035
10128
|
return { $loc, token: "import " };
|
|
10036
10129
|
});
|
|
10037
10130
|
function ImpliedImport(state) {
|
|
@@ -10180,7 +10273,7 @@ ${input.slice(result.pos)}
|
|
|
10180
10273
|
return result;
|
|
10181
10274
|
}
|
|
10182
10275
|
}
|
|
10183
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10276
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L89, fail, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10184
10277
|
function ImportAssertion(state) {
|
|
10185
10278
|
let eventData;
|
|
10186
10279
|
if (state.events) {
|
|
@@ -10396,7 +10489,7 @@ ${input.slice(result.pos)}
|
|
|
10396
10489
|
return result;
|
|
10397
10490
|
}
|
|
10398
10491
|
}
|
|
10399
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
10492
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R10, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
10400
10493
|
var spec = $0;
|
|
10401
10494
|
return { $loc, token: `"${spec}"` };
|
|
10402
10495
|
});
|
|
@@ -10784,7 +10877,7 @@ ${input.slice(result.pos)}
|
|
|
10784
10877
|
return result;
|
|
10785
10878
|
}
|
|
10786
10879
|
}
|
|
10787
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
10880
|
+
var ConstAssignment$0 = $TV($EXPECT($L90, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
10788
10881
|
return { $loc, token: "=" };
|
|
10789
10882
|
});
|
|
10790
10883
|
function ConstAssignment(state) {
|
|
@@ -10809,7 +10902,7 @@ ${input.slice(result.pos)}
|
|
|
10809
10902
|
return result;
|
|
10810
10903
|
}
|
|
10811
10904
|
}
|
|
10812
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
10905
|
+
var LetAssignment$0 = $TV($EXPECT($L91, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10813
10906
|
return { $loc, token: "=" };
|
|
10814
10907
|
});
|
|
10815
10908
|
function LetAssignment(state) {
|
|
@@ -11058,7 +11151,7 @@ ${input.slice(result.pos)}
|
|
|
11058
11151
|
return result;
|
|
11059
11152
|
}
|
|
11060
11153
|
}
|
|
11061
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
11154
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R11, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
11062
11155
|
function DecimalBigIntegerLiteral(state) {
|
|
11063
11156
|
let eventData;
|
|
11064
11157
|
if (state.events) {
|
|
@@ -11081,11 +11174,11 @@ ${input.slice(result.pos)}
|
|
|
11081
11174
|
return result;
|
|
11082
11175
|
}
|
|
11083
11176
|
}
|
|
11084
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
11177
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R12, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
11085
11178
|
return $1 + ".";
|
|
11086
11179
|
});
|
|
11087
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
11088
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
11180
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R13, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
11181
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R14, fail, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
11089
11182
|
function DecimalLiteral(state) {
|
|
11090
11183
|
let eventData;
|
|
11091
11184
|
if (state.events) {
|
|
@@ -11108,7 +11201,7 @@ ${input.slice(result.pos)}
|
|
|
11108
11201
|
return result;
|
|
11109
11202
|
}
|
|
11110
11203
|
}
|
|
11111
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
11204
|
+
var ExponentPart$0 = $R$0($EXPECT($R15, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
11112
11205
|
function ExponentPart(state) {
|
|
11113
11206
|
let eventData;
|
|
11114
11207
|
if (state.events) {
|
|
@@ -11131,7 +11224,7 @@ ${input.slice(result.pos)}
|
|
|
11131
11224
|
return result;
|
|
11132
11225
|
}
|
|
11133
11226
|
}
|
|
11134
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
11227
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R16, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
11135
11228
|
function BinaryIntegerLiteral(state) {
|
|
11136
11229
|
let eventData;
|
|
11137
11230
|
if (state.events) {
|
|
@@ -11154,7 +11247,7 @@ ${input.slice(result.pos)}
|
|
|
11154
11247
|
return result;
|
|
11155
11248
|
}
|
|
11156
11249
|
}
|
|
11157
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11250
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R17, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
11158
11251
|
function OctalIntegerLiteral(state) {
|
|
11159
11252
|
let eventData;
|
|
11160
11253
|
if (state.events) {
|
|
@@ -11177,7 +11270,7 @@ ${input.slice(result.pos)}
|
|
|
11177
11270
|
return result;
|
|
11178
11271
|
}
|
|
11179
11272
|
}
|
|
11180
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
11273
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R18, fail, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
11181
11274
|
function HexIntegerLiteral(state) {
|
|
11182
11275
|
let eventData;
|
|
11183
11276
|
if (state.events) {
|
|
@@ -11252,7 +11345,7 @@ ${input.slice(result.pos)}
|
|
|
11252
11345
|
return result;
|
|
11253
11346
|
}
|
|
11254
11347
|
}
|
|
11255
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11348
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R19, fail, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
11256
11349
|
function DecimalIntegerLiteral(state) {
|
|
11257
11350
|
let eventData;
|
|
11258
11351
|
if (state.events) {
|
|
@@ -11313,7 +11406,7 @@ ${input.slice(result.pos)}
|
|
|
11313
11406
|
return result;
|
|
11314
11407
|
}
|
|
11315
11408
|
}
|
|
11316
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
11409
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R20, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11317
11410
|
return { $loc, token: $0 };
|
|
11318
11411
|
});
|
|
11319
11412
|
function DoubleStringCharacters(state) {
|
|
@@ -11338,7 +11431,7 @@ ${input.slice(result.pos)}
|
|
|
11338
11431
|
return result;
|
|
11339
11432
|
}
|
|
11340
11433
|
}
|
|
11341
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
11434
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R21, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11342
11435
|
return { $loc, token: $0 };
|
|
11343
11436
|
});
|
|
11344
11437
|
function SingleStringCharacters(state) {
|
|
@@ -11363,7 +11456,7 @@ ${input.slice(result.pos)}
|
|
|
11363
11456
|
return result;
|
|
11364
11457
|
}
|
|
11365
11458
|
}
|
|
11366
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
11459
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R22, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11367
11460
|
return { $loc, token: $0 };
|
|
11368
11461
|
});
|
|
11369
11462
|
function TripleDoubleStringCharacters(state) {
|
|
@@ -11388,7 +11481,7 @@ ${input.slice(result.pos)}
|
|
|
11388
11481
|
return result;
|
|
11389
11482
|
}
|
|
11390
11483
|
}
|
|
11391
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
11484
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R23, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11392
11485
|
return { $loc, token: $0 };
|
|
11393
11486
|
});
|
|
11394
11487
|
function TripleSingleStringCharacters(state) {
|
|
@@ -11481,7 +11574,7 @@ ${input.slice(result.pos)}
|
|
|
11481
11574
|
return result;
|
|
11482
11575
|
}
|
|
11483
11576
|
}
|
|
11484
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
11577
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R24, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11485
11578
|
return { $loc, token: $0 };
|
|
11486
11579
|
});
|
|
11487
11580
|
function CoffeeDoubleQuotedStringCharacters(state) {
|
|
@@ -11507,7 +11600,7 @@ ${input.slice(result.pos)}
|
|
|
11507
11600
|
}
|
|
11508
11601
|
}
|
|
11509
11602
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
11510
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
11603
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L54, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L54, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
11511
11604
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
11512
11605
|
});
|
|
11513
11606
|
function RegularExpressionLiteral(state) {
|
|
@@ -11557,7 +11650,7 @@ ${input.slice(result.pos)}
|
|
|
11557
11650
|
return result;
|
|
11558
11651
|
}
|
|
11559
11652
|
}
|
|
11560
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
11653
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R25, fail, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11561
11654
|
return { $loc, token: $0 };
|
|
11562
11655
|
});
|
|
11563
11656
|
function RegularExpressionClassCharacters(state) {
|
|
@@ -11667,7 +11760,7 @@ ${input.slice(result.pos)}
|
|
|
11667
11760
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
11668
11761
|
return { "type": "Substitution", "children": value[0] };
|
|
11669
11762
|
});
|
|
11670
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
11763
|
+
var HeregexPart$3 = $TR($EXPECT($R26, fail, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11671
11764
|
let token = $0;
|
|
11672
11765
|
switch ($0[1]) {
|
|
11673
11766
|
case "\n":
|
|
@@ -11685,13 +11778,13 @@ ${input.slice(result.pos)}
|
|
|
11685
11778
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
11686
11779
|
return { $loc, token: "" };
|
|
11687
11780
|
});
|
|
11688
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
11781
|
+
var HeregexPart$5 = $TR($EXPECT($R27, fail, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11689
11782
|
return { $loc, token: "" };
|
|
11690
11783
|
});
|
|
11691
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
11784
|
+
var HeregexPart$6 = $TR($EXPECT($R28, fail, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11692
11785
|
return { $loc, token: "\\/" };
|
|
11693
11786
|
});
|
|
11694
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
11787
|
+
var HeregexPart$7 = $TR($EXPECT($R29, fail, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11695
11788
|
return { $loc, token: $0 };
|
|
11696
11789
|
});
|
|
11697
11790
|
function HeregexPart(state) {
|
|
@@ -11740,7 +11833,7 @@ ${input.slice(result.pos)}
|
|
|
11740
11833
|
return result;
|
|
11741
11834
|
}
|
|
11742
11835
|
}
|
|
11743
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
11836
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R30, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
11744
11837
|
function RegularExpressionBody(state) {
|
|
11745
11838
|
let eventData;
|
|
11746
11839
|
if (state.events) {
|
|
@@ -11787,7 +11880,7 @@ ${input.slice(result.pos)}
|
|
|
11787
11880
|
return result;
|
|
11788
11881
|
}
|
|
11789
11882
|
}
|
|
11790
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
11883
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R31, fail, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
11791
11884
|
function RegExpCharacter(state) {
|
|
11792
11885
|
let eventData;
|
|
11793
11886
|
if (state.events) {
|
|
@@ -11810,7 +11903,7 @@ ${input.slice(result.pos)}
|
|
|
11810
11903
|
return result;
|
|
11811
11904
|
}
|
|
11812
11905
|
}
|
|
11813
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
11906
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R32, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
11814
11907
|
function RegularExpressionFlags(state) {
|
|
11815
11908
|
let eventData;
|
|
11816
11909
|
if (state.events) {
|
|
@@ -11900,7 +11993,7 @@ ${input.slice(result.pos)}
|
|
|
11900
11993
|
return result;
|
|
11901
11994
|
}
|
|
11902
11995
|
}
|
|
11903
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
11996
|
+
var TemplateCharacters$0 = $TR($EXPECT($R33, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11904
11997
|
return { $loc, token: $0 };
|
|
11905
11998
|
});
|
|
11906
11999
|
function TemplateCharacters(state) {
|
|
@@ -11925,7 +12018,7 @@ ${input.slice(result.pos)}
|
|
|
11925
12018
|
return result;
|
|
11926
12019
|
}
|
|
11927
12020
|
}
|
|
11928
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
12021
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R34, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11929
12022
|
return { $loc, token: $0 };
|
|
11930
12023
|
});
|
|
11931
12024
|
function TemplateBlockCharacters(state) {
|
|
@@ -11950,11 +12043,11 @@ ${input.slice(result.pos)}
|
|
|
11950
12043
|
return result;
|
|
11951
12044
|
}
|
|
11952
12045
|
}
|
|
11953
|
-
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($
|
|
11954
|
-
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($
|
|
11955
|
-
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($
|
|
11956
|
-
var ReservedWord$3 = $S(CoffeeOfEnabled, $R$0($EXPECT($
|
|
11957
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
12046
|
+
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R35, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
|
|
12047
|
+
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($R36, fail, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")));
|
|
12048
|
+
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($R37, fail, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")));
|
|
12049
|
+
var ReservedWord$3 = $S(CoffeeOfEnabled, $R$0($EXPECT($R38, fail, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")));
|
|
12050
|
+
var ReservedWord$4 = $R$0($EXPECT($R39, fail, "ReservedWord /(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
11958
12051
|
function ReservedWord(state) {
|
|
11959
12052
|
let eventData;
|
|
11960
12053
|
if (state.events) {
|
|
@@ -12025,7 +12118,7 @@ ${input.slice(result.pos)}
|
|
|
12025
12118
|
return result;
|
|
12026
12119
|
}
|
|
12027
12120
|
}
|
|
12028
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
12121
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R40, fail, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12029
12122
|
return { $loc, token: $0 };
|
|
12030
12123
|
});
|
|
12031
12124
|
function JSSingleLineComment(state) {
|
|
@@ -12074,7 +12167,7 @@ ${input.slice(result.pos)}
|
|
|
12074
12167
|
return result;
|
|
12075
12168
|
}
|
|
12076
12169
|
}
|
|
12077
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12170
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L92, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L93, fail, 'JSMultiLineComment "*/"')), $EXPECT($R41, fail, "JSMultiLineComment /./"))), $EXPECT($L93, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
12078
12171
|
return { $loc, token: $1 };
|
|
12079
12172
|
});
|
|
12080
12173
|
function JSMultiLineComment(state) {
|
|
@@ -12099,7 +12192,7 @@ ${input.slice(result.pos)}
|
|
|
12099
12192
|
return result;
|
|
12100
12193
|
}
|
|
12101
12194
|
}
|
|
12102
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
12195
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R42, fail, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12103
12196
|
return { $loc, token: `//${$1}` };
|
|
12104
12197
|
});
|
|
12105
12198
|
function CoffeeSingleLineComment(state) {
|
|
@@ -12124,7 +12217,7 @@ ${input.slice(result.pos)}
|
|
|
12124
12217
|
return result;
|
|
12125
12218
|
}
|
|
12126
12219
|
}
|
|
12127
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
12220
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R43, fail, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
12128
12221
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
12129
12222
|
return { $loc, token: `/*${$2}*/` };
|
|
12130
12223
|
});
|
|
@@ -12150,7 +12243,7 @@ ${input.slice(result.pos)}
|
|
|
12150
12243
|
return result;
|
|
12151
12244
|
}
|
|
12152
12245
|
}
|
|
12153
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
12246
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R44, fail, "CoffeeHereCommentStart /###(?!#)/"));
|
|
12154
12247
|
function CoffeeHereCommentStart(state) {
|
|
12155
12248
|
let eventData;
|
|
12156
12249
|
if (state.events) {
|
|
@@ -12173,7 +12266,7 @@ ${input.slice(result.pos)}
|
|
|
12173
12266
|
return result;
|
|
12174
12267
|
}
|
|
12175
12268
|
}
|
|
12176
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12269
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L92, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L93, fail, 'InlineComment "*/"')), $EXPECT($R45, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L93, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
12177
12270
|
return { $loc, token: $1 };
|
|
12178
12271
|
});
|
|
12179
12272
|
function InlineComment(state) {
|
|
@@ -12269,10 +12362,10 @@ ${input.slice(result.pos)}
|
|
|
12269
12362
|
return result;
|
|
12270
12363
|
}
|
|
12271
12364
|
}
|
|
12272
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
12365
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R46, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12273
12366
|
return { $loc, token: $0 };
|
|
12274
12367
|
});
|
|
12275
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
12368
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L94, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
12276
12369
|
return "";
|
|
12277
12370
|
});
|
|
12278
12371
|
function NonNewlineWhitespace(state) {
|
|
@@ -12346,7 +12439,7 @@ ${input.slice(result.pos)}
|
|
|
12346
12439
|
return result;
|
|
12347
12440
|
}
|
|
12348
12441
|
}
|
|
12349
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
12442
|
+
var Whitespace$0 = $TR($EXPECT($R27, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12350
12443
|
return { $loc, token: $0 };
|
|
12351
12444
|
});
|
|
12352
12445
|
function Whitespace(state) {
|
|
@@ -12424,7 +12517,7 @@ ${input.slice(result.pos)}
|
|
|
12424
12517
|
}
|
|
12425
12518
|
}
|
|
12426
12519
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
12427
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($
|
|
12520
|
+
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($L95, fail, 'StatementDelimiter "["'), $EXPECT($L96, fail, 'StatementDelimiter "`"'), $EXPECT($L57, fail, 'StatementDelimiter "+"'), $EXPECT($L16, fail, 'StatementDelimiter "-"'), $EXPECT($L53, fail, 'StatementDelimiter "*"'), $EXPECT($L54, fail, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L2, fail, 'StatementDelimiter "("'))))), InsertSemicolon);
|
|
12428
12521
|
var StatementDelimiter$2 = $Y(EOS);
|
|
12429
12522
|
function StatementDelimiter(state) {
|
|
12430
12523
|
let eventData;
|
|
@@ -12476,7 +12569,7 @@ ${input.slice(result.pos)}
|
|
|
12476
12569
|
return result;
|
|
12477
12570
|
}
|
|
12478
12571
|
}
|
|
12479
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
12572
|
+
var NonIdContinue$0 = $R$0($EXPECT($R47, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
12480
12573
|
function NonIdContinue(state) {
|
|
12481
12574
|
let eventData;
|
|
12482
12575
|
if (state.events) {
|
|
@@ -12499,7 +12592,7 @@ ${input.slice(result.pos)}
|
|
|
12499
12592
|
return result;
|
|
12500
12593
|
}
|
|
12501
12594
|
}
|
|
12502
|
-
var Loc$0 = $TV($EXPECT($
|
|
12595
|
+
var Loc$0 = $TV($EXPECT($L18, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
12503
12596
|
return { $loc, token: "" };
|
|
12504
12597
|
});
|
|
12505
12598
|
function Loc(state) {
|
|
@@ -12524,7 +12617,7 @@ ${input.slice(result.pos)}
|
|
|
12524
12617
|
return result;
|
|
12525
12618
|
}
|
|
12526
12619
|
}
|
|
12527
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
12620
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L97, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L8, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
12528
12621
|
return { $loc, token: $1, ts: true };
|
|
12529
12622
|
});
|
|
12530
12623
|
function Abstract(state) {
|
|
@@ -12549,7 +12642,7 @@ ${input.slice(result.pos)}
|
|
|
12549
12642
|
return result;
|
|
12550
12643
|
}
|
|
12551
12644
|
}
|
|
12552
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
12645
|
+
var Ampersand$0 = $TV($EXPECT($L82, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
12553
12646
|
return { $loc, token: $1 };
|
|
12554
12647
|
});
|
|
12555
12648
|
function Ampersand(state) {
|
|
@@ -12574,7 +12667,7 @@ ${input.slice(result.pos)}
|
|
|
12574
12667
|
return result;
|
|
12575
12668
|
}
|
|
12576
12669
|
}
|
|
12577
|
-
var As$0 = $TS($S($EXPECT($
|
|
12670
|
+
var As$0 = $TS($S($EXPECT($L98, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12578
12671
|
return { $loc, token: $1 };
|
|
12579
12672
|
});
|
|
12580
12673
|
function As(state) {
|
|
@@ -12599,7 +12692,7 @@ ${input.slice(result.pos)}
|
|
|
12599
12692
|
return result;
|
|
12600
12693
|
}
|
|
12601
12694
|
}
|
|
12602
|
-
var At$0 = $TV($EXPECT($
|
|
12695
|
+
var At$0 = $TV($EXPECT($L99, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
12603
12696
|
return { $loc, token: $1 };
|
|
12604
12697
|
});
|
|
12605
12698
|
function At(state) {
|
|
@@ -12624,7 +12717,7 @@ ${input.slice(result.pos)}
|
|
|
12624
12717
|
return result;
|
|
12625
12718
|
}
|
|
12626
12719
|
}
|
|
12627
|
-
var AtAt$0 = $TV($EXPECT($
|
|
12720
|
+
var AtAt$0 = $TV($EXPECT($L100, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
12628
12721
|
return { $loc, token: "@" };
|
|
12629
12722
|
});
|
|
12630
12723
|
function AtAt(state) {
|
|
@@ -12649,7 +12742,7 @@ ${input.slice(result.pos)}
|
|
|
12649
12742
|
return result;
|
|
12650
12743
|
}
|
|
12651
12744
|
}
|
|
12652
|
-
var Async$0 = $TS($S($EXPECT($
|
|
12745
|
+
var Async$0 = $TS($S($EXPECT($L101, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12653
12746
|
return { $loc, token: $1, type: "Async" };
|
|
12654
12747
|
});
|
|
12655
12748
|
function Async(state) {
|
|
@@ -12674,7 +12767,7 @@ ${input.slice(result.pos)}
|
|
|
12674
12767
|
return result;
|
|
12675
12768
|
}
|
|
12676
12769
|
}
|
|
12677
|
-
var Await$0 = $TS($S($EXPECT($
|
|
12770
|
+
var Await$0 = $TS($S($EXPECT($L102, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12678
12771
|
return { $loc, token: $1 };
|
|
12679
12772
|
});
|
|
12680
12773
|
function Await(state) {
|
|
@@ -12699,7 +12792,7 @@ ${input.slice(result.pos)}
|
|
|
12699
12792
|
return result;
|
|
12700
12793
|
}
|
|
12701
12794
|
}
|
|
12702
|
-
var Backtick$0 = $TV($EXPECT($
|
|
12795
|
+
var Backtick$0 = $TV($EXPECT($L96, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
12703
12796
|
return { $loc, token: $1 };
|
|
12704
12797
|
});
|
|
12705
12798
|
function Backtick(state) {
|
|
@@ -12724,7 +12817,7 @@ ${input.slice(result.pos)}
|
|
|
12724
12817
|
return result;
|
|
12725
12818
|
}
|
|
12726
12819
|
}
|
|
12727
|
-
var By$0 = $TS($S($EXPECT($
|
|
12820
|
+
var By$0 = $TS($S($EXPECT($L103, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12728
12821
|
return { $loc, token: $1 };
|
|
12729
12822
|
});
|
|
12730
12823
|
function By(state) {
|
|
@@ -12749,7 +12842,7 @@ ${input.slice(result.pos)}
|
|
|
12749
12842
|
return result;
|
|
12750
12843
|
}
|
|
12751
12844
|
}
|
|
12752
|
-
var Case$0 = $TS($S($EXPECT($
|
|
12845
|
+
var Case$0 = $TS($S($EXPECT($L104, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12753
12846
|
return { $loc, token: $1 };
|
|
12754
12847
|
});
|
|
12755
12848
|
function Case(state) {
|
|
@@ -12774,7 +12867,7 @@ ${input.slice(result.pos)}
|
|
|
12774
12867
|
return result;
|
|
12775
12868
|
}
|
|
12776
12869
|
}
|
|
12777
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
12870
|
+
var Catch$0 = $TS($S($EXPECT($L105, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12778
12871
|
return { $loc, token: $1 };
|
|
12779
12872
|
});
|
|
12780
12873
|
function Catch(state) {
|
|
@@ -12799,7 +12892,7 @@ ${input.slice(result.pos)}
|
|
|
12799
12892
|
return result;
|
|
12800
12893
|
}
|
|
12801
12894
|
}
|
|
12802
|
-
var Class$0 = $TS($S($EXPECT($
|
|
12895
|
+
var Class$0 = $TS($S($EXPECT($L106, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12803
12896
|
return { $loc, token: $1 };
|
|
12804
12897
|
});
|
|
12805
12898
|
function Class(state) {
|
|
@@ -12824,7 +12917,7 @@ ${input.slice(result.pos)}
|
|
|
12824
12917
|
return result;
|
|
12825
12918
|
}
|
|
12826
12919
|
}
|
|
12827
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
12920
|
+
var CloseBrace$0 = $TV($EXPECT($L22, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
12828
12921
|
return { $loc, token: $1 };
|
|
12829
12922
|
});
|
|
12830
12923
|
function CloseBrace(state) {
|
|
@@ -12849,7 +12942,7 @@ ${input.slice(result.pos)}
|
|
|
12849
12942
|
return result;
|
|
12850
12943
|
}
|
|
12851
12944
|
}
|
|
12852
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
12945
|
+
var CloseBracket$0 = $TV($EXPECT($L31, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
12853
12946
|
return { $loc, token: $1 };
|
|
12854
12947
|
});
|
|
12855
12948
|
function CloseBracket(state) {
|
|
@@ -12874,7 +12967,7 @@ ${input.slice(result.pos)}
|
|
|
12874
12967
|
return result;
|
|
12875
12968
|
}
|
|
12876
12969
|
}
|
|
12877
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
12970
|
+
var CloseParen$0 = $TV($EXPECT($L19, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
12878
12971
|
return { $loc, token: $1 };
|
|
12879
12972
|
});
|
|
12880
12973
|
function CloseParen(state) {
|
|
@@ -12899,7 +12992,7 @@ ${input.slice(result.pos)}
|
|
|
12899
12992
|
return result;
|
|
12900
12993
|
}
|
|
12901
12994
|
}
|
|
12902
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
12995
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L107, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
12903
12996
|
return { $loc, token: "${" };
|
|
12904
12997
|
});
|
|
12905
12998
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -12924,7 +13017,7 @@ ${input.slice(result.pos)}
|
|
|
12924
13017
|
return result;
|
|
12925
13018
|
}
|
|
12926
13019
|
}
|
|
12927
|
-
var Colon$0 = $TV($EXPECT($
|
|
13020
|
+
var Colon$0 = $TV($EXPECT($L32, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
12928
13021
|
return { $loc, token: $1 };
|
|
12929
13022
|
});
|
|
12930
13023
|
function Colon(state) {
|
|
@@ -12949,7 +13042,7 @@ ${input.slice(result.pos)}
|
|
|
12949
13042
|
return result;
|
|
12950
13043
|
}
|
|
12951
13044
|
}
|
|
12952
|
-
var Comma$0 = $TV($EXPECT($
|
|
13045
|
+
var Comma$0 = $TV($EXPECT($L20, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
12953
13046
|
return { $loc, token: $1 };
|
|
12954
13047
|
});
|
|
12955
13048
|
function Comma(state) {
|
|
@@ -12974,7 +13067,7 @@ ${input.slice(result.pos)}
|
|
|
12974
13067
|
return result;
|
|
12975
13068
|
}
|
|
12976
13069
|
}
|
|
12977
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
13070
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L99, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
12978
13071
|
return { $loc, token: "constructor" };
|
|
12979
13072
|
});
|
|
12980
13073
|
function ConstructorShorthand(state) {
|
|
@@ -12999,7 +13092,7 @@ ${input.slice(result.pos)}
|
|
|
12999
13092
|
return result;
|
|
13000
13093
|
}
|
|
13001
13094
|
}
|
|
13002
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
13095
|
+
var Declare$0 = $TS($S($EXPECT($L108, fail, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13003
13096
|
return { $loc, token: $1 };
|
|
13004
13097
|
});
|
|
13005
13098
|
function Declare(state) {
|
|
@@ -13024,7 +13117,7 @@ ${input.slice(result.pos)}
|
|
|
13024
13117
|
return result;
|
|
13025
13118
|
}
|
|
13026
13119
|
}
|
|
13027
|
-
var Default$0 = $TS($S($EXPECT($
|
|
13120
|
+
var Default$0 = $TS($S($EXPECT($L109, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13028
13121
|
return { $loc, token: $1 };
|
|
13029
13122
|
});
|
|
13030
13123
|
function Default(state) {
|
|
@@ -13049,7 +13142,7 @@ ${input.slice(result.pos)}
|
|
|
13049
13142
|
return result;
|
|
13050
13143
|
}
|
|
13051
13144
|
}
|
|
13052
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
13145
|
+
var Delete$0 = $TS($S($EXPECT($L110, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13053
13146
|
return { $loc, token: $1 };
|
|
13054
13147
|
});
|
|
13055
13148
|
function Delete(state) {
|
|
@@ -13074,7 +13167,7 @@ ${input.slice(result.pos)}
|
|
|
13074
13167
|
return result;
|
|
13075
13168
|
}
|
|
13076
13169
|
}
|
|
13077
|
-
var Do$0 = $TS($S($EXPECT($
|
|
13170
|
+
var Do$0 = $TS($S($EXPECT($L111, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13078
13171
|
return { $loc, token: $1 };
|
|
13079
13172
|
});
|
|
13080
13173
|
function Do(state) {
|
|
@@ -13124,7 +13217,7 @@ ${input.slice(result.pos)}
|
|
|
13124
13217
|
return result;
|
|
13125
13218
|
}
|
|
13126
13219
|
}
|
|
13127
|
-
var DotDot$0 = $TV($EXPECT($
|
|
13220
|
+
var DotDot$0 = $TV($EXPECT($L112, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
13128
13221
|
return { $loc, token: $1 };
|
|
13129
13222
|
});
|
|
13130
13223
|
function DotDot(state) {
|
|
@@ -13149,7 +13242,7 @@ ${input.slice(result.pos)}
|
|
|
13149
13242
|
return result;
|
|
13150
13243
|
}
|
|
13151
13244
|
}
|
|
13152
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
13245
|
+
var DotDotDot$0 = $TV($EXPECT($L113, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
13153
13246
|
return { $loc, token: $1 };
|
|
13154
13247
|
});
|
|
13155
13248
|
function DotDotDot(state) {
|
|
@@ -13174,7 +13267,7 @@ ${input.slice(result.pos)}
|
|
|
13174
13267
|
return result;
|
|
13175
13268
|
}
|
|
13176
13269
|
}
|
|
13177
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
13270
|
+
var DoubleColon$0 = $TV($EXPECT($L114, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
13178
13271
|
return { $loc, token: $1 };
|
|
13179
13272
|
});
|
|
13180
13273
|
function DoubleColon(state) {
|
|
@@ -13199,7 +13292,7 @@ ${input.slice(result.pos)}
|
|
|
13199
13292
|
return result;
|
|
13200
13293
|
}
|
|
13201
13294
|
}
|
|
13202
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
13295
|
+
var DoubleQuote$0 = $TV($EXPECT($L115, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
13203
13296
|
return { $loc, token: $1 };
|
|
13204
13297
|
});
|
|
13205
13298
|
function DoubleQuote(state) {
|
|
@@ -13224,7 +13317,7 @@ ${input.slice(result.pos)}
|
|
|
13224
13317
|
return result;
|
|
13225
13318
|
}
|
|
13226
13319
|
}
|
|
13227
|
-
var Else$0 = $TS($S($EXPECT($
|
|
13320
|
+
var Else$0 = $TS($S($EXPECT($L116, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13228
13321
|
return { $loc, token: $1 };
|
|
13229
13322
|
});
|
|
13230
13323
|
function Else(state) {
|
|
@@ -13274,7 +13367,7 @@ ${input.slice(result.pos)}
|
|
|
13274
13367
|
return result;
|
|
13275
13368
|
}
|
|
13276
13369
|
}
|
|
13277
|
-
var Export$0 = $TS($S($EXPECT($
|
|
13370
|
+
var Export$0 = $TS($S($EXPECT($L117, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13278
13371
|
return { $loc, token: $1 };
|
|
13279
13372
|
});
|
|
13280
13373
|
function Export(state) {
|
|
@@ -13299,7 +13392,7 @@ ${input.slice(result.pos)}
|
|
|
13299
13392
|
return result;
|
|
13300
13393
|
}
|
|
13301
13394
|
}
|
|
13302
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
13395
|
+
var Extends$0 = $TS($S($EXPECT($L118, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13303
13396
|
return { $loc, token: $1 };
|
|
13304
13397
|
});
|
|
13305
13398
|
function Extends(state) {
|
|
@@ -13324,7 +13417,7 @@ ${input.slice(result.pos)}
|
|
|
13324
13417
|
return result;
|
|
13325
13418
|
}
|
|
13326
13419
|
}
|
|
13327
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
13420
|
+
var Finally$0 = $TS($S($EXPECT($L119, fail, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13328
13421
|
return { $loc, token: $1 };
|
|
13329
13422
|
});
|
|
13330
13423
|
function Finally(state) {
|
|
@@ -13349,7 +13442,7 @@ ${input.slice(result.pos)}
|
|
|
13349
13442
|
return result;
|
|
13350
13443
|
}
|
|
13351
13444
|
}
|
|
13352
|
-
var For$0 = $TS($S($EXPECT($
|
|
13445
|
+
var For$0 = $TS($S($EXPECT($L120, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13353
13446
|
return { $loc, token: $1 };
|
|
13354
13447
|
});
|
|
13355
13448
|
function For(state) {
|
|
@@ -13374,7 +13467,7 @@ ${input.slice(result.pos)}
|
|
|
13374
13467
|
return result;
|
|
13375
13468
|
}
|
|
13376
13469
|
}
|
|
13377
|
-
var From$0 = $TS($S($EXPECT($
|
|
13470
|
+
var From$0 = $TS($S($EXPECT($L121, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13378
13471
|
return { $loc, token: $1 };
|
|
13379
13472
|
});
|
|
13380
13473
|
function From(state) {
|
|
@@ -13399,7 +13492,7 @@ ${input.slice(result.pos)}
|
|
|
13399
13492
|
return result;
|
|
13400
13493
|
}
|
|
13401
13494
|
}
|
|
13402
|
-
var Function$0 = $TS($S($EXPECT($
|
|
13495
|
+
var Function$0 = $TS($S($EXPECT($L122, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13403
13496
|
return { $loc, token: $1 };
|
|
13404
13497
|
});
|
|
13405
13498
|
function Function(state) {
|
|
@@ -13424,7 +13517,7 @@ ${input.slice(result.pos)}
|
|
|
13424
13517
|
return result;
|
|
13425
13518
|
}
|
|
13426
13519
|
}
|
|
13427
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
13520
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L123, fail, 'GetOrSet "get"'), $EXPECT($L124, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13428
13521
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
13429
13522
|
});
|
|
13430
13523
|
function GetOrSet(state) {
|
|
@@ -13449,7 +13542,7 @@ ${input.slice(result.pos)}
|
|
|
13449
13542
|
return result;
|
|
13450
13543
|
}
|
|
13451
13544
|
}
|
|
13452
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
13545
|
+
var If$0 = $TV($TEXT($S($EXPECT($L125, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L8, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
13453
13546
|
return { $loc, token: $1 };
|
|
13454
13547
|
});
|
|
13455
13548
|
function If(state) {
|
|
@@ -13474,7 +13567,7 @@ ${input.slice(result.pos)}
|
|
|
13474
13567
|
return result;
|
|
13475
13568
|
}
|
|
13476
13569
|
}
|
|
13477
|
-
var Import$0 = $TS($S($EXPECT($L13, fail, 'Import "import"'), $Y($EXPECT($
|
|
13570
|
+
var Import$0 = $TS($S($EXPECT($L13, fail, 'Import "import"'), $Y($EXPECT($R48, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
13478
13571
|
return { $loc, token: $1 };
|
|
13479
13572
|
});
|
|
13480
13573
|
function Import(state) {
|
|
@@ -13499,7 +13592,7 @@ ${input.slice(result.pos)}
|
|
|
13499
13592
|
return result;
|
|
13500
13593
|
}
|
|
13501
13594
|
}
|
|
13502
|
-
var In$0 = $TS($S($EXPECT($
|
|
13595
|
+
var In$0 = $TS($S($EXPECT($L80, fail, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13503
13596
|
return { $loc, token: $1 };
|
|
13504
13597
|
});
|
|
13505
13598
|
function In(state) {
|
|
@@ -13524,7 +13617,7 @@ ${input.slice(result.pos)}
|
|
|
13524
13617
|
return result;
|
|
13525
13618
|
}
|
|
13526
13619
|
}
|
|
13527
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
13620
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L126, fail, 'LetOrConst "let"'), $EXPECT($L127, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13528
13621
|
return { $loc, token: $1 };
|
|
13529
13622
|
});
|
|
13530
13623
|
function LetOrConst(state) {
|
|
@@ -13549,7 +13642,7 @@ ${input.slice(result.pos)}
|
|
|
13549
13642
|
return result;
|
|
13550
13643
|
}
|
|
13551
13644
|
}
|
|
13552
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
13645
|
+
var Loop$0 = $TS($S($EXPECT($L128, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13553
13646
|
return { $loc, token: "while(true)" };
|
|
13554
13647
|
});
|
|
13555
13648
|
function Loop(state) {
|
|
@@ -13574,7 +13667,7 @@ ${input.slice(result.pos)}
|
|
|
13574
13667
|
return result;
|
|
13575
13668
|
}
|
|
13576
13669
|
}
|
|
13577
|
-
var New$0 = $TS($S($EXPECT($
|
|
13670
|
+
var New$0 = $TS($S($EXPECT($L129, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13578
13671
|
return { $loc, token: $1 };
|
|
13579
13672
|
});
|
|
13580
13673
|
function New(state) {
|
|
@@ -13599,7 +13692,7 @@ ${input.slice(result.pos)}
|
|
|
13599
13692
|
return result;
|
|
13600
13693
|
}
|
|
13601
13694
|
}
|
|
13602
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
13695
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L51, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L8, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
13603
13696
|
return { $loc, token: "!" };
|
|
13604
13697
|
});
|
|
13605
13698
|
function Not(state) {
|
|
@@ -13624,7 +13717,7 @@ ${input.slice(result.pos)}
|
|
|
13624
13717
|
return result;
|
|
13625
13718
|
}
|
|
13626
13719
|
}
|
|
13627
|
-
var Of$0 = $TS($S($EXPECT($
|
|
13720
|
+
var Of$0 = $TS($S($EXPECT($L72, fail, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13628
13721
|
return { $loc, token: $1 };
|
|
13629
13722
|
});
|
|
13630
13723
|
function Of(state) {
|
|
@@ -13649,7 +13742,7 @@ ${input.slice(result.pos)}
|
|
|
13649
13742
|
return result;
|
|
13650
13743
|
}
|
|
13651
13744
|
}
|
|
13652
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
13745
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L130, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
13653
13746
|
return { $loc, token: $1 };
|
|
13654
13747
|
});
|
|
13655
13748
|
function OpenAngleBracket(state) {
|
|
@@ -13674,7 +13767,7 @@ ${input.slice(result.pos)}
|
|
|
13674
13767
|
return result;
|
|
13675
13768
|
}
|
|
13676
13769
|
}
|
|
13677
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
13770
|
+
var OpenBrace$0 = $TV($EXPECT($L131, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
13678
13771
|
return { $loc, token: $1 };
|
|
13679
13772
|
});
|
|
13680
13773
|
function OpenBrace(state) {
|
|
@@ -13699,7 +13792,7 @@ ${input.slice(result.pos)}
|
|
|
13699
13792
|
return result;
|
|
13700
13793
|
}
|
|
13701
13794
|
}
|
|
13702
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
13795
|
+
var OpenBracket$0 = $TV($EXPECT($L95, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
13703
13796
|
return { $loc, token: $1 };
|
|
13704
13797
|
});
|
|
13705
13798
|
function OpenBracket(state) {
|
|
@@ -13749,7 +13842,7 @@ ${input.slice(result.pos)}
|
|
|
13749
13842
|
return result;
|
|
13750
13843
|
}
|
|
13751
13844
|
}
|
|
13752
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
13845
|
+
var Operator$0 = $TS($S($EXPECT($L132, fail, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13753
13846
|
return { $loc, token: $1 };
|
|
13754
13847
|
});
|
|
13755
13848
|
function Operator(state) {
|
|
@@ -13774,7 +13867,7 @@ ${input.slice(result.pos)}
|
|
|
13774
13867
|
return result;
|
|
13775
13868
|
}
|
|
13776
13869
|
}
|
|
13777
|
-
var Public$0 = $TS($S($EXPECT($
|
|
13870
|
+
var Public$0 = $TS($S($EXPECT($L133, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13778
13871
|
return { $loc, token: $1 };
|
|
13779
13872
|
});
|
|
13780
13873
|
function Public(state) {
|
|
@@ -13799,7 +13892,7 @@ ${input.slice(result.pos)}
|
|
|
13799
13892
|
return result;
|
|
13800
13893
|
}
|
|
13801
13894
|
}
|
|
13802
|
-
var Private$0 = $TS($S($EXPECT($
|
|
13895
|
+
var Private$0 = $TS($S($EXPECT($L134, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13803
13896
|
return { $loc, token: $1 };
|
|
13804
13897
|
});
|
|
13805
13898
|
function Private(state) {
|
|
@@ -13824,7 +13917,7 @@ ${input.slice(result.pos)}
|
|
|
13824
13917
|
return result;
|
|
13825
13918
|
}
|
|
13826
13919
|
}
|
|
13827
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
13920
|
+
var Protected$0 = $TS($S($EXPECT($L135, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13828
13921
|
return { $loc, token: $1 };
|
|
13829
13922
|
});
|
|
13830
13923
|
function Protected(state) {
|
|
@@ -13849,7 +13942,13 @@ ${input.slice(result.pos)}
|
|
|
13849
13942
|
return result;
|
|
13850
13943
|
}
|
|
13851
13944
|
}
|
|
13852
|
-
var Pipe$0 = $TV($EXPECT($
|
|
13945
|
+
var Pipe$0 = $TV($EXPECT($L136, fail, 'Pipe "||>"'), function($skip, $loc, $0, $1) {
|
|
13946
|
+
return { $loc, token: $1 };
|
|
13947
|
+
});
|
|
13948
|
+
var Pipe$1 = $TV($EXPECT($L137, fail, 'Pipe "|>="'), function($skip, $loc, $0, $1) {
|
|
13949
|
+
return { $loc, token: $1 };
|
|
13950
|
+
});
|
|
13951
|
+
var Pipe$2 = $TV($EXPECT($L138, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
13853
13952
|
return { $loc, token: $1 };
|
|
13854
13953
|
});
|
|
13855
13954
|
function Pipe(state) {
|
|
@@ -13863,12 +13962,12 @@ ${input.slice(result.pos)}
|
|
|
13863
13962
|
}
|
|
13864
13963
|
}
|
|
13865
13964
|
if (state.tokenize) {
|
|
13866
|
-
const result = $TOKEN("Pipe", state, Pipe$0(state));
|
|
13965
|
+
const result = $TOKEN("Pipe", state, Pipe$0(state) || Pipe$1(state) || Pipe$2(state));
|
|
13867
13966
|
if (state.events)
|
|
13868
13967
|
state.events.exit?.("Pipe", state, result, eventData);
|
|
13869
13968
|
return result;
|
|
13870
13969
|
} else {
|
|
13871
|
-
const result = Pipe$0(state);
|
|
13970
|
+
const result = Pipe$0(state) || Pipe$1(state) || Pipe$2(state);
|
|
13872
13971
|
if (state.events)
|
|
13873
13972
|
state.events.exit?.("Pipe", state, result, eventData);
|
|
13874
13973
|
return result;
|
|
@@ -13899,7 +13998,7 @@ ${input.slice(result.pos)}
|
|
|
13899
13998
|
return result;
|
|
13900
13999
|
}
|
|
13901
14000
|
}
|
|
13902
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
14001
|
+
var Readonly$0 = $TS($S($EXPECT($L139, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13903
14002
|
return { $loc, token: $1, ts: true };
|
|
13904
14003
|
});
|
|
13905
14004
|
function Readonly(state) {
|
|
@@ -13924,7 +14023,7 @@ ${input.slice(result.pos)}
|
|
|
13924
14023
|
return result;
|
|
13925
14024
|
}
|
|
13926
14025
|
}
|
|
13927
|
-
var Return$0 = $TS($S($EXPECT($
|
|
14026
|
+
var Return$0 = $TS($S($EXPECT($L140, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13928
14027
|
return { $loc, token: $1 };
|
|
13929
14028
|
});
|
|
13930
14029
|
function Return(state) {
|
|
@@ -13949,7 +14048,7 @@ ${input.slice(result.pos)}
|
|
|
13949
14048
|
return result;
|
|
13950
14049
|
}
|
|
13951
14050
|
}
|
|
13952
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
14051
|
+
var Satisfies$0 = $TS($S($EXPECT($L141, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13953
14052
|
return { $loc, token: $1 };
|
|
13954
14053
|
});
|
|
13955
14054
|
function Satisfies(state) {
|
|
@@ -13974,7 +14073,7 @@ ${input.slice(result.pos)}
|
|
|
13974
14073
|
return result;
|
|
13975
14074
|
}
|
|
13976
14075
|
}
|
|
13977
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
14076
|
+
var Semicolon$0 = $TV($EXPECT($L84, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
13978
14077
|
return { $loc, token: $1 };
|
|
13979
14078
|
});
|
|
13980
14079
|
function Semicolon(state) {
|
|
@@ -13999,7 +14098,7 @@ ${input.slice(result.pos)}
|
|
|
13999
14098
|
return result;
|
|
14000
14099
|
}
|
|
14001
14100
|
}
|
|
14002
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
14101
|
+
var SingleQuote$0 = $TV($EXPECT($L142, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
14003
14102
|
return { $loc, token: $1 };
|
|
14004
14103
|
});
|
|
14005
14104
|
function SingleQuote(state) {
|
|
@@ -14024,7 +14123,7 @@ ${input.slice(result.pos)}
|
|
|
14024
14123
|
return result;
|
|
14025
14124
|
}
|
|
14026
14125
|
}
|
|
14027
|
-
var Star$0 = $TV($EXPECT($
|
|
14126
|
+
var Star$0 = $TV($EXPECT($L53, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
14028
14127
|
return { $loc, token: $1 };
|
|
14029
14128
|
});
|
|
14030
14129
|
function Star(state) {
|
|
@@ -14049,10 +14148,10 @@ ${input.slice(result.pos)}
|
|
|
14049
14148
|
return result;
|
|
14050
14149
|
}
|
|
14051
14150
|
}
|
|
14052
|
-
var Static$0 = $TS($S($EXPECT($
|
|
14151
|
+
var Static$0 = $TS($S($EXPECT($L143, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14053
14152
|
return { $loc, token: $1 };
|
|
14054
14153
|
});
|
|
14055
|
-
var Static$1 = $TS($S($EXPECT($
|
|
14154
|
+
var Static$1 = $TS($S($EXPECT($L99, fail, 'Static "@"'), $N($C($EXPECT($L2, fail, 'Static "("'), $EXPECT($L99, fail, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
14056
14155
|
return { $loc, token: "static " };
|
|
14057
14156
|
});
|
|
14058
14157
|
function Static(state) {
|
|
@@ -14077,7 +14176,7 @@ ${input.slice(result.pos)}
|
|
|
14077
14176
|
return result;
|
|
14078
14177
|
}
|
|
14079
14178
|
}
|
|
14080
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
14179
|
+
var SubstitutionStart$0 = $TV($EXPECT($L144, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
14081
14180
|
return { $loc, token: $1 };
|
|
14082
14181
|
});
|
|
14083
14182
|
function SubstitutionStart(state) {
|
|
@@ -14102,7 +14201,7 @@ ${input.slice(result.pos)}
|
|
|
14102
14201
|
return result;
|
|
14103
14202
|
}
|
|
14104
14203
|
}
|
|
14105
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
14204
|
+
var Switch$0 = $TS($S($EXPECT($L145, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14106
14205
|
return { $loc, token: $1 };
|
|
14107
14206
|
});
|
|
14108
14207
|
function Switch(state) {
|
|
@@ -14127,7 +14226,7 @@ ${input.slice(result.pos)}
|
|
|
14127
14226
|
return result;
|
|
14128
14227
|
}
|
|
14129
14228
|
}
|
|
14130
|
-
var Target$0 = $TS($S($EXPECT($
|
|
14229
|
+
var Target$0 = $TS($S($EXPECT($L146, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14131
14230
|
return { $loc, token: $1 };
|
|
14132
14231
|
});
|
|
14133
14232
|
function Target(state) {
|
|
@@ -14152,7 +14251,7 @@ ${input.slice(result.pos)}
|
|
|
14152
14251
|
return result;
|
|
14153
14252
|
}
|
|
14154
14253
|
}
|
|
14155
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
14254
|
+
var Then$0 = $TS($S(__, $EXPECT($L147, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
14156
14255
|
return { $loc, token: "" };
|
|
14157
14256
|
});
|
|
14158
14257
|
function Then(state) {
|
|
@@ -14177,7 +14276,7 @@ ${input.slice(result.pos)}
|
|
|
14177
14276
|
return result;
|
|
14178
14277
|
}
|
|
14179
14278
|
}
|
|
14180
|
-
var This$0 = $TS($S($EXPECT($
|
|
14279
|
+
var This$0 = $TS($S($EXPECT($L148, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14181
14280
|
return { $loc, token: $1 };
|
|
14182
14281
|
});
|
|
14183
14282
|
function This(state) {
|
|
@@ -14202,7 +14301,7 @@ ${input.slice(result.pos)}
|
|
|
14202
14301
|
return result;
|
|
14203
14302
|
}
|
|
14204
14303
|
}
|
|
14205
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
14304
|
+
var Throw$0 = $TS($S($EXPECT($L149, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14206
14305
|
return { $loc, token: $1 };
|
|
14207
14306
|
});
|
|
14208
14307
|
function Throw(state) {
|
|
@@ -14227,7 +14326,7 @@ ${input.slice(result.pos)}
|
|
|
14227
14326
|
return result;
|
|
14228
14327
|
}
|
|
14229
14328
|
}
|
|
14230
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
14329
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L150, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
14231
14330
|
return { $loc, token: "`" };
|
|
14232
14331
|
});
|
|
14233
14332
|
function TripleDoubleQuote(state) {
|
|
@@ -14252,7 +14351,7 @@ ${input.slice(result.pos)}
|
|
|
14252
14351
|
return result;
|
|
14253
14352
|
}
|
|
14254
14353
|
}
|
|
14255
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
14354
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L151, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
14256
14355
|
return { $loc, token: "`" };
|
|
14257
14356
|
});
|
|
14258
14357
|
function TripleSingleQuote(state) {
|
|
@@ -14277,7 +14376,7 @@ ${input.slice(result.pos)}
|
|
|
14277
14376
|
return result;
|
|
14278
14377
|
}
|
|
14279
14378
|
}
|
|
14280
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
14379
|
+
var TripleSlash$0 = $TV($EXPECT($L152, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
14281
14380
|
return { $loc, token: "/" };
|
|
14282
14381
|
});
|
|
14283
14382
|
function TripleSlash(state) {
|
|
@@ -14302,7 +14401,7 @@ ${input.slice(result.pos)}
|
|
|
14302
14401
|
return result;
|
|
14303
14402
|
}
|
|
14304
14403
|
}
|
|
14305
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
14404
|
+
var TripleTick$0 = $TV($EXPECT($L153, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
14306
14405
|
return { $loc, token: "`" };
|
|
14307
14406
|
});
|
|
14308
14407
|
function TripleTick(state) {
|
|
@@ -14327,7 +14426,7 @@ ${input.slice(result.pos)}
|
|
|
14327
14426
|
return result;
|
|
14328
14427
|
}
|
|
14329
14428
|
}
|
|
14330
|
-
var Try$0 = $TS($S($EXPECT($
|
|
14429
|
+
var Try$0 = $TS($S($EXPECT($L154, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14331
14430
|
return { $loc, token: $1 };
|
|
14332
14431
|
});
|
|
14333
14432
|
function Try(state) {
|
|
@@ -14352,7 +14451,7 @@ ${input.slice(result.pos)}
|
|
|
14352
14451
|
return result;
|
|
14353
14452
|
}
|
|
14354
14453
|
}
|
|
14355
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
14454
|
+
var Typeof$0 = $TS($S($EXPECT($L155, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14356
14455
|
return { $loc, token: $1 };
|
|
14357
14456
|
});
|
|
14358
14457
|
function Typeof(state) {
|
|
@@ -14377,7 +14476,7 @@ ${input.slice(result.pos)}
|
|
|
14377
14476
|
return result;
|
|
14378
14477
|
}
|
|
14379
14478
|
}
|
|
14380
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
14479
|
+
var Unless$0 = $TS($S($EXPECT($L156, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14381
14480
|
return { $loc, token: $1 };
|
|
14382
14481
|
});
|
|
14383
14482
|
function Unless(state) {
|
|
@@ -14402,7 +14501,7 @@ ${input.slice(result.pos)}
|
|
|
14402
14501
|
return result;
|
|
14403
14502
|
}
|
|
14404
14503
|
}
|
|
14405
|
-
var Until$0 = $TS($S($EXPECT($
|
|
14504
|
+
var Until$0 = $TS($S($EXPECT($L157, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14406
14505
|
return { $loc, token: $1 };
|
|
14407
14506
|
});
|
|
14408
14507
|
function Until(state) {
|
|
@@ -14427,7 +14526,7 @@ ${input.slice(result.pos)}
|
|
|
14427
14526
|
return result;
|
|
14428
14527
|
}
|
|
14429
14528
|
}
|
|
14430
|
-
var Var$0 = $TS($S($EXPECT($
|
|
14529
|
+
var Var$0 = $TS($S($EXPECT($L158, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14431
14530
|
return { $loc, token: $1 };
|
|
14432
14531
|
});
|
|
14433
14532
|
function Var(state) {
|
|
@@ -14452,7 +14551,7 @@ ${input.slice(result.pos)}
|
|
|
14452
14551
|
return result;
|
|
14453
14552
|
}
|
|
14454
14553
|
}
|
|
14455
|
-
var Void$0 = $TS($S($EXPECT($
|
|
14554
|
+
var Void$0 = $TS($S($EXPECT($L159, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14456
14555
|
return { $loc, token: $1 };
|
|
14457
14556
|
});
|
|
14458
14557
|
function Void(state) {
|
|
@@ -14477,7 +14576,7 @@ ${input.slice(result.pos)}
|
|
|
14477
14576
|
return result;
|
|
14478
14577
|
}
|
|
14479
14578
|
}
|
|
14480
|
-
var When$0 = $TS($S($EXPECT($
|
|
14579
|
+
var When$0 = $TS($S($EXPECT($L160, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14481
14580
|
return { $loc, token: "case" };
|
|
14482
14581
|
});
|
|
14483
14582
|
function When(state) {
|
|
@@ -14502,7 +14601,7 @@ ${input.slice(result.pos)}
|
|
|
14502
14601
|
return result;
|
|
14503
14602
|
}
|
|
14504
14603
|
}
|
|
14505
|
-
var While$0 = $TS($S($EXPECT($
|
|
14604
|
+
var While$0 = $TS($S($EXPECT($L161, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14506
14605
|
return { $loc, token: $1 };
|
|
14507
14606
|
});
|
|
14508
14607
|
function While(state) {
|
|
@@ -14527,7 +14626,7 @@ ${input.slice(result.pos)}
|
|
|
14527
14626
|
return result;
|
|
14528
14627
|
}
|
|
14529
14628
|
}
|
|
14530
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
14629
|
+
var Yield$0 = $TS($S($EXPECT($L162, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14531
14630
|
return { $loc, token: $1 };
|
|
14532
14631
|
});
|
|
14533
14632
|
function Yield(state) {
|
|
@@ -14673,7 +14772,7 @@ ${input.slice(result.pos)}
|
|
|
14673
14772
|
return result;
|
|
14674
14773
|
}
|
|
14675
14774
|
}
|
|
14676
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
14775
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L130, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L163, fail, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
14677
14776
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
14678
14777
|
});
|
|
14679
14778
|
function JSXSelfClosingElement(state) {
|
|
@@ -14724,7 +14823,7 @@ ${input.slice(result.pos)}
|
|
|
14724
14823
|
return result;
|
|
14725
14824
|
}
|
|
14726
14825
|
}
|
|
14727
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
14826
|
+
var JSXOpeningElement$0 = $S($EXPECT($L130, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L30, fail, 'JSXOpeningElement ">"'));
|
|
14728
14827
|
function JSXOpeningElement(state) {
|
|
14729
14828
|
let eventData;
|
|
14730
14829
|
if (state.events) {
|
|
@@ -14753,7 +14852,7 @@ ${input.slice(result.pos)}
|
|
|
14753
14852
|
return $skip;
|
|
14754
14853
|
return $0;
|
|
14755
14854
|
});
|
|
14756
|
-
var JSXOptionalClosingElement$1 = $EXPECT($
|
|
14855
|
+
var JSXOptionalClosingElement$1 = $EXPECT($L18, fail, 'JSXOptionalClosingElement ""');
|
|
14757
14856
|
function JSXOptionalClosingElement(state) {
|
|
14758
14857
|
let eventData;
|
|
14759
14858
|
if (state.events) {
|
|
@@ -14776,7 +14875,7 @@ ${input.slice(result.pos)}
|
|
|
14776
14875
|
return result;
|
|
14777
14876
|
}
|
|
14778
14877
|
}
|
|
14779
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
14878
|
+
var JSXClosingElement$0 = $S($EXPECT($L164, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L30, fail, 'JSXClosingElement ">"'));
|
|
14780
14879
|
function JSXClosingElement(state) {
|
|
14781
14880
|
let eventData;
|
|
14782
14881
|
if (state.events) {
|
|
@@ -14815,7 +14914,7 @@ ${input.slice(result.pos)}
|
|
|
14815
14914
|
];
|
|
14816
14915
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
14817
14916
|
});
|
|
14818
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
14917
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L165, fail, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
14819
14918
|
var children = $3;
|
|
14820
14919
|
$0 = $0.slice(1);
|
|
14821
14920
|
return {
|
|
@@ -14846,7 +14945,7 @@ ${input.slice(result.pos)}
|
|
|
14846
14945
|
return result;
|
|
14847
14946
|
}
|
|
14848
14947
|
}
|
|
14849
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
14948
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L165, fail, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
14850
14949
|
module.JSXTagStack.push("");
|
|
14851
14950
|
return $1;
|
|
14852
14951
|
});
|
|
@@ -14877,7 +14976,7 @@ ${input.slice(result.pos)}
|
|
|
14877
14976
|
return $skip;
|
|
14878
14977
|
return $0;
|
|
14879
14978
|
});
|
|
14880
|
-
var JSXOptionalClosingFragment$1 = $EXPECT($
|
|
14979
|
+
var JSXOptionalClosingFragment$1 = $EXPECT($L18, fail, 'JSXOptionalClosingFragment ""');
|
|
14881
14980
|
function JSXOptionalClosingFragment(state) {
|
|
14882
14981
|
let eventData;
|
|
14883
14982
|
if (state.events) {
|
|
@@ -14900,7 +14999,7 @@ ${input.slice(result.pos)}
|
|
|
14900
14999
|
return result;
|
|
14901
15000
|
}
|
|
14902
15001
|
}
|
|
14903
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
15002
|
+
var JSXClosingFragment$0 = $EXPECT($L166, fail, 'JSXClosingFragment "</>"');
|
|
14904
15003
|
function JSXClosingFragment(state) {
|
|
14905
15004
|
let eventData;
|
|
14906
15005
|
if (state.events) {
|
|
@@ -14946,7 +15045,7 @@ ${input.slice(result.pos)}
|
|
|
14946
15045
|
return result;
|
|
14947
15046
|
}
|
|
14948
15047
|
}
|
|
14949
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
15048
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R49, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
14950
15049
|
function JSXIdentifierName(state) {
|
|
14951
15050
|
let eventData;
|
|
14952
15051
|
if (state.events) {
|
|
@@ -15089,7 +15188,7 @@ ${input.slice(result.pos)}
|
|
|
15089
15188
|
}
|
|
15090
15189
|
break;
|
|
15091
15190
|
case "SpreadProperty":
|
|
15092
|
-
parts.push(["{", part.value, "}"]);
|
|
15191
|
+
parts.push(["{", part.dots, part.value, "}"]);
|
|
15093
15192
|
break;
|
|
15094
15193
|
case "MethodDefinition":
|
|
15095
15194
|
try {
|
|
@@ -15162,7 +15261,7 @@ ${input.slice(result.pos)}
|
|
|
15162
15261
|
return result;
|
|
15163
15262
|
}
|
|
15164
15263
|
}
|
|
15165
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
15264
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R50, fail, "JSXAttributeSpace /[\\s>]/"));
|
|
15166
15265
|
function JSXAttributeSpace(state) {
|
|
15167
15266
|
let eventData;
|
|
15168
15267
|
if (state.events) {
|
|
@@ -15185,7 +15284,7 @@ ${input.slice(result.pos)}
|
|
|
15185
15284
|
return result;
|
|
15186
15285
|
}
|
|
15187
15286
|
}
|
|
15188
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
15287
|
+
var JSXShorthandString$0 = $TR($EXPECT($R51, fail, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15189
15288
|
return module.quoteString($0);
|
|
15190
15289
|
});
|
|
15191
15290
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -15321,7 +15420,7 @@ ${input.slice(result.pos)}
|
|
|
15321
15420
|
return result;
|
|
15322
15421
|
}
|
|
15323
15422
|
}
|
|
15324
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
15423
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R52, fail, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
15325
15424
|
var op = $2;
|
|
15326
15425
|
var rhs = $3;
|
|
15327
15426
|
return [[], op, [], rhs];
|
|
@@ -15376,7 +15475,7 @@ ${input.slice(result.pos)}
|
|
|
15376
15475
|
return result;
|
|
15377
15476
|
}
|
|
15378
15477
|
}
|
|
15379
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
15478
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R8, fail, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15380
15479
|
return { $loc, token: $0 };
|
|
15381
15480
|
});
|
|
15382
15481
|
function InlineJSXUnaryOp(state) {
|
|
@@ -15667,7 +15766,7 @@ ${input.slice(result.pos)}
|
|
|
15667
15766
|
}
|
|
15668
15767
|
return $skip;
|
|
15669
15768
|
});
|
|
15670
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
15769
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L22, fail, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
15671
15770
|
return { children: [], jsxChildren: [] };
|
|
15672
15771
|
});
|
|
15673
15772
|
function JSXNestedChildren(state) {
|
|
@@ -15796,7 +15895,7 @@ ${input.slice(result.pos)}
|
|
|
15796
15895
|
return result;
|
|
15797
15896
|
}
|
|
15798
15897
|
}
|
|
15799
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
15898
|
+
var JSXComment$0 = $TS($S($EXPECT($L167, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L168, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
15800
15899
|
return ["{/*", $2, "*/}"];
|
|
15801
15900
|
});
|
|
15802
15901
|
function JSXComment(state) {
|
|
@@ -15821,7 +15920,7 @@ ${input.slice(result.pos)}
|
|
|
15821
15920
|
return result;
|
|
15822
15921
|
}
|
|
15823
15922
|
}
|
|
15824
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
15923
|
+
var JSXCommentContent$0 = $TR($EXPECT($R53, fail, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15825
15924
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
15826
15925
|
});
|
|
15827
15926
|
function JSXCommentContent(state) {
|
|
@@ -15846,7 +15945,7 @@ ${input.slice(result.pos)}
|
|
|
15846
15945
|
return result;
|
|
15847
15946
|
}
|
|
15848
15947
|
}
|
|
15849
|
-
var JSXText$0 = $TR($EXPECT($
|
|
15948
|
+
var JSXText$0 = $TR($EXPECT($R54, fail, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15850
15949
|
return {
|
|
15851
15950
|
type: "JSXText",
|
|
15852
15951
|
token: $0,
|
|
@@ -16094,7 +16193,7 @@ ${input.slice(result.pos)}
|
|
|
16094
16193
|
return result;
|
|
16095
16194
|
}
|
|
16096
16195
|
}
|
|
16097
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
16196
|
+
var TypeKeyword$0 = $S($EXPECT($L169, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
16098
16197
|
function TypeKeyword(state) {
|
|
16099
16198
|
let eventData;
|
|
16100
16199
|
if (state.events) {
|
|
@@ -16117,7 +16216,7 @@ ${input.slice(result.pos)}
|
|
|
16117
16216
|
return result;
|
|
16118
16217
|
}
|
|
16119
16218
|
}
|
|
16120
|
-
var Interface$0 = $S($EXPECT($
|
|
16219
|
+
var Interface$0 = $S($EXPECT($L170, fail, 'Interface "interface"'), NonIdContinue);
|
|
16121
16220
|
function Interface(state) {
|
|
16122
16221
|
let eventData;
|
|
16123
16222
|
if (state.events) {
|
|
@@ -16140,7 +16239,7 @@ ${input.slice(result.pos)}
|
|
|
16140
16239
|
return result;
|
|
16141
16240
|
}
|
|
16142
16241
|
}
|
|
16143
|
-
var Namespace$0 = $S($EXPECT($
|
|
16242
|
+
var Namespace$0 = $S($EXPECT($L171, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
16144
16243
|
function Namespace(state) {
|
|
16145
16244
|
let eventData;
|
|
16146
16245
|
if (state.events) {
|
|
@@ -16388,7 +16487,7 @@ ${input.slice(result.pos)}
|
|
|
16388
16487
|
return result;
|
|
16389
16488
|
}
|
|
16390
16489
|
}
|
|
16391
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
16490
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R55, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L139, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R56, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
16392
16491
|
function TypeIndexSignature(state) {
|
|
16393
16492
|
let eventData;
|
|
16394
16493
|
if (state.events) {
|
|
@@ -16460,7 +16559,7 @@ ${input.slice(result.pos)}
|
|
|
16460
16559
|
return result;
|
|
16461
16560
|
}
|
|
16462
16561
|
}
|
|
16463
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
16562
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L172, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
16464
16563
|
const children = [...$1, $2];
|
|
16465
16564
|
if ($3)
|
|
16466
16565
|
children.push($3);
|
|
@@ -16493,7 +16592,7 @@ ${input.slice(result.pos)}
|
|
|
16493
16592
|
return result;
|
|
16494
16593
|
}
|
|
16495
16594
|
}
|
|
16496
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
16595
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L81, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
16497
16596
|
if (!$2)
|
|
16498
16597
|
return $1;
|
|
16499
16598
|
return $0;
|
|
@@ -16619,10 +16718,10 @@ ${input.slice(result.pos)}
|
|
|
16619
16718
|
return result;
|
|
16620
16719
|
}
|
|
16621
16720
|
}
|
|
16622
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
16623
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
16624
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
16625
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
16721
|
+
var TypeUnaryOp$0 = $S($EXPECT($L173, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
16722
|
+
var TypeUnaryOp$1 = $S($EXPECT($L155, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
16723
|
+
var TypeUnaryOp$2 = $S($EXPECT($L174, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
16724
|
+
var TypeUnaryOp$3 = $S($EXPECT($L139, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
16626
16725
|
function TypeUnaryOp(state) {
|
|
16627
16726
|
let eventData;
|
|
16628
16727
|
if (state.events) {
|
|
@@ -16820,7 +16919,7 @@ ${input.slice(result.pos)}
|
|
|
16820
16919
|
return result;
|
|
16821
16920
|
}
|
|
16822
16921
|
}
|
|
16823
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
16922
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L118, fail, 'TypeConditional "extends"'), NonIdContinue, Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
16824
16923
|
if ($2)
|
|
16825
16924
|
return $0;
|
|
16826
16925
|
return $1;
|
|
@@ -16849,10 +16948,10 @@ ${input.slice(result.pos)}
|
|
|
16849
16948
|
}
|
|
16850
16949
|
var TypeLiteral$0 = TemplateLiteral;
|
|
16851
16950
|
var TypeLiteral$1 = Literal;
|
|
16852
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
16951
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L159, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
16853
16952
|
return { $loc, token: "void" };
|
|
16854
16953
|
});
|
|
16855
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
16954
|
+
var TypeLiteral$3 = $TV($EXPECT($L175, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
16856
16955
|
return { $loc, token: "[]" };
|
|
16857
16956
|
});
|
|
16858
16957
|
function TypeLiteral(state) {
|
|
@@ -16927,7 +17026,7 @@ ${input.slice(result.pos)}
|
|
|
16927
17026
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
16928
17027
|
return value[1];
|
|
16929
17028
|
});
|
|
16930
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
17029
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L32, fail, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L19, fail, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L31, fail, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L22, fail, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
16931
17030
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
16932
17031
|
function InlineInterfacePropertyDelimiter(state) {
|
|
16933
17032
|
let eventData;
|
|
@@ -16951,10 +17050,10 @@ ${input.slice(result.pos)}
|
|
|
16951
17050
|
return result;
|
|
16952
17051
|
}
|
|
16953
17052
|
}
|
|
16954
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
17053
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L83, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
16955
17054
|
return { $loc, token: "|" };
|
|
16956
17055
|
});
|
|
16957
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
17056
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L82, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
16958
17057
|
return { $loc, token: "&" };
|
|
16959
17058
|
});
|
|
16960
17059
|
function TypeBinaryOp(state) {
|
|
@@ -17011,7 +17110,7 @@ ${input.slice(result.pos)}
|
|
|
17011
17110
|
var TypeArrowFunction$0 = $TV($EXPECT($L7, fail, 'TypeArrowFunction "=>"'), function($skip, $loc, $0, $1) {
|
|
17012
17111
|
return { $loc, token: "=>" };
|
|
17013
17112
|
});
|
|
17014
|
-
var TypeArrowFunction$1 = $TV($EXPECT($
|
|
17113
|
+
var TypeArrowFunction$1 = $TV($EXPECT($L21, fail, 'TypeArrowFunction "->"'), function($skip, $loc, $0, $1) {
|
|
17015
17114
|
return { $loc, token: "=>" };
|
|
17016
17115
|
});
|
|
17017
17116
|
function TypeArrowFunction(state) {
|
|
@@ -17036,7 +17135,7 @@ ${input.slice(result.pos)}
|
|
|
17036
17135
|
return result;
|
|
17037
17136
|
}
|
|
17038
17137
|
}
|
|
17039
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
17138
|
+
var TypeArguments$0 = $TS($S($EXPECT($L130, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L30, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17040
17139
|
return { ts: true, children: $0 };
|
|
17041
17140
|
});
|
|
17042
17141
|
function TypeArguments(state) {
|
|
@@ -17107,7 +17206,7 @@ ${input.slice(result.pos)}
|
|
|
17107
17206
|
return result;
|
|
17108
17207
|
}
|
|
17109
17208
|
}
|
|
17110
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
17209
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L130, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L30, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
17111
17210
|
var parameters = $3;
|
|
17112
17211
|
return {
|
|
17113
17212
|
type: "TypeParameters",
|
|
@@ -17161,7 +17260,7 @@ ${input.slice(result.pos)}
|
|
|
17161
17260
|
return result;
|
|
17162
17261
|
}
|
|
17163
17262
|
}
|
|
17164
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
17263
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L118, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
17165
17264
|
function TypeConstraint(state) {
|
|
17166
17265
|
let eventData;
|
|
17167
17266
|
if (state.events) {
|
|
@@ -17208,7 +17307,7 @@ ${input.slice(result.pos)}
|
|
|
17208
17307
|
}
|
|
17209
17308
|
}
|
|
17210
17309
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
17211
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
17310
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L30, fail, 'TypeParameterDelimiter ">"')));
|
|
17212
17311
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
17213
17312
|
return value[1];
|
|
17214
17313
|
});
|
|
@@ -17259,7 +17358,7 @@ ${input.slice(result.pos)}
|
|
|
17259
17358
|
return result;
|
|
17260
17359
|
}
|
|
17261
17360
|
}
|
|
17262
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
17361
|
+
var Shebang$0 = $S($R$0($EXPECT($R57, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
17263
17362
|
function Shebang(state) {
|
|
17264
17363
|
let eventData;
|
|
17265
17364
|
if (state.events) {
|
|
@@ -17282,11 +17381,11 @@ ${input.slice(result.pos)}
|
|
|
17282
17381
|
return result;
|
|
17283
17382
|
}
|
|
17284
17383
|
}
|
|
17285
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
17384
|
+
var CivetPrologue$0 = $T($S($EXPECT($R58, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
|
|
17286
17385
|
var content = value[2];
|
|
17287
17386
|
return content;
|
|
17288
17387
|
});
|
|
17289
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
17388
|
+
var CivetPrologue$1 = $T($S($EXPECT($R58, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
|
|
17290
17389
|
var content = value[2];
|
|
17291
17390
|
return content;
|
|
17292
17391
|
});
|
|
@@ -17312,7 +17411,7 @@ ${input.slice(result.pos)}
|
|
|
17312
17411
|
return result;
|
|
17313
17412
|
}
|
|
17314
17413
|
}
|
|
17315
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
17414
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L176, fail, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R59, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17316
17415
|
var options = $3;
|
|
17317
17416
|
return {
|
|
17318
17417
|
type: "CivetPrologue",
|
|
@@ -17342,7 +17441,7 @@ ${input.slice(result.pos)}
|
|
|
17342
17441
|
return result;
|
|
17343
17442
|
}
|
|
17344
17443
|
}
|
|
17345
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
17444
|
+
var CivetOption$0 = $TR($EXPECT($R60, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
17346
17445
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
17347
17446
|
if (l)
|
|
17348
17447
|
return l.toUpperCase();
|
|
@@ -17378,7 +17477,7 @@ ${input.slice(result.pos)}
|
|
|
17378
17477
|
return result;
|
|
17379
17478
|
}
|
|
17380
17479
|
}
|
|
17381
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
17480
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R58, fail, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
17382
17481
|
function UnknownPrologue(state) {
|
|
17383
17482
|
let eventData;
|
|
17384
17483
|
if (state.events) {
|
|
@@ -17448,7 +17547,7 @@ ${input.slice(result.pos)}
|
|
|
17448
17547
|
return result;
|
|
17449
17548
|
}
|
|
17450
17549
|
}
|
|
17451
|
-
var EOL$0 = $TR($EXPECT($
|
|
17550
|
+
var EOL$0 = $TR($EXPECT($R61, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
17452
17551
|
return { $loc, token: $0 };
|
|
17453
17552
|
});
|
|
17454
17553
|
function EOL(state) {
|
|
@@ -17473,7 +17572,7 @@ ${input.slice(result.pos)}
|
|
|
17473
17572
|
return result;
|
|
17474
17573
|
}
|
|
17475
17574
|
}
|
|
17476
|
-
var Debugger$0 = $TV($EXPECT($
|
|
17575
|
+
var Debugger$0 = $TV($EXPECT($L18, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
17477
17576
|
debugger;
|
|
17478
17577
|
});
|
|
17479
17578
|
function Debugger(state) {
|
|
@@ -17498,7 +17597,7 @@ ${input.slice(result.pos)}
|
|
|
17498
17597
|
return result;
|
|
17499
17598
|
}
|
|
17500
17599
|
}
|
|
17501
|
-
var InsertSemicolon$0 = $TV($EXPECT($
|
|
17600
|
+
var InsertSemicolon$0 = $TV($EXPECT($L18, fail, 'InsertSemicolon ""'), function($skip, $loc, $0, $1) {
|
|
17502
17601
|
return { $loc, token: ";" };
|
|
17503
17602
|
});
|
|
17504
17603
|
function InsertSemicolon(state) {
|
|
@@ -17523,7 +17622,7 @@ ${input.slice(result.pos)}
|
|
|
17523
17622
|
return result;
|
|
17524
17623
|
}
|
|
17525
17624
|
}
|
|
17526
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
17625
|
+
var InsertOpenParen$0 = $TV($EXPECT($L18, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
17527
17626
|
return { $loc, token: "(" };
|
|
17528
17627
|
});
|
|
17529
17628
|
function InsertOpenParen(state) {
|
|
@@ -17548,7 +17647,7 @@ ${input.slice(result.pos)}
|
|
|
17548
17647
|
return result;
|
|
17549
17648
|
}
|
|
17550
17649
|
}
|
|
17551
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
17650
|
+
var InsertCloseParen$0 = $TV($EXPECT($L18, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
17552
17651
|
return { $loc, token: ")" };
|
|
17553
17652
|
});
|
|
17554
17653
|
function InsertCloseParen(state) {
|
|
@@ -17573,7 +17672,7 @@ ${input.slice(result.pos)}
|
|
|
17573
17672
|
return result;
|
|
17574
17673
|
}
|
|
17575
17674
|
}
|
|
17576
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
17675
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L18, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
17577
17676
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
17578
17677
|
});
|
|
17579
17678
|
function InsertOpenBrace(state) {
|
|
@@ -17598,7 +17697,7 @@ ${input.slice(result.pos)}
|
|
|
17598
17697
|
return result;
|
|
17599
17698
|
}
|
|
17600
17699
|
}
|
|
17601
|
-
var InsertInlineOpenBrace$0 = $TV($EXPECT($
|
|
17700
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L18, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
17602
17701
|
return { $loc, token: "{" };
|
|
17603
17702
|
});
|
|
17604
17703
|
function InsertInlineOpenBrace(state) {
|
|
@@ -17623,7 +17722,7 @@ ${input.slice(result.pos)}
|
|
|
17623
17722
|
return result;
|
|
17624
17723
|
}
|
|
17625
17724
|
}
|
|
17626
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
17725
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L18, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
17627
17726
|
return { $loc, token: "}" };
|
|
17628
17727
|
});
|
|
17629
17728
|
function InsertCloseBrace(state) {
|
|
@@ -17648,7 +17747,7 @@ ${input.slice(result.pos)}
|
|
|
17648
17747
|
return result;
|
|
17649
17748
|
}
|
|
17650
17749
|
}
|
|
17651
|
-
var InsertOpenBracket$0 = $TV($EXPECT($
|
|
17750
|
+
var InsertOpenBracket$0 = $TV($EXPECT($L18, fail, 'InsertOpenBracket ""'), function($skip, $loc, $0, $1) {
|
|
17652
17751
|
return { $loc, token: "[" };
|
|
17653
17752
|
});
|
|
17654
17753
|
function InsertOpenBracket(state) {
|
|
@@ -17673,7 +17772,7 @@ ${input.slice(result.pos)}
|
|
|
17673
17772
|
return result;
|
|
17674
17773
|
}
|
|
17675
17774
|
}
|
|
17676
|
-
var InsertCloseBracket$0 = $TV($EXPECT($
|
|
17775
|
+
var InsertCloseBracket$0 = $TV($EXPECT($L18, fail, 'InsertCloseBracket ""'), function($skip, $loc, $0, $1) {
|
|
17677
17776
|
return { $loc, token: "]" };
|
|
17678
17777
|
});
|
|
17679
17778
|
function InsertCloseBracket(state) {
|
|
@@ -17698,7 +17797,7 @@ ${input.slice(result.pos)}
|
|
|
17698
17797
|
return result;
|
|
17699
17798
|
}
|
|
17700
17799
|
}
|
|
17701
|
-
var InsertComma$0 = $TV($EXPECT($
|
|
17800
|
+
var InsertComma$0 = $TV($EXPECT($L18, fail, 'InsertComma ""'), function($skip, $loc, $0, $1) {
|
|
17702
17801
|
return { $loc, token: "," };
|
|
17703
17802
|
});
|
|
17704
17803
|
function InsertComma(state) {
|
|
@@ -17723,7 +17822,7 @@ ${input.slice(result.pos)}
|
|
|
17723
17822
|
return result;
|
|
17724
17823
|
}
|
|
17725
17824
|
}
|
|
17726
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
17825
|
+
var InsertConst$0 = $TV($EXPECT($L18, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
17727
17826
|
return { $loc, token: "const " };
|
|
17728
17827
|
});
|
|
17729
17828
|
function InsertConst(state) {
|
|
@@ -17748,7 +17847,7 @@ ${input.slice(result.pos)}
|
|
|
17748
17847
|
return result;
|
|
17749
17848
|
}
|
|
17750
17849
|
}
|
|
17751
|
-
var InsertLet$0 = $TV($EXPECT($
|
|
17850
|
+
var InsertLet$0 = $TV($EXPECT($L18, fail, 'InsertLet ""'), function($skip, $loc, $0, $1) {
|
|
17752
17851
|
return { $loc, token: "let " };
|
|
17753
17852
|
});
|
|
17754
17853
|
function InsertLet(state) {
|
|
@@ -17773,7 +17872,7 @@ ${input.slice(result.pos)}
|
|
|
17773
17872
|
return result;
|
|
17774
17873
|
}
|
|
17775
17874
|
}
|
|
17776
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
17875
|
+
var InsertReadonly$0 = $TV($EXPECT($L18, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
17777
17876
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
17778
17877
|
});
|
|
17779
17878
|
function InsertReadonly(state) {
|
|
@@ -17798,7 +17897,7 @@ ${input.slice(result.pos)}
|
|
|
17798
17897
|
return result;
|
|
17799
17898
|
}
|
|
17800
17899
|
}
|
|
17801
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
17900
|
+
var InsertNewline$0 = $TV($EXPECT($L18, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
17802
17901
|
return "\n";
|
|
17803
17902
|
});
|
|
17804
17903
|
function InsertNewline(state) {
|
|
@@ -17823,7 +17922,7 @@ ${input.slice(result.pos)}
|
|
|
17823
17922
|
return result;
|
|
17824
17923
|
}
|
|
17825
17924
|
}
|
|
17826
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
17925
|
+
var InsertIndent$0 = $TV($EXPECT($L18, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
17827
17926
|
return module.currentIndent.token;
|
|
17828
17927
|
});
|
|
17829
17928
|
function InsertIndent(state) {
|
|
@@ -17848,7 +17947,7 @@ ${input.slice(result.pos)}
|
|
|
17848
17947
|
return result;
|
|
17849
17948
|
}
|
|
17850
17949
|
}
|
|
17851
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
17950
|
+
var InsertSpace$0 = $TV($EXPECT($L18, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
17852
17951
|
return { $loc, token: " " };
|
|
17853
17952
|
});
|
|
17854
17953
|
function InsertSpace(state) {
|
|
@@ -17873,7 +17972,7 @@ ${input.slice(result.pos)}
|
|
|
17873
17972
|
return result;
|
|
17874
17973
|
}
|
|
17875
17974
|
}
|
|
17876
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
17975
|
+
var InsertDot$0 = $TV($EXPECT($L18, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
17877
17976
|
return { $loc, token: "." };
|
|
17878
17977
|
});
|
|
17879
17978
|
function InsertDot(state) {
|
|
@@ -17898,7 +17997,7 @@ ${input.slice(result.pos)}
|
|
|
17898
17997
|
return result;
|
|
17899
17998
|
}
|
|
17900
17999
|
}
|
|
17901
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
18000
|
+
var InsertBreak$0 = $TV($EXPECT($L18, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
17902
18001
|
return { $loc, token: ";break;" };
|
|
17903
18002
|
});
|
|
17904
18003
|
function InsertBreak(state) {
|
|
@@ -17923,7 +18022,7 @@ ${input.slice(result.pos)}
|
|
|
17923
18022
|
return result;
|
|
17924
18023
|
}
|
|
17925
18024
|
}
|
|
17926
|
-
var InsertVar$0 = $TV($EXPECT($
|
|
18025
|
+
var InsertVar$0 = $TV($EXPECT($L18, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
17927
18026
|
return { $loc, token: "var " };
|
|
17928
18027
|
});
|
|
17929
18028
|
function InsertVar(state) {
|
|
@@ -17948,7 +18047,7 @@ ${input.slice(result.pos)}
|
|
|
17948
18047
|
return result;
|
|
17949
18048
|
}
|
|
17950
18049
|
}
|
|
17951
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
18050
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
17952
18051
|
if (module.config.coffeeBinaryExistential)
|
|
17953
18052
|
return;
|
|
17954
18053
|
return $skip;
|
|
@@ -17975,7 +18074,7 @@ ${input.slice(result.pos)}
|
|
|
17975
18074
|
return result;
|
|
17976
18075
|
}
|
|
17977
18076
|
}
|
|
17978
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
18077
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
17979
18078
|
if (module.config.coffeeBooleans)
|
|
17980
18079
|
return;
|
|
17981
18080
|
return $skip;
|
|
@@ -18002,7 +18101,7 @@ ${input.slice(result.pos)}
|
|
|
18002
18101
|
return result;
|
|
18003
18102
|
}
|
|
18004
18103
|
}
|
|
18005
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
18104
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18006
18105
|
if (module.config.coffeeClasses)
|
|
18007
18106
|
return;
|
|
18008
18107
|
return $skip;
|
|
@@ -18029,7 +18128,7 @@ ${input.slice(result.pos)}
|
|
|
18029
18128
|
return result;
|
|
18030
18129
|
}
|
|
18031
18130
|
}
|
|
18032
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
18131
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18033
18132
|
if (module.config.coffeeComment)
|
|
18034
18133
|
return;
|
|
18035
18134
|
return $skip;
|
|
@@ -18056,7 +18155,7 @@ ${input.slice(result.pos)}
|
|
|
18056
18155
|
return result;
|
|
18057
18156
|
}
|
|
18058
18157
|
}
|
|
18059
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
18158
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18060
18159
|
if (module.config.coffeeDo)
|
|
18061
18160
|
return;
|
|
18062
18161
|
return $skip;
|
|
@@ -18083,7 +18182,7 @@ ${input.slice(result.pos)}
|
|
|
18083
18182
|
return result;
|
|
18084
18183
|
}
|
|
18085
18184
|
}
|
|
18086
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
18185
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18087
18186
|
if (module.config.coffeeForLoops)
|
|
18088
18187
|
return;
|
|
18089
18188
|
return $skip;
|
|
@@ -18110,7 +18209,7 @@ ${input.slice(result.pos)}
|
|
|
18110
18209
|
return result;
|
|
18111
18210
|
}
|
|
18112
18211
|
}
|
|
18113
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
18212
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18114
18213
|
if (module.config.coffeeInterpolation)
|
|
18115
18214
|
return;
|
|
18116
18215
|
return $skip;
|
|
@@ -18137,7 +18236,7 @@ ${input.slice(result.pos)}
|
|
|
18137
18236
|
return result;
|
|
18138
18237
|
}
|
|
18139
18238
|
}
|
|
18140
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
18239
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18141
18240
|
if (module.config.coffeeIsnt)
|
|
18142
18241
|
return;
|
|
18143
18242
|
return $skip;
|
|
@@ -18164,7 +18263,7 @@ ${input.slice(result.pos)}
|
|
|
18164
18263
|
return result;
|
|
18165
18264
|
}
|
|
18166
18265
|
}
|
|
18167
|
-
var CoffeeJSXEnabled$0 = $TV($EXPECT($
|
|
18266
|
+
var CoffeeJSXEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeJSXEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18168
18267
|
if (module.config.coffeeJSX)
|
|
18169
18268
|
return;
|
|
18170
18269
|
return $skip;
|
|
@@ -18191,7 +18290,7 @@ ${input.slice(result.pos)}
|
|
|
18191
18290
|
return result;
|
|
18192
18291
|
}
|
|
18193
18292
|
}
|
|
18194
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
18293
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18195
18294
|
if (module.config.coffeeLineContinuation)
|
|
18196
18295
|
return;
|
|
18197
18296
|
return $skip;
|
|
@@ -18218,7 +18317,7 @@ ${input.slice(result.pos)}
|
|
|
18218
18317
|
return result;
|
|
18219
18318
|
}
|
|
18220
18319
|
}
|
|
18221
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
18320
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18222
18321
|
if (module.config.coffeeNot)
|
|
18223
18322
|
return;
|
|
18224
18323
|
return $skip;
|
|
@@ -18245,7 +18344,7 @@ ${input.slice(result.pos)}
|
|
|
18245
18344
|
return result;
|
|
18246
18345
|
}
|
|
18247
18346
|
}
|
|
18248
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
18347
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18249
18348
|
if (module.config.coffeeOf)
|
|
18250
18349
|
return;
|
|
18251
18350
|
return $skip;
|
|
@@ -18272,7 +18371,7 @@ ${input.slice(result.pos)}
|
|
|
18272
18371
|
return result;
|
|
18273
18372
|
}
|
|
18274
18373
|
}
|
|
18275
|
-
var CoffeePrototypeEnabled$0 = $TV($EXPECT($
|
|
18374
|
+
var CoffeePrototypeEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18276
18375
|
if (module.config.coffeePrototype)
|
|
18277
18376
|
return;
|
|
18278
18377
|
return $skip;
|
|
@@ -18299,7 +18398,7 @@ ${input.slice(result.pos)}
|
|
|
18299
18398
|
return result;
|
|
18300
18399
|
}
|
|
18301
18400
|
}
|
|
18302
|
-
var ObjectIsEnabled$0 = $TV($EXPECT($
|
|
18401
|
+
var ObjectIsEnabled$0 = $TV($EXPECT($L18, fail, 'ObjectIsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18303
18402
|
if (module.config.objectIs)
|
|
18304
18403
|
return;
|
|
18305
18404
|
return $skip;
|
|
@@ -18326,7 +18425,7 @@ ${input.slice(result.pos)}
|
|
|
18326
18425
|
return result;
|
|
18327
18426
|
}
|
|
18328
18427
|
}
|
|
18329
|
-
var Reset$0 = $TV($EXPECT($
|
|
18428
|
+
var Reset$0 = $TV($EXPECT($L18, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
18330
18429
|
module.indentLevels = [{
|
|
18331
18430
|
level: 0,
|
|
18332
18431
|
token: ""
|
|
@@ -18393,39 +18492,54 @@ ${input.slice(result.pos)}
|
|
|
18393
18492
|
children: [" as const"]
|
|
18394
18493
|
};
|
|
18395
18494
|
module.prelude = [];
|
|
18495
|
+
const preludeVar = "var ";
|
|
18396
18496
|
const declareRef = {
|
|
18397
18497
|
indexOf(indexOfRef) {
|
|
18398
18498
|
const typeSuffix = {
|
|
18399
18499
|
ts: true,
|
|
18400
18500
|
children: [": <T>(this: T[], searchElement: T) => boolean"]
|
|
18401
18501
|
};
|
|
18402
|
-
module.prelude.push(["", [
|
|
18502
|
+
module.prelude.push(["", [preludeVar, indexOfRef, typeSuffix, " = [].indexOf", module.asAny, ";\n"]]);
|
|
18403
18503
|
},
|
|
18404
18504
|
hasProp(hasPropRef) {
|
|
18405
18505
|
const typeSuffix = {
|
|
18406
18506
|
ts: true,
|
|
18407
18507
|
children: [": <T>(this: T, prop: keyof T) => boolean"]
|
|
18408
18508
|
};
|
|
18409
|
-
module.prelude.push(["", [
|
|
18509
|
+
module.prelude.push(["", [preludeVar, hasPropRef, typeSuffix, " = {}.hasOwnProperty", module.asAny, ";\n"]]);
|
|
18410
18510
|
},
|
|
18411
18511
|
is(isRef) {
|
|
18412
18512
|
const typeSuffix = {
|
|
18413
18513
|
ts: true,
|
|
18414
18514
|
children: [": { <B, A extends B> (a: A, b: B): b is A, <A, B> (a: A, b: B): a is A & B }"]
|
|
18415
18515
|
};
|
|
18416
|
-
module.prelude.push(["", [
|
|
18516
|
+
module.prelude.push(["", [preludeVar, isRef, typeSuffix, " = Object.is", module.asAny, ";\n"]]);
|
|
18417
18517
|
},
|
|
18418
18518
|
modulo(moduloRef) {
|
|
18419
18519
|
const typeSuffix = {
|
|
18420
18520
|
ts: true,
|
|
18421
18521
|
children: [": (a: number, b: number) => number"]
|
|
18422
18522
|
};
|
|
18423
|
-
module.prelude.push(["", [
|
|
18523
|
+
module.prelude.push(["", [preludeVar, moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
|
|
18524
|
+
},
|
|
18525
|
+
xor(xorRef) {
|
|
18526
|
+
const typeSuffix = {
|
|
18527
|
+
ts: true,
|
|
18528
|
+
children: [": (a: unknown, b: unknown) => boolean"]
|
|
18529
|
+
};
|
|
18530
|
+
module.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => a ? !b && a : b;", "\n"]]);
|
|
18531
|
+
},
|
|
18532
|
+
xnor(xnorRef) {
|
|
18533
|
+
const typeSuffix = {
|
|
18534
|
+
ts: true,
|
|
18535
|
+
children: [": (a: unknown, b: unknown) => boolean"]
|
|
18536
|
+
};
|
|
18537
|
+
module.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => a ? b : !b || a;", "\n"]]);
|
|
18424
18538
|
},
|
|
18425
18539
|
returnSymbol(ref) {
|
|
18426
18540
|
module.prelude.push({
|
|
18427
18541
|
children: [
|
|
18428
|
-
|
|
18542
|
+
preludeVar,
|
|
18429
18543
|
ref,
|
|
18430
18544
|
` = Symbol("return")';
|
|
18431
18545
|
`
|
|
@@ -18604,7 +18718,7 @@ ${input.slice(result.pos)}
|
|
|
18604
18718
|
return result;
|
|
18605
18719
|
}
|
|
18606
18720
|
}
|
|
18607
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
18721
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L18, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
18608
18722
|
var directives = $2;
|
|
18609
18723
|
directives.forEach((directive) => {
|
|
18610
18724
|
if (directive.type === "CivetPrologue") {
|
|
@@ -18619,35 +18733,43 @@ ${input.slice(result.pos)}
|
|
|
18619
18733
|
const prefix = children.slice(0, i).concat(glob.children[0]);
|
|
18620
18734
|
const parts = [];
|
|
18621
18735
|
for (const part of glob.object.content) {
|
|
18622
|
-
if (part.type === "SpreadProperty") {
|
|
18623
|
-
throw new Error("Glob pattern cannot have ...spread property");
|
|
18624
|
-
}
|
|
18625
18736
|
if (part.type === "MethodDefinition") {
|
|
18626
18737
|
throw new Error("Glob pattern cannot have method definition");
|
|
18627
18738
|
}
|
|
18628
18739
|
if (part.value && !["CallExpression", "MemberExpression", "Identifier"].includes(part.value.type)) {
|
|
18629
18740
|
throw new Error("Glob pattern must have call or member expression value");
|
|
18630
18741
|
}
|
|
18631
|
-
const { name } = part;
|
|
18632
18742
|
let value = part.value ?? part.name;
|
|
18633
18743
|
const wValue = module.getTrimmingSpace(part.value);
|
|
18634
18744
|
value = prefix.concat(module.insertTrimmingSpace(value, ""));
|
|
18635
18745
|
if (wValue)
|
|
18636
18746
|
value.unshift(wValue);
|
|
18637
|
-
|
|
18638
|
-
|
|
18639
|
-
|
|
18640
|
-
value,
|
|
18641
|
-
names: part.names,
|
|
18642
|
-
children: [
|
|
18643
|
-
module.isWhitespaceOrEmpty(part.children[0]) && part.children[0],
|
|
18644
|
-
name,
|
|
18645
|
-
module.isWhitespaceOrEmpty(part.children[2]) && part.children[2],
|
|
18646
|
-
part.children[3]?.token === ":" ? part.children[3] : ":",
|
|
18747
|
+
if (part.type === "SpreadProperty") {
|
|
18748
|
+
parts.push({
|
|
18749
|
+
type: part.type,
|
|
18647
18750
|
value,
|
|
18648
|
-
part.
|
|
18649
|
-
|
|
18650
|
-
|
|
18751
|
+
dots: part.dots,
|
|
18752
|
+
delim: part.delim,
|
|
18753
|
+
names: part.names,
|
|
18754
|
+
children: part.children.slice(0, 2).concat(value, part.delim)
|
|
18755
|
+
});
|
|
18756
|
+
} else {
|
|
18757
|
+
parts.push({
|
|
18758
|
+
type: part.type,
|
|
18759
|
+
name: part.name,
|
|
18760
|
+
value,
|
|
18761
|
+
delim: part.delim,
|
|
18762
|
+
names: part.names,
|
|
18763
|
+
children: [
|
|
18764
|
+
module.isWhitespaceOrEmpty(part.children[0]) && part.children[0],
|
|
18765
|
+
part.name,
|
|
18766
|
+
module.isWhitespaceOrEmpty(part.children[2]) && part.children[2],
|
|
18767
|
+
part.children[3]?.token === ":" ? part.children[3] : ":",
|
|
18768
|
+
value,
|
|
18769
|
+
part.delim
|
|
18770
|
+
]
|
|
18771
|
+
});
|
|
18772
|
+
}
|
|
18651
18773
|
}
|
|
18652
18774
|
const object = {
|
|
18653
18775
|
type: "ObjectExpression",
|
|
@@ -18716,6 +18838,43 @@ ${input.slice(result.pos)}
|
|
|
18716
18838
|
return { children };
|
|
18717
18839
|
}
|
|
18718
18840
|
};
|
|
18841
|
+
module.literalValue = function(literal) {
|
|
18842
|
+
let { raw } = literal;
|
|
18843
|
+
switch (raw) {
|
|
18844
|
+
case "null":
|
|
18845
|
+
return null;
|
|
18846
|
+
case "true":
|
|
18847
|
+
return true;
|
|
18848
|
+
case "false":
|
|
18849
|
+
return false;
|
|
18850
|
+
}
|
|
18851
|
+
if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
|
|
18852
|
+
return raw.slice(1, -1);
|
|
18853
|
+
}
|
|
18854
|
+
const numeric = literal.children.find(
|
|
18855
|
+
(child) => child.type === "NumericLiteral"
|
|
18856
|
+
);
|
|
18857
|
+
if (numeric) {
|
|
18858
|
+
raw = raw.replace(/_/g, "");
|
|
18859
|
+
const { token } = numeric;
|
|
18860
|
+
if (token.endsWith("n")) {
|
|
18861
|
+
return BigInt(raw.slice(0, -1));
|
|
18862
|
+
} else if (token.match(/[\.eE]/)) {
|
|
18863
|
+
return parseFloat(raw);
|
|
18864
|
+
} else if (token.startsWith("0")) {
|
|
18865
|
+
switch (token.charAt(1).toLowerCase()) {
|
|
18866
|
+
case "x":
|
|
18867
|
+
return parseInt(raw.replace(/0[xX]/, ""), 16);
|
|
18868
|
+
case "b":
|
|
18869
|
+
return parseInt(raw.replace(/0[bB]/, ""), 2);
|
|
18870
|
+
case "o":
|
|
18871
|
+
return parseInt(raw.replace(/0[oO]/, ""), 8);
|
|
18872
|
+
}
|
|
18873
|
+
}
|
|
18874
|
+
return parseInt(raw, 10);
|
|
18875
|
+
}
|
|
18876
|
+
throw new Error("Unrecognized literal " + JSON.stringify(literal));
|
|
18877
|
+
};
|
|
18719
18878
|
module.expressionizeIfClause = function(clause, b, e) {
|
|
18720
18879
|
const children = clause.children.slice(1);
|
|
18721
18880
|
children.push("?", b);
|
|
@@ -19793,7 +19952,52 @@ ${input.slice(result.pos)}
|
|
|
19793
19952
|
s.children = [root];
|
|
19794
19953
|
});
|
|
19795
19954
|
}
|
|
19955
|
+
function processPipelineExpressions(statements) {
|
|
19956
|
+
gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
|
|
19957
|
+
const [, body] = s.children;
|
|
19958
|
+
let [arg] = s.children;
|
|
19959
|
+
let i = 0, l = body.length;
|
|
19960
|
+
const children = [];
|
|
19961
|
+
for (i = 0; i < l; i++) {
|
|
19962
|
+
const step = body[i];
|
|
19963
|
+
const [leadingComment, pipe, trailingComment, expr] = step;
|
|
19964
|
+
const returns = pipe.token === "||>";
|
|
19965
|
+
if (pipe.token === "|>=") {
|
|
19966
|
+
if (i === 0) {
|
|
19967
|
+
children.push(arg, " = ");
|
|
19968
|
+
} else {
|
|
19969
|
+
children.push({
|
|
19970
|
+
type: "Error",
|
|
19971
|
+
message: "Can't use |>= in the middle of a pipeline"
|
|
19972
|
+
});
|
|
19973
|
+
}
|
|
19974
|
+
}
|
|
19975
|
+
const [result, returning] = module.constructPipeStep(
|
|
19976
|
+
{
|
|
19977
|
+
leadingComment: module.skipIfOnlyWS(leadingComment),
|
|
19978
|
+
trailingComment: module.skipIfOnlyWS(trailingComment),
|
|
19979
|
+
expr
|
|
19980
|
+
},
|
|
19981
|
+
arg,
|
|
19982
|
+
returns ? arg : null
|
|
19983
|
+
);
|
|
19984
|
+
if (result.type === "ReturnStatement") {
|
|
19985
|
+
arg = result;
|
|
19986
|
+
break;
|
|
19987
|
+
}
|
|
19988
|
+
if (returning) {
|
|
19989
|
+
arg = returning;
|
|
19990
|
+
children.push(result, ",");
|
|
19991
|
+
} else {
|
|
19992
|
+
arg = result;
|
|
19993
|
+
}
|
|
19994
|
+
}
|
|
19995
|
+
children.push(arg);
|
|
19996
|
+
s.children = children;
|
|
19997
|
+
});
|
|
19998
|
+
}
|
|
19796
19999
|
module.processProgram = function(statements) {
|
|
20000
|
+
processPipelineExpressions(statements);
|
|
19797
20001
|
processAssignments(statements);
|
|
19798
20002
|
processFunctions(statements);
|
|
19799
20003
|
processSwitchExpressions(statements);
|
|
@@ -20006,20 +20210,56 @@ ${input.slice(result.pos)}
|
|
|
20006
20210
|
return [splices, thisAssignments];
|
|
20007
20211
|
}
|
|
20008
20212
|
module.gatherBindingCode = gatherBindingCode;
|
|
20009
|
-
module.constructInvocation = function(
|
|
20010
|
-
const
|
|
20011
|
-
const
|
|
20012
|
-
|
|
20013
|
-
|
|
20014
|
-
|
|
20015
|
-
|
|
20213
|
+
module.constructInvocation = function(fn, arg) {
|
|
20214
|
+
const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
|
|
20215
|
+
const lhs = module.makeLeftHandSideExpression(fn.expr);
|
|
20216
|
+
let comment = module.skipIfOnlyWS(fn.trailingComment);
|
|
20217
|
+
if (comment)
|
|
20218
|
+
lhs.children.splice(2, 0, comment);
|
|
20219
|
+
comment = module.skipIfOnlyWS(fn.leadingComment);
|
|
20220
|
+
if (comment)
|
|
20221
|
+
lhs.children.splice(1, 0, comment);
|
|
20222
|
+
switch (arg.type) {
|
|
20223
|
+
case "CommaExpression":
|
|
20224
|
+
arg = {
|
|
20225
|
+
type: "ParenthesizedExpression",
|
|
20226
|
+
children: ["(", arg, ")"]
|
|
20227
|
+
};
|
|
20228
|
+
break;
|
|
20016
20229
|
}
|
|
20230
|
+
return {
|
|
20231
|
+
type: "CallExpression",
|
|
20232
|
+
children: [lhs, "(", arg, ")"]
|
|
20233
|
+
};
|
|
20017
20234
|
};
|
|
20018
|
-
module.constructPipeStep = function(
|
|
20019
|
-
|
|
20020
|
-
|
|
20235
|
+
module.constructPipeStep = function(fn, arg, returning) {
|
|
20236
|
+
const children = [[fn.leadingComment, fn.expr, fn.trailingComment].map(module.skipIfOnlyWS), " ", arg];
|
|
20237
|
+
switch (fn.expr.token) {
|
|
20238
|
+
case "yield":
|
|
20239
|
+
case "await":
|
|
20240
|
+
if (returning) {
|
|
20241
|
+
return [
|
|
20242
|
+
children,
|
|
20243
|
+
returning
|
|
20244
|
+
];
|
|
20245
|
+
}
|
|
20246
|
+
return [
|
|
20247
|
+
children,
|
|
20248
|
+
null
|
|
20249
|
+
];
|
|
20250
|
+
case "return":
|
|
20251
|
+
return [{
|
|
20252
|
+
type: "ReturnStatement",
|
|
20253
|
+
children
|
|
20254
|
+
}, null];
|
|
20255
|
+
}
|
|
20256
|
+
if (returning) {
|
|
20257
|
+
return [
|
|
20258
|
+
module.constructInvocation(fn, arg),
|
|
20259
|
+
returning
|
|
20260
|
+
];
|
|
20021
20261
|
}
|
|
20022
|
-
return module.constructInvocation(
|
|
20262
|
+
return [module.constructInvocation(fn, arg), null];
|
|
20023
20263
|
};
|
|
20024
20264
|
return $0;
|
|
20025
20265
|
});
|
|
@@ -20045,7 +20285,7 @@ ${input.slice(result.pos)}
|
|
|
20045
20285
|
return result;
|
|
20046
20286
|
}
|
|
20047
20287
|
}
|
|
20048
|
-
var Indent$0 = $TR($EXPECT($
|
|
20288
|
+
var Indent$0 = $TR($EXPECT($R62, fail, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
20049
20289
|
let level;
|
|
20050
20290
|
if (module.config.tab) {
|
|
20051
20291
|
const tabs = $0.match(/\t/g);
|
|
@@ -20200,7 +20440,7 @@ ${input.slice(result.pos)}
|
|
|
20200
20440
|
return result;
|
|
20201
20441
|
}
|
|
20202
20442
|
}
|
|
20203
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
20443
|
+
var PopIndent$0 = $TV($EXPECT($L18, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
20204
20444
|
if (module.config.verbose) {
|
|
20205
20445
|
console.log("popping indent", module.indentLevels[module.indentLevels.length - 1], "->", module.indentLevels[module.indentLevels.length - 2]);
|
|
20206
20446
|
}
|