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