@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.js
CHANGED
|
@@ -443,11 +443,12 @@ ${input.slice(result.pos)}
|
|
|
443
443
|
NonSuppressedTrailingMemberExpressions,
|
|
444
444
|
CommaDelimiter,
|
|
445
445
|
ArgumentList,
|
|
446
|
+
NonPipelineArgumentList,
|
|
446
447
|
NestedArgumentList,
|
|
447
448
|
NestedArgument,
|
|
448
|
-
InlineArgumentExpressions,
|
|
449
449
|
SingleLineArgumentExpressions,
|
|
450
450
|
ArgumentPart,
|
|
451
|
+
NonPipelineArgumentPart,
|
|
451
452
|
BinaryOpExpression,
|
|
452
453
|
BinaryOpRHS,
|
|
453
454
|
RHS,
|
|
@@ -625,6 +626,8 @@ ${input.slice(result.pos)}
|
|
|
625
626
|
CoffeeWordAssignmentOp,
|
|
626
627
|
BinaryOp,
|
|
627
628
|
BinaryOpSymbol,
|
|
629
|
+
Xor,
|
|
630
|
+
Xnor,
|
|
628
631
|
UnaryOp,
|
|
629
632
|
ModuleItem,
|
|
630
633
|
StatementListItem,
|
|
@@ -1021,225 +1024,231 @@ ${input.slice(result.pos)}
|
|
|
1021
1024
|
var $L12 = $L("super");
|
|
1022
1025
|
var $L13 = $L("import");
|
|
1023
1026
|
var $L14 = $L("!");
|
|
1024
|
-
var $L15 = $L("
|
|
1025
|
-
var $L16 = $L("
|
|
1026
|
-
var $L17 = $L("");
|
|
1027
|
-
var $L18 = $L("
|
|
1028
|
-
var $L19 = $L("
|
|
1029
|
-
var $L20 = $L("
|
|
1030
|
-
var $L21 = $L("
|
|
1031
|
-
var $L22 = $L("
|
|
1032
|
-
var $L23 = $L("
|
|
1033
|
-
var $L24 = $L("
|
|
1034
|
-
var $L25 = $L("
|
|
1035
|
-
var $L26 = $L("
|
|
1036
|
-
var $L27 = $L("
|
|
1037
|
-
var $L28 = $L("
|
|
1038
|
-
var $L29 = $L("
|
|
1039
|
-
var $L30 = $L("
|
|
1040
|
-
var $L31 = $L("
|
|
1041
|
-
var $L32 = $L("
|
|
1042
|
-
var $L33 = $L("
|
|
1043
|
-
var $L34 = $L("
|
|
1044
|
-
var $L35 = $L("
|
|
1045
|
-
var $L36 = $L("
|
|
1046
|
-
var $L37 = $L("
|
|
1047
|
-
var $L38 = $L("
|
|
1048
|
-
var $L39 = $L("
|
|
1049
|
-
var $L40 = $L("
|
|
1050
|
-
var $L41 = $L("
|
|
1051
|
-
var $L42 = $L("
|
|
1052
|
-
var $L43 = $L("
|
|
1053
|
-
var $L44 = $L("
|
|
1054
|
-
var $L45 = $L("
|
|
1055
|
-
var $L46 = $L("
|
|
1056
|
-
var $L47 = $L("
|
|
1057
|
-
var $L48 = $L("
|
|
1058
|
-
var $L49 = $L("
|
|
1059
|
-
var $L50 = $L("
|
|
1060
|
-
var $L51 = $L("
|
|
1061
|
-
var $L52 = $L("
|
|
1062
|
-
var $L53 = $L("
|
|
1063
|
-
var $L54 = $L("
|
|
1064
|
-
var $L55 = $L("
|
|
1065
|
-
var $L56 = $L("
|
|
1066
|
-
var $L57 = $L("
|
|
1067
|
-
var $L58 = $L("
|
|
1068
|
-
var $L59 = $L("
|
|
1069
|
-
var $L60 = $L("
|
|
1070
|
-
var $L61 = $L("
|
|
1071
|
-
var $L62 = $L("
|
|
1072
|
-
var $L63 = $L("
|
|
1073
|
-
var $L64 = $L("
|
|
1074
|
-
var $L65 = $L("
|
|
1075
|
-
var $L66 = $L("
|
|
1076
|
-
var $L67 = $L("
|
|
1077
|
-
var $L68 = $L("
|
|
1078
|
-
var $L69 = $L("
|
|
1079
|
-
var $L70 = $L("
|
|
1080
|
-
var $L71 = $L("
|
|
1081
|
-
var $L72 = $L("
|
|
1082
|
-
var $L73 = $L("
|
|
1083
|
-
var $L74 = $L("
|
|
1084
|
-
var $L75 = $L("
|
|
1085
|
-
var $L76 = $L("
|
|
1086
|
-
var $L77 = $L("
|
|
1087
|
-
var $L78 = $L("
|
|
1088
|
-
var $L79 = $L("
|
|
1089
|
-
var $L80 = $L("
|
|
1090
|
-
var $L81 = $L("
|
|
1091
|
-
var $L82 = $L("
|
|
1092
|
-
var $L83 = $L("
|
|
1093
|
-
var $L84 = $L("
|
|
1094
|
-
var $L85 = $L("
|
|
1095
|
-
var $L86 = $L("
|
|
1096
|
-
var $L87 = $L("
|
|
1097
|
-
var $L88 = $L("
|
|
1098
|
-
var $L89 = $L("
|
|
1099
|
-
var $L90 = $L("
|
|
1100
|
-
var $L91 = $L("
|
|
1101
|
-
var $L92 = $L("
|
|
1102
|
-
var $L93 = $L("
|
|
1103
|
-
var $L94 = $L("
|
|
1104
|
-
var $L95 = $L("
|
|
1105
|
-
var $L96 = $L("
|
|
1106
|
-
var $L97 = $L("
|
|
1107
|
-
var $L98 = $L("
|
|
1108
|
-
var $L99 = $L("
|
|
1109
|
-
var $L100 = $L("
|
|
1110
|
-
var $L101 = $L("
|
|
1111
|
-
var $L102 = $L("
|
|
1112
|
-
var $L103 = $L("
|
|
1113
|
-
var $L104 = $L("
|
|
1114
|
-
var $L105 = $L("
|
|
1115
|
-
var $L106 = $L("
|
|
1116
|
-
var $L107 = $L("
|
|
1117
|
-
var $L108 = $L("
|
|
1118
|
-
var $L109 = $L("
|
|
1119
|
-
var $L110 = $L("
|
|
1120
|
-
var $L111 = $L("
|
|
1121
|
-
var $L112 = $L(
|
|
1122
|
-
var $L113 = $L("
|
|
1123
|
-
var $L114 = $L("
|
|
1124
|
-
var $L115 = $L("
|
|
1125
|
-
var $L116 = $L("
|
|
1126
|
-
var $L117 = $L("
|
|
1127
|
-
var $L118 = $L("
|
|
1128
|
-
var $L119 = $L("
|
|
1129
|
-
var $L120 = $L("
|
|
1130
|
-
var $L121 = $L("
|
|
1131
|
-
var $L122 = $L("
|
|
1132
|
-
var $L123 = $L("
|
|
1133
|
-
var $L124 = $L("
|
|
1134
|
-
var $L125 = $L("
|
|
1135
|
-
var $L126 = $L("
|
|
1136
|
-
var $L127 = $L("
|
|
1137
|
-
var $L128 = $L("
|
|
1138
|
-
var $L129 = $L("
|
|
1139
|
-
var $L130 = $L("
|
|
1140
|
-
var $L131 = $L("
|
|
1141
|
-
var $L132 = $L("
|
|
1142
|
-
var $L133 = $L("
|
|
1143
|
-
var $L134 = $L("
|
|
1144
|
-
var $L135 = $L("
|
|
1145
|
-
var $L136 = $L("
|
|
1146
|
-
var $L137 = $L("
|
|
1147
|
-
var $L138 = $L("
|
|
1148
|
-
var $L139 = $L("
|
|
1149
|
-
var $L140 = $L("
|
|
1150
|
-
var $L141 = $L("
|
|
1151
|
-
var $L142 = $L("
|
|
1152
|
-
var $L143 = $L("
|
|
1153
|
-
var $L144 = $L("
|
|
1154
|
-
var $L145 = $L(
|
|
1155
|
-
var $L146 = $L("
|
|
1156
|
-
var $L147 = $L("
|
|
1157
|
-
var $L148 = $L("
|
|
1158
|
-
var $L149 = $L("
|
|
1159
|
-
var $L150 = $L("
|
|
1160
|
-
var $L151 = $L("
|
|
1161
|
-
var $L152 = $L("
|
|
1162
|
-
var $L153 = $L("
|
|
1163
|
-
var $L154 = $L("
|
|
1164
|
-
var $L155 = $L("
|
|
1165
|
-
var $L156 = $L("
|
|
1166
|
-
var $L157 = $L("
|
|
1167
|
-
var $L158 = $L("
|
|
1168
|
-
var $L159 = $L("
|
|
1169
|
-
var $L160 = $L("
|
|
1170
|
-
var $L161 = $L("
|
|
1171
|
-
var $L162 = $L("
|
|
1172
|
-
var $L163 = $L("
|
|
1173
|
-
var $L164 = $L("
|
|
1174
|
-
var $L165 = $L("
|
|
1175
|
-
var $L166 = $L("
|
|
1176
|
-
var $L167 = $L("
|
|
1177
|
-
var $L168 = $L("
|
|
1178
|
-
var $L169 = $L("
|
|
1179
|
-
var $L170 = $L("
|
|
1180
|
-
var $L171 = $L("
|
|
1181
|
-
var $
|
|
1027
|
+
var $L15 = $L("^");
|
|
1028
|
+
var $L16 = $L("-");
|
|
1029
|
+
var $L17 = $L("import.meta");
|
|
1030
|
+
var $L18 = $L("");
|
|
1031
|
+
var $L19 = $L(")");
|
|
1032
|
+
var $L20 = $L(",");
|
|
1033
|
+
var $L21 = $L("->");
|
|
1034
|
+
var $L22 = $L("}");
|
|
1035
|
+
var $L23 = $L("null");
|
|
1036
|
+
var $L24 = $L("true");
|
|
1037
|
+
var $L25 = $L("false");
|
|
1038
|
+
var $L26 = $L("yes");
|
|
1039
|
+
var $L27 = $L("on");
|
|
1040
|
+
var $L28 = $L("no");
|
|
1041
|
+
var $L29 = $L("off");
|
|
1042
|
+
var $L30 = $L(">");
|
|
1043
|
+
var $L31 = $L("]");
|
|
1044
|
+
var $L32 = $L(":");
|
|
1045
|
+
var $L33 = $L("**=");
|
|
1046
|
+
var $L34 = $L("*=");
|
|
1047
|
+
var $L35 = $L("/=");
|
|
1048
|
+
var $L36 = $L("%=");
|
|
1049
|
+
var $L37 = $L("+=");
|
|
1050
|
+
var $L38 = $L("-=");
|
|
1051
|
+
var $L39 = $L("<<=");
|
|
1052
|
+
var $L40 = $L(">>>=");
|
|
1053
|
+
var $L41 = $L(">>=");
|
|
1054
|
+
var $L42 = $L("&&=");
|
|
1055
|
+
var $L43 = $L("&=");
|
|
1056
|
+
var $L44 = $L("^=");
|
|
1057
|
+
var $L45 = $L("||=");
|
|
1058
|
+
var $L46 = $L("|=");
|
|
1059
|
+
var $L47 = $L("??=");
|
|
1060
|
+
var $L48 = $L("?=");
|
|
1061
|
+
var $L49 = $L("and=");
|
|
1062
|
+
var $L50 = $L("or=");
|
|
1063
|
+
var $L51 = $L("not");
|
|
1064
|
+
var $L52 = $L("**");
|
|
1065
|
+
var $L53 = $L("*");
|
|
1066
|
+
var $L54 = $L("/");
|
|
1067
|
+
var $L55 = $L("%%");
|
|
1068
|
+
var $L56 = $L("%");
|
|
1069
|
+
var $L57 = $L("+");
|
|
1070
|
+
var $L58 = $L("<=");
|
|
1071
|
+
var $L59 = $L(">=");
|
|
1072
|
+
var $L60 = $L("<?");
|
|
1073
|
+
var $L61 = $L("!<?");
|
|
1074
|
+
var $L62 = $L("<<");
|
|
1075
|
+
var $L63 = $L(">>>");
|
|
1076
|
+
var $L64 = $L(">>");
|
|
1077
|
+
var $L65 = $L("!==");
|
|
1078
|
+
var $L66 = $L("!=");
|
|
1079
|
+
var $L67 = $L("isnt");
|
|
1080
|
+
var $L68 = $L("===");
|
|
1081
|
+
var $L69 = $L("==");
|
|
1082
|
+
var $L70 = $L("and");
|
|
1083
|
+
var $L71 = $L("&&");
|
|
1084
|
+
var $L72 = $L("of");
|
|
1085
|
+
var $L73 = $L("or");
|
|
1086
|
+
var $L74 = $L("||");
|
|
1087
|
+
var $L75 = $L("^^");
|
|
1088
|
+
var $L76 = $L("xor");
|
|
1089
|
+
var $L77 = $L("xnor");
|
|
1090
|
+
var $L78 = $L("??");
|
|
1091
|
+
var $L79 = $L("instanceof");
|
|
1092
|
+
var $L80 = $L("in");
|
|
1093
|
+
var $L81 = $L("is");
|
|
1094
|
+
var $L82 = $L("&");
|
|
1095
|
+
var $L83 = $L("|");
|
|
1096
|
+
var $L84 = $L(";");
|
|
1097
|
+
var $L85 = $L("own");
|
|
1098
|
+
var $L86 = $L("break");
|
|
1099
|
+
var $L87 = $L("continue");
|
|
1100
|
+
var $L88 = $L("debugger");
|
|
1101
|
+
var $L89 = $L("assert");
|
|
1102
|
+
var $L90 = $L(":=");
|
|
1103
|
+
var $L91 = $L(".=");
|
|
1104
|
+
var $L92 = $L("/*");
|
|
1105
|
+
var $L93 = $L("*/");
|
|
1106
|
+
var $L94 = $L("\\");
|
|
1107
|
+
var $L95 = $L("[");
|
|
1108
|
+
var $L96 = $L("`");
|
|
1109
|
+
var $L97 = $L("abstract");
|
|
1110
|
+
var $L98 = $L("as");
|
|
1111
|
+
var $L99 = $L("@");
|
|
1112
|
+
var $L100 = $L("@@");
|
|
1113
|
+
var $L101 = $L("async");
|
|
1114
|
+
var $L102 = $L("await");
|
|
1115
|
+
var $L103 = $L("by");
|
|
1116
|
+
var $L104 = $L("case");
|
|
1117
|
+
var $L105 = $L("catch");
|
|
1118
|
+
var $L106 = $L("class");
|
|
1119
|
+
var $L107 = $L("#{");
|
|
1120
|
+
var $L108 = $L("declare");
|
|
1121
|
+
var $L109 = $L("default");
|
|
1122
|
+
var $L110 = $L("delete");
|
|
1123
|
+
var $L111 = $L("do");
|
|
1124
|
+
var $L112 = $L("..");
|
|
1125
|
+
var $L113 = $L("...");
|
|
1126
|
+
var $L114 = $L("::");
|
|
1127
|
+
var $L115 = $L('"');
|
|
1128
|
+
var $L116 = $L("else");
|
|
1129
|
+
var $L117 = $L("export");
|
|
1130
|
+
var $L118 = $L("extends");
|
|
1131
|
+
var $L119 = $L("finally");
|
|
1132
|
+
var $L120 = $L("for");
|
|
1133
|
+
var $L121 = $L("from");
|
|
1134
|
+
var $L122 = $L("function");
|
|
1135
|
+
var $L123 = $L("get");
|
|
1136
|
+
var $L124 = $L("set");
|
|
1137
|
+
var $L125 = $L("if");
|
|
1138
|
+
var $L126 = $L("let");
|
|
1139
|
+
var $L127 = $L("const");
|
|
1140
|
+
var $L128 = $L("loop");
|
|
1141
|
+
var $L129 = $L("new");
|
|
1142
|
+
var $L130 = $L("<");
|
|
1143
|
+
var $L131 = $L("{");
|
|
1144
|
+
var $L132 = $L("operator");
|
|
1145
|
+
var $L133 = $L("public");
|
|
1146
|
+
var $L134 = $L("private");
|
|
1147
|
+
var $L135 = $L("protected");
|
|
1148
|
+
var $L136 = $L("||>");
|
|
1149
|
+
var $L137 = $L("|>=");
|
|
1150
|
+
var $L138 = $L("|>");
|
|
1151
|
+
var $L139 = $L("readonly");
|
|
1152
|
+
var $L140 = $L("return");
|
|
1153
|
+
var $L141 = $L("satisfies");
|
|
1154
|
+
var $L142 = $L("'");
|
|
1155
|
+
var $L143 = $L("static");
|
|
1156
|
+
var $L144 = $L("${");
|
|
1157
|
+
var $L145 = $L("switch");
|
|
1158
|
+
var $L146 = $L("target");
|
|
1159
|
+
var $L147 = $L("then");
|
|
1160
|
+
var $L148 = $L("this");
|
|
1161
|
+
var $L149 = $L("throw");
|
|
1162
|
+
var $L150 = $L('"""');
|
|
1163
|
+
var $L151 = $L("'''");
|
|
1164
|
+
var $L152 = $L("///");
|
|
1165
|
+
var $L153 = $L("```");
|
|
1166
|
+
var $L154 = $L("try");
|
|
1167
|
+
var $L155 = $L("typeof");
|
|
1168
|
+
var $L156 = $L("unless");
|
|
1169
|
+
var $L157 = $L("until");
|
|
1170
|
+
var $L158 = $L("var");
|
|
1171
|
+
var $L159 = $L("void");
|
|
1172
|
+
var $L160 = $L("when");
|
|
1173
|
+
var $L161 = $L("while");
|
|
1174
|
+
var $L162 = $L("yield");
|
|
1175
|
+
var $L163 = $L("/>");
|
|
1176
|
+
var $L164 = $L("</");
|
|
1177
|
+
var $L165 = $L("<>");
|
|
1178
|
+
var $L166 = $L("</>");
|
|
1179
|
+
var $L167 = $L("<!--");
|
|
1180
|
+
var $L168 = $L("-->");
|
|
1181
|
+
var $L169 = $L("type");
|
|
1182
|
+
var $L170 = $L("interface");
|
|
1183
|
+
var $L171 = $L("namespace");
|
|
1184
|
+
var $L172 = $L("asserts");
|
|
1185
|
+
var $L173 = $L("keyof");
|
|
1186
|
+
var $L174 = $L("infer");
|
|
1187
|
+
var $L175 = $L("[]");
|
|
1188
|
+
var $L176 = $L("civet");
|
|
1189
|
+
var $R0 = $R(new RegExp("(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1182
1190
|
var $R1 = $R(new RegExp("[0-9]", "suy"));
|
|
1183
1191
|
var $R2 = $R(new RegExp("[&]", "suy"));
|
|
1184
1192
|
var $R3 = $R(new RegExp("[!~+-]+", "suy"));
|
|
1185
1193
|
var $R4 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
1186
1194
|
var $R5 = $R(new RegExp("[!+-]", "suy"));
|
|
1187
1195
|
var $R6 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
|
|
1188
|
-
var $R7 = $R(new RegExp("
|
|
1189
|
-
var $R8 = $R(new RegExp("(
|
|
1190
|
-
var $R9 = $R(new RegExp(
|
|
1191
|
-
var $R10 = $R(new RegExp("
|
|
1192
|
-
var $R11 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)
|
|
1193
|
-
var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(
|
|
1194
|
-
var $R13 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1195
|
-
var $R14 = $R(new RegExp("(
|
|
1196
|
-
var $R15 = $R(new RegExp("
|
|
1197
|
-
var $R16 = $R(new RegExp("0[
|
|
1198
|
-
var $R17 = $R(new RegExp("0[
|
|
1199
|
-
var $R18 = $R(new RegExp("
|
|
1200
|
-
var $R19 = $R(new RegExp(
|
|
1201
|
-
var $R20 = $R(new RegExp(
|
|
1202
|
-
var $R21 = $R(new RegExp(
|
|
1203
|
-
var $R22 = $R(new RegExp(
|
|
1204
|
-
var $R23 = $R(new RegExp('(
|
|
1205
|
-
var $R24 = $R(new RegExp(
|
|
1206
|
-
var $R25 = $R(new RegExp("(
|
|
1207
|
-
var $R26 = $R(new RegExp("
|
|
1208
|
-
var $R27 = $R(new RegExp("
|
|
1209
|
-
var $R28 = $R(new RegExp("
|
|
1210
|
-
var $R29 = $R(new RegExp("[
|
|
1211
|
-
var $R30 = $R(new RegExp("
|
|
1212
|
-
var $R31 = $R(new RegExp("(
|
|
1213
|
-
var $R32 = $R(new RegExp("(
|
|
1214
|
-
var $R33 = $R(new RegExp("(?:\\$(?!\\{)
|
|
1215
|
-
var $R34 = $R(new RegExp("(
|
|
1216
|
-
var $R35 = $R(new RegExp("(?:
|
|
1217
|
-
var $R36 = $R(new RegExp("(?:
|
|
1218
|
-
var $R37 = $R(new RegExp("(?:
|
|
1219
|
-
var $R38 = $R(new RegExp("(?:
|
|
1220
|
-
var $R39 = $R(new RegExp("
|
|
1221
|
-
var $R40 = $R(new RegExp("
|
|
1222
|
-
var $R41 = $R(new RegExp("
|
|
1223
|
-
var $R42 = $R(new RegExp("[
|
|
1224
|
-
var $R43 = $R(new RegExp("
|
|
1225
|
-
var $R44 = $R(new RegExp("
|
|
1226
|
-
var $R45 = $R(new RegExp("[
|
|
1227
|
-
var $R46 = $R(new RegExp("
|
|
1228
|
-
var $R47 = $R(new RegExp("
|
|
1229
|
-
var $R48 = $R(new RegExp("
|
|
1230
|
-
var $R49 = $R(new RegExp("[\\
|
|
1231
|
-
var $R50 = $R(new RegExp("
|
|
1232
|
-
var $R51 = $R(new RegExp("[
|
|
1233
|
-
var $R52 = $R(new RegExp("
|
|
1234
|
-
var $R53 = $R(new RegExp("[
|
|
1235
|
-
var $R54 = $R(new RegExp("[
|
|
1236
|
-
var $R55 = $R(new RegExp("[+-]", "suy"));
|
|
1237
|
-
var $R56 = $R(new RegExp("
|
|
1238
|
-
var $R57 = $R(new RegExp("[\\
|
|
1239
|
-
var $R58 = $R(new RegExp("[\\
|
|
1240
|
-
var $R59 = $R(new RegExp("
|
|
1241
|
-
var $R60 = $R(new RegExp("\\
|
|
1242
|
-
var $R61 = $R(new RegExp("
|
|
1196
|
+
var $R7 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
1197
|
+
var $R8 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
1198
|
+
var $R9 = $R(new RegExp("(?=[\\s\\)])", "suy"));
|
|
1199
|
+
var $R10 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
1200
|
+
var $R11 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
1201
|
+
var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
1202
|
+
var $R13 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
1203
|
+
var $R14 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1204
|
+
var $R15 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
1205
|
+
var $R16 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
1206
|
+
var $R17 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
1207
|
+
var $R18 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
1208
|
+
var $R19 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1209
|
+
var $R20 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
1210
|
+
var $R21 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
1211
|
+
var $R22 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
1212
|
+
var $R23 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
1213
|
+
var $R24 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
1214
|
+
var $R25 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
1215
|
+
var $R26 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
1216
|
+
var $R27 = $R(new RegExp("[\\s]+", "suy"));
|
|
1217
|
+
var $R28 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
1218
|
+
var $R29 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
1219
|
+
var $R30 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
1220
|
+
var $R31 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
1221
|
+
var $R32 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
1222
|
+
var $R33 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
1223
|
+
var $R34 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
1224
|
+
var $R35 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
1225
|
+
var $R36 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
1226
|
+
var $R37 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
1227
|
+
var $R38 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
1228
|
+
var $R39 = $R(new RegExp("(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
1229
|
+
var $R40 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
1230
|
+
var $R41 = $R(new RegExp(".", "suy"));
|
|
1231
|
+
var $R42 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
1232
|
+
var $R43 = $R(new RegExp("[^]*?###", "suy"));
|
|
1233
|
+
var $R44 = $R(new RegExp("###(?!#)", "suy"));
|
|
1234
|
+
var $R45 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
1235
|
+
var $R46 = $R(new RegExp("[ \\t]+", "suy"));
|
|
1236
|
+
var $R47 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
1237
|
+
var $R48 = $R(new RegExp("\\s", "suy"));
|
|
1238
|
+
var $R49 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
1239
|
+
var $R50 = $R(new RegExp("[\\s>]", "suy"));
|
|
1240
|
+
var $R51 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
1241
|
+
var $R52 = $R(new RegExp("[<>]", "suy"));
|
|
1242
|
+
var $R53 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
1243
|
+
var $R54 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
1244
|
+
var $R55 = $R(new RegExp("[+-]?", "suy"));
|
|
1245
|
+
var $R56 = $R(new RegExp("[+-]", "suy"));
|
|
1246
|
+
var $R57 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
1247
|
+
var $R58 = $R(new RegExp("[\\t ]*", "suy"));
|
|
1248
|
+
var $R59 = $R(new RegExp("[\\s]*", "suy"));
|
|
1249
|
+
var $R60 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
1250
|
+
var $R61 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
1251
|
+
var $R62 = $R(new RegExp("[ \\t]*", "suy"));
|
|
1243
1252
|
var Program$0 = $TS($S(Reset, Init, __, $Q(TopLevelStatement), __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1244
1253
|
var statements = $4;
|
|
1245
1254
|
module2.processProgram(statements);
|
|
@@ -1482,7 +1491,7 @@ ${input.slice(result.pos)}
|
|
|
1482
1491
|
return result;
|
|
1483
1492
|
}
|
|
1484
1493
|
}
|
|
1485
|
-
var ImplicitArguments$0 = $TS($S($E($S(TypeArguments, $N(ImplementsToken))), ApplicationStart, InsertOpenParen, $Q(_),
|
|
1494
|
+
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) {
|
|
1486
1495
|
var ta = $1;
|
|
1487
1496
|
var open = $3;
|
|
1488
1497
|
var ws = $4;
|
|
@@ -1559,7 +1568,7 @@ ${input.slice(result.pos)}
|
|
|
1559
1568
|
return result;
|
|
1560
1569
|
}
|
|
1561
1570
|
}
|
|
1562
|
-
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|for|while|until|of|satisfies|then|when|implements)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
1571
|
+
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
1563
1572
|
var ForbiddenImplicitCalls$1 = $EXPECT($L0, fail, 'ForbiddenImplicitCalls "/ "');
|
|
1564
1573
|
var ForbiddenImplicitCalls$2 = AtAt;
|
|
1565
1574
|
var ForbiddenImplicitCalls$3 = $S(Identifier, $EXPECT($L1, fail, 'ForbiddenImplicitCalls "="'), Whitespace);
|
|
@@ -1700,7 +1709,9 @@ ${input.slice(result.pos)}
|
|
|
1700
1709
|
return module2.insertTrimmingSpace($1, "");
|
|
1701
1710
|
});
|
|
1702
1711
|
var ArgumentList$2 = NestedArgumentList;
|
|
1703
|
-
var ArgumentList$3 =
|
|
1712
|
+
var ArgumentList$3 = $TS($S($Q(TrailingComment), ArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
|
|
1713
|
+
return [...$1, $2, ...$3];
|
|
1714
|
+
});
|
|
1704
1715
|
function ArgumentList(state) {
|
|
1705
1716
|
let eventData;
|
|
1706
1717
|
if (state.events) {
|
|
@@ -1723,6 +1734,36 @@ ${input.slice(result.pos)}
|
|
|
1723
1734
|
return result;
|
|
1724
1735
|
}
|
|
1725
1736
|
}
|
|
1737
|
+
var NonPipelineArgumentList$0 = $S(NonPipelineArgumentPart, $P($S(CommaDelimiter, $C(NestedImplicitObjectLiteral, NestedArgumentList))));
|
|
1738
|
+
var NonPipelineArgumentList$1 = $TS($S(NestedImplicitObjectLiteral), function($skip, $loc, $0, $1) {
|
|
1739
|
+
return module2.insertTrimmingSpace($1, "");
|
|
1740
|
+
});
|
|
1741
|
+
var NonPipelineArgumentList$2 = NestedArgumentList;
|
|
1742
|
+
var NonPipelineArgumentList$3 = $TS($S($Q(TrailingComment), NonPipelineArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), NonPipelineArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
|
|
1743
|
+
return [...$1, $2, ...$3];
|
|
1744
|
+
});
|
|
1745
|
+
function NonPipelineArgumentList(state) {
|
|
1746
|
+
let eventData;
|
|
1747
|
+
if (state.events) {
|
|
1748
|
+
const result = state.events.enter?.("NonPipelineArgumentList", state);
|
|
1749
|
+
if (result) {
|
|
1750
|
+
if (result.cache)
|
|
1751
|
+
return result.cache;
|
|
1752
|
+
eventData = result.data;
|
|
1753
|
+
}
|
|
1754
|
+
}
|
|
1755
|
+
if (state.tokenize) {
|
|
1756
|
+
const result = $TOKEN("NonPipelineArgumentList", state, NonPipelineArgumentList$0(state) || NonPipelineArgumentList$1(state) || NonPipelineArgumentList$2(state) || NonPipelineArgumentList$3(state));
|
|
1757
|
+
if (state.events)
|
|
1758
|
+
state.events.exit?.("NonPipelineArgumentList", state, result, eventData);
|
|
1759
|
+
return result;
|
|
1760
|
+
} else {
|
|
1761
|
+
const result = NonPipelineArgumentList$0(state) || NonPipelineArgumentList$1(state) || NonPipelineArgumentList$2(state) || NonPipelineArgumentList$3(state);
|
|
1762
|
+
if (state.events)
|
|
1763
|
+
state.events.exit?.("NonPipelineArgumentList", state, result, eventData);
|
|
1764
|
+
return result;
|
|
1765
|
+
}
|
|
1766
|
+
}
|
|
1726
1767
|
var NestedArgumentList$0 = $TS($S(PushIndent, $Q(NestedArgument), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
1727
1768
|
var args = $2;
|
|
1728
1769
|
if (args.length)
|
|
@@ -1774,13 +1815,11 @@ ${input.slice(result.pos)}
|
|
|
1774
1815
|
return result;
|
|
1775
1816
|
}
|
|
1776
1817
|
}
|
|
1777
|
-
var
|
|
1778
|
-
|
|
1779
|
-
});
|
|
1780
|
-
function InlineArgumentExpressions(state) {
|
|
1818
|
+
var SingleLineArgumentExpressions$0 = $S($Q(TrailingComment), ArgumentPart, $Q($S($Q(TrailingComment), Comma, $Q(TrailingComment), ArgumentPart)));
|
|
1819
|
+
function SingleLineArgumentExpressions(state) {
|
|
1781
1820
|
let eventData;
|
|
1782
1821
|
if (state.events) {
|
|
1783
|
-
const result = state.events.enter?.("
|
|
1822
|
+
const result = state.events.enter?.("SingleLineArgumentExpressions", state);
|
|
1784
1823
|
if (result) {
|
|
1785
1824
|
if (result.cache)
|
|
1786
1825
|
return result.cache;
|
|
@@ -1788,22 +1827,28 @@ ${input.slice(result.pos)}
|
|
|
1788
1827
|
}
|
|
1789
1828
|
}
|
|
1790
1829
|
if (state.tokenize) {
|
|
1791
|
-
const result = $TOKEN("
|
|
1830
|
+
const result = $TOKEN("SingleLineArgumentExpressions", state, SingleLineArgumentExpressions$0(state));
|
|
1792
1831
|
if (state.events)
|
|
1793
|
-
state.events.exit?.("
|
|
1832
|
+
state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
|
|
1794
1833
|
return result;
|
|
1795
1834
|
} else {
|
|
1796
|
-
const result =
|
|
1835
|
+
const result = SingleLineArgumentExpressions$0(state);
|
|
1797
1836
|
if (state.events)
|
|
1798
|
-
state.events.exit?.("
|
|
1837
|
+
state.events.exit?.("SingleLineArgumentExpressions", state, result, eventData);
|
|
1799
1838
|
return result;
|
|
1800
1839
|
}
|
|
1801
1840
|
}
|
|
1802
|
-
var
|
|
1803
|
-
|
|
1841
|
+
var ArgumentPart$0 = $S(DotDotDot, ExtendedExpression);
|
|
1842
|
+
var ArgumentPart$1 = $TS($S(ExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
|
|
1843
|
+
if ($2) {
|
|
1844
|
+
return [$2, $1];
|
|
1845
|
+
}
|
|
1846
|
+
return $1;
|
|
1847
|
+
});
|
|
1848
|
+
function ArgumentPart(state) {
|
|
1804
1849
|
let eventData;
|
|
1805
1850
|
if (state.events) {
|
|
1806
|
-
const result = state.events.enter?.("
|
|
1851
|
+
const result = state.events.enter?.("ArgumentPart", state);
|
|
1807
1852
|
if (result) {
|
|
1808
1853
|
if (result.cache)
|
|
1809
1854
|
return result.cache;
|
|
@@ -1811,28 +1856,28 @@ ${input.slice(result.pos)}
|
|
|
1811
1856
|
}
|
|
1812
1857
|
}
|
|
1813
1858
|
if (state.tokenize) {
|
|
1814
|
-
const result = $TOKEN("
|
|
1859
|
+
const result = $TOKEN("ArgumentPart", state, ArgumentPart$0(state) || ArgumentPart$1(state));
|
|
1815
1860
|
if (state.events)
|
|
1816
|
-
state.events.exit?.("
|
|
1861
|
+
state.events.exit?.("ArgumentPart", state, result, eventData);
|
|
1817
1862
|
return result;
|
|
1818
1863
|
} else {
|
|
1819
|
-
const result =
|
|
1864
|
+
const result = ArgumentPart$0(state) || ArgumentPart$1(state);
|
|
1820
1865
|
if (state.events)
|
|
1821
|
-
state.events.exit?.("
|
|
1866
|
+
state.events.exit?.("ArgumentPart", state, result, eventData);
|
|
1822
1867
|
return result;
|
|
1823
1868
|
}
|
|
1824
1869
|
}
|
|
1825
|
-
var
|
|
1826
|
-
var
|
|
1870
|
+
var NonPipelineArgumentPart$0 = $S(DotDotDot, NonPipelineExtendedExpression);
|
|
1871
|
+
var NonPipelineArgumentPart$1 = $TS($S(NonPipelineExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
|
|
1827
1872
|
if ($2) {
|
|
1828
1873
|
return [$2, $1];
|
|
1829
1874
|
}
|
|
1830
1875
|
return $1;
|
|
1831
1876
|
});
|
|
1832
|
-
function
|
|
1877
|
+
function NonPipelineArgumentPart(state) {
|
|
1833
1878
|
let eventData;
|
|
1834
1879
|
if (state.events) {
|
|
1835
|
-
const result = state.events.enter?.("
|
|
1880
|
+
const result = state.events.enter?.("NonPipelineArgumentPart", state);
|
|
1836
1881
|
if (result) {
|
|
1837
1882
|
if (result.cache)
|
|
1838
1883
|
return result.cache;
|
|
@@ -1840,14 +1885,14 @@ ${input.slice(result.pos)}
|
|
|
1840
1885
|
}
|
|
1841
1886
|
}
|
|
1842
1887
|
if (state.tokenize) {
|
|
1843
|
-
const result = $TOKEN("
|
|
1888
|
+
const result = $TOKEN("NonPipelineArgumentPart", state, NonPipelineArgumentPart$0(state) || NonPipelineArgumentPart$1(state));
|
|
1844
1889
|
if (state.events)
|
|
1845
|
-
state.events.exit?.("
|
|
1890
|
+
state.events.exit?.("NonPipelineArgumentPart", state, result, eventData);
|
|
1846
1891
|
return result;
|
|
1847
1892
|
} else {
|
|
1848
|
-
const result =
|
|
1893
|
+
const result = NonPipelineArgumentPart$0(state) || NonPipelineArgumentPart$1(state);
|
|
1849
1894
|
if (state.events)
|
|
1850
|
-
state.events.exit?.("
|
|
1895
|
+
state.events.exit?.("NonPipelineArgumentPart", state, result, eventData);
|
|
1851
1896
|
return result;
|
|
1852
1897
|
}
|
|
1853
1898
|
}
|
|
@@ -2096,7 +2141,6 @@ ${input.slice(result.pos)}
|
|
|
2096
2141
|
}
|
|
2097
2142
|
}
|
|
2098
2143
|
var NonPipelineAssignmentExpression$0 = SingleLineAssignmentExpression;
|
|
2099
|
-
var NonPipelineAssignmentExpression$1 = $S(__, AssignmentExpressionTail);
|
|
2100
2144
|
function NonPipelineAssignmentExpression(state) {
|
|
2101
2145
|
let eventData;
|
|
2102
2146
|
if (state.events) {
|
|
@@ -2108,12 +2152,12 @@ ${input.slice(result.pos)}
|
|
|
2108
2152
|
}
|
|
2109
2153
|
}
|
|
2110
2154
|
if (state.tokenize) {
|
|
2111
|
-
const result = $TOKEN("NonPipelineAssignmentExpression", state, NonPipelineAssignmentExpression$0(state)
|
|
2155
|
+
const result = $TOKEN("NonPipelineAssignmentExpression", state, NonPipelineAssignmentExpression$0(state));
|
|
2112
2156
|
if (state.events)
|
|
2113
2157
|
state.events.exit?.("NonPipelineAssignmentExpression", state, result, eventData);
|
|
2114
2158
|
return result;
|
|
2115
2159
|
} else {
|
|
2116
|
-
const result = NonPipelineAssignmentExpression$0(state)
|
|
2160
|
+
const result = NonPipelineAssignmentExpression$0(state);
|
|
2117
2161
|
if (state.events)
|
|
2118
2162
|
state.events.exit?.("NonPipelineAssignmentExpression", state, result, eventData);
|
|
2119
2163
|
return result;
|
|
@@ -2485,30 +2529,12 @@ ${input.slice(result.pos)}
|
|
|
2485
2529
|
return result;
|
|
2486
2530
|
}
|
|
2487
2531
|
}
|
|
2488
|
-
var PipelineExpression$0 = $TS($S(
|
|
2532
|
+
var PipelineExpression$0 = $TS($S(PipelineHeadItem, $P($S(__, Pipe, __, PipelineTailItem))), function($skip, $loc, $0, $1, $2) {
|
|
2489
2533
|
var head = $1;
|
|
2490
2534
|
var body = $2;
|
|
2491
|
-
var preTailWS = $3;
|
|
2492
|
-
var tail = $4;
|
|
2493
|
-
let children = head.slice(0, -1).map(module2.skipIfOnlyWS);
|
|
2494
|
-
for (const [leadingComment, expr, trailingComment] of body) {
|
|
2495
|
-
children = module2.constructPipeStep(
|
|
2496
|
-
{
|
|
2497
|
-
leadingComment: module2.skipIfOnlyWS(leadingComment),
|
|
2498
|
-
trailingComment: module2.skipIfOnlyWS(trailingComment),
|
|
2499
|
-
expr
|
|
2500
|
-
},
|
|
2501
|
-
{ expr: children }
|
|
2502
|
-
);
|
|
2503
|
-
}
|
|
2504
2535
|
return {
|
|
2505
|
-
|
|
2506
|
-
|
|
2507
|
-
leadingComment: module2.skipIfOnlyWS(preTailWS),
|
|
2508
|
-
expr: tail
|
|
2509
|
-
},
|
|
2510
|
-
{ expr: children }
|
|
2511
|
-
)
|
|
2536
|
+
type: "PipelineExpression",
|
|
2537
|
+
children: [head, body]
|
|
2512
2538
|
};
|
|
2513
2539
|
});
|
|
2514
2540
|
function PipelineExpression(state) {
|
|
@@ -3367,8 +3393,8 @@ ${input.slice(result.pos)}
|
|
|
3367
3393
|
return result;
|
|
3368
3394
|
}
|
|
3369
3395
|
}
|
|
3370
|
-
var NonNullAssertion$0 = $T($EXPECT($L14, fail, 'NonNullAssertion "!"'), function(value) {
|
|
3371
|
-
return { "type": "NonNullAssertion", "ts": true, "children": value };
|
|
3396
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L14, fail, 'NonNullAssertion "!"'), $N($EXPECT($L15, fail, 'NonNullAssertion "^"'))), function(value) {
|
|
3397
|
+
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
3372
3398
|
});
|
|
3373
3399
|
function NonNullAssertion(state) {
|
|
3374
3400
|
let eventData;
|
|
@@ -3505,7 +3531,7 @@ ${input.slice(result.pos)}
|
|
|
3505
3531
|
]
|
|
3506
3532
|
};
|
|
3507
3533
|
});
|
|
3508
|
-
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($
|
|
3534
|
+
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($L16, fail, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
3509
3535
|
var dot = $1;
|
|
3510
3536
|
var neg = $2;
|
|
3511
3537
|
var num = $3;
|
|
@@ -3702,7 +3728,7 @@ ${input.slice(result.pos)}
|
|
|
3702
3728
|
}
|
|
3703
3729
|
}
|
|
3704
3730
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
3705
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
3731
|
+
var MetaProperty$1 = $TS($S($EXPECT($L17, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3706
3732
|
return { $loc, token: $1 };
|
|
3707
3733
|
});
|
|
3708
3734
|
function MetaProperty(state) {
|
|
@@ -3728,7 +3754,7 @@ ${input.slice(result.pos)}
|
|
|
3728
3754
|
}
|
|
3729
3755
|
}
|
|
3730
3756
|
var Parameters$0 = NonEmptyParameters;
|
|
3731
|
-
var Parameters$1 = $TV($EXPECT($
|
|
3757
|
+
var Parameters$1 = $TV($EXPECT($L18, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
3732
3758
|
return {
|
|
3733
3759
|
type: "Parameters",
|
|
3734
3760
|
children: [{ $loc, token: "()" }],
|
|
@@ -3889,7 +3915,7 @@ ${input.slice(result.pos)}
|
|
|
3889
3915
|
}
|
|
3890
3916
|
}
|
|
3891
3917
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
3892
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
3918
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L19, fail, 'ParameterElementDelimiter ")"')));
|
|
3893
3919
|
var ParameterElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
3894
3920
|
return value[1];
|
|
3895
3921
|
});
|
|
@@ -4509,7 +4535,7 @@ ${input.slice(result.pos)}
|
|
|
4509
4535
|
children: $0
|
|
4510
4536
|
};
|
|
4511
4537
|
});
|
|
4512
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
4538
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
4513
4539
|
return {
|
|
4514
4540
|
children: [{
|
|
4515
4541
|
type: "ElisionElement",
|
|
@@ -4582,7 +4608,7 @@ ${input.slice(result.pos)}
|
|
|
4582
4608
|
return result;
|
|
4583
4609
|
}
|
|
4584
4610
|
}
|
|
4585
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
4611
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L18, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
4586
4612
|
const ref = {
|
|
4587
4613
|
type: "Ref",
|
|
4588
4614
|
base: "ref",
|
|
@@ -5058,7 +5084,7 @@ ${input.slice(result.pos)}
|
|
|
5058
5084
|
children: [ws, binding]
|
|
5059
5085
|
};
|
|
5060
5086
|
});
|
|
5061
|
-
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($
|
|
5087
|
+
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'MatchingElement ","'))), function($skip, $loc, $0, $1) {
|
|
5062
5088
|
return {
|
|
5063
5089
|
children: [{
|
|
5064
5090
|
type: "ElisionElement",
|
|
@@ -5452,7 +5478,7 @@ ${input.slice(result.pos)}
|
|
|
5452
5478
|
return result;
|
|
5453
5479
|
}
|
|
5454
5480
|
}
|
|
5455
|
-
var Arrow$0 = $TV($EXPECT($
|
|
5481
|
+
var Arrow$0 = $TV($EXPECT($L21, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
5456
5482
|
return { $loc, token: $1 };
|
|
5457
5483
|
});
|
|
5458
5484
|
function Arrow(state) {
|
|
@@ -5686,7 +5712,7 @@ ${input.slice(result.pos)}
|
|
|
5686
5712
|
return result;
|
|
5687
5713
|
}
|
|
5688
5714
|
}
|
|
5689
|
-
var EmptyBareBlock$0 = $TV($EXPECT($
|
|
5715
|
+
var EmptyBareBlock$0 = $TV($EXPECT($L18, fail, 'EmptyBareBlock ""'), function($skip, $loc, $0, $1) {
|
|
5690
5716
|
const expressions = [];
|
|
5691
5717
|
return {
|
|
5692
5718
|
type: "BlockStatement",
|
|
@@ -5909,7 +5935,7 @@ ${input.slice(result.pos)}
|
|
|
5909
5935
|
children: [$1, expressions]
|
|
5910
5936
|
};
|
|
5911
5937
|
});
|
|
5912
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
5938
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L22, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
5913
5939
|
const expressions = [];
|
|
5914
5940
|
return {
|
|
5915
5941
|
type: "BlockStatement",
|
|
@@ -6054,7 +6080,7 @@ ${input.slice(result.pos)}
|
|
|
6054
6080
|
return result;
|
|
6055
6081
|
}
|
|
6056
6082
|
}
|
|
6057
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
6083
|
+
var NullLiteral$0 = $TS($S($EXPECT($L23, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6058
6084
|
return { $loc, token: $1 };
|
|
6059
6085
|
});
|
|
6060
6086
|
function NullLiteral(state) {
|
|
@@ -6082,7 +6108,7 @@ ${input.slice(result.pos)}
|
|
|
6082
6108
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
6083
6109
|
return value[1];
|
|
6084
6110
|
});
|
|
6085
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6111
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L24, fail, 'BooleanLiteral "true"'), $EXPECT($L25, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6086
6112
|
return { $loc, token: $1 };
|
|
6087
6113
|
});
|
|
6088
6114
|
function BooleanLiteral(state) {
|
|
@@ -6107,10 +6133,10 @@ ${input.slice(result.pos)}
|
|
|
6107
6133
|
return result;
|
|
6108
6134
|
}
|
|
6109
6135
|
}
|
|
6110
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
6136
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L26, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L27, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6111
6137
|
return { $loc, token: "true" };
|
|
6112
6138
|
});
|
|
6113
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6139
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L28, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L29, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6114
6140
|
return { $loc, token: "false" };
|
|
6115
6141
|
});
|
|
6116
6142
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -6216,7 +6242,7 @@ ${input.slice(result.pos)}
|
|
|
6216
6242
|
return result;
|
|
6217
6243
|
}
|
|
6218
6244
|
}
|
|
6219
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($
|
|
6245
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($L30, fail, 'UpcomingAssignment ">"')))));
|
|
6220
6246
|
function UpcomingAssignment(state) {
|
|
6221
6247
|
let eventData;
|
|
6222
6248
|
if (state.events) {
|
|
@@ -6296,17 +6322,8 @@ ${input.slice(result.pos)}
|
|
|
6296
6322
|
const inclusive = range.token === "..";
|
|
6297
6323
|
range.token = ",";
|
|
6298
6324
|
if (s.type === "Literal" && e.type === "Literal") {
|
|
6299
|
-
|
|
6300
|
-
|
|
6301
|
-
start = s.raw.match(/^'(.*)'$/)[1];
|
|
6302
|
-
} else {
|
|
6303
|
-
start = JSON.parse(s.raw);
|
|
6304
|
-
}
|
|
6305
|
-
if (e.raw[0] === "'") {
|
|
6306
|
-
end = e.raw.match(/^'(.*)'$/)[1];
|
|
6307
|
-
} else {
|
|
6308
|
-
end = JSON.parse(e.raw);
|
|
6309
|
-
}
|
|
6325
|
+
const start = module2.literalValue(s);
|
|
6326
|
+
const end = module2.literalValue(e);
|
|
6310
6327
|
if (typeof start !== typeof end) {
|
|
6311
6328
|
throw new Error("Range start and end must be of the same type");
|
|
6312
6329
|
}
|
|
@@ -6489,7 +6506,7 @@ ${input.slice(result.pos)}
|
|
|
6489
6506
|
}
|
|
6490
6507
|
}
|
|
6491
6508
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
6492
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6509
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L31, fail, 'ArrayElementDelimiter "]"')));
|
|
6493
6510
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6494
6511
|
return value[1];
|
|
6495
6512
|
});
|
|
@@ -6915,7 +6932,7 @@ ${input.slice(result.pos)}
|
|
|
6915
6932
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
|
|
6916
6933
|
return value[1];
|
|
6917
6934
|
});
|
|
6918
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
6935
|
+
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($L32, fail, 'ImplicitInlineObjectPropertyDelimiter ":"'), $EXPECT($L19, fail, 'ImplicitInlineObjectPropertyDelimiter ")"'), $EXPECT($L31, fail, 'ImplicitInlineObjectPropertyDelimiter "]"'), $EXPECT($L22, fail, 'ImplicitInlineObjectPropertyDelimiter "}"'), ReservedWord))), function(value) {
|
|
6919
6936
|
return "";
|
|
6920
6937
|
});
|
|
6921
6938
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -6944,7 +6961,7 @@ ${input.slice(result.pos)}
|
|
|
6944
6961
|
}
|
|
6945
6962
|
}
|
|
6946
6963
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
6947
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6964
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L22, fail, 'ObjectPropertyDelimiter "}"')));
|
|
6948
6965
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6949
6966
|
return value[1];
|
|
6950
6967
|
});
|
|
@@ -6974,6 +6991,7 @@ ${input.slice(result.pos)}
|
|
|
6974
6991
|
return $0.map(([prop, delim]) => {
|
|
6975
6992
|
return {
|
|
6976
6993
|
...prop,
|
|
6994
|
+
delim,
|
|
6977
6995
|
children: [...prop.children, delim]
|
|
6978
6996
|
};
|
|
6979
6997
|
});
|
|
@@ -7052,7 +7070,8 @@ ${input.slice(result.pos)}
|
|
|
7052
7070
|
type: "SpreadProperty",
|
|
7053
7071
|
children: [ws, dots, exp],
|
|
7054
7072
|
names: exp.names,
|
|
7055
|
-
|
|
7073
|
+
dots,
|
|
7074
|
+
value: exp
|
|
7056
7075
|
};
|
|
7057
7076
|
});
|
|
7058
7077
|
var PropertyDefinition$5 = $TS($S(__, CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
@@ -7219,7 +7238,7 @@ ${input.slice(result.pos)}
|
|
|
7219
7238
|
expression
|
|
7220
7239
|
};
|
|
7221
7240
|
});
|
|
7222
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7241
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L16, fail, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7223
7242
|
return {
|
|
7224
7243
|
type: "ComputedPropertyName",
|
|
7225
7244
|
children: $0
|
|
@@ -7525,7 +7544,21 @@ ${input.slice(result.pos)}
|
|
|
7525
7544
|
return result;
|
|
7526
7545
|
}
|
|
7527
7546
|
}
|
|
7528
|
-
var OperatorAssignmentOp$0 = $TS($S(
|
|
7547
|
+
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7548
|
+
return {
|
|
7549
|
+
special: true,
|
|
7550
|
+
call: module2.getRef("xor"),
|
|
7551
|
+
children: [$2, ...$4]
|
|
7552
|
+
};
|
|
7553
|
+
});
|
|
7554
|
+
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7555
|
+
return {
|
|
7556
|
+
special: true,
|
|
7557
|
+
call: module2.getRef("xnor"),
|
|
7558
|
+
children: [$2, ...$4]
|
|
7559
|
+
};
|
|
7560
|
+
});
|
|
7561
|
+
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7529
7562
|
return {
|
|
7530
7563
|
special: true,
|
|
7531
7564
|
call: $1,
|
|
@@ -7543,33 +7576,33 @@ ${input.slice(result.pos)}
|
|
|
7543
7576
|
}
|
|
7544
7577
|
}
|
|
7545
7578
|
if (state.tokenize) {
|
|
7546
|
-
const result = $TOKEN("OperatorAssignmentOp", state, OperatorAssignmentOp$0(state));
|
|
7579
|
+
const result = $TOKEN("OperatorAssignmentOp", state, OperatorAssignmentOp$0(state) || OperatorAssignmentOp$1(state) || OperatorAssignmentOp$2(state));
|
|
7547
7580
|
if (state.events)
|
|
7548
7581
|
state.events.exit?.("OperatorAssignmentOp", state, result, eventData);
|
|
7549
7582
|
return result;
|
|
7550
7583
|
} else {
|
|
7551
|
-
const result = OperatorAssignmentOp$0(state);
|
|
7584
|
+
const result = OperatorAssignmentOp$0(state) || OperatorAssignmentOp$1(state) || OperatorAssignmentOp$2(state);
|
|
7552
7585
|
if (state.events)
|
|
7553
7586
|
state.events.exit?.("OperatorAssignmentOp", state, result, eventData);
|
|
7554
7587
|
return result;
|
|
7555
7588
|
}
|
|
7556
7589
|
}
|
|
7557
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
7558
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
7559
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
7560
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
7561
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
7562
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
7563
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
7564
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
7565
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
7566
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
7567
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
7568
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
7569
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
7570
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
7571
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
7572
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
7590
|
+
var AssignmentOpSymbol$0 = $EXPECT($L33, fail, 'AssignmentOpSymbol "**="');
|
|
7591
|
+
var AssignmentOpSymbol$1 = $EXPECT($L34, fail, 'AssignmentOpSymbol "*="');
|
|
7592
|
+
var AssignmentOpSymbol$2 = $EXPECT($L35, fail, 'AssignmentOpSymbol "/="');
|
|
7593
|
+
var AssignmentOpSymbol$3 = $EXPECT($L36, fail, 'AssignmentOpSymbol "%="');
|
|
7594
|
+
var AssignmentOpSymbol$4 = $EXPECT($L37, fail, 'AssignmentOpSymbol "+="');
|
|
7595
|
+
var AssignmentOpSymbol$5 = $EXPECT($L38, fail, 'AssignmentOpSymbol "-="');
|
|
7596
|
+
var AssignmentOpSymbol$6 = $EXPECT($L39, fail, 'AssignmentOpSymbol "<<="');
|
|
7597
|
+
var AssignmentOpSymbol$7 = $EXPECT($L40, fail, 'AssignmentOpSymbol ">>>="');
|
|
7598
|
+
var AssignmentOpSymbol$8 = $EXPECT($L41, fail, 'AssignmentOpSymbol ">>="');
|
|
7599
|
+
var AssignmentOpSymbol$9 = $EXPECT($L42, fail, 'AssignmentOpSymbol "&&="');
|
|
7600
|
+
var AssignmentOpSymbol$10 = $EXPECT($L43, fail, 'AssignmentOpSymbol "&="');
|
|
7601
|
+
var AssignmentOpSymbol$11 = $EXPECT($L44, fail, 'AssignmentOpSymbol "^="');
|
|
7602
|
+
var AssignmentOpSymbol$12 = $EXPECT($L45, fail, 'AssignmentOpSymbol "||="');
|
|
7603
|
+
var AssignmentOpSymbol$13 = $EXPECT($L46, fail, 'AssignmentOpSymbol "|="');
|
|
7604
|
+
var AssignmentOpSymbol$14 = $EXPECT($L47, fail, 'AssignmentOpSymbol "??="');
|
|
7605
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L48, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
7573
7606
|
return "??=";
|
|
7574
7607
|
});
|
|
7575
7608
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L1, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L1, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -7600,10 +7633,10 @@ ${input.slice(result.pos)}
|
|
|
7600
7633
|
return result;
|
|
7601
7634
|
}
|
|
7602
7635
|
}
|
|
7603
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
7636
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L49, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
7604
7637
|
return "&&=";
|
|
7605
7638
|
});
|
|
7606
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
7639
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L50, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
7607
7640
|
return "||=";
|
|
7608
7641
|
});
|
|
7609
7642
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -7642,7 +7675,7 @@ ${input.slice(result.pos)}
|
|
|
7642
7675
|
special: true
|
|
7643
7676
|
};
|
|
7644
7677
|
});
|
|
7645
|
-
var BinaryOp$2 = $TS($S($EXPECT($
|
|
7678
|
+
var BinaryOp$2 = $TS($S($EXPECT($L51, fail, 'BinaryOp "not"'), NonIdContinue, __, Identifier), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7646
7679
|
var id = $4;
|
|
7647
7680
|
if (!module2.operators.has(id.name))
|
|
7648
7681
|
return $skip;
|
|
@@ -7674,21 +7707,21 @@ ${input.slice(result.pos)}
|
|
|
7674
7707
|
return result;
|
|
7675
7708
|
}
|
|
7676
7709
|
}
|
|
7677
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
7678
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
7679
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
7680
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
7710
|
+
var BinaryOpSymbol$0 = $EXPECT($L52, fail, 'BinaryOpSymbol "**"');
|
|
7711
|
+
var BinaryOpSymbol$1 = $EXPECT($L53, fail, 'BinaryOpSymbol "*"');
|
|
7712
|
+
var BinaryOpSymbol$2 = $EXPECT($L54, fail, 'BinaryOpSymbol "/"');
|
|
7713
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L55, fail, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
7681
7714
|
return {
|
|
7682
7715
|
call: module2.getRef("modulo"),
|
|
7683
7716
|
special: true
|
|
7684
7717
|
};
|
|
7685
7718
|
});
|
|
7686
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
7687
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
7688
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
7689
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
7690
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
7691
|
-
var BinaryOpSymbol$9 = $TV($EXPECT($
|
|
7719
|
+
var BinaryOpSymbol$4 = $EXPECT($L56, fail, 'BinaryOpSymbol "%"');
|
|
7720
|
+
var BinaryOpSymbol$5 = $EXPECT($L57, fail, 'BinaryOpSymbol "+"');
|
|
7721
|
+
var BinaryOpSymbol$6 = $EXPECT($L16, fail, 'BinaryOpSymbol "-"');
|
|
7722
|
+
var BinaryOpSymbol$7 = $EXPECT($L58, fail, 'BinaryOpSymbol "<="');
|
|
7723
|
+
var BinaryOpSymbol$8 = $EXPECT($L59, fail, 'BinaryOpSymbol ">="');
|
|
7724
|
+
var BinaryOpSymbol$9 = $TV($EXPECT($L60, fail, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
7692
7725
|
return {
|
|
7693
7726
|
$loc,
|
|
7694
7727
|
token: "instanceof",
|
|
@@ -7696,7 +7729,7 @@ ${input.slice(result.pos)}
|
|
|
7696
7729
|
special: true
|
|
7697
7730
|
};
|
|
7698
7731
|
});
|
|
7699
|
-
var BinaryOpSymbol$10 = $TV($EXPECT($
|
|
7732
|
+
var BinaryOpSymbol$10 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
7700
7733
|
return {
|
|
7701
7734
|
$loc,
|
|
7702
7735
|
token: "instanceof",
|
|
@@ -7705,46 +7738,58 @@ ${input.slice(result.pos)}
|
|
|
7705
7738
|
negated: true
|
|
7706
7739
|
};
|
|
7707
7740
|
});
|
|
7708
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
7741
|
+
var BinaryOpSymbol$11 = $EXPECT($L62, fail, 'BinaryOpSymbol "<<"');
|
|
7709
7742
|
var BinaryOpSymbol$12 = $TR($EXPECT($R6, fail, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7710
7743
|
return "<";
|
|
7711
7744
|
});
|
|
7712
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
7713
|
-
var BinaryOpSymbol$14 = $EXPECT($
|
|
7714
|
-
var BinaryOpSymbol$15 = $EXPECT($
|
|
7715
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
7716
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
7745
|
+
var BinaryOpSymbol$13 = $EXPECT($L63, fail, 'BinaryOpSymbol ">>>"');
|
|
7746
|
+
var BinaryOpSymbol$14 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>"');
|
|
7747
|
+
var BinaryOpSymbol$15 = $EXPECT($L30, fail, 'BinaryOpSymbol ">"');
|
|
7748
|
+
var BinaryOpSymbol$16 = $EXPECT($L65, fail, 'BinaryOpSymbol "!=="');
|
|
7749
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L66, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
7717
7750
|
if (module2.config.coffeeEq)
|
|
7718
7751
|
return "!==";
|
|
7719
7752
|
return $1;
|
|
7720
7753
|
});
|
|
7721
|
-
var BinaryOpSymbol$18 = $TS($S($EXPECT($
|
|
7754
|
+
var BinaryOpSymbol$18 = $TS($S($EXPECT($L67, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7722
7755
|
if (module2.config.coffeeIsnt)
|
|
7723
7756
|
return "!==";
|
|
7724
7757
|
return $skip;
|
|
7725
7758
|
});
|
|
7726
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
7727
|
-
var BinaryOpSymbol$20 = $TV($EXPECT($
|
|
7759
|
+
var BinaryOpSymbol$19 = $EXPECT($L68, fail, 'BinaryOpSymbol "==="');
|
|
7760
|
+
var BinaryOpSymbol$20 = $TV($EXPECT($L69, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
7728
7761
|
if (module2.config.coffeeEq)
|
|
7729
7762
|
return "===";
|
|
7730
7763
|
return $1;
|
|
7731
7764
|
});
|
|
7732
|
-
var BinaryOpSymbol$21 = $T($S($EXPECT($
|
|
7765
|
+
var BinaryOpSymbol$21 = $T($S($EXPECT($L70, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
7733
7766
|
return "&&";
|
|
7734
7767
|
});
|
|
7735
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
7736
|
-
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
7768
|
+
var BinaryOpSymbol$22 = $EXPECT($L71, fail, 'BinaryOpSymbol "&&"');
|
|
7769
|
+
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($L72, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
7737
7770
|
return "in";
|
|
7738
7771
|
});
|
|
7739
|
-
var BinaryOpSymbol$24 = $T($S($EXPECT($
|
|
7772
|
+
var BinaryOpSymbol$24 = $T($S($EXPECT($L73, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
7740
7773
|
return "||";
|
|
7741
7774
|
});
|
|
7742
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
7743
|
-
var BinaryOpSymbol$26 = $EXPECT($
|
|
7744
|
-
|
|
7775
|
+
var BinaryOpSymbol$25 = $EXPECT($L74, fail, 'BinaryOpSymbol "||"');
|
|
7776
|
+
var BinaryOpSymbol$26 = $TV($C($EXPECT($L75, fail, 'BinaryOpSymbol "^^"'), $S($EXPECT($L76, fail, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7777
|
+
return {
|
|
7778
|
+
call: module2.getRef("xor"),
|
|
7779
|
+
special: true
|
|
7780
|
+
};
|
|
7781
|
+
});
|
|
7782
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($R7, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L77, fail, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7783
|
+
return {
|
|
7784
|
+
call: module2.getRef("xnor"),
|
|
7785
|
+
special: true
|
|
7786
|
+
};
|
|
7787
|
+
});
|
|
7788
|
+
var BinaryOpSymbol$28 = $EXPECT($L78, fail, 'BinaryOpSymbol "??"');
|
|
7789
|
+
var BinaryOpSymbol$29 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L3, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
7745
7790
|
return "??";
|
|
7746
7791
|
});
|
|
7747
|
-
var BinaryOpSymbol$
|
|
7792
|
+
var BinaryOpSymbol$30 = $TS($S($EXPECT($L79, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7748
7793
|
return {
|
|
7749
7794
|
$loc,
|
|
7750
7795
|
token: $1,
|
|
@@ -7752,7 +7797,7 @@ ${input.slice(result.pos)}
|
|
|
7752
7797
|
special: true
|
|
7753
7798
|
};
|
|
7754
7799
|
});
|
|
7755
|
-
var BinaryOpSymbol$
|
|
7800
|
+
var BinaryOpSymbol$31 = $TS($S($EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L79, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7756
7801
|
return {
|
|
7757
7802
|
$loc,
|
|
7758
7803
|
token: "instanceof",
|
|
@@ -7761,7 +7806,7 @@ ${input.slice(result.pos)}
|
|
|
7761
7806
|
negated: true
|
|
7762
7807
|
};
|
|
7763
7808
|
});
|
|
7764
|
-
var BinaryOpSymbol$
|
|
7809
|
+
var BinaryOpSymbol$32 = $TV($C($S($N(CoffeeOfEnabled), $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), $S(CoffeeOfEnabled, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L72, fail, 'BinaryOpSymbol "of"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7765
7810
|
return {
|
|
7766
7811
|
$loc,
|
|
7767
7812
|
token: "in",
|
|
@@ -7769,7 +7814,7 @@ ${input.slice(result.pos)}
|
|
|
7769
7814
|
negated: true
|
|
7770
7815
|
};
|
|
7771
7816
|
});
|
|
7772
|
-
var BinaryOpSymbol$
|
|
7817
|
+
var BinaryOpSymbol$33 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7773
7818
|
return {
|
|
7774
7819
|
method: "includes",
|
|
7775
7820
|
relational: true,
|
|
@@ -7777,7 +7822,7 @@ ${input.slice(result.pos)}
|
|
|
7777
7822
|
special: true
|
|
7778
7823
|
};
|
|
7779
7824
|
});
|
|
7780
|
-
var BinaryOpSymbol$
|
|
7825
|
+
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
7781
7826
|
return {
|
|
7782
7827
|
call: [module2.getRef("indexOf"), ".call"],
|
|
7783
7828
|
relational: true,
|
|
@@ -7786,7 +7831,7 @@ ${input.slice(result.pos)}
|
|
|
7786
7831
|
special: true
|
|
7787
7832
|
};
|
|
7788
7833
|
});
|
|
7789
|
-
var BinaryOpSymbol$
|
|
7834
|
+
var BinaryOpSymbol$35 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
7790
7835
|
return {
|
|
7791
7836
|
method: "includes",
|
|
7792
7837
|
relational: true,
|
|
@@ -7795,7 +7840,7 @@ ${input.slice(result.pos)}
|
|
|
7795
7840
|
negated: true
|
|
7796
7841
|
};
|
|
7797
7842
|
});
|
|
7798
|
-
var BinaryOpSymbol$
|
|
7843
|
+
var BinaryOpSymbol$36 = $TS($S(CoffeeOfEnabled, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
7799
7844
|
return {
|
|
7800
7845
|
call: [module2.getRef("indexOf"), ".call"],
|
|
7801
7846
|
relational: true,
|
|
@@ -7804,7 +7849,7 @@ ${input.slice(result.pos)}
|
|
|
7804
7849
|
special: true
|
|
7805
7850
|
};
|
|
7806
7851
|
});
|
|
7807
|
-
var BinaryOpSymbol$
|
|
7852
|
+
var BinaryOpSymbol$37 = $TS($S($N(CoffeeNotEnabled), $EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
7808
7853
|
if (module2.config.objectIs) {
|
|
7809
7854
|
return {
|
|
7810
7855
|
call: module2.getRef("is"),
|
|
@@ -7816,7 +7861,7 @@ ${input.slice(result.pos)}
|
|
|
7816
7861
|
}
|
|
7817
7862
|
return "!==";
|
|
7818
7863
|
});
|
|
7819
|
-
var BinaryOpSymbol$
|
|
7864
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7820
7865
|
if (module2.config.objectIs) {
|
|
7821
7866
|
return {
|
|
7822
7867
|
call: module2.getRef("is"),
|
|
@@ -7827,12 +7872,12 @@ ${input.slice(result.pos)}
|
|
|
7827
7872
|
}
|
|
7828
7873
|
return "===";
|
|
7829
7874
|
});
|
|
7830
|
-
var BinaryOpSymbol$
|
|
7875
|
+
var BinaryOpSymbol$39 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7831
7876
|
return $1;
|
|
7832
7877
|
});
|
|
7833
|
-
var BinaryOpSymbol$
|
|
7834
|
-
var BinaryOpSymbol$
|
|
7835
|
-
var BinaryOpSymbol$
|
|
7878
|
+
var BinaryOpSymbol$40 = $EXPECT($L82, fail, 'BinaryOpSymbol "&"');
|
|
7879
|
+
var BinaryOpSymbol$41 = $EXPECT($L15, fail, 'BinaryOpSymbol "^"');
|
|
7880
|
+
var BinaryOpSymbol$42 = $EXPECT($L83, fail, 'BinaryOpSymbol "|"');
|
|
7836
7881
|
function BinaryOpSymbol(state) {
|
|
7837
7882
|
let eventData;
|
|
7838
7883
|
if (state.events) {
|
|
@@ -7844,18 +7889,66 @@ ${input.slice(result.pos)}
|
|
|
7844
7889
|
}
|
|
7845
7890
|
}
|
|
7846
7891
|
if (state.tokenize) {
|
|
7847
|
-
const result = $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state) || BinaryOpSymbol$37(state) || BinaryOpSymbol$38(state) || BinaryOpSymbol$39(state) || BinaryOpSymbol$40(state));
|
|
7892
|
+
const result = $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state) || BinaryOpSymbol$37(state) || BinaryOpSymbol$38(state) || BinaryOpSymbol$39(state) || BinaryOpSymbol$40(state) || BinaryOpSymbol$41(state) || BinaryOpSymbol$42(state));
|
|
7848
7893
|
if (state.events)
|
|
7849
7894
|
state.events.exit?.("BinaryOpSymbol", state, result, eventData);
|
|
7850
7895
|
return result;
|
|
7851
7896
|
} else {
|
|
7852
|
-
const result = BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state) || BinaryOpSymbol$37(state) || BinaryOpSymbol$38(state) || BinaryOpSymbol$39(state) || BinaryOpSymbol$40(state);
|
|
7897
|
+
const result = BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state) || BinaryOpSymbol$37(state) || BinaryOpSymbol$38(state) || BinaryOpSymbol$39(state) || BinaryOpSymbol$40(state) || BinaryOpSymbol$41(state) || BinaryOpSymbol$42(state);
|
|
7853
7898
|
if (state.events)
|
|
7854
7899
|
state.events.exit?.("BinaryOpSymbol", state, result, eventData);
|
|
7855
7900
|
return result;
|
|
7856
7901
|
}
|
|
7857
7902
|
}
|
|
7858
|
-
var
|
|
7903
|
+
var Xor$0 = $EXPECT($L75, fail, 'Xor "^^"');
|
|
7904
|
+
var Xor$1 = $S($EXPECT($L76, fail, 'Xor "xor"'), NonIdContinue);
|
|
7905
|
+
function Xor(state) {
|
|
7906
|
+
let eventData;
|
|
7907
|
+
if (state.events) {
|
|
7908
|
+
const result = state.events.enter?.("Xor", state);
|
|
7909
|
+
if (result) {
|
|
7910
|
+
if (result.cache)
|
|
7911
|
+
return result.cache;
|
|
7912
|
+
eventData = result.data;
|
|
7913
|
+
}
|
|
7914
|
+
}
|
|
7915
|
+
if (state.tokenize) {
|
|
7916
|
+
const result = $TOKEN("Xor", state, Xor$0(state) || Xor$1(state));
|
|
7917
|
+
if (state.events)
|
|
7918
|
+
state.events.exit?.("Xor", state, result, eventData);
|
|
7919
|
+
return result;
|
|
7920
|
+
} else {
|
|
7921
|
+
const result = Xor$0(state) || Xor$1(state);
|
|
7922
|
+
if (state.events)
|
|
7923
|
+
state.events.exit?.("Xor", state, result, eventData);
|
|
7924
|
+
return result;
|
|
7925
|
+
}
|
|
7926
|
+
}
|
|
7927
|
+
var Xnor$0 = $R$0($EXPECT($R7, fail, "Xnor /!\\^\\^?/"));
|
|
7928
|
+
var Xnor$1 = $EXPECT($L77, fail, 'Xnor "xnor"');
|
|
7929
|
+
function Xnor(state) {
|
|
7930
|
+
let eventData;
|
|
7931
|
+
if (state.events) {
|
|
7932
|
+
const result = state.events.enter?.("Xnor", state);
|
|
7933
|
+
if (result) {
|
|
7934
|
+
if (result.cache)
|
|
7935
|
+
return result.cache;
|
|
7936
|
+
eventData = result.data;
|
|
7937
|
+
}
|
|
7938
|
+
}
|
|
7939
|
+
if (state.tokenize) {
|
|
7940
|
+
const result = $TOKEN("Xnor", state, Xnor$0(state) || Xnor$1(state));
|
|
7941
|
+
if (state.events)
|
|
7942
|
+
state.events.exit?.("Xnor", state, result, eventData);
|
|
7943
|
+
return result;
|
|
7944
|
+
} else {
|
|
7945
|
+
const result = Xnor$0(state) || Xnor$1(state);
|
|
7946
|
+
if (state.events)
|
|
7947
|
+
state.events.exit?.("Xnor", state, result, eventData);
|
|
7948
|
+
return result;
|
|
7949
|
+
}
|
|
7950
|
+
}
|
|
7951
|
+
var UnaryOp$0 = $TR($EXPECT($R8, fail, "UnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7859
7952
|
return { $loc, token: $0 };
|
|
7860
7953
|
});
|
|
7861
7954
|
var UnaryOp$1 = $S($C(Await, Delete, Void, Typeof), __);
|
|
@@ -8052,7 +8145,7 @@ ${input.slice(result.pos)}
|
|
|
8052
8145
|
return result;
|
|
8053
8146
|
}
|
|
8054
8147
|
}
|
|
8055
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
8148
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L84, fail, 'EmptyStatement ";"'))), function(value) {
|
|
8056
8149
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
8057
8150
|
});
|
|
8058
8151
|
function EmptyStatement(state) {
|
|
@@ -9007,7 +9100,7 @@ ${input.slice(result.pos)}
|
|
|
9007
9100
|
return result;
|
|
9008
9101
|
}
|
|
9009
9102
|
}
|
|
9010
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
9103
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L85, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
9011
9104
|
var own = $1;
|
|
9012
9105
|
var binding = $2;
|
|
9013
9106
|
return {
|
|
@@ -9130,7 +9223,7 @@ ${input.slice(result.pos)}
|
|
|
9130
9223
|
names: binding.names
|
|
9131
9224
|
};
|
|
9132
9225
|
});
|
|
9133
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
9226
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R9, fail, "ForDeclaration /(?=[\\s\\)])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
9134
9227
|
var c = $1;
|
|
9135
9228
|
var binding = $2;
|
|
9136
9229
|
return {
|
|
@@ -9488,7 +9581,7 @@ ${input.slice(result.pos)}
|
|
|
9488
9581
|
}
|
|
9489
9582
|
}
|
|
9490
9583
|
var ImpliedColon$0 = $S(__, Colon);
|
|
9491
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
9584
|
+
var ImpliedColon$1 = $TV($EXPECT($L18, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
9492
9585
|
return { $loc, token: ":" };
|
|
9493
9586
|
});
|
|
9494
9587
|
function ImpliedColon(state) {
|
|
@@ -9742,7 +9835,7 @@ ${input.slice(result.pos)}
|
|
|
9742
9835
|
return result;
|
|
9743
9836
|
}
|
|
9744
9837
|
}
|
|
9745
|
-
var SuppressIndentedApplication$0 = $TV($EXPECT($
|
|
9838
|
+
var SuppressIndentedApplication$0 = $TV($EXPECT($L18, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
9746
9839
|
module2.suppressIndentedApplication = true;
|
|
9747
9840
|
});
|
|
9748
9841
|
function SuppressIndentedApplication(state) {
|
|
@@ -9767,7 +9860,7 @@ ${input.slice(result.pos)}
|
|
|
9767
9860
|
return result;
|
|
9768
9861
|
}
|
|
9769
9862
|
}
|
|
9770
|
-
var IndentedApplicationAllowed$0 = $TV($EXPECT($
|
|
9863
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L18, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
9771
9864
|
if (module2.suppressIndentedApplication)
|
|
9772
9865
|
return $skip;
|
|
9773
9866
|
return;
|
|
@@ -9794,7 +9887,7 @@ ${input.slice(result.pos)}
|
|
|
9794
9887
|
return result;
|
|
9795
9888
|
}
|
|
9796
9889
|
}
|
|
9797
|
-
var SuppressTrailingMemberProperty$0 = $TV($EXPECT($
|
|
9890
|
+
var SuppressTrailingMemberProperty$0 = $TV($EXPECT($L18, fail, 'SuppressTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
9798
9891
|
module2.suppressTrailingMemberProperty.push(true);
|
|
9799
9892
|
});
|
|
9800
9893
|
function SuppressTrailingMemberProperty(state) {
|
|
@@ -9819,7 +9912,7 @@ ${input.slice(result.pos)}
|
|
|
9819
9912
|
return result;
|
|
9820
9913
|
}
|
|
9821
9914
|
}
|
|
9822
|
-
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($
|
|
9915
|
+
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($L18, fail, 'TrailingMemberPropertyAllowed ""'), function($skip, $loc, $0, $1) {
|
|
9823
9916
|
if (module2.trailingMemberPropertySuppressed)
|
|
9824
9917
|
return $skip;
|
|
9825
9918
|
});
|
|
@@ -9868,13 +9961,13 @@ ${input.slice(result.pos)}
|
|
|
9868
9961
|
return result;
|
|
9869
9962
|
}
|
|
9870
9963
|
}
|
|
9871
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
9964
|
+
var KeywordStatement$0 = $T($S($EXPECT($L86, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
9872
9965
|
return { "type": "BreakStatement", "children": value };
|
|
9873
9966
|
});
|
|
9874
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
9967
|
+
var KeywordStatement$1 = $T($S($EXPECT($L87, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
9875
9968
|
return { "type": "ContinueStatement", "children": value };
|
|
9876
9969
|
});
|
|
9877
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
9970
|
+
var KeywordStatement$2 = $T($S($EXPECT($L88, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
9878
9971
|
return { "type": "DebuggerStatement", "children": value };
|
|
9879
9972
|
});
|
|
9880
9973
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -9905,7 +9998,7 @@ ${input.slice(result.pos)}
|
|
|
9905
9998
|
return result;
|
|
9906
9999
|
}
|
|
9907
10000
|
}
|
|
9908
|
-
var DebuggerExpression$0 = $TS($S($EXPECT($
|
|
10001
|
+
var DebuggerExpression$0 = $TS($S($EXPECT($L88, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9909
10002
|
return {
|
|
9910
10003
|
type: "DebuggerExpression",
|
|
9911
10004
|
children: ["(()=>{", $1, "})()"]
|
|
@@ -10033,7 +10126,7 @@ ${input.slice(result.pos)}
|
|
|
10033
10126
|
return result;
|
|
10034
10127
|
}
|
|
10035
10128
|
}
|
|
10036
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
10129
|
+
var ImpliedImport$0 = $TV($EXPECT($L18, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
10037
10130
|
return { $loc, token: "import " };
|
|
10038
10131
|
});
|
|
10039
10132
|
function ImpliedImport(state) {
|
|
@@ -10182,7 +10275,7 @@ ${input.slice(result.pos)}
|
|
|
10182
10275
|
return result;
|
|
10183
10276
|
}
|
|
10184
10277
|
}
|
|
10185
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10278
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L89, fail, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10186
10279
|
function ImportAssertion(state) {
|
|
10187
10280
|
let eventData;
|
|
10188
10281
|
if (state.events) {
|
|
@@ -10398,7 +10491,7 @@ ${input.slice(result.pos)}
|
|
|
10398
10491
|
return result;
|
|
10399
10492
|
}
|
|
10400
10493
|
}
|
|
10401
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
10494
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R10, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
10402
10495
|
var spec = $0;
|
|
10403
10496
|
return { $loc, token: `"${spec}"` };
|
|
10404
10497
|
});
|
|
@@ -10786,7 +10879,7 @@ ${input.slice(result.pos)}
|
|
|
10786
10879
|
return result;
|
|
10787
10880
|
}
|
|
10788
10881
|
}
|
|
10789
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
10882
|
+
var ConstAssignment$0 = $TV($EXPECT($L90, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
10790
10883
|
return { $loc, token: "=" };
|
|
10791
10884
|
});
|
|
10792
10885
|
function ConstAssignment(state) {
|
|
@@ -10811,7 +10904,7 @@ ${input.slice(result.pos)}
|
|
|
10811
10904
|
return result;
|
|
10812
10905
|
}
|
|
10813
10906
|
}
|
|
10814
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
10907
|
+
var LetAssignment$0 = $TV($EXPECT($L91, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10815
10908
|
return { $loc, token: "=" };
|
|
10816
10909
|
});
|
|
10817
10910
|
function LetAssignment(state) {
|
|
@@ -11060,7 +11153,7 @@ ${input.slice(result.pos)}
|
|
|
11060
11153
|
return result;
|
|
11061
11154
|
}
|
|
11062
11155
|
}
|
|
11063
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
11156
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R11, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
11064
11157
|
function DecimalBigIntegerLiteral(state) {
|
|
11065
11158
|
let eventData;
|
|
11066
11159
|
if (state.events) {
|
|
@@ -11083,11 +11176,11 @@ ${input.slice(result.pos)}
|
|
|
11083
11176
|
return result;
|
|
11084
11177
|
}
|
|
11085
11178
|
}
|
|
11086
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
11179
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R12, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
11087
11180
|
return $1 + ".";
|
|
11088
11181
|
});
|
|
11089
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
11090
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
11182
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R13, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
11183
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R14, fail, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
11091
11184
|
function DecimalLiteral(state) {
|
|
11092
11185
|
let eventData;
|
|
11093
11186
|
if (state.events) {
|
|
@@ -11110,7 +11203,7 @@ ${input.slice(result.pos)}
|
|
|
11110
11203
|
return result;
|
|
11111
11204
|
}
|
|
11112
11205
|
}
|
|
11113
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
11206
|
+
var ExponentPart$0 = $R$0($EXPECT($R15, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
11114
11207
|
function ExponentPart(state) {
|
|
11115
11208
|
let eventData;
|
|
11116
11209
|
if (state.events) {
|
|
@@ -11133,7 +11226,7 @@ ${input.slice(result.pos)}
|
|
|
11133
11226
|
return result;
|
|
11134
11227
|
}
|
|
11135
11228
|
}
|
|
11136
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
11229
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R16, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
11137
11230
|
function BinaryIntegerLiteral(state) {
|
|
11138
11231
|
let eventData;
|
|
11139
11232
|
if (state.events) {
|
|
@@ -11156,7 +11249,7 @@ ${input.slice(result.pos)}
|
|
|
11156
11249
|
return result;
|
|
11157
11250
|
}
|
|
11158
11251
|
}
|
|
11159
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11252
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R17, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
11160
11253
|
function OctalIntegerLiteral(state) {
|
|
11161
11254
|
let eventData;
|
|
11162
11255
|
if (state.events) {
|
|
@@ -11179,7 +11272,7 @@ ${input.slice(result.pos)}
|
|
|
11179
11272
|
return result;
|
|
11180
11273
|
}
|
|
11181
11274
|
}
|
|
11182
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
11275
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R18, fail, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
11183
11276
|
function HexIntegerLiteral(state) {
|
|
11184
11277
|
let eventData;
|
|
11185
11278
|
if (state.events) {
|
|
@@ -11254,7 +11347,7 @@ ${input.slice(result.pos)}
|
|
|
11254
11347
|
return result;
|
|
11255
11348
|
}
|
|
11256
11349
|
}
|
|
11257
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11350
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R19, fail, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
11258
11351
|
function DecimalIntegerLiteral(state) {
|
|
11259
11352
|
let eventData;
|
|
11260
11353
|
if (state.events) {
|
|
@@ -11315,7 +11408,7 @@ ${input.slice(result.pos)}
|
|
|
11315
11408
|
return result;
|
|
11316
11409
|
}
|
|
11317
11410
|
}
|
|
11318
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
11411
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R20, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11319
11412
|
return { $loc, token: $0 };
|
|
11320
11413
|
});
|
|
11321
11414
|
function DoubleStringCharacters(state) {
|
|
@@ -11340,7 +11433,7 @@ ${input.slice(result.pos)}
|
|
|
11340
11433
|
return result;
|
|
11341
11434
|
}
|
|
11342
11435
|
}
|
|
11343
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
11436
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R21, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11344
11437
|
return { $loc, token: $0 };
|
|
11345
11438
|
});
|
|
11346
11439
|
function SingleStringCharacters(state) {
|
|
@@ -11365,7 +11458,7 @@ ${input.slice(result.pos)}
|
|
|
11365
11458
|
return result;
|
|
11366
11459
|
}
|
|
11367
11460
|
}
|
|
11368
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
11461
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R22, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11369
11462
|
return { $loc, token: $0 };
|
|
11370
11463
|
});
|
|
11371
11464
|
function TripleDoubleStringCharacters(state) {
|
|
@@ -11390,7 +11483,7 @@ ${input.slice(result.pos)}
|
|
|
11390
11483
|
return result;
|
|
11391
11484
|
}
|
|
11392
11485
|
}
|
|
11393
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
11486
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R23, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11394
11487
|
return { $loc, token: $0 };
|
|
11395
11488
|
});
|
|
11396
11489
|
function TripleSingleStringCharacters(state) {
|
|
@@ -11483,7 +11576,7 @@ ${input.slice(result.pos)}
|
|
|
11483
11576
|
return result;
|
|
11484
11577
|
}
|
|
11485
11578
|
}
|
|
11486
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
11579
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R24, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11487
11580
|
return { $loc, token: $0 };
|
|
11488
11581
|
});
|
|
11489
11582
|
function CoffeeDoubleQuotedStringCharacters(state) {
|
|
@@ -11509,7 +11602,7 @@ ${input.slice(result.pos)}
|
|
|
11509
11602
|
}
|
|
11510
11603
|
}
|
|
11511
11604
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
11512
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
11605
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L54, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L54, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
11513
11606
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
11514
11607
|
});
|
|
11515
11608
|
function RegularExpressionLiteral(state) {
|
|
@@ -11559,7 +11652,7 @@ ${input.slice(result.pos)}
|
|
|
11559
11652
|
return result;
|
|
11560
11653
|
}
|
|
11561
11654
|
}
|
|
11562
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
11655
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R25, fail, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11563
11656
|
return { $loc, token: $0 };
|
|
11564
11657
|
});
|
|
11565
11658
|
function RegularExpressionClassCharacters(state) {
|
|
@@ -11669,7 +11762,7 @@ ${input.slice(result.pos)}
|
|
|
11669
11762
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
11670
11763
|
return { "type": "Substitution", "children": value[0] };
|
|
11671
11764
|
});
|
|
11672
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
11765
|
+
var HeregexPart$3 = $TR($EXPECT($R26, fail, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11673
11766
|
let token = $0;
|
|
11674
11767
|
switch ($0[1]) {
|
|
11675
11768
|
case "\n":
|
|
@@ -11687,13 +11780,13 @@ ${input.slice(result.pos)}
|
|
|
11687
11780
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
11688
11781
|
return { $loc, token: "" };
|
|
11689
11782
|
});
|
|
11690
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
11783
|
+
var HeregexPart$5 = $TR($EXPECT($R27, fail, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11691
11784
|
return { $loc, token: "" };
|
|
11692
11785
|
});
|
|
11693
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
11786
|
+
var HeregexPart$6 = $TR($EXPECT($R28, fail, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11694
11787
|
return { $loc, token: "\\/" };
|
|
11695
11788
|
});
|
|
11696
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
11789
|
+
var HeregexPart$7 = $TR($EXPECT($R29, fail, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11697
11790
|
return { $loc, token: $0 };
|
|
11698
11791
|
});
|
|
11699
11792
|
function HeregexPart(state) {
|
|
@@ -11742,7 +11835,7 @@ ${input.slice(result.pos)}
|
|
|
11742
11835
|
return result;
|
|
11743
11836
|
}
|
|
11744
11837
|
}
|
|
11745
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
11838
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R30, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
11746
11839
|
function RegularExpressionBody(state) {
|
|
11747
11840
|
let eventData;
|
|
11748
11841
|
if (state.events) {
|
|
@@ -11789,7 +11882,7 @@ ${input.slice(result.pos)}
|
|
|
11789
11882
|
return result;
|
|
11790
11883
|
}
|
|
11791
11884
|
}
|
|
11792
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
11885
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R31, fail, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
11793
11886
|
function RegExpCharacter(state) {
|
|
11794
11887
|
let eventData;
|
|
11795
11888
|
if (state.events) {
|
|
@@ -11812,7 +11905,7 @@ ${input.slice(result.pos)}
|
|
|
11812
11905
|
return result;
|
|
11813
11906
|
}
|
|
11814
11907
|
}
|
|
11815
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
11908
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R32, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
11816
11909
|
function RegularExpressionFlags(state) {
|
|
11817
11910
|
let eventData;
|
|
11818
11911
|
if (state.events) {
|
|
@@ -11902,7 +11995,7 @@ ${input.slice(result.pos)}
|
|
|
11902
11995
|
return result;
|
|
11903
11996
|
}
|
|
11904
11997
|
}
|
|
11905
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
11998
|
+
var TemplateCharacters$0 = $TR($EXPECT($R33, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11906
11999
|
return { $loc, token: $0 };
|
|
11907
12000
|
});
|
|
11908
12001
|
function TemplateCharacters(state) {
|
|
@@ -11927,7 +12020,7 @@ ${input.slice(result.pos)}
|
|
|
11927
12020
|
return result;
|
|
11928
12021
|
}
|
|
11929
12022
|
}
|
|
11930
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
12023
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R34, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11931
12024
|
return { $loc, token: $0 };
|
|
11932
12025
|
});
|
|
11933
12026
|
function TemplateBlockCharacters(state) {
|
|
@@ -11952,11 +12045,11 @@ ${input.slice(result.pos)}
|
|
|
11952
12045
|
return result;
|
|
11953
12046
|
}
|
|
11954
12047
|
}
|
|
11955
|
-
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($
|
|
11956
|
-
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($
|
|
11957
|
-
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($
|
|
11958
|
-
var ReservedWord$3 = $S(CoffeeOfEnabled, $R$0($EXPECT($
|
|
11959
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
12048
|
+
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R35, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
|
|
12049
|
+
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($R36, fail, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")));
|
|
12050
|
+
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($R37, fail, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")));
|
|
12051
|
+
var ReservedWord$3 = $S(CoffeeOfEnabled, $R$0($EXPECT($R38, fail, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")));
|
|
12052
|
+
var ReservedWord$4 = $R$0($EXPECT($R39, fail, "ReservedWord /(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
11960
12053
|
function ReservedWord(state) {
|
|
11961
12054
|
let eventData;
|
|
11962
12055
|
if (state.events) {
|
|
@@ -12027,7 +12120,7 @@ ${input.slice(result.pos)}
|
|
|
12027
12120
|
return result;
|
|
12028
12121
|
}
|
|
12029
12122
|
}
|
|
12030
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
12123
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R40, fail, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12031
12124
|
return { $loc, token: $0 };
|
|
12032
12125
|
});
|
|
12033
12126
|
function JSSingleLineComment(state) {
|
|
@@ -12076,7 +12169,7 @@ ${input.slice(result.pos)}
|
|
|
12076
12169
|
return result;
|
|
12077
12170
|
}
|
|
12078
12171
|
}
|
|
12079
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12172
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L92, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L93, fail, 'JSMultiLineComment "*/"')), $EXPECT($R41, fail, "JSMultiLineComment /./"))), $EXPECT($L93, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
12080
12173
|
return { $loc, token: $1 };
|
|
12081
12174
|
});
|
|
12082
12175
|
function JSMultiLineComment(state) {
|
|
@@ -12101,7 +12194,7 @@ ${input.slice(result.pos)}
|
|
|
12101
12194
|
return result;
|
|
12102
12195
|
}
|
|
12103
12196
|
}
|
|
12104
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
12197
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R42, fail, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12105
12198
|
return { $loc, token: `//${$1}` };
|
|
12106
12199
|
});
|
|
12107
12200
|
function CoffeeSingleLineComment(state) {
|
|
@@ -12126,7 +12219,7 @@ ${input.slice(result.pos)}
|
|
|
12126
12219
|
return result;
|
|
12127
12220
|
}
|
|
12128
12221
|
}
|
|
12129
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
12222
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R43, fail, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
12130
12223
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
12131
12224
|
return { $loc, token: `/*${$2}*/` };
|
|
12132
12225
|
});
|
|
@@ -12152,7 +12245,7 @@ ${input.slice(result.pos)}
|
|
|
12152
12245
|
return result;
|
|
12153
12246
|
}
|
|
12154
12247
|
}
|
|
12155
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
12248
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R44, fail, "CoffeeHereCommentStart /###(?!#)/"));
|
|
12156
12249
|
function CoffeeHereCommentStart(state) {
|
|
12157
12250
|
let eventData;
|
|
12158
12251
|
if (state.events) {
|
|
@@ -12175,7 +12268,7 @@ ${input.slice(result.pos)}
|
|
|
12175
12268
|
return result;
|
|
12176
12269
|
}
|
|
12177
12270
|
}
|
|
12178
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12271
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L92, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L93, fail, 'InlineComment "*/"')), $EXPECT($R45, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L93, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
12179
12272
|
return { $loc, token: $1 };
|
|
12180
12273
|
});
|
|
12181
12274
|
function InlineComment(state) {
|
|
@@ -12271,10 +12364,10 @@ ${input.slice(result.pos)}
|
|
|
12271
12364
|
return result;
|
|
12272
12365
|
}
|
|
12273
12366
|
}
|
|
12274
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
12367
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R46, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12275
12368
|
return { $loc, token: $0 };
|
|
12276
12369
|
});
|
|
12277
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
12370
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L94, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
12278
12371
|
return "";
|
|
12279
12372
|
});
|
|
12280
12373
|
function NonNewlineWhitespace(state) {
|
|
@@ -12348,7 +12441,7 @@ ${input.slice(result.pos)}
|
|
|
12348
12441
|
return result;
|
|
12349
12442
|
}
|
|
12350
12443
|
}
|
|
12351
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
12444
|
+
var Whitespace$0 = $TR($EXPECT($R27, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12352
12445
|
return { $loc, token: $0 };
|
|
12353
12446
|
});
|
|
12354
12447
|
function Whitespace(state) {
|
|
@@ -12426,7 +12519,7 @@ ${input.slice(result.pos)}
|
|
|
12426
12519
|
}
|
|
12427
12520
|
}
|
|
12428
12521
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
12429
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($
|
|
12522
|
+
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($L95, fail, 'StatementDelimiter "["'), $EXPECT($L96, fail, 'StatementDelimiter "`"'), $EXPECT($L57, fail, 'StatementDelimiter "+"'), $EXPECT($L16, fail, 'StatementDelimiter "-"'), $EXPECT($L53, fail, 'StatementDelimiter "*"'), $EXPECT($L54, fail, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L2, fail, 'StatementDelimiter "("'))))), InsertSemicolon);
|
|
12430
12523
|
var StatementDelimiter$2 = $Y(EOS);
|
|
12431
12524
|
function StatementDelimiter(state) {
|
|
12432
12525
|
let eventData;
|
|
@@ -12478,7 +12571,7 @@ ${input.slice(result.pos)}
|
|
|
12478
12571
|
return result;
|
|
12479
12572
|
}
|
|
12480
12573
|
}
|
|
12481
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
12574
|
+
var NonIdContinue$0 = $R$0($EXPECT($R47, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
12482
12575
|
function NonIdContinue(state) {
|
|
12483
12576
|
let eventData;
|
|
12484
12577
|
if (state.events) {
|
|
@@ -12501,7 +12594,7 @@ ${input.slice(result.pos)}
|
|
|
12501
12594
|
return result;
|
|
12502
12595
|
}
|
|
12503
12596
|
}
|
|
12504
|
-
var Loc$0 = $TV($EXPECT($
|
|
12597
|
+
var Loc$0 = $TV($EXPECT($L18, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
12505
12598
|
return { $loc, token: "" };
|
|
12506
12599
|
});
|
|
12507
12600
|
function Loc(state) {
|
|
@@ -12526,7 +12619,7 @@ ${input.slice(result.pos)}
|
|
|
12526
12619
|
return result;
|
|
12527
12620
|
}
|
|
12528
12621
|
}
|
|
12529
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
12622
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L97, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L8, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
12530
12623
|
return { $loc, token: $1, ts: true };
|
|
12531
12624
|
});
|
|
12532
12625
|
function Abstract(state) {
|
|
@@ -12551,7 +12644,7 @@ ${input.slice(result.pos)}
|
|
|
12551
12644
|
return result;
|
|
12552
12645
|
}
|
|
12553
12646
|
}
|
|
12554
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
12647
|
+
var Ampersand$0 = $TV($EXPECT($L82, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
12555
12648
|
return { $loc, token: $1 };
|
|
12556
12649
|
});
|
|
12557
12650
|
function Ampersand(state) {
|
|
@@ -12576,7 +12669,7 @@ ${input.slice(result.pos)}
|
|
|
12576
12669
|
return result;
|
|
12577
12670
|
}
|
|
12578
12671
|
}
|
|
12579
|
-
var As$0 = $TS($S($EXPECT($
|
|
12672
|
+
var As$0 = $TS($S($EXPECT($L98, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12580
12673
|
return { $loc, token: $1 };
|
|
12581
12674
|
});
|
|
12582
12675
|
function As(state) {
|
|
@@ -12601,7 +12694,7 @@ ${input.slice(result.pos)}
|
|
|
12601
12694
|
return result;
|
|
12602
12695
|
}
|
|
12603
12696
|
}
|
|
12604
|
-
var At$0 = $TV($EXPECT($
|
|
12697
|
+
var At$0 = $TV($EXPECT($L99, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
12605
12698
|
return { $loc, token: $1 };
|
|
12606
12699
|
});
|
|
12607
12700
|
function At(state) {
|
|
@@ -12626,7 +12719,7 @@ ${input.slice(result.pos)}
|
|
|
12626
12719
|
return result;
|
|
12627
12720
|
}
|
|
12628
12721
|
}
|
|
12629
|
-
var AtAt$0 = $TV($EXPECT($
|
|
12722
|
+
var AtAt$0 = $TV($EXPECT($L100, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
12630
12723
|
return { $loc, token: "@" };
|
|
12631
12724
|
});
|
|
12632
12725
|
function AtAt(state) {
|
|
@@ -12651,7 +12744,7 @@ ${input.slice(result.pos)}
|
|
|
12651
12744
|
return result;
|
|
12652
12745
|
}
|
|
12653
12746
|
}
|
|
12654
|
-
var Async$0 = $TS($S($EXPECT($
|
|
12747
|
+
var Async$0 = $TS($S($EXPECT($L101, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12655
12748
|
return { $loc, token: $1, type: "Async" };
|
|
12656
12749
|
});
|
|
12657
12750
|
function Async(state) {
|
|
@@ -12676,7 +12769,7 @@ ${input.slice(result.pos)}
|
|
|
12676
12769
|
return result;
|
|
12677
12770
|
}
|
|
12678
12771
|
}
|
|
12679
|
-
var Await$0 = $TS($S($EXPECT($
|
|
12772
|
+
var Await$0 = $TS($S($EXPECT($L102, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12680
12773
|
return { $loc, token: $1 };
|
|
12681
12774
|
});
|
|
12682
12775
|
function Await(state) {
|
|
@@ -12701,7 +12794,7 @@ ${input.slice(result.pos)}
|
|
|
12701
12794
|
return result;
|
|
12702
12795
|
}
|
|
12703
12796
|
}
|
|
12704
|
-
var Backtick$0 = $TV($EXPECT($
|
|
12797
|
+
var Backtick$0 = $TV($EXPECT($L96, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
12705
12798
|
return { $loc, token: $1 };
|
|
12706
12799
|
});
|
|
12707
12800
|
function Backtick(state) {
|
|
@@ -12726,7 +12819,7 @@ ${input.slice(result.pos)}
|
|
|
12726
12819
|
return result;
|
|
12727
12820
|
}
|
|
12728
12821
|
}
|
|
12729
|
-
var By$0 = $TS($S($EXPECT($
|
|
12822
|
+
var By$0 = $TS($S($EXPECT($L103, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12730
12823
|
return { $loc, token: $1 };
|
|
12731
12824
|
});
|
|
12732
12825
|
function By(state) {
|
|
@@ -12751,7 +12844,7 @@ ${input.slice(result.pos)}
|
|
|
12751
12844
|
return result;
|
|
12752
12845
|
}
|
|
12753
12846
|
}
|
|
12754
|
-
var Case$0 = $TS($S($EXPECT($
|
|
12847
|
+
var Case$0 = $TS($S($EXPECT($L104, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12755
12848
|
return { $loc, token: $1 };
|
|
12756
12849
|
});
|
|
12757
12850
|
function Case(state) {
|
|
@@ -12776,7 +12869,7 @@ ${input.slice(result.pos)}
|
|
|
12776
12869
|
return result;
|
|
12777
12870
|
}
|
|
12778
12871
|
}
|
|
12779
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
12872
|
+
var Catch$0 = $TS($S($EXPECT($L105, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12780
12873
|
return { $loc, token: $1 };
|
|
12781
12874
|
});
|
|
12782
12875
|
function Catch(state) {
|
|
@@ -12801,7 +12894,7 @@ ${input.slice(result.pos)}
|
|
|
12801
12894
|
return result;
|
|
12802
12895
|
}
|
|
12803
12896
|
}
|
|
12804
|
-
var Class$0 = $TS($S($EXPECT($
|
|
12897
|
+
var Class$0 = $TS($S($EXPECT($L106, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12805
12898
|
return { $loc, token: $1 };
|
|
12806
12899
|
});
|
|
12807
12900
|
function Class(state) {
|
|
@@ -12826,7 +12919,7 @@ ${input.slice(result.pos)}
|
|
|
12826
12919
|
return result;
|
|
12827
12920
|
}
|
|
12828
12921
|
}
|
|
12829
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
12922
|
+
var CloseBrace$0 = $TV($EXPECT($L22, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
12830
12923
|
return { $loc, token: $1 };
|
|
12831
12924
|
});
|
|
12832
12925
|
function CloseBrace(state) {
|
|
@@ -12851,7 +12944,7 @@ ${input.slice(result.pos)}
|
|
|
12851
12944
|
return result;
|
|
12852
12945
|
}
|
|
12853
12946
|
}
|
|
12854
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
12947
|
+
var CloseBracket$0 = $TV($EXPECT($L31, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
12855
12948
|
return { $loc, token: $1 };
|
|
12856
12949
|
});
|
|
12857
12950
|
function CloseBracket(state) {
|
|
@@ -12876,7 +12969,7 @@ ${input.slice(result.pos)}
|
|
|
12876
12969
|
return result;
|
|
12877
12970
|
}
|
|
12878
12971
|
}
|
|
12879
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
12972
|
+
var CloseParen$0 = $TV($EXPECT($L19, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
12880
12973
|
return { $loc, token: $1 };
|
|
12881
12974
|
});
|
|
12882
12975
|
function CloseParen(state) {
|
|
@@ -12901,7 +12994,7 @@ ${input.slice(result.pos)}
|
|
|
12901
12994
|
return result;
|
|
12902
12995
|
}
|
|
12903
12996
|
}
|
|
12904
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
12997
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L107, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
12905
12998
|
return { $loc, token: "${" };
|
|
12906
12999
|
});
|
|
12907
13000
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -12926,7 +13019,7 @@ ${input.slice(result.pos)}
|
|
|
12926
13019
|
return result;
|
|
12927
13020
|
}
|
|
12928
13021
|
}
|
|
12929
|
-
var Colon$0 = $TV($EXPECT($
|
|
13022
|
+
var Colon$0 = $TV($EXPECT($L32, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
12930
13023
|
return { $loc, token: $1 };
|
|
12931
13024
|
});
|
|
12932
13025
|
function Colon(state) {
|
|
@@ -12951,7 +13044,7 @@ ${input.slice(result.pos)}
|
|
|
12951
13044
|
return result;
|
|
12952
13045
|
}
|
|
12953
13046
|
}
|
|
12954
|
-
var Comma$0 = $TV($EXPECT($
|
|
13047
|
+
var Comma$0 = $TV($EXPECT($L20, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
12955
13048
|
return { $loc, token: $1 };
|
|
12956
13049
|
});
|
|
12957
13050
|
function Comma(state) {
|
|
@@ -12976,7 +13069,7 @@ ${input.slice(result.pos)}
|
|
|
12976
13069
|
return result;
|
|
12977
13070
|
}
|
|
12978
13071
|
}
|
|
12979
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
13072
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L99, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
12980
13073
|
return { $loc, token: "constructor" };
|
|
12981
13074
|
});
|
|
12982
13075
|
function ConstructorShorthand(state) {
|
|
@@ -13001,7 +13094,7 @@ ${input.slice(result.pos)}
|
|
|
13001
13094
|
return result;
|
|
13002
13095
|
}
|
|
13003
13096
|
}
|
|
13004
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
13097
|
+
var Declare$0 = $TS($S($EXPECT($L108, fail, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13005
13098
|
return { $loc, token: $1 };
|
|
13006
13099
|
});
|
|
13007
13100
|
function Declare(state) {
|
|
@@ -13026,7 +13119,7 @@ ${input.slice(result.pos)}
|
|
|
13026
13119
|
return result;
|
|
13027
13120
|
}
|
|
13028
13121
|
}
|
|
13029
|
-
var Default$0 = $TS($S($EXPECT($
|
|
13122
|
+
var Default$0 = $TS($S($EXPECT($L109, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13030
13123
|
return { $loc, token: $1 };
|
|
13031
13124
|
});
|
|
13032
13125
|
function Default(state) {
|
|
@@ -13051,7 +13144,7 @@ ${input.slice(result.pos)}
|
|
|
13051
13144
|
return result;
|
|
13052
13145
|
}
|
|
13053
13146
|
}
|
|
13054
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
13147
|
+
var Delete$0 = $TS($S($EXPECT($L110, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13055
13148
|
return { $loc, token: $1 };
|
|
13056
13149
|
});
|
|
13057
13150
|
function Delete(state) {
|
|
@@ -13076,7 +13169,7 @@ ${input.slice(result.pos)}
|
|
|
13076
13169
|
return result;
|
|
13077
13170
|
}
|
|
13078
13171
|
}
|
|
13079
|
-
var Do$0 = $TS($S($EXPECT($
|
|
13172
|
+
var Do$0 = $TS($S($EXPECT($L111, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13080
13173
|
return { $loc, token: $1 };
|
|
13081
13174
|
});
|
|
13082
13175
|
function Do(state) {
|
|
@@ -13126,7 +13219,7 @@ ${input.slice(result.pos)}
|
|
|
13126
13219
|
return result;
|
|
13127
13220
|
}
|
|
13128
13221
|
}
|
|
13129
|
-
var DotDot$0 = $TV($EXPECT($
|
|
13222
|
+
var DotDot$0 = $TV($EXPECT($L112, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
13130
13223
|
return { $loc, token: $1 };
|
|
13131
13224
|
});
|
|
13132
13225
|
function DotDot(state) {
|
|
@@ -13151,7 +13244,7 @@ ${input.slice(result.pos)}
|
|
|
13151
13244
|
return result;
|
|
13152
13245
|
}
|
|
13153
13246
|
}
|
|
13154
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
13247
|
+
var DotDotDot$0 = $TV($EXPECT($L113, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
13155
13248
|
return { $loc, token: $1 };
|
|
13156
13249
|
});
|
|
13157
13250
|
function DotDotDot(state) {
|
|
@@ -13176,7 +13269,7 @@ ${input.slice(result.pos)}
|
|
|
13176
13269
|
return result;
|
|
13177
13270
|
}
|
|
13178
13271
|
}
|
|
13179
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
13272
|
+
var DoubleColon$0 = $TV($EXPECT($L114, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
13180
13273
|
return { $loc, token: $1 };
|
|
13181
13274
|
});
|
|
13182
13275
|
function DoubleColon(state) {
|
|
@@ -13201,7 +13294,7 @@ ${input.slice(result.pos)}
|
|
|
13201
13294
|
return result;
|
|
13202
13295
|
}
|
|
13203
13296
|
}
|
|
13204
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
13297
|
+
var DoubleQuote$0 = $TV($EXPECT($L115, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
13205
13298
|
return { $loc, token: $1 };
|
|
13206
13299
|
});
|
|
13207
13300
|
function DoubleQuote(state) {
|
|
@@ -13226,7 +13319,7 @@ ${input.slice(result.pos)}
|
|
|
13226
13319
|
return result;
|
|
13227
13320
|
}
|
|
13228
13321
|
}
|
|
13229
|
-
var Else$0 = $TS($S($EXPECT($
|
|
13322
|
+
var Else$0 = $TS($S($EXPECT($L116, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13230
13323
|
return { $loc, token: $1 };
|
|
13231
13324
|
});
|
|
13232
13325
|
function Else(state) {
|
|
@@ -13276,7 +13369,7 @@ ${input.slice(result.pos)}
|
|
|
13276
13369
|
return result;
|
|
13277
13370
|
}
|
|
13278
13371
|
}
|
|
13279
|
-
var Export$0 = $TS($S($EXPECT($
|
|
13372
|
+
var Export$0 = $TS($S($EXPECT($L117, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13280
13373
|
return { $loc, token: $1 };
|
|
13281
13374
|
});
|
|
13282
13375
|
function Export(state) {
|
|
@@ -13301,7 +13394,7 @@ ${input.slice(result.pos)}
|
|
|
13301
13394
|
return result;
|
|
13302
13395
|
}
|
|
13303
13396
|
}
|
|
13304
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
13397
|
+
var Extends$0 = $TS($S($EXPECT($L118, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13305
13398
|
return { $loc, token: $1 };
|
|
13306
13399
|
});
|
|
13307
13400
|
function Extends(state) {
|
|
@@ -13326,7 +13419,7 @@ ${input.slice(result.pos)}
|
|
|
13326
13419
|
return result;
|
|
13327
13420
|
}
|
|
13328
13421
|
}
|
|
13329
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
13422
|
+
var Finally$0 = $TS($S($EXPECT($L119, fail, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13330
13423
|
return { $loc, token: $1 };
|
|
13331
13424
|
});
|
|
13332
13425
|
function Finally(state) {
|
|
@@ -13351,7 +13444,7 @@ ${input.slice(result.pos)}
|
|
|
13351
13444
|
return result;
|
|
13352
13445
|
}
|
|
13353
13446
|
}
|
|
13354
|
-
var For$0 = $TS($S($EXPECT($
|
|
13447
|
+
var For$0 = $TS($S($EXPECT($L120, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13355
13448
|
return { $loc, token: $1 };
|
|
13356
13449
|
});
|
|
13357
13450
|
function For(state) {
|
|
@@ -13376,7 +13469,7 @@ ${input.slice(result.pos)}
|
|
|
13376
13469
|
return result;
|
|
13377
13470
|
}
|
|
13378
13471
|
}
|
|
13379
|
-
var From$0 = $TS($S($EXPECT($
|
|
13472
|
+
var From$0 = $TS($S($EXPECT($L121, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13380
13473
|
return { $loc, token: $1 };
|
|
13381
13474
|
});
|
|
13382
13475
|
function From(state) {
|
|
@@ -13401,7 +13494,7 @@ ${input.slice(result.pos)}
|
|
|
13401
13494
|
return result;
|
|
13402
13495
|
}
|
|
13403
13496
|
}
|
|
13404
|
-
var Function$0 = $TS($S($EXPECT($
|
|
13497
|
+
var Function$0 = $TS($S($EXPECT($L122, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13405
13498
|
return { $loc, token: $1 };
|
|
13406
13499
|
});
|
|
13407
13500
|
function Function(state) {
|
|
@@ -13426,7 +13519,7 @@ ${input.slice(result.pos)}
|
|
|
13426
13519
|
return result;
|
|
13427
13520
|
}
|
|
13428
13521
|
}
|
|
13429
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
13522
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L123, fail, 'GetOrSet "get"'), $EXPECT($L124, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13430
13523
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
13431
13524
|
});
|
|
13432
13525
|
function GetOrSet(state) {
|
|
@@ -13451,7 +13544,7 @@ ${input.slice(result.pos)}
|
|
|
13451
13544
|
return result;
|
|
13452
13545
|
}
|
|
13453
13546
|
}
|
|
13454
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
13547
|
+
var If$0 = $TV($TEXT($S($EXPECT($L125, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L8, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
13455
13548
|
return { $loc, token: $1 };
|
|
13456
13549
|
});
|
|
13457
13550
|
function If(state) {
|
|
@@ -13476,7 +13569,7 @@ ${input.slice(result.pos)}
|
|
|
13476
13569
|
return result;
|
|
13477
13570
|
}
|
|
13478
13571
|
}
|
|
13479
|
-
var Import$0 = $TS($S($EXPECT($L13, fail, 'Import "import"'), $Y($EXPECT($
|
|
13572
|
+
var Import$0 = $TS($S($EXPECT($L13, fail, 'Import "import"'), $Y($EXPECT($R48, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
13480
13573
|
return { $loc, token: $1 };
|
|
13481
13574
|
});
|
|
13482
13575
|
function Import(state) {
|
|
@@ -13501,7 +13594,7 @@ ${input.slice(result.pos)}
|
|
|
13501
13594
|
return result;
|
|
13502
13595
|
}
|
|
13503
13596
|
}
|
|
13504
|
-
var In$0 = $TS($S($EXPECT($
|
|
13597
|
+
var In$0 = $TS($S($EXPECT($L80, fail, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13505
13598
|
return { $loc, token: $1 };
|
|
13506
13599
|
});
|
|
13507
13600
|
function In(state) {
|
|
@@ -13526,7 +13619,7 @@ ${input.slice(result.pos)}
|
|
|
13526
13619
|
return result;
|
|
13527
13620
|
}
|
|
13528
13621
|
}
|
|
13529
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
13622
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L126, fail, 'LetOrConst "let"'), $EXPECT($L127, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13530
13623
|
return { $loc, token: $1 };
|
|
13531
13624
|
});
|
|
13532
13625
|
function LetOrConst(state) {
|
|
@@ -13551,7 +13644,7 @@ ${input.slice(result.pos)}
|
|
|
13551
13644
|
return result;
|
|
13552
13645
|
}
|
|
13553
13646
|
}
|
|
13554
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
13647
|
+
var Loop$0 = $TS($S($EXPECT($L128, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13555
13648
|
return { $loc, token: "while(true)" };
|
|
13556
13649
|
});
|
|
13557
13650
|
function Loop(state) {
|
|
@@ -13576,7 +13669,7 @@ ${input.slice(result.pos)}
|
|
|
13576
13669
|
return result;
|
|
13577
13670
|
}
|
|
13578
13671
|
}
|
|
13579
|
-
var New$0 = $TS($S($EXPECT($
|
|
13672
|
+
var New$0 = $TS($S($EXPECT($L129, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13580
13673
|
return { $loc, token: $1 };
|
|
13581
13674
|
});
|
|
13582
13675
|
function New(state) {
|
|
@@ -13601,7 +13694,7 @@ ${input.slice(result.pos)}
|
|
|
13601
13694
|
return result;
|
|
13602
13695
|
}
|
|
13603
13696
|
}
|
|
13604
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
13697
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L51, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L8, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
13605
13698
|
return { $loc, token: "!" };
|
|
13606
13699
|
});
|
|
13607
13700
|
function Not(state) {
|
|
@@ -13626,7 +13719,7 @@ ${input.slice(result.pos)}
|
|
|
13626
13719
|
return result;
|
|
13627
13720
|
}
|
|
13628
13721
|
}
|
|
13629
|
-
var Of$0 = $TS($S($EXPECT($
|
|
13722
|
+
var Of$0 = $TS($S($EXPECT($L72, fail, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13630
13723
|
return { $loc, token: $1 };
|
|
13631
13724
|
});
|
|
13632
13725
|
function Of(state) {
|
|
@@ -13651,7 +13744,7 @@ ${input.slice(result.pos)}
|
|
|
13651
13744
|
return result;
|
|
13652
13745
|
}
|
|
13653
13746
|
}
|
|
13654
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
13747
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L130, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
13655
13748
|
return { $loc, token: $1 };
|
|
13656
13749
|
});
|
|
13657
13750
|
function OpenAngleBracket(state) {
|
|
@@ -13676,7 +13769,7 @@ ${input.slice(result.pos)}
|
|
|
13676
13769
|
return result;
|
|
13677
13770
|
}
|
|
13678
13771
|
}
|
|
13679
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
13772
|
+
var OpenBrace$0 = $TV($EXPECT($L131, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
13680
13773
|
return { $loc, token: $1 };
|
|
13681
13774
|
});
|
|
13682
13775
|
function OpenBrace(state) {
|
|
@@ -13701,7 +13794,7 @@ ${input.slice(result.pos)}
|
|
|
13701
13794
|
return result;
|
|
13702
13795
|
}
|
|
13703
13796
|
}
|
|
13704
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
13797
|
+
var OpenBracket$0 = $TV($EXPECT($L95, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
13705
13798
|
return { $loc, token: $1 };
|
|
13706
13799
|
});
|
|
13707
13800
|
function OpenBracket(state) {
|
|
@@ -13751,7 +13844,7 @@ ${input.slice(result.pos)}
|
|
|
13751
13844
|
return result;
|
|
13752
13845
|
}
|
|
13753
13846
|
}
|
|
13754
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
13847
|
+
var Operator$0 = $TS($S($EXPECT($L132, fail, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13755
13848
|
return { $loc, token: $1 };
|
|
13756
13849
|
});
|
|
13757
13850
|
function Operator(state) {
|
|
@@ -13776,7 +13869,7 @@ ${input.slice(result.pos)}
|
|
|
13776
13869
|
return result;
|
|
13777
13870
|
}
|
|
13778
13871
|
}
|
|
13779
|
-
var Public$0 = $TS($S($EXPECT($
|
|
13872
|
+
var Public$0 = $TS($S($EXPECT($L133, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13780
13873
|
return { $loc, token: $1 };
|
|
13781
13874
|
});
|
|
13782
13875
|
function Public(state) {
|
|
@@ -13801,7 +13894,7 @@ ${input.slice(result.pos)}
|
|
|
13801
13894
|
return result;
|
|
13802
13895
|
}
|
|
13803
13896
|
}
|
|
13804
|
-
var Private$0 = $TS($S($EXPECT($
|
|
13897
|
+
var Private$0 = $TS($S($EXPECT($L134, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13805
13898
|
return { $loc, token: $1 };
|
|
13806
13899
|
});
|
|
13807
13900
|
function Private(state) {
|
|
@@ -13826,7 +13919,7 @@ ${input.slice(result.pos)}
|
|
|
13826
13919
|
return result;
|
|
13827
13920
|
}
|
|
13828
13921
|
}
|
|
13829
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
13922
|
+
var Protected$0 = $TS($S($EXPECT($L135, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13830
13923
|
return { $loc, token: $1 };
|
|
13831
13924
|
});
|
|
13832
13925
|
function Protected(state) {
|
|
@@ -13851,7 +13944,13 @@ ${input.slice(result.pos)}
|
|
|
13851
13944
|
return result;
|
|
13852
13945
|
}
|
|
13853
13946
|
}
|
|
13854
|
-
var Pipe$0 = $TV($EXPECT($
|
|
13947
|
+
var Pipe$0 = $TV($EXPECT($L136, fail, 'Pipe "||>"'), function($skip, $loc, $0, $1) {
|
|
13948
|
+
return { $loc, token: $1 };
|
|
13949
|
+
});
|
|
13950
|
+
var Pipe$1 = $TV($EXPECT($L137, fail, 'Pipe "|>="'), function($skip, $loc, $0, $1) {
|
|
13951
|
+
return { $loc, token: $1 };
|
|
13952
|
+
});
|
|
13953
|
+
var Pipe$2 = $TV($EXPECT($L138, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
13855
13954
|
return { $loc, token: $1 };
|
|
13856
13955
|
});
|
|
13857
13956
|
function Pipe(state) {
|
|
@@ -13865,12 +13964,12 @@ ${input.slice(result.pos)}
|
|
|
13865
13964
|
}
|
|
13866
13965
|
}
|
|
13867
13966
|
if (state.tokenize) {
|
|
13868
|
-
const result = $TOKEN("Pipe", state, Pipe$0(state));
|
|
13967
|
+
const result = $TOKEN("Pipe", state, Pipe$0(state) || Pipe$1(state) || Pipe$2(state));
|
|
13869
13968
|
if (state.events)
|
|
13870
13969
|
state.events.exit?.("Pipe", state, result, eventData);
|
|
13871
13970
|
return result;
|
|
13872
13971
|
} else {
|
|
13873
|
-
const result = Pipe$0(state);
|
|
13972
|
+
const result = Pipe$0(state) || Pipe$1(state) || Pipe$2(state);
|
|
13874
13973
|
if (state.events)
|
|
13875
13974
|
state.events.exit?.("Pipe", state, result, eventData);
|
|
13876
13975
|
return result;
|
|
@@ -13901,7 +14000,7 @@ ${input.slice(result.pos)}
|
|
|
13901
14000
|
return result;
|
|
13902
14001
|
}
|
|
13903
14002
|
}
|
|
13904
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
14003
|
+
var Readonly$0 = $TS($S($EXPECT($L139, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13905
14004
|
return { $loc, token: $1, ts: true };
|
|
13906
14005
|
});
|
|
13907
14006
|
function Readonly(state) {
|
|
@@ -13926,7 +14025,7 @@ ${input.slice(result.pos)}
|
|
|
13926
14025
|
return result;
|
|
13927
14026
|
}
|
|
13928
14027
|
}
|
|
13929
|
-
var Return$0 = $TS($S($EXPECT($
|
|
14028
|
+
var Return$0 = $TS($S($EXPECT($L140, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13930
14029
|
return { $loc, token: $1 };
|
|
13931
14030
|
});
|
|
13932
14031
|
function Return(state) {
|
|
@@ -13951,7 +14050,7 @@ ${input.slice(result.pos)}
|
|
|
13951
14050
|
return result;
|
|
13952
14051
|
}
|
|
13953
14052
|
}
|
|
13954
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
14053
|
+
var Satisfies$0 = $TS($S($EXPECT($L141, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13955
14054
|
return { $loc, token: $1 };
|
|
13956
14055
|
});
|
|
13957
14056
|
function Satisfies(state) {
|
|
@@ -13976,7 +14075,7 @@ ${input.slice(result.pos)}
|
|
|
13976
14075
|
return result;
|
|
13977
14076
|
}
|
|
13978
14077
|
}
|
|
13979
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
14078
|
+
var Semicolon$0 = $TV($EXPECT($L84, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
13980
14079
|
return { $loc, token: $1 };
|
|
13981
14080
|
});
|
|
13982
14081
|
function Semicolon(state) {
|
|
@@ -14001,7 +14100,7 @@ ${input.slice(result.pos)}
|
|
|
14001
14100
|
return result;
|
|
14002
14101
|
}
|
|
14003
14102
|
}
|
|
14004
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
14103
|
+
var SingleQuote$0 = $TV($EXPECT($L142, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
14005
14104
|
return { $loc, token: $1 };
|
|
14006
14105
|
});
|
|
14007
14106
|
function SingleQuote(state) {
|
|
@@ -14026,7 +14125,7 @@ ${input.slice(result.pos)}
|
|
|
14026
14125
|
return result;
|
|
14027
14126
|
}
|
|
14028
14127
|
}
|
|
14029
|
-
var Star$0 = $TV($EXPECT($
|
|
14128
|
+
var Star$0 = $TV($EXPECT($L53, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
14030
14129
|
return { $loc, token: $1 };
|
|
14031
14130
|
});
|
|
14032
14131
|
function Star(state) {
|
|
@@ -14051,10 +14150,10 @@ ${input.slice(result.pos)}
|
|
|
14051
14150
|
return result;
|
|
14052
14151
|
}
|
|
14053
14152
|
}
|
|
14054
|
-
var Static$0 = $TS($S($EXPECT($
|
|
14153
|
+
var Static$0 = $TS($S($EXPECT($L143, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14055
14154
|
return { $loc, token: $1 };
|
|
14056
14155
|
});
|
|
14057
|
-
var Static$1 = $TS($S($EXPECT($
|
|
14156
|
+
var Static$1 = $TS($S($EXPECT($L99, fail, 'Static "@"'), $N($C($EXPECT($L2, fail, 'Static "("'), $EXPECT($L99, fail, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
14058
14157
|
return { $loc, token: "static " };
|
|
14059
14158
|
});
|
|
14060
14159
|
function Static(state) {
|
|
@@ -14079,7 +14178,7 @@ ${input.slice(result.pos)}
|
|
|
14079
14178
|
return result;
|
|
14080
14179
|
}
|
|
14081
14180
|
}
|
|
14082
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
14181
|
+
var SubstitutionStart$0 = $TV($EXPECT($L144, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
14083
14182
|
return { $loc, token: $1 };
|
|
14084
14183
|
});
|
|
14085
14184
|
function SubstitutionStart(state) {
|
|
@@ -14104,7 +14203,7 @@ ${input.slice(result.pos)}
|
|
|
14104
14203
|
return result;
|
|
14105
14204
|
}
|
|
14106
14205
|
}
|
|
14107
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
14206
|
+
var Switch$0 = $TS($S($EXPECT($L145, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14108
14207
|
return { $loc, token: $1 };
|
|
14109
14208
|
});
|
|
14110
14209
|
function Switch(state) {
|
|
@@ -14129,7 +14228,7 @@ ${input.slice(result.pos)}
|
|
|
14129
14228
|
return result;
|
|
14130
14229
|
}
|
|
14131
14230
|
}
|
|
14132
|
-
var Target$0 = $TS($S($EXPECT($
|
|
14231
|
+
var Target$0 = $TS($S($EXPECT($L146, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14133
14232
|
return { $loc, token: $1 };
|
|
14134
14233
|
});
|
|
14135
14234
|
function Target(state) {
|
|
@@ -14154,7 +14253,7 @@ ${input.slice(result.pos)}
|
|
|
14154
14253
|
return result;
|
|
14155
14254
|
}
|
|
14156
14255
|
}
|
|
14157
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
14256
|
+
var Then$0 = $TS($S(__, $EXPECT($L147, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
14158
14257
|
return { $loc, token: "" };
|
|
14159
14258
|
});
|
|
14160
14259
|
function Then(state) {
|
|
@@ -14179,7 +14278,7 @@ ${input.slice(result.pos)}
|
|
|
14179
14278
|
return result;
|
|
14180
14279
|
}
|
|
14181
14280
|
}
|
|
14182
|
-
var This$0 = $TS($S($EXPECT($
|
|
14281
|
+
var This$0 = $TS($S($EXPECT($L148, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14183
14282
|
return { $loc, token: $1 };
|
|
14184
14283
|
});
|
|
14185
14284
|
function This(state) {
|
|
@@ -14204,7 +14303,7 @@ ${input.slice(result.pos)}
|
|
|
14204
14303
|
return result;
|
|
14205
14304
|
}
|
|
14206
14305
|
}
|
|
14207
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
14306
|
+
var Throw$0 = $TS($S($EXPECT($L149, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14208
14307
|
return { $loc, token: $1 };
|
|
14209
14308
|
});
|
|
14210
14309
|
function Throw(state) {
|
|
@@ -14229,7 +14328,7 @@ ${input.slice(result.pos)}
|
|
|
14229
14328
|
return result;
|
|
14230
14329
|
}
|
|
14231
14330
|
}
|
|
14232
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
14331
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L150, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
14233
14332
|
return { $loc, token: "`" };
|
|
14234
14333
|
});
|
|
14235
14334
|
function TripleDoubleQuote(state) {
|
|
@@ -14254,7 +14353,7 @@ ${input.slice(result.pos)}
|
|
|
14254
14353
|
return result;
|
|
14255
14354
|
}
|
|
14256
14355
|
}
|
|
14257
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
14356
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L151, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
14258
14357
|
return { $loc, token: "`" };
|
|
14259
14358
|
});
|
|
14260
14359
|
function TripleSingleQuote(state) {
|
|
@@ -14279,7 +14378,7 @@ ${input.slice(result.pos)}
|
|
|
14279
14378
|
return result;
|
|
14280
14379
|
}
|
|
14281
14380
|
}
|
|
14282
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
14381
|
+
var TripleSlash$0 = $TV($EXPECT($L152, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
14283
14382
|
return { $loc, token: "/" };
|
|
14284
14383
|
});
|
|
14285
14384
|
function TripleSlash(state) {
|
|
@@ -14304,7 +14403,7 @@ ${input.slice(result.pos)}
|
|
|
14304
14403
|
return result;
|
|
14305
14404
|
}
|
|
14306
14405
|
}
|
|
14307
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
14406
|
+
var TripleTick$0 = $TV($EXPECT($L153, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
14308
14407
|
return { $loc, token: "`" };
|
|
14309
14408
|
});
|
|
14310
14409
|
function TripleTick(state) {
|
|
@@ -14329,7 +14428,7 @@ ${input.slice(result.pos)}
|
|
|
14329
14428
|
return result;
|
|
14330
14429
|
}
|
|
14331
14430
|
}
|
|
14332
|
-
var Try$0 = $TS($S($EXPECT($
|
|
14431
|
+
var Try$0 = $TS($S($EXPECT($L154, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14333
14432
|
return { $loc, token: $1 };
|
|
14334
14433
|
});
|
|
14335
14434
|
function Try(state) {
|
|
@@ -14354,7 +14453,7 @@ ${input.slice(result.pos)}
|
|
|
14354
14453
|
return result;
|
|
14355
14454
|
}
|
|
14356
14455
|
}
|
|
14357
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
14456
|
+
var Typeof$0 = $TS($S($EXPECT($L155, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14358
14457
|
return { $loc, token: $1 };
|
|
14359
14458
|
});
|
|
14360
14459
|
function Typeof(state) {
|
|
@@ -14379,7 +14478,7 @@ ${input.slice(result.pos)}
|
|
|
14379
14478
|
return result;
|
|
14380
14479
|
}
|
|
14381
14480
|
}
|
|
14382
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
14481
|
+
var Unless$0 = $TS($S($EXPECT($L156, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14383
14482
|
return { $loc, token: $1 };
|
|
14384
14483
|
});
|
|
14385
14484
|
function Unless(state) {
|
|
@@ -14404,7 +14503,7 @@ ${input.slice(result.pos)}
|
|
|
14404
14503
|
return result;
|
|
14405
14504
|
}
|
|
14406
14505
|
}
|
|
14407
|
-
var Until$0 = $TS($S($EXPECT($
|
|
14506
|
+
var Until$0 = $TS($S($EXPECT($L157, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14408
14507
|
return { $loc, token: $1 };
|
|
14409
14508
|
});
|
|
14410
14509
|
function Until(state) {
|
|
@@ -14429,7 +14528,7 @@ ${input.slice(result.pos)}
|
|
|
14429
14528
|
return result;
|
|
14430
14529
|
}
|
|
14431
14530
|
}
|
|
14432
|
-
var Var$0 = $TS($S($EXPECT($
|
|
14531
|
+
var Var$0 = $TS($S($EXPECT($L158, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14433
14532
|
return { $loc, token: $1 };
|
|
14434
14533
|
});
|
|
14435
14534
|
function Var(state) {
|
|
@@ -14454,7 +14553,7 @@ ${input.slice(result.pos)}
|
|
|
14454
14553
|
return result;
|
|
14455
14554
|
}
|
|
14456
14555
|
}
|
|
14457
|
-
var Void$0 = $TS($S($EXPECT($
|
|
14556
|
+
var Void$0 = $TS($S($EXPECT($L159, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14458
14557
|
return { $loc, token: $1 };
|
|
14459
14558
|
});
|
|
14460
14559
|
function Void(state) {
|
|
@@ -14479,7 +14578,7 @@ ${input.slice(result.pos)}
|
|
|
14479
14578
|
return result;
|
|
14480
14579
|
}
|
|
14481
14580
|
}
|
|
14482
|
-
var When$0 = $TS($S($EXPECT($
|
|
14581
|
+
var When$0 = $TS($S($EXPECT($L160, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14483
14582
|
return { $loc, token: "case" };
|
|
14484
14583
|
});
|
|
14485
14584
|
function When(state) {
|
|
@@ -14504,7 +14603,7 @@ ${input.slice(result.pos)}
|
|
|
14504
14603
|
return result;
|
|
14505
14604
|
}
|
|
14506
14605
|
}
|
|
14507
|
-
var While$0 = $TS($S($EXPECT($
|
|
14606
|
+
var While$0 = $TS($S($EXPECT($L161, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14508
14607
|
return { $loc, token: $1 };
|
|
14509
14608
|
});
|
|
14510
14609
|
function While(state) {
|
|
@@ -14529,7 +14628,7 @@ ${input.slice(result.pos)}
|
|
|
14529
14628
|
return result;
|
|
14530
14629
|
}
|
|
14531
14630
|
}
|
|
14532
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
14631
|
+
var Yield$0 = $TS($S($EXPECT($L162, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14533
14632
|
return { $loc, token: $1 };
|
|
14534
14633
|
});
|
|
14535
14634
|
function Yield(state) {
|
|
@@ -14675,7 +14774,7 @@ ${input.slice(result.pos)}
|
|
|
14675
14774
|
return result;
|
|
14676
14775
|
}
|
|
14677
14776
|
}
|
|
14678
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
14777
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L130, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L163, fail, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
14679
14778
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
14680
14779
|
});
|
|
14681
14780
|
function JSXSelfClosingElement(state) {
|
|
@@ -14726,7 +14825,7 @@ ${input.slice(result.pos)}
|
|
|
14726
14825
|
return result;
|
|
14727
14826
|
}
|
|
14728
14827
|
}
|
|
14729
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
14828
|
+
var JSXOpeningElement$0 = $S($EXPECT($L130, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L30, fail, 'JSXOpeningElement ">"'));
|
|
14730
14829
|
function JSXOpeningElement(state) {
|
|
14731
14830
|
let eventData;
|
|
14732
14831
|
if (state.events) {
|
|
@@ -14755,7 +14854,7 @@ ${input.slice(result.pos)}
|
|
|
14755
14854
|
return $skip;
|
|
14756
14855
|
return $0;
|
|
14757
14856
|
});
|
|
14758
|
-
var JSXOptionalClosingElement$1 = $EXPECT($
|
|
14857
|
+
var JSXOptionalClosingElement$1 = $EXPECT($L18, fail, 'JSXOptionalClosingElement ""');
|
|
14759
14858
|
function JSXOptionalClosingElement(state) {
|
|
14760
14859
|
let eventData;
|
|
14761
14860
|
if (state.events) {
|
|
@@ -14778,7 +14877,7 @@ ${input.slice(result.pos)}
|
|
|
14778
14877
|
return result;
|
|
14779
14878
|
}
|
|
14780
14879
|
}
|
|
14781
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
14880
|
+
var JSXClosingElement$0 = $S($EXPECT($L164, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L30, fail, 'JSXClosingElement ">"'));
|
|
14782
14881
|
function JSXClosingElement(state) {
|
|
14783
14882
|
let eventData;
|
|
14784
14883
|
if (state.events) {
|
|
@@ -14817,7 +14916,7 @@ ${input.slice(result.pos)}
|
|
|
14817
14916
|
];
|
|
14818
14917
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
14819
14918
|
});
|
|
14820
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
14919
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L165, fail, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
14821
14920
|
var children = $3;
|
|
14822
14921
|
$0 = $0.slice(1);
|
|
14823
14922
|
return {
|
|
@@ -14848,7 +14947,7 @@ ${input.slice(result.pos)}
|
|
|
14848
14947
|
return result;
|
|
14849
14948
|
}
|
|
14850
14949
|
}
|
|
14851
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
14950
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L165, fail, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
14852
14951
|
module2.JSXTagStack.push("");
|
|
14853
14952
|
return $1;
|
|
14854
14953
|
});
|
|
@@ -14879,7 +14978,7 @@ ${input.slice(result.pos)}
|
|
|
14879
14978
|
return $skip;
|
|
14880
14979
|
return $0;
|
|
14881
14980
|
});
|
|
14882
|
-
var JSXOptionalClosingFragment$1 = $EXPECT($
|
|
14981
|
+
var JSXOptionalClosingFragment$1 = $EXPECT($L18, fail, 'JSXOptionalClosingFragment ""');
|
|
14883
14982
|
function JSXOptionalClosingFragment(state) {
|
|
14884
14983
|
let eventData;
|
|
14885
14984
|
if (state.events) {
|
|
@@ -14902,7 +15001,7 @@ ${input.slice(result.pos)}
|
|
|
14902
15001
|
return result;
|
|
14903
15002
|
}
|
|
14904
15003
|
}
|
|
14905
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
15004
|
+
var JSXClosingFragment$0 = $EXPECT($L166, fail, 'JSXClosingFragment "</>"');
|
|
14906
15005
|
function JSXClosingFragment(state) {
|
|
14907
15006
|
let eventData;
|
|
14908
15007
|
if (state.events) {
|
|
@@ -14948,7 +15047,7 @@ ${input.slice(result.pos)}
|
|
|
14948
15047
|
return result;
|
|
14949
15048
|
}
|
|
14950
15049
|
}
|
|
14951
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
15050
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R49, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
14952
15051
|
function JSXIdentifierName(state) {
|
|
14953
15052
|
let eventData;
|
|
14954
15053
|
if (state.events) {
|
|
@@ -15091,7 +15190,7 @@ ${input.slice(result.pos)}
|
|
|
15091
15190
|
}
|
|
15092
15191
|
break;
|
|
15093
15192
|
case "SpreadProperty":
|
|
15094
|
-
parts.push(["{", part.value, "}"]);
|
|
15193
|
+
parts.push(["{", part.dots, part.value, "}"]);
|
|
15095
15194
|
break;
|
|
15096
15195
|
case "MethodDefinition":
|
|
15097
15196
|
try {
|
|
@@ -15164,7 +15263,7 @@ ${input.slice(result.pos)}
|
|
|
15164
15263
|
return result;
|
|
15165
15264
|
}
|
|
15166
15265
|
}
|
|
15167
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
15266
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R50, fail, "JSXAttributeSpace /[\\s>]/"));
|
|
15168
15267
|
function JSXAttributeSpace(state) {
|
|
15169
15268
|
let eventData;
|
|
15170
15269
|
if (state.events) {
|
|
@@ -15187,7 +15286,7 @@ ${input.slice(result.pos)}
|
|
|
15187
15286
|
return result;
|
|
15188
15287
|
}
|
|
15189
15288
|
}
|
|
15190
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
15289
|
+
var JSXShorthandString$0 = $TR($EXPECT($R51, fail, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15191
15290
|
return module2.quoteString($0);
|
|
15192
15291
|
});
|
|
15193
15292
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -15323,7 +15422,7 @@ ${input.slice(result.pos)}
|
|
|
15323
15422
|
return result;
|
|
15324
15423
|
}
|
|
15325
15424
|
}
|
|
15326
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
15425
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R52, fail, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
15327
15426
|
var op = $2;
|
|
15328
15427
|
var rhs = $3;
|
|
15329
15428
|
return [[], op, [], rhs];
|
|
@@ -15378,7 +15477,7 @@ ${input.slice(result.pos)}
|
|
|
15378
15477
|
return result;
|
|
15379
15478
|
}
|
|
15380
15479
|
}
|
|
15381
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
15480
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R8, fail, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15382
15481
|
return { $loc, token: $0 };
|
|
15383
15482
|
});
|
|
15384
15483
|
function InlineJSXUnaryOp(state) {
|
|
@@ -15669,7 +15768,7 @@ ${input.slice(result.pos)}
|
|
|
15669
15768
|
}
|
|
15670
15769
|
return $skip;
|
|
15671
15770
|
});
|
|
15672
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
15771
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L22, fail, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
15673
15772
|
return { children: [], jsxChildren: [] };
|
|
15674
15773
|
});
|
|
15675
15774
|
function JSXNestedChildren(state) {
|
|
@@ -15798,7 +15897,7 @@ ${input.slice(result.pos)}
|
|
|
15798
15897
|
return result;
|
|
15799
15898
|
}
|
|
15800
15899
|
}
|
|
15801
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
15900
|
+
var JSXComment$0 = $TS($S($EXPECT($L167, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L168, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
15802
15901
|
return ["{/*", $2, "*/}"];
|
|
15803
15902
|
});
|
|
15804
15903
|
function JSXComment(state) {
|
|
@@ -15823,7 +15922,7 @@ ${input.slice(result.pos)}
|
|
|
15823
15922
|
return result;
|
|
15824
15923
|
}
|
|
15825
15924
|
}
|
|
15826
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
15925
|
+
var JSXCommentContent$0 = $TR($EXPECT($R53, fail, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15827
15926
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
15828
15927
|
});
|
|
15829
15928
|
function JSXCommentContent(state) {
|
|
@@ -15848,7 +15947,7 @@ ${input.slice(result.pos)}
|
|
|
15848
15947
|
return result;
|
|
15849
15948
|
}
|
|
15850
15949
|
}
|
|
15851
|
-
var JSXText$0 = $TR($EXPECT($
|
|
15950
|
+
var JSXText$0 = $TR($EXPECT($R54, fail, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15852
15951
|
return {
|
|
15853
15952
|
type: "JSXText",
|
|
15854
15953
|
token: $0,
|
|
@@ -16096,7 +16195,7 @@ ${input.slice(result.pos)}
|
|
|
16096
16195
|
return result;
|
|
16097
16196
|
}
|
|
16098
16197
|
}
|
|
16099
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
16198
|
+
var TypeKeyword$0 = $S($EXPECT($L169, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
16100
16199
|
function TypeKeyword(state) {
|
|
16101
16200
|
let eventData;
|
|
16102
16201
|
if (state.events) {
|
|
@@ -16119,7 +16218,7 @@ ${input.slice(result.pos)}
|
|
|
16119
16218
|
return result;
|
|
16120
16219
|
}
|
|
16121
16220
|
}
|
|
16122
|
-
var Interface$0 = $S($EXPECT($
|
|
16221
|
+
var Interface$0 = $S($EXPECT($L170, fail, 'Interface "interface"'), NonIdContinue);
|
|
16123
16222
|
function Interface(state) {
|
|
16124
16223
|
let eventData;
|
|
16125
16224
|
if (state.events) {
|
|
@@ -16142,7 +16241,7 @@ ${input.slice(result.pos)}
|
|
|
16142
16241
|
return result;
|
|
16143
16242
|
}
|
|
16144
16243
|
}
|
|
16145
|
-
var Namespace$0 = $S($EXPECT($
|
|
16244
|
+
var Namespace$0 = $S($EXPECT($L171, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
16146
16245
|
function Namespace(state) {
|
|
16147
16246
|
let eventData;
|
|
16148
16247
|
if (state.events) {
|
|
@@ -16390,7 +16489,7 @@ ${input.slice(result.pos)}
|
|
|
16390
16489
|
return result;
|
|
16391
16490
|
}
|
|
16392
16491
|
}
|
|
16393
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
16492
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R55, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L139, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R56, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
16394
16493
|
function TypeIndexSignature(state) {
|
|
16395
16494
|
let eventData;
|
|
16396
16495
|
if (state.events) {
|
|
@@ -16462,7 +16561,7 @@ ${input.slice(result.pos)}
|
|
|
16462
16561
|
return result;
|
|
16463
16562
|
}
|
|
16464
16563
|
}
|
|
16465
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
16564
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L172, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
16466
16565
|
const children = [...$1, $2];
|
|
16467
16566
|
if ($3)
|
|
16468
16567
|
children.push($3);
|
|
@@ -16495,7 +16594,7 @@ ${input.slice(result.pos)}
|
|
|
16495
16594
|
return result;
|
|
16496
16595
|
}
|
|
16497
16596
|
}
|
|
16498
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
16597
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L81, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
16499
16598
|
if (!$2)
|
|
16500
16599
|
return $1;
|
|
16501
16600
|
return $0;
|
|
@@ -16621,10 +16720,10 @@ ${input.slice(result.pos)}
|
|
|
16621
16720
|
return result;
|
|
16622
16721
|
}
|
|
16623
16722
|
}
|
|
16624
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
16625
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
16626
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
16627
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
16723
|
+
var TypeUnaryOp$0 = $S($EXPECT($L173, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
16724
|
+
var TypeUnaryOp$1 = $S($EXPECT($L155, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
16725
|
+
var TypeUnaryOp$2 = $S($EXPECT($L174, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
16726
|
+
var TypeUnaryOp$3 = $S($EXPECT($L139, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
16628
16727
|
function TypeUnaryOp(state) {
|
|
16629
16728
|
let eventData;
|
|
16630
16729
|
if (state.events) {
|
|
@@ -16822,7 +16921,7 @@ ${input.slice(result.pos)}
|
|
|
16822
16921
|
return result;
|
|
16823
16922
|
}
|
|
16824
16923
|
}
|
|
16825
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
16924
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L118, fail, 'TypeConditional "extends"'), NonIdContinue, Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
16826
16925
|
if ($2)
|
|
16827
16926
|
return $0;
|
|
16828
16927
|
return $1;
|
|
@@ -16851,10 +16950,10 @@ ${input.slice(result.pos)}
|
|
|
16851
16950
|
}
|
|
16852
16951
|
var TypeLiteral$0 = TemplateLiteral;
|
|
16853
16952
|
var TypeLiteral$1 = Literal;
|
|
16854
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
16953
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L159, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
16855
16954
|
return { $loc, token: "void" };
|
|
16856
16955
|
});
|
|
16857
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
16956
|
+
var TypeLiteral$3 = $TV($EXPECT($L175, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
16858
16957
|
return { $loc, token: "[]" };
|
|
16859
16958
|
});
|
|
16860
16959
|
function TypeLiteral(state) {
|
|
@@ -16929,7 +17028,7 @@ ${input.slice(result.pos)}
|
|
|
16929
17028
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
16930
17029
|
return value[1];
|
|
16931
17030
|
});
|
|
16932
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
17031
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L32, fail, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L19, fail, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L31, fail, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L22, fail, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
16933
17032
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
16934
17033
|
function InlineInterfacePropertyDelimiter(state) {
|
|
16935
17034
|
let eventData;
|
|
@@ -16953,10 +17052,10 @@ ${input.slice(result.pos)}
|
|
|
16953
17052
|
return result;
|
|
16954
17053
|
}
|
|
16955
17054
|
}
|
|
16956
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
17055
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L83, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
16957
17056
|
return { $loc, token: "|" };
|
|
16958
17057
|
});
|
|
16959
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
17058
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L82, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
16960
17059
|
return { $loc, token: "&" };
|
|
16961
17060
|
});
|
|
16962
17061
|
function TypeBinaryOp(state) {
|
|
@@ -17013,7 +17112,7 @@ ${input.slice(result.pos)}
|
|
|
17013
17112
|
var TypeArrowFunction$0 = $TV($EXPECT($L7, fail, 'TypeArrowFunction "=>"'), function($skip, $loc, $0, $1) {
|
|
17014
17113
|
return { $loc, token: "=>" };
|
|
17015
17114
|
});
|
|
17016
|
-
var TypeArrowFunction$1 = $TV($EXPECT($
|
|
17115
|
+
var TypeArrowFunction$1 = $TV($EXPECT($L21, fail, 'TypeArrowFunction "->"'), function($skip, $loc, $0, $1) {
|
|
17017
17116
|
return { $loc, token: "=>" };
|
|
17018
17117
|
});
|
|
17019
17118
|
function TypeArrowFunction(state) {
|
|
@@ -17038,7 +17137,7 @@ ${input.slice(result.pos)}
|
|
|
17038
17137
|
return result;
|
|
17039
17138
|
}
|
|
17040
17139
|
}
|
|
17041
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
17140
|
+
var TypeArguments$0 = $TS($S($EXPECT($L130, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L30, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17042
17141
|
return { ts: true, children: $0 };
|
|
17043
17142
|
});
|
|
17044
17143
|
function TypeArguments(state) {
|
|
@@ -17109,7 +17208,7 @@ ${input.slice(result.pos)}
|
|
|
17109
17208
|
return result;
|
|
17110
17209
|
}
|
|
17111
17210
|
}
|
|
17112
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
17211
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L130, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L30, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
17113
17212
|
var parameters = $3;
|
|
17114
17213
|
return {
|
|
17115
17214
|
type: "TypeParameters",
|
|
@@ -17163,7 +17262,7 @@ ${input.slice(result.pos)}
|
|
|
17163
17262
|
return result;
|
|
17164
17263
|
}
|
|
17165
17264
|
}
|
|
17166
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
17265
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L118, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
17167
17266
|
function TypeConstraint(state) {
|
|
17168
17267
|
let eventData;
|
|
17169
17268
|
if (state.events) {
|
|
@@ -17210,7 +17309,7 @@ ${input.slice(result.pos)}
|
|
|
17210
17309
|
}
|
|
17211
17310
|
}
|
|
17212
17311
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
17213
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
17312
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L30, fail, 'TypeParameterDelimiter ">"')));
|
|
17214
17313
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
17215
17314
|
return value[1];
|
|
17216
17315
|
});
|
|
@@ -17261,7 +17360,7 @@ ${input.slice(result.pos)}
|
|
|
17261
17360
|
return result;
|
|
17262
17361
|
}
|
|
17263
17362
|
}
|
|
17264
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
17363
|
+
var Shebang$0 = $S($R$0($EXPECT($R57, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
17265
17364
|
function Shebang(state) {
|
|
17266
17365
|
let eventData;
|
|
17267
17366
|
if (state.events) {
|
|
@@ -17284,11 +17383,11 @@ ${input.slice(result.pos)}
|
|
|
17284
17383
|
return result;
|
|
17285
17384
|
}
|
|
17286
17385
|
}
|
|
17287
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
17386
|
+
var CivetPrologue$0 = $T($S($EXPECT($R58, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
|
|
17288
17387
|
var content = value[2];
|
|
17289
17388
|
return content;
|
|
17290
17389
|
});
|
|
17291
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
17390
|
+
var CivetPrologue$1 = $T($S($EXPECT($R58, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
|
|
17292
17391
|
var content = value[2];
|
|
17293
17392
|
return content;
|
|
17294
17393
|
});
|
|
@@ -17314,7 +17413,7 @@ ${input.slice(result.pos)}
|
|
|
17314
17413
|
return result;
|
|
17315
17414
|
}
|
|
17316
17415
|
}
|
|
17317
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
17416
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L176, fail, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R59, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17318
17417
|
var options = $3;
|
|
17319
17418
|
return {
|
|
17320
17419
|
type: "CivetPrologue",
|
|
@@ -17344,7 +17443,7 @@ ${input.slice(result.pos)}
|
|
|
17344
17443
|
return result;
|
|
17345
17444
|
}
|
|
17346
17445
|
}
|
|
17347
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
17446
|
+
var CivetOption$0 = $TR($EXPECT($R60, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
17348
17447
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
17349
17448
|
if (l)
|
|
17350
17449
|
return l.toUpperCase();
|
|
@@ -17380,7 +17479,7 @@ ${input.slice(result.pos)}
|
|
|
17380
17479
|
return result;
|
|
17381
17480
|
}
|
|
17382
17481
|
}
|
|
17383
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
17482
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R58, fail, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
17384
17483
|
function UnknownPrologue(state) {
|
|
17385
17484
|
let eventData;
|
|
17386
17485
|
if (state.events) {
|
|
@@ -17450,7 +17549,7 @@ ${input.slice(result.pos)}
|
|
|
17450
17549
|
return result;
|
|
17451
17550
|
}
|
|
17452
17551
|
}
|
|
17453
|
-
var EOL$0 = $TR($EXPECT($
|
|
17552
|
+
var EOL$0 = $TR($EXPECT($R61, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
17454
17553
|
return { $loc, token: $0 };
|
|
17455
17554
|
});
|
|
17456
17555
|
function EOL(state) {
|
|
@@ -17475,7 +17574,7 @@ ${input.slice(result.pos)}
|
|
|
17475
17574
|
return result;
|
|
17476
17575
|
}
|
|
17477
17576
|
}
|
|
17478
|
-
var Debugger$0 = $TV($EXPECT($
|
|
17577
|
+
var Debugger$0 = $TV($EXPECT($L18, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
17479
17578
|
debugger;
|
|
17480
17579
|
});
|
|
17481
17580
|
function Debugger(state) {
|
|
@@ -17500,7 +17599,7 @@ ${input.slice(result.pos)}
|
|
|
17500
17599
|
return result;
|
|
17501
17600
|
}
|
|
17502
17601
|
}
|
|
17503
|
-
var InsertSemicolon$0 = $TV($EXPECT($
|
|
17602
|
+
var InsertSemicolon$0 = $TV($EXPECT($L18, fail, 'InsertSemicolon ""'), function($skip, $loc, $0, $1) {
|
|
17504
17603
|
return { $loc, token: ";" };
|
|
17505
17604
|
});
|
|
17506
17605
|
function InsertSemicolon(state) {
|
|
@@ -17525,7 +17624,7 @@ ${input.slice(result.pos)}
|
|
|
17525
17624
|
return result;
|
|
17526
17625
|
}
|
|
17527
17626
|
}
|
|
17528
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
17627
|
+
var InsertOpenParen$0 = $TV($EXPECT($L18, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
17529
17628
|
return { $loc, token: "(" };
|
|
17530
17629
|
});
|
|
17531
17630
|
function InsertOpenParen(state) {
|
|
@@ -17550,7 +17649,7 @@ ${input.slice(result.pos)}
|
|
|
17550
17649
|
return result;
|
|
17551
17650
|
}
|
|
17552
17651
|
}
|
|
17553
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
17652
|
+
var InsertCloseParen$0 = $TV($EXPECT($L18, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
17554
17653
|
return { $loc, token: ")" };
|
|
17555
17654
|
});
|
|
17556
17655
|
function InsertCloseParen(state) {
|
|
@@ -17575,7 +17674,7 @@ ${input.slice(result.pos)}
|
|
|
17575
17674
|
return result;
|
|
17576
17675
|
}
|
|
17577
17676
|
}
|
|
17578
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
17677
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L18, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
17579
17678
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
17580
17679
|
});
|
|
17581
17680
|
function InsertOpenBrace(state) {
|
|
@@ -17600,7 +17699,7 @@ ${input.slice(result.pos)}
|
|
|
17600
17699
|
return result;
|
|
17601
17700
|
}
|
|
17602
17701
|
}
|
|
17603
|
-
var InsertInlineOpenBrace$0 = $TV($EXPECT($
|
|
17702
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L18, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
17604
17703
|
return { $loc, token: "{" };
|
|
17605
17704
|
});
|
|
17606
17705
|
function InsertInlineOpenBrace(state) {
|
|
@@ -17625,7 +17724,7 @@ ${input.slice(result.pos)}
|
|
|
17625
17724
|
return result;
|
|
17626
17725
|
}
|
|
17627
17726
|
}
|
|
17628
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
17727
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L18, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
17629
17728
|
return { $loc, token: "}" };
|
|
17630
17729
|
});
|
|
17631
17730
|
function InsertCloseBrace(state) {
|
|
@@ -17650,7 +17749,7 @@ ${input.slice(result.pos)}
|
|
|
17650
17749
|
return result;
|
|
17651
17750
|
}
|
|
17652
17751
|
}
|
|
17653
|
-
var InsertOpenBracket$0 = $TV($EXPECT($
|
|
17752
|
+
var InsertOpenBracket$0 = $TV($EXPECT($L18, fail, 'InsertOpenBracket ""'), function($skip, $loc, $0, $1) {
|
|
17654
17753
|
return { $loc, token: "[" };
|
|
17655
17754
|
});
|
|
17656
17755
|
function InsertOpenBracket(state) {
|
|
@@ -17675,7 +17774,7 @@ ${input.slice(result.pos)}
|
|
|
17675
17774
|
return result;
|
|
17676
17775
|
}
|
|
17677
17776
|
}
|
|
17678
|
-
var InsertCloseBracket$0 = $TV($EXPECT($
|
|
17777
|
+
var InsertCloseBracket$0 = $TV($EXPECT($L18, fail, 'InsertCloseBracket ""'), function($skip, $loc, $0, $1) {
|
|
17679
17778
|
return { $loc, token: "]" };
|
|
17680
17779
|
});
|
|
17681
17780
|
function InsertCloseBracket(state) {
|
|
@@ -17700,7 +17799,7 @@ ${input.slice(result.pos)}
|
|
|
17700
17799
|
return result;
|
|
17701
17800
|
}
|
|
17702
17801
|
}
|
|
17703
|
-
var InsertComma$0 = $TV($EXPECT($
|
|
17802
|
+
var InsertComma$0 = $TV($EXPECT($L18, fail, 'InsertComma ""'), function($skip, $loc, $0, $1) {
|
|
17704
17803
|
return { $loc, token: "," };
|
|
17705
17804
|
});
|
|
17706
17805
|
function InsertComma(state) {
|
|
@@ -17725,7 +17824,7 @@ ${input.slice(result.pos)}
|
|
|
17725
17824
|
return result;
|
|
17726
17825
|
}
|
|
17727
17826
|
}
|
|
17728
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
17827
|
+
var InsertConst$0 = $TV($EXPECT($L18, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
17729
17828
|
return { $loc, token: "const " };
|
|
17730
17829
|
});
|
|
17731
17830
|
function InsertConst(state) {
|
|
@@ -17750,7 +17849,7 @@ ${input.slice(result.pos)}
|
|
|
17750
17849
|
return result;
|
|
17751
17850
|
}
|
|
17752
17851
|
}
|
|
17753
|
-
var InsertLet$0 = $TV($EXPECT($
|
|
17852
|
+
var InsertLet$0 = $TV($EXPECT($L18, fail, 'InsertLet ""'), function($skip, $loc, $0, $1) {
|
|
17754
17853
|
return { $loc, token: "let " };
|
|
17755
17854
|
});
|
|
17756
17855
|
function InsertLet(state) {
|
|
@@ -17775,7 +17874,7 @@ ${input.slice(result.pos)}
|
|
|
17775
17874
|
return result;
|
|
17776
17875
|
}
|
|
17777
17876
|
}
|
|
17778
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
17877
|
+
var InsertReadonly$0 = $TV($EXPECT($L18, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
17779
17878
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
17780
17879
|
});
|
|
17781
17880
|
function InsertReadonly(state) {
|
|
@@ -17800,7 +17899,7 @@ ${input.slice(result.pos)}
|
|
|
17800
17899
|
return result;
|
|
17801
17900
|
}
|
|
17802
17901
|
}
|
|
17803
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
17902
|
+
var InsertNewline$0 = $TV($EXPECT($L18, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
17804
17903
|
return "\n";
|
|
17805
17904
|
});
|
|
17806
17905
|
function InsertNewline(state) {
|
|
@@ -17825,7 +17924,7 @@ ${input.slice(result.pos)}
|
|
|
17825
17924
|
return result;
|
|
17826
17925
|
}
|
|
17827
17926
|
}
|
|
17828
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
17927
|
+
var InsertIndent$0 = $TV($EXPECT($L18, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
17829
17928
|
return module2.currentIndent.token;
|
|
17830
17929
|
});
|
|
17831
17930
|
function InsertIndent(state) {
|
|
@@ -17850,7 +17949,7 @@ ${input.slice(result.pos)}
|
|
|
17850
17949
|
return result;
|
|
17851
17950
|
}
|
|
17852
17951
|
}
|
|
17853
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
17952
|
+
var InsertSpace$0 = $TV($EXPECT($L18, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
17854
17953
|
return { $loc, token: " " };
|
|
17855
17954
|
});
|
|
17856
17955
|
function InsertSpace(state) {
|
|
@@ -17875,7 +17974,7 @@ ${input.slice(result.pos)}
|
|
|
17875
17974
|
return result;
|
|
17876
17975
|
}
|
|
17877
17976
|
}
|
|
17878
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
17977
|
+
var InsertDot$0 = $TV($EXPECT($L18, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
17879
17978
|
return { $loc, token: "." };
|
|
17880
17979
|
});
|
|
17881
17980
|
function InsertDot(state) {
|
|
@@ -17900,7 +17999,7 @@ ${input.slice(result.pos)}
|
|
|
17900
17999
|
return result;
|
|
17901
18000
|
}
|
|
17902
18001
|
}
|
|
17903
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
18002
|
+
var InsertBreak$0 = $TV($EXPECT($L18, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
17904
18003
|
return { $loc, token: ";break;" };
|
|
17905
18004
|
});
|
|
17906
18005
|
function InsertBreak(state) {
|
|
@@ -17925,7 +18024,7 @@ ${input.slice(result.pos)}
|
|
|
17925
18024
|
return result;
|
|
17926
18025
|
}
|
|
17927
18026
|
}
|
|
17928
|
-
var InsertVar$0 = $TV($EXPECT($
|
|
18027
|
+
var InsertVar$0 = $TV($EXPECT($L18, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
17929
18028
|
return { $loc, token: "var " };
|
|
17930
18029
|
});
|
|
17931
18030
|
function InsertVar(state) {
|
|
@@ -17950,7 +18049,7 @@ ${input.slice(result.pos)}
|
|
|
17950
18049
|
return result;
|
|
17951
18050
|
}
|
|
17952
18051
|
}
|
|
17953
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
18052
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
17954
18053
|
if (module2.config.coffeeBinaryExistential)
|
|
17955
18054
|
return;
|
|
17956
18055
|
return $skip;
|
|
@@ -17977,7 +18076,7 @@ ${input.slice(result.pos)}
|
|
|
17977
18076
|
return result;
|
|
17978
18077
|
}
|
|
17979
18078
|
}
|
|
17980
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
18079
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
17981
18080
|
if (module2.config.coffeeBooleans)
|
|
17982
18081
|
return;
|
|
17983
18082
|
return $skip;
|
|
@@ -18004,7 +18103,7 @@ ${input.slice(result.pos)}
|
|
|
18004
18103
|
return result;
|
|
18005
18104
|
}
|
|
18006
18105
|
}
|
|
18007
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
18106
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18008
18107
|
if (module2.config.coffeeClasses)
|
|
18009
18108
|
return;
|
|
18010
18109
|
return $skip;
|
|
@@ -18031,7 +18130,7 @@ ${input.slice(result.pos)}
|
|
|
18031
18130
|
return result;
|
|
18032
18131
|
}
|
|
18033
18132
|
}
|
|
18034
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
18133
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18035
18134
|
if (module2.config.coffeeComment)
|
|
18036
18135
|
return;
|
|
18037
18136
|
return $skip;
|
|
@@ -18058,7 +18157,7 @@ ${input.slice(result.pos)}
|
|
|
18058
18157
|
return result;
|
|
18059
18158
|
}
|
|
18060
18159
|
}
|
|
18061
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
18160
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18062
18161
|
if (module2.config.coffeeDo)
|
|
18063
18162
|
return;
|
|
18064
18163
|
return $skip;
|
|
@@ -18085,7 +18184,7 @@ ${input.slice(result.pos)}
|
|
|
18085
18184
|
return result;
|
|
18086
18185
|
}
|
|
18087
18186
|
}
|
|
18088
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
18187
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18089
18188
|
if (module2.config.coffeeForLoops)
|
|
18090
18189
|
return;
|
|
18091
18190
|
return $skip;
|
|
@@ -18112,7 +18211,7 @@ ${input.slice(result.pos)}
|
|
|
18112
18211
|
return result;
|
|
18113
18212
|
}
|
|
18114
18213
|
}
|
|
18115
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
18214
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18116
18215
|
if (module2.config.coffeeInterpolation)
|
|
18117
18216
|
return;
|
|
18118
18217
|
return $skip;
|
|
@@ -18139,7 +18238,7 @@ ${input.slice(result.pos)}
|
|
|
18139
18238
|
return result;
|
|
18140
18239
|
}
|
|
18141
18240
|
}
|
|
18142
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
18241
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18143
18242
|
if (module2.config.coffeeIsnt)
|
|
18144
18243
|
return;
|
|
18145
18244
|
return $skip;
|
|
@@ -18166,7 +18265,7 @@ ${input.slice(result.pos)}
|
|
|
18166
18265
|
return result;
|
|
18167
18266
|
}
|
|
18168
18267
|
}
|
|
18169
|
-
var CoffeeJSXEnabled$0 = $TV($EXPECT($
|
|
18268
|
+
var CoffeeJSXEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeJSXEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18170
18269
|
if (module2.config.coffeeJSX)
|
|
18171
18270
|
return;
|
|
18172
18271
|
return $skip;
|
|
@@ -18193,7 +18292,7 @@ ${input.slice(result.pos)}
|
|
|
18193
18292
|
return result;
|
|
18194
18293
|
}
|
|
18195
18294
|
}
|
|
18196
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
18295
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18197
18296
|
if (module2.config.coffeeLineContinuation)
|
|
18198
18297
|
return;
|
|
18199
18298
|
return $skip;
|
|
@@ -18220,7 +18319,7 @@ ${input.slice(result.pos)}
|
|
|
18220
18319
|
return result;
|
|
18221
18320
|
}
|
|
18222
18321
|
}
|
|
18223
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
18322
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18224
18323
|
if (module2.config.coffeeNot)
|
|
18225
18324
|
return;
|
|
18226
18325
|
return $skip;
|
|
@@ -18247,7 +18346,7 @@ ${input.slice(result.pos)}
|
|
|
18247
18346
|
return result;
|
|
18248
18347
|
}
|
|
18249
18348
|
}
|
|
18250
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
18349
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18251
18350
|
if (module2.config.coffeeOf)
|
|
18252
18351
|
return;
|
|
18253
18352
|
return $skip;
|
|
@@ -18274,7 +18373,7 @@ ${input.slice(result.pos)}
|
|
|
18274
18373
|
return result;
|
|
18275
18374
|
}
|
|
18276
18375
|
}
|
|
18277
|
-
var CoffeePrototypeEnabled$0 = $TV($EXPECT($
|
|
18376
|
+
var CoffeePrototypeEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18278
18377
|
if (module2.config.coffeePrototype)
|
|
18279
18378
|
return;
|
|
18280
18379
|
return $skip;
|
|
@@ -18301,7 +18400,7 @@ ${input.slice(result.pos)}
|
|
|
18301
18400
|
return result;
|
|
18302
18401
|
}
|
|
18303
18402
|
}
|
|
18304
|
-
var ObjectIsEnabled$0 = $TV($EXPECT($
|
|
18403
|
+
var ObjectIsEnabled$0 = $TV($EXPECT($L18, fail, 'ObjectIsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18305
18404
|
if (module2.config.objectIs)
|
|
18306
18405
|
return;
|
|
18307
18406
|
return $skip;
|
|
@@ -18328,7 +18427,7 @@ ${input.slice(result.pos)}
|
|
|
18328
18427
|
return result;
|
|
18329
18428
|
}
|
|
18330
18429
|
}
|
|
18331
|
-
var Reset$0 = $TV($EXPECT($
|
|
18430
|
+
var Reset$0 = $TV($EXPECT($L18, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
18332
18431
|
module2.indentLevels = [{
|
|
18333
18432
|
level: 0,
|
|
18334
18433
|
token: ""
|
|
@@ -18395,39 +18494,54 @@ ${input.slice(result.pos)}
|
|
|
18395
18494
|
children: [" as const"]
|
|
18396
18495
|
};
|
|
18397
18496
|
module2.prelude = [];
|
|
18497
|
+
const preludeVar = "var ";
|
|
18398
18498
|
const declareRef = {
|
|
18399
18499
|
indexOf(indexOfRef) {
|
|
18400
18500
|
const typeSuffix = {
|
|
18401
18501
|
ts: true,
|
|
18402
18502
|
children: [": <T>(this: T[], searchElement: T) => boolean"]
|
|
18403
18503
|
};
|
|
18404
|
-
module2.prelude.push(["", [
|
|
18504
|
+
module2.prelude.push(["", [preludeVar, indexOfRef, typeSuffix, " = [].indexOf", module2.asAny, ";\n"]]);
|
|
18405
18505
|
},
|
|
18406
18506
|
hasProp(hasPropRef) {
|
|
18407
18507
|
const typeSuffix = {
|
|
18408
18508
|
ts: true,
|
|
18409
18509
|
children: [": <T>(this: T, prop: keyof T) => boolean"]
|
|
18410
18510
|
};
|
|
18411
|
-
module2.prelude.push(["", [
|
|
18511
|
+
module2.prelude.push(["", [preludeVar, hasPropRef, typeSuffix, " = {}.hasOwnProperty", module2.asAny, ";\n"]]);
|
|
18412
18512
|
},
|
|
18413
18513
|
is(isRef) {
|
|
18414
18514
|
const typeSuffix = {
|
|
18415
18515
|
ts: true,
|
|
18416
18516
|
children: [": { <B, A extends B> (a: A, b: B): b is A, <A, B> (a: A, b: B): a is A & B }"]
|
|
18417
18517
|
};
|
|
18418
|
-
module2.prelude.push(["", [
|
|
18518
|
+
module2.prelude.push(["", [preludeVar, isRef, typeSuffix, " = Object.is", module2.asAny, ";\n"]]);
|
|
18419
18519
|
},
|
|
18420
18520
|
modulo(moduloRef) {
|
|
18421
18521
|
const typeSuffix = {
|
|
18422
18522
|
ts: true,
|
|
18423
18523
|
children: [": (a: number, b: number) => number"]
|
|
18424
18524
|
};
|
|
18425
|
-
module2.prelude.push(["", [
|
|
18525
|
+
module2.prelude.push(["", [preludeVar, moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
|
|
18526
|
+
},
|
|
18527
|
+
xor(xorRef) {
|
|
18528
|
+
const typeSuffix = {
|
|
18529
|
+
ts: true,
|
|
18530
|
+
children: [": (a: unknown, b: unknown) => boolean"]
|
|
18531
|
+
};
|
|
18532
|
+
module2.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => a ? !b && a : b;", "\n"]]);
|
|
18533
|
+
},
|
|
18534
|
+
xnor(xnorRef) {
|
|
18535
|
+
const typeSuffix = {
|
|
18536
|
+
ts: true,
|
|
18537
|
+
children: [": (a: unknown, b: unknown) => boolean"]
|
|
18538
|
+
};
|
|
18539
|
+
module2.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => a ? b : !b || a;", "\n"]]);
|
|
18426
18540
|
},
|
|
18427
18541
|
returnSymbol(ref) {
|
|
18428
18542
|
module2.prelude.push({
|
|
18429
18543
|
children: [
|
|
18430
|
-
|
|
18544
|
+
preludeVar,
|
|
18431
18545
|
ref,
|
|
18432
18546
|
` = Symbol("return")';
|
|
18433
18547
|
`
|
|
@@ -18606,7 +18720,7 @@ ${input.slice(result.pos)}
|
|
|
18606
18720
|
return result;
|
|
18607
18721
|
}
|
|
18608
18722
|
}
|
|
18609
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
18723
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L18, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
18610
18724
|
var directives = $2;
|
|
18611
18725
|
directives.forEach((directive) => {
|
|
18612
18726
|
if (directive.type === "CivetPrologue") {
|
|
@@ -18621,35 +18735,43 @@ ${input.slice(result.pos)}
|
|
|
18621
18735
|
const prefix = children.slice(0, i).concat(glob.children[0]);
|
|
18622
18736
|
const parts = [];
|
|
18623
18737
|
for (const part of glob.object.content) {
|
|
18624
|
-
if (part.type === "SpreadProperty") {
|
|
18625
|
-
throw new Error("Glob pattern cannot have ...spread property");
|
|
18626
|
-
}
|
|
18627
18738
|
if (part.type === "MethodDefinition") {
|
|
18628
18739
|
throw new Error("Glob pattern cannot have method definition");
|
|
18629
18740
|
}
|
|
18630
18741
|
if (part.value && !["CallExpression", "MemberExpression", "Identifier"].includes(part.value.type)) {
|
|
18631
18742
|
throw new Error("Glob pattern must have call or member expression value");
|
|
18632
18743
|
}
|
|
18633
|
-
const { name } = part;
|
|
18634
18744
|
let value = part.value ?? part.name;
|
|
18635
18745
|
const wValue = module2.getTrimmingSpace(part.value);
|
|
18636
18746
|
value = prefix.concat(module2.insertTrimmingSpace(value, ""));
|
|
18637
18747
|
if (wValue)
|
|
18638
18748
|
value.unshift(wValue);
|
|
18639
|
-
|
|
18640
|
-
|
|
18641
|
-
|
|
18642
|
-
value,
|
|
18643
|
-
names: part.names,
|
|
18644
|
-
children: [
|
|
18645
|
-
module2.isWhitespaceOrEmpty(part.children[0]) && part.children[0],
|
|
18646
|
-
name,
|
|
18647
|
-
module2.isWhitespaceOrEmpty(part.children[2]) && part.children[2],
|
|
18648
|
-
part.children[3]?.token === ":" ? part.children[3] : ":",
|
|
18749
|
+
if (part.type === "SpreadProperty") {
|
|
18750
|
+
parts.push({
|
|
18751
|
+
type: part.type,
|
|
18649
18752
|
value,
|
|
18650
|
-
part.
|
|
18651
|
-
|
|
18652
|
-
|
|
18753
|
+
dots: part.dots,
|
|
18754
|
+
delim: part.delim,
|
|
18755
|
+
names: part.names,
|
|
18756
|
+
children: part.children.slice(0, 2).concat(value, part.delim)
|
|
18757
|
+
});
|
|
18758
|
+
} else {
|
|
18759
|
+
parts.push({
|
|
18760
|
+
type: part.type,
|
|
18761
|
+
name: part.name,
|
|
18762
|
+
value,
|
|
18763
|
+
delim: part.delim,
|
|
18764
|
+
names: part.names,
|
|
18765
|
+
children: [
|
|
18766
|
+
module2.isWhitespaceOrEmpty(part.children[0]) && part.children[0],
|
|
18767
|
+
part.name,
|
|
18768
|
+
module2.isWhitespaceOrEmpty(part.children[2]) && part.children[2],
|
|
18769
|
+
part.children[3]?.token === ":" ? part.children[3] : ":",
|
|
18770
|
+
value,
|
|
18771
|
+
part.delim
|
|
18772
|
+
]
|
|
18773
|
+
});
|
|
18774
|
+
}
|
|
18653
18775
|
}
|
|
18654
18776
|
const object = {
|
|
18655
18777
|
type: "ObjectExpression",
|
|
@@ -18718,6 +18840,43 @@ ${input.slice(result.pos)}
|
|
|
18718
18840
|
return { children };
|
|
18719
18841
|
}
|
|
18720
18842
|
};
|
|
18843
|
+
module2.literalValue = function(literal) {
|
|
18844
|
+
let { raw } = literal;
|
|
18845
|
+
switch (raw) {
|
|
18846
|
+
case "null":
|
|
18847
|
+
return null;
|
|
18848
|
+
case "true":
|
|
18849
|
+
return true;
|
|
18850
|
+
case "false":
|
|
18851
|
+
return false;
|
|
18852
|
+
}
|
|
18853
|
+
if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
|
|
18854
|
+
return raw.slice(1, -1);
|
|
18855
|
+
}
|
|
18856
|
+
const numeric = literal.children.find(
|
|
18857
|
+
(child) => child.type === "NumericLiteral"
|
|
18858
|
+
);
|
|
18859
|
+
if (numeric) {
|
|
18860
|
+
raw = raw.replace(/_/g, "");
|
|
18861
|
+
const { token } = numeric;
|
|
18862
|
+
if (token.endsWith("n")) {
|
|
18863
|
+
return BigInt(raw.slice(0, -1));
|
|
18864
|
+
} else if (token.match(/[\.eE]/)) {
|
|
18865
|
+
return parseFloat(raw);
|
|
18866
|
+
} else if (token.startsWith("0")) {
|
|
18867
|
+
switch (token.charAt(1).toLowerCase()) {
|
|
18868
|
+
case "x":
|
|
18869
|
+
return parseInt(raw.replace(/0[xX]/, ""), 16);
|
|
18870
|
+
case "b":
|
|
18871
|
+
return parseInt(raw.replace(/0[bB]/, ""), 2);
|
|
18872
|
+
case "o":
|
|
18873
|
+
return parseInt(raw.replace(/0[oO]/, ""), 8);
|
|
18874
|
+
}
|
|
18875
|
+
}
|
|
18876
|
+
return parseInt(raw, 10);
|
|
18877
|
+
}
|
|
18878
|
+
throw new Error("Unrecognized literal " + JSON.stringify(literal));
|
|
18879
|
+
};
|
|
18721
18880
|
module2.expressionizeIfClause = function(clause, b, e) {
|
|
18722
18881
|
const children = clause.children.slice(1);
|
|
18723
18882
|
children.push("?", b);
|
|
@@ -19795,7 +19954,52 @@ ${input.slice(result.pos)}
|
|
|
19795
19954
|
s.children = [root];
|
|
19796
19955
|
});
|
|
19797
19956
|
}
|
|
19957
|
+
function processPipelineExpressions(statements) {
|
|
19958
|
+
gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
|
|
19959
|
+
const [, body] = s.children;
|
|
19960
|
+
let [arg] = s.children;
|
|
19961
|
+
let i = 0, l = body.length;
|
|
19962
|
+
const children = [];
|
|
19963
|
+
for (i = 0; i < l; i++) {
|
|
19964
|
+
const step = body[i];
|
|
19965
|
+
const [leadingComment, pipe, trailingComment, expr] = step;
|
|
19966
|
+
const returns = pipe.token === "||>";
|
|
19967
|
+
if (pipe.token === "|>=") {
|
|
19968
|
+
if (i === 0) {
|
|
19969
|
+
children.push(arg, " = ");
|
|
19970
|
+
} else {
|
|
19971
|
+
children.push({
|
|
19972
|
+
type: "Error",
|
|
19973
|
+
message: "Can't use |>= in the middle of a pipeline"
|
|
19974
|
+
});
|
|
19975
|
+
}
|
|
19976
|
+
}
|
|
19977
|
+
const [result, returning] = module2.constructPipeStep(
|
|
19978
|
+
{
|
|
19979
|
+
leadingComment: module2.skipIfOnlyWS(leadingComment),
|
|
19980
|
+
trailingComment: module2.skipIfOnlyWS(trailingComment),
|
|
19981
|
+
expr
|
|
19982
|
+
},
|
|
19983
|
+
arg,
|
|
19984
|
+
returns ? arg : null
|
|
19985
|
+
);
|
|
19986
|
+
if (result.type === "ReturnStatement") {
|
|
19987
|
+
arg = result;
|
|
19988
|
+
break;
|
|
19989
|
+
}
|
|
19990
|
+
if (returning) {
|
|
19991
|
+
arg = returning;
|
|
19992
|
+
children.push(result, ",");
|
|
19993
|
+
} else {
|
|
19994
|
+
arg = result;
|
|
19995
|
+
}
|
|
19996
|
+
}
|
|
19997
|
+
children.push(arg);
|
|
19998
|
+
s.children = children;
|
|
19999
|
+
});
|
|
20000
|
+
}
|
|
19798
20001
|
module2.processProgram = function(statements) {
|
|
20002
|
+
processPipelineExpressions(statements);
|
|
19799
20003
|
processAssignments(statements);
|
|
19800
20004
|
processFunctions(statements);
|
|
19801
20005
|
processSwitchExpressions(statements);
|
|
@@ -20008,20 +20212,56 @@ ${input.slice(result.pos)}
|
|
|
20008
20212
|
return [splices, thisAssignments];
|
|
20009
20213
|
}
|
|
20010
20214
|
module2.gatherBindingCode = gatherBindingCode;
|
|
20011
|
-
module2.constructInvocation = function(
|
|
20012
|
-
const
|
|
20013
|
-
const
|
|
20014
|
-
|
|
20015
|
-
|
|
20016
|
-
|
|
20017
|
-
|
|
20215
|
+
module2.constructInvocation = function(fn, arg) {
|
|
20216
|
+
const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
|
|
20217
|
+
const lhs = module2.makeLeftHandSideExpression(fn.expr);
|
|
20218
|
+
let comment = module2.skipIfOnlyWS(fn.trailingComment);
|
|
20219
|
+
if (comment)
|
|
20220
|
+
lhs.children.splice(2, 0, comment);
|
|
20221
|
+
comment = module2.skipIfOnlyWS(fn.leadingComment);
|
|
20222
|
+
if (comment)
|
|
20223
|
+
lhs.children.splice(1, 0, comment);
|
|
20224
|
+
switch (arg.type) {
|
|
20225
|
+
case "CommaExpression":
|
|
20226
|
+
arg = {
|
|
20227
|
+
type: "ParenthesizedExpression",
|
|
20228
|
+
children: ["(", arg, ")"]
|
|
20229
|
+
};
|
|
20230
|
+
break;
|
|
20018
20231
|
}
|
|
20232
|
+
return {
|
|
20233
|
+
type: "CallExpression",
|
|
20234
|
+
children: [lhs, "(", arg, ")"]
|
|
20235
|
+
};
|
|
20019
20236
|
};
|
|
20020
|
-
module2.constructPipeStep = function(
|
|
20021
|
-
|
|
20022
|
-
|
|
20237
|
+
module2.constructPipeStep = function(fn, arg, returning) {
|
|
20238
|
+
const children = [[fn.leadingComment, fn.expr, fn.trailingComment].map(module2.skipIfOnlyWS), " ", arg];
|
|
20239
|
+
switch (fn.expr.token) {
|
|
20240
|
+
case "yield":
|
|
20241
|
+
case "await":
|
|
20242
|
+
if (returning) {
|
|
20243
|
+
return [
|
|
20244
|
+
children,
|
|
20245
|
+
returning
|
|
20246
|
+
];
|
|
20247
|
+
}
|
|
20248
|
+
return [
|
|
20249
|
+
children,
|
|
20250
|
+
null
|
|
20251
|
+
];
|
|
20252
|
+
case "return":
|
|
20253
|
+
return [{
|
|
20254
|
+
type: "ReturnStatement",
|
|
20255
|
+
children
|
|
20256
|
+
}, null];
|
|
20257
|
+
}
|
|
20258
|
+
if (returning) {
|
|
20259
|
+
return [
|
|
20260
|
+
module2.constructInvocation(fn, arg),
|
|
20261
|
+
returning
|
|
20262
|
+
];
|
|
20023
20263
|
}
|
|
20024
|
-
return module2.constructInvocation(
|
|
20264
|
+
return [module2.constructInvocation(fn, arg), null];
|
|
20025
20265
|
};
|
|
20026
20266
|
return $0;
|
|
20027
20267
|
});
|
|
@@ -20047,7 +20287,7 @@ ${input.slice(result.pos)}
|
|
|
20047
20287
|
return result;
|
|
20048
20288
|
}
|
|
20049
20289
|
}
|
|
20050
|
-
var Indent$0 = $TR($EXPECT($
|
|
20290
|
+
var Indent$0 = $TR($EXPECT($R62, fail, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
20051
20291
|
let level;
|
|
20052
20292
|
if (module2.config.tab) {
|
|
20053
20293
|
const tabs = $0.match(/\t/g);
|
|
@@ -20202,7 +20442,7 @@ ${input.slice(result.pos)}
|
|
|
20202
20442
|
return result;
|
|
20203
20443
|
}
|
|
20204
20444
|
}
|
|
20205
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
20445
|
+
var PopIndent$0 = $TV($EXPECT($L18, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
20206
20446
|
if (module2.config.verbose) {
|
|
20207
20447
|
console.log("popping indent", module2.indentLevels[module2.indentLevels.length - 1], "->", module2.indentLevels[module2.indentLevels.length - 2]);
|
|
20208
20448
|
}
|