@danielx/civet 0.5.64 → 0.5.66
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/browser.js +749 -560
- package/dist/main.js +749 -560
- package/dist/main.mjs +749 -560
- package/package.json +1 -1
package/dist/main.mjs
CHANGED
|
@@ -623,6 +623,8 @@ ${input.slice(result.pos)}
|
|
|
623
623
|
CoffeeWordAssignmentOp,
|
|
624
624
|
BinaryOp,
|
|
625
625
|
BinaryOpSymbol,
|
|
626
|
+
Xor,
|
|
627
|
+
Xnor,
|
|
626
628
|
UnaryOp,
|
|
627
629
|
ModuleItem,
|
|
628
630
|
StatementListItem,
|
|
@@ -746,6 +748,7 @@ ${input.slice(result.pos)}
|
|
|
746
748
|
HeregexPart,
|
|
747
749
|
HeregexComment,
|
|
748
750
|
RegularExpressionBody,
|
|
751
|
+
RegExpPart,
|
|
749
752
|
RegExpCharacter,
|
|
750
753
|
RegularExpressionFlags,
|
|
751
754
|
TemplateLiteral,
|
|
@@ -1018,225 +1021,231 @@ ${input.slice(result.pos)}
|
|
|
1018
1021
|
var $L12 = $L("super");
|
|
1019
1022
|
var $L13 = $L("import");
|
|
1020
1023
|
var $L14 = $L("!");
|
|
1021
|
-
var $L15 = $L("
|
|
1022
|
-
var $L16 = $L("
|
|
1023
|
-
var $L17 = $L("");
|
|
1024
|
-
var $L18 = $L("
|
|
1025
|
-
var $L19 = $L("
|
|
1026
|
-
var $L20 = $L("
|
|
1027
|
-
var $L21 = $L("
|
|
1028
|
-
var $L22 = $L("
|
|
1029
|
-
var $L23 = $L("
|
|
1030
|
-
var $L24 = $L("
|
|
1031
|
-
var $L25 = $L("
|
|
1032
|
-
var $L26 = $L("
|
|
1033
|
-
var $L27 = $L("
|
|
1034
|
-
var $L28 = $L("
|
|
1035
|
-
var $L29 = $L("
|
|
1036
|
-
var $L30 = $L("
|
|
1037
|
-
var $L31 = $L("
|
|
1038
|
-
var $L32 = $L("
|
|
1039
|
-
var $L33 = $L("
|
|
1040
|
-
var $L34 = $L("
|
|
1041
|
-
var $L35 = $L("
|
|
1042
|
-
var $L36 = $L("
|
|
1043
|
-
var $L37 = $L("
|
|
1044
|
-
var $L38 = $L("
|
|
1045
|
-
var $L39 = $L("
|
|
1046
|
-
var $L40 = $L("
|
|
1047
|
-
var $L41 = $L("
|
|
1048
|
-
var $L42 = $L("
|
|
1049
|
-
var $L43 = $L("
|
|
1050
|
-
var $L44 = $L("
|
|
1051
|
-
var $L45 = $L("
|
|
1052
|
-
var $L46 = $L("
|
|
1053
|
-
var $L47 = $L("
|
|
1054
|
-
var $L48 = $L("
|
|
1055
|
-
var $L49 = $L("
|
|
1056
|
-
var $L50 = $L("
|
|
1057
|
-
var $L51 = $L("
|
|
1058
|
-
var $L52 = $L("
|
|
1059
|
-
var $L53 = $L("
|
|
1060
|
-
var $L54 = $L("
|
|
1061
|
-
var $L55 = $L("
|
|
1062
|
-
var $L56 = $L("
|
|
1063
|
-
var $L57 = $L("
|
|
1064
|
-
var $L58 = $L("
|
|
1065
|
-
var $L59 = $L("
|
|
1066
|
-
var $L60 = $L("
|
|
1067
|
-
var $L61 = $L("
|
|
1068
|
-
var $L62 = $L("
|
|
1069
|
-
var $L63 = $L("
|
|
1070
|
-
var $L64 = $L("
|
|
1071
|
-
var $L65 = $L("
|
|
1072
|
-
var $L66 = $L("
|
|
1073
|
-
var $L67 = $L("
|
|
1074
|
-
var $L68 = $L("
|
|
1075
|
-
var $L69 = $L("
|
|
1076
|
-
var $L70 = $L("
|
|
1077
|
-
var $L71 = $L("
|
|
1078
|
-
var $L72 = $L("
|
|
1079
|
-
var $L73 = $L("
|
|
1080
|
-
var $L74 = $L("
|
|
1081
|
-
var $L75 = $L("
|
|
1082
|
-
var $L76 = $L("
|
|
1083
|
-
var $L77 = $L("
|
|
1084
|
-
var $L78 = $L("
|
|
1085
|
-
var $L79 = $L("
|
|
1086
|
-
var $L80 = $L("
|
|
1087
|
-
var $L81 = $L("
|
|
1088
|
-
var $L82 = $L("
|
|
1089
|
-
var $L83 = $L("
|
|
1090
|
-
var $L84 = $L("
|
|
1091
|
-
var $L85 = $L("
|
|
1092
|
-
var $L86 = $L("
|
|
1093
|
-
var $L87 = $L("
|
|
1094
|
-
var $L88 = $L("
|
|
1095
|
-
var $L89 = $L("
|
|
1096
|
-
var $L90 = $L("
|
|
1097
|
-
var $L91 = $L("
|
|
1098
|
-
var $L92 = $L("
|
|
1099
|
-
var $L93 = $L("
|
|
1100
|
-
var $L94 = $L("
|
|
1101
|
-
var $L95 = $L("
|
|
1102
|
-
var $L96 = $L("
|
|
1103
|
-
var $L97 = $L("
|
|
1104
|
-
var $L98 = $L("
|
|
1105
|
-
var $L99 = $L("
|
|
1106
|
-
var $L100 = $L("
|
|
1107
|
-
var $L101 = $L("
|
|
1108
|
-
var $L102 = $L("
|
|
1109
|
-
var $L103 = $L("
|
|
1110
|
-
var $L104 = $L("
|
|
1111
|
-
var $L105 = $L("
|
|
1112
|
-
var $L106 = $L("
|
|
1113
|
-
var $L107 = $L("
|
|
1114
|
-
var $L108 = $L("
|
|
1115
|
-
var $L109 = $L("
|
|
1116
|
-
var $L110 = $L("
|
|
1117
|
-
var $L111 = $L("
|
|
1118
|
-
var $L112 = $L(
|
|
1119
|
-
var $L113 = $L("
|
|
1120
|
-
var $L114 = $L("
|
|
1121
|
-
var $L115 = $L("
|
|
1122
|
-
var $L116 = $L("
|
|
1123
|
-
var $L117 = $L("
|
|
1124
|
-
var $L118 = $L("
|
|
1125
|
-
var $L119 = $L("
|
|
1126
|
-
var $L120 = $L("
|
|
1127
|
-
var $L121 = $L("
|
|
1128
|
-
var $L122 = $L("
|
|
1129
|
-
var $L123 = $L("
|
|
1130
|
-
var $L124 = $L("
|
|
1131
|
-
var $L125 = $L("
|
|
1132
|
-
var $L126 = $L("
|
|
1133
|
-
var $L127 = $L("
|
|
1134
|
-
var $L128 = $L("
|
|
1135
|
-
var $L129 = $L("
|
|
1136
|
-
var $L130 = $L("
|
|
1137
|
-
var $L131 = $L("
|
|
1138
|
-
var $L132 = $L("
|
|
1139
|
-
var $L133 = $L("
|
|
1140
|
-
var $L134 = $L("
|
|
1141
|
-
var $L135 = $L("
|
|
1142
|
-
var $L136 = $L("
|
|
1143
|
-
var $L137 = $L("
|
|
1144
|
-
var $L138 = $L("
|
|
1145
|
-
var $L139 = $L("
|
|
1146
|
-
var $L140 = $L("
|
|
1147
|
-
var $L141 = $L("
|
|
1148
|
-
var $L142 = $L("
|
|
1149
|
-
var $L143 = $L("
|
|
1150
|
-
var $L144 = $L("
|
|
1151
|
-
var $L145 = $L(
|
|
1152
|
-
var $L146 = $L("
|
|
1153
|
-
var $L147 = $L("
|
|
1154
|
-
var $L148 = $L("
|
|
1155
|
-
var $L149 = $L("
|
|
1156
|
-
var $L150 = $L("
|
|
1157
|
-
var $L151 = $L("
|
|
1158
|
-
var $L152 = $L("
|
|
1159
|
-
var $L153 = $L("
|
|
1160
|
-
var $L154 = $L("
|
|
1161
|
-
var $L155 = $L("
|
|
1162
|
-
var $L156 = $L("
|
|
1163
|
-
var $L157 = $L("
|
|
1164
|
-
var $L158 = $L("
|
|
1165
|
-
var $L159 = $L("
|
|
1166
|
-
var $L160 = $L("
|
|
1167
|
-
var $L161 = $L("
|
|
1168
|
-
var $L162 = $L("
|
|
1169
|
-
var $L163 = $L("
|
|
1170
|
-
var $L164 = $L("
|
|
1171
|
-
var $L165 = $L("
|
|
1172
|
-
var $L166 = $L("
|
|
1173
|
-
var $L167 = $L("
|
|
1174
|
-
var $L168 = $L("
|
|
1175
|
-
var $L169 = $L("
|
|
1176
|
-
var $L170 = $L("
|
|
1177
|
-
var $L171 = $L("
|
|
1178
|
-
var $
|
|
1024
|
+
var $L15 = $L("^");
|
|
1025
|
+
var $L16 = $L("-");
|
|
1026
|
+
var $L17 = $L("import.meta");
|
|
1027
|
+
var $L18 = $L("");
|
|
1028
|
+
var $L19 = $L(")");
|
|
1029
|
+
var $L20 = $L(",");
|
|
1030
|
+
var $L21 = $L("->");
|
|
1031
|
+
var $L22 = $L("}");
|
|
1032
|
+
var $L23 = $L("null");
|
|
1033
|
+
var $L24 = $L("true");
|
|
1034
|
+
var $L25 = $L("false");
|
|
1035
|
+
var $L26 = $L("yes");
|
|
1036
|
+
var $L27 = $L("on");
|
|
1037
|
+
var $L28 = $L("no");
|
|
1038
|
+
var $L29 = $L("off");
|
|
1039
|
+
var $L30 = $L(">");
|
|
1040
|
+
var $L31 = $L("]");
|
|
1041
|
+
var $L32 = $L(":");
|
|
1042
|
+
var $L33 = $L("**=");
|
|
1043
|
+
var $L34 = $L("*=");
|
|
1044
|
+
var $L35 = $L("/=");
|
|
1045
|
+
var $L36 = $L("%=");
|
|
1046
|
+
var $L37 = $L("+=");
|
|
1047
|
+
var $L38 = $L("-=");
|
|
1048
|
+
var $L39 = $L("<<=");
|
|
1049
|
+
var $L40 = $L(">>>=");
|
|
1050
|
+
var $L41 = $L(">>=");
|
|
1051
|
+
var $L42 = $L("&&=");
|
|
1052
|
+
var $L43 = $L("&=");
|
|
1053
|
+
var $L44 = $L("^=");
|
|
1054
|
+
var $L45 = $L("||=");
|
|
1055
|
+
var $L46 = $L("|=");
|
|
1056
|
+
var $L47 = $L("??=");
|
|
1057
|
+
var $L48 = $L("?=");
|
|
1058
|
+
var $L49 = $L("and=");
|
|
1059
|
+
var $L50 = $L("or=");
|
|
1060
|
+
var $L51 = $L("not");
|
|
1061
|
+
var $L52 = $L("**");
|
|
1062
|
+
var $L53 = $L("*");
|
|
1063
|
+
var $L54 = $L("/");
|
|
1064
|
+
var $L55 = $L("%%");
|
|
1065
|
+
var $L56 = $L("%");
|
|
1066
|
+
var $L57 = $L("+");
|
|
1067
|
+
var $L58 = $L("<=");
|
|
1068
|
+
var $L59 = $L(">=");
|
|
1069
|
+
var $L60 = $L("<?");
|
|
1070
|
+
var $L61 = $L("!<?");
|
|
1071
|
+
var $L62 = $L("<<");
|
|
1072
|
+
var $L63 = $L(">>>");
|
|
1073
|
+
var $L64 = $L(">>");
|
|
1074
|
+
var $L65 = $L("!==");
|
|
1075
|
+
var $L66 = $L("!=");
|
|
1076
|
+
var $L67 = $L("isnt");
|
|
1077
|
+
var $L68 = $L("===");
|
|
1078
|
+
var $L69 = $L("==");
|
|
1079
|
+
var $L70 = $L("and");
|
|
1080
|
+
var $L71 = $L("&&");
|
|
1081
|
+
var $L72 = $L("of");
|
|
1082
|
+
var $L73 = $L("or");
|
|
1083
|
+
var $L74 = $L("||");
|
|
1084
|
+
var $L75 = $L("^^");
|
|
1085
|
+
var $L76 = $L("xor");
|
|
1086
|
+
var $L77 = $L("xnor");
|
|
1087
|
+
var $L78 = $L("??");
|
|
1088
|
+
var $L79 = $L("instanceof");
|
|
1089
|
+
var $L80 = $L("in");
|
|
1090
|
+
var $L81 = $L("is");
|
|
1091
|
+
var $L82 = $L("&");
|
|
1092
|
+
var $L83 = $L("|");
|
|
1093
|
+
var $L84 = $L(";");
|
|
1094
|
+
var $L85 = $L("own");
|
|
1095
|
+
var $L86 = $L("break");
|
|
1096
|
+
var $L87 = $L("continue");
|
|
1097
|
+
var $L88 = $L("debugger");
|
|
1098
|
+
var $L89 = $L("assert");
|
|
1099
|
+
var $L90 = $L(":=");
|
|
1100
|
+
var $L91 = $L(".=");
|
|
1101
|
+
var $L92 = $L("/*");
|
|
1102
|
+
var $L93 = $L("*/");
|
|
1103
|
+
var $L94 = $L("\\");
|
|
1104
|
+
var $L95 = $L("[");
|
|
1105
|
+
var $L96 = $L("`");
|
|
1106
|
+
var $L97 = $L("abstract");
|
|
1107
|
+
var $L98 = $L("as");
|
|
1108
|
+
var $L99 = $L("@");
|
|
1109
|
+
var $L100 = $L("@@");
|
|
1110
|
+
var $L101 = $L("async");
|
|
1111
|
+
var $L102 = $L("await");
|
|
1112
|
+
var $L103 = $L("by");
|
|
1113
|
+
var $L104 = $L("case");
|
|
1114
|
+
var $L105 = $L("catch");
|
|
1115
|
+
var $L106 = $L("class");
|
|
1116
|
+
var $L107 = $L("#{");
|
|
1117
|
+
var $L108 = $L("declare");
|
|
1118
|
+
var $L109 = $L("default");
|
|
1119
|
+
var $L110 = $L("delete");
|
|
1120
|
+
var $L111 = $L("do");
|
|
1121
|
+
var $L112 = $L("..");
|
|
1122
|
+
var $L113 = $L("...");
|
|
1123
|
+
var $L114 = $L("::");
|
|
1124
|
+
var $L115 = $L('"');
|
|
1125
|
+
var $L116 = $L("else");
|
|
1126
|
+
var $L117 = $L("export");
|
|
1127
|
+
var $L118 = $L("extends");
|
|
1128
|
+
var $L119 = $L("finally");
|
|
1129
|
+
var $L120 = $L("for");
|
|
1130
|
+
var $L121 = $L("from");
|
|
1131
|
+
var $L122 = $L("function");
|
|
1132
|
+
var $L123 = $L("get");
|
|
1133
|
+
var $L124 = $L("set");
|
|
1134
|
+
var $L125 = $L("if");
|
|
1135
|
+
var $L126 = $L("let");
|
|
1136
|
+
var $L127 = $L("const");
|
|
1137
|
+
var $L128 = $L("loop");
|
|
1138
|
+
var $L129 = $L("new");
|
|
1139
|
+
var $L130 = $L("<");
|
|
1140
|
+
var $L131 = $L("{");
|
|
1141
|
+
var $L132 = $L("operator");
|
|
1142
|
+
var $L133 = $L("public");
|
|
1143
|
+
var $L134 = $L("private");
|
|
1144
|
+
var $L135 = $L("protected");
|
|
1145
|
+
var $L136 = $L("||>");
|
|
1146
|
+
var $L137 = $L("|>=");
|
|
1147
|
+
var $L138 = $L("|>");
|
|
1148
|
+
var $L139 = $L("readonly");
|
|
1149
|
+
var $L140 = $L("return");
|
|
1150
|
+
var $L141 = $L("satisfies");
|
|
1151
|
+
var $L142 = $L("'");
|
|
1152
|
+
var $L143 = $L("static");
|
|
1153
|
+
var $L144 = $L("${");
|
|
1154
|
+
var $L145 = $L("switch");
|
|
1155
|
+
var $L146 = $L("target");
|
|
1156
|
+
var $L147 = $L("then");
|
|
1157
|
+
var $L148 = $L("this");
|
|
1158
|
+
var $L149 = $L("throw");
|
|
1159
|
+
var $L150 = $L('"""');
|
|
1160
|
+
var $L151 = $L("'''");
|
|
1161
|
+
var $L152 = $L("///");
|
|
1162
|
+
var $L153 = $L("```");
|
|
1163
|
+
var $L154 = $L("try");
|
|
1164
|
+
var $L155 = $L("typeof");
|
|
1165
|
+
var $L156 = $L("unless");
|
|
1166
|
+
var $L157 = $L("until");
|
|
1167
|
+
var $L158 = $L("var");
|
|
1168
|
+
var $L159 = $L("void");
|
|
1169
|
+
var $L160 = $L("when");
|
|
1170
|
+
var $L161 = $L("while");
|
|
1171
|
+
var $L162 = $L("yield");
|
|
1172
|
+
var $L163 = $L("/>");
|
|
1173
|
+
var $L164 = $L("</");
|
|
1174
|
+
var $L165 = $L("<>");
|
|
1175
|
+
var $L166 = $L("</>");
|
|
1176
|
+
var $L167 = $L("<!--");
|
|
1177
|
+
var $L168 = $L("-->");
|
|
1178
|
+
var $L169 = $L("type");
|
|
1179
|
+
var $L170 = $L("interface");
|
|
1180
|
+
var $L171 = $L("namespace");
|
|
1181
|
+
var $L172 = $L("asserts");
|
|
1182
|
+
var $L173 = $L("keyof");
|
|
1183
|
+
var $L174 = $L("infer");
|
|
1184
|
+
var $L175 = $L("[]");
|
|
1185
|
+
var $L176 = $L("civet");
|
|
1186
|
+
var $R0 = $R(new RegExp("(as|for|while|until|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1179
1187
|
var $R1 = $R(new RegExp("[0-9]", "suy"));
|
|
1180
1188
|
var $R2 = $R(new RegExp("[&]", "suy"));
|
|
1181
1189
|
var $R3 = $R(new RegExp("[!~+-]+", "suy"));
|
|
1182
1190
|
var $R4 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
1183
1191
|
var $R5 = $R(new RegExp("[!+-]", "suy"));
|
|
1184
1192
|
var $R6 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
|
|
1185
|
-
var $R7 = $R(new RegExp("
|
|
1186
|
-
var $R8 = $R(new RegExp("(
|
|
1187
|
-
var $R9 = $R(new RegExp(
|
|
1188
|
-
var $R10 = $R(new RegExp("
|
|
1189
|
-
var $R11 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)
|
|
1190
|
-
var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(
|
|
1191
|
-
var $R13 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1192
|
-
var $R14 = $R(new RegExp("(
|
|
1193
|
-
var $R15 = $R(new RegExp("
|
|
1194
|
-
var $R16 = $R(new RegExp("0[
|
|
1195
|
-
var $R17 = $R(new RegExp("0[
|
|
1196
|
-
var $R18 = $R(new RegExp("
|
|
1197
|
-
var $R19 = $R(new RegExp(
|
|
1198
|
-
var $R20 = $R(new RegExp(
|
|
1199
|
-
var $R21 = $R(new RegExp(
|
|
1200
|
-
var $R22 = $R(new RegExp(
|
|
1201
|
-
var $R23 = $R(new RegExp('(
|
|
1202
|
-
var $R24 = $R(new RegExp(
|
|
1203
|
-
var $R25 = $R(new RegExp("(
|
|
1204
|
-
var $R26 = $R(new RegExp("
|
|
1205
|
-
var $R27 = $R(new RegExp("
|
|
1206
|
-
var $R28 = $R(new RegExp("
|
|
1207
|
-
var $R29 = $R(new RegExp("[
|
|
1208
|
-
var $R30 = $R(new RegExp("
|
|
1209
|
-
var $R31 = $R(new RegExp("(
|
|
1210
|
-
var $R32 = $R(new RegExp("(
|
|
1211
|
-
var $R33 = $R(new RegExp("(?:\\$(?!\\{)
|
|
1212
|
-
var $R34 = $R(new RegExp("(
|
|
1213
|
-
var $R35 = $R(new RegExp("(?:
|
|
1214
|
-
var $R36 = $R(new RegExp("(?:
|
|
1215
|
-
var $R37 = $R(new RegExp("(?:
|
|
1216
|
-
var $R38 = $R(new RegExp("(?:
|
|
1217
|
-
var $R39 = $R(new RegExp("
|
|
1218
|
-
var $R40 = $R(new RegExp("
|
|
1219
|
-
var $R41 = $R(new RegExp("
|
|
1220
|
-
var $R42 = $R(new RegExp("[
|
|
1221
|
-
var $R43 = $R(new RegExp("
|
|
1222
|
-
var $R44 = $R(new RegExp("
|
|
1223
|
-
var $R45 = $R(new RegExp("[
|
|
1224
|
-
var $R46 = $R(new RegExp("
|
|
1225
|
-
var $R47 = $R(new RegExp("
|
|
1226
|
-
var $R48 = $R(new RegExp("
|
|
1227
|
-
var $R49 = $R(new RegExp("[\\
|
|
1228
|
-
var $R50 = $R(new RegExp("
|
|
1229
|
-
var $R51 = $R(new RegExp("[
|
|
1230
|
-
var $R52 = $R(new RegExp("
|
|
1231
|
-
var $R53 = $R(new RegExp("[
|
|
1232
|
-
var $R54 = $R(new RegExp("[
|
|
1233
|
-
var $R55 = $R(new RegExp("[+-]", "suy"));
|
|
1234
|
-
var $R56 = $R(new RegExp("
|
|
1235
|
-
var $R57 = $R(new RegExp("[\\
|
|
1236
|
-
var $R58 = $R(new RegExp("[\\
|
|
1237
|
-
var $R59 = $R(new RegExp("
|
|
1238
|
-
var $R60 = $R(new RegExp("\\
|
|
1239
|
-
var $R61 = $R(new RegExp("
|
|
1193
|
+
var $R7 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
1194
|
+
var $R8 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
1195
|
+
var $R9 = $R(new RegExp("(?=[\\s\\)])", "suy"));
|
|
1196
|
+
var $R10 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
1197
|
+
var $R11 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
1198
|
+
var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
1199
|
+
var $R13 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
1200
|
+
var $R14 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1201
|
+
var $R15 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
1202
|
+
var $R16 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
1203
|
+
var $R17 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
1204
|
+
var $R18 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
1205
|
+
var $R19 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
1206
|
+
var $R20 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
1207
|
+
var $R21 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
1208
|
+
var $R22 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
1209
|
+
var $R23 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
1210
|
+
var $R24 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
1211
|
+
var $R25 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
1212
|
+
var $R26 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
1213
|
+
var $R27 = $R(new RegExp("[\\s]+", "suy"));
|
|
1214
|
+
var $R28 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
1215
|
+
var $R29 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
1216
|
+
var $R30 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
1217
|
+
var $R31 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
1218
|
+
var $R32 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
1219
|
+
var $R33 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
1220
|
+
var $R34 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
1221
|
+
var $R35 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
1222
|
+
var $R36 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
1223
|
+
var $R37 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
1224
|
+
var $R38 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
1225
|
+
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"));
|
|
1226
|
+
var $R40 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
1227
|
+
var $R41 = $R(new RegExp(".", "suy"));
|
|
1228
|
+
var $R42 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
1229
|
+
var $R43 = $R(new RegExp("[^]*?###", "suy"));
|
|
1230
|
+
var $R44 = $R(new RegExp("###(?!#)", "suy"));
|
|
1231
|
+
var $R45 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
1232
|
+
var $R46 = $R(new RegExp("[ \\t]+", "suy"));
|
|
1233
|
+
var $R47 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
1234
|
+
var $R48 = $R(new RegExp("\\s", "suy"));
|
|
1235
|
+
var $R49 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
1236
|
+
var $R50 = $R(new RegExp("[\\s>]", "suy"));
|
|
1237
|
+
var $R51 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
1238
|
+
var $R52 = $R(new RegExp("[<>]", "suy"));
|
|
1239
|
+
var $R53 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
1240
|
+
var $R54 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
1241
|
+
var $R55 = $R(new RegExp("[+-]?", "suy"));
|
|
1242
|
+
var $R56 = $R(new RegExp("[+-]", "suy"));
|
|
1243
|
+
var $R57 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
1244
|
+
var $R58 = $R(new RegExp("[\\t ]*", "suy"));
|
|
1245
|
+
var $R59 = $R(new RegExp("[\\s]*", "suy"));
|
|
1246
|
+
var $R60 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
1247
|
+
var $R61 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
1248
|
+
var $R62 = $R(new RegExp("[ \\t]*", "suy"));
|
|
1240
1249
|
var Program$0 = $TS($S(Reset, Init, __, $Q(TopLevelStatement), __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1241
1250
|
var statements = $4;
|
|
1242
1251
|
module.processProgram(statements);
|
|
@@ -1556,7 +1565,7 @@ ${input.slice(result.pos)}
|
|
|
1556
1565
|
return result;
|
|
1557
1566
|
}
|
|
1558
1567
|
}
|
|
1559
|
-
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|for|while|until|of|satisfies|then|when|implements)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
1568
|
+
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$])/"));
|
|
1560
1569
|
var ForbiddenImplicitCalls$1 = $EXPECT($L0, fail, 'ForbiddenImplicitCalls "/ "');
|
|
1561
1570
|
var ForbiddenImplicitCalls$2 = AtAt;
|
|
1562
1571
|
var ForbiddenImplicitCalls$3 = $S(Identifier, $EXPECT($L1, fail, 'ForbiddenImplicitCalls "="'), Whitespace);
|
|
@@ -2093,7 +2102,6 @@ ${input.slice(result.pos)}
|
|
|
2093
2102
|
}
|
|
2094
2103
|
}
|
|
2095
2104
|
var NonPipelineAssignmentExpression$0 = SingleLineAssignmentExpression;
|
|
2096
|
-
var NonPipelineAssignmentExpression$1 = $S(__, AssignmentExpressionTail);
|
|
2097
2105
|
function NonPipelineAssignmentExpression(state) {
|
|
2098
2106
|
let eventData;
|
|
2099
2107
|
if (state.events) {
|
|
@@ -2105,12 +2113,12 @@ ${input.slice(result.pos)}
|
|
|
2105
2113
|
}
|
|
2106
2114
|
}
|
|
2107
2115
|
if (state.tokenize) {
|
|
2108
|
-
const result = $TOKEN("NonPipelineAssignmentExpression", state, NonPipelineAssignmentExpression$0(state)
|
|
2116
|
+
const result = $TOKEN("NonPipelineAssignmentExpression", state, NonPipelineAssignmentExpression$0(state));
|
|
2109
2117
|
if (state.events)
|
|
2110
2118
|
state.events.exit?.("NonPipelineAssignmentExpression", state, result, eventData);
|
|
2111
2119
|
return result;
|
|
2112
2120
|
} else {
|
|
2113
|
-
const result = NonPipelineAssignmentExpression$0(state)
|
|
2121
|
+
const result = NonPipelineAssignmentExpression$0(state);
|
|
2114
2122
|
if (state.events)
|
|
2115
2123
|
state.events.exit?.("NonPipelineAssignmentExpression", state, result, eventData);
|
|
2116
2124
|
return result;
|
|
@@ -2482,30 +2490,12 @@ ${input.slice(result.pos)}
|
|
|
2482
2490
|
return result;
|
|
2483
2491
|
}
|
|
2484
2492
|
}
|
|
2485
|
-
var PipelineExpression$0 = $TS($S(
|
|
2493
|
+
var PipelineExpression$0 = $TS($S(PipelineHeadItem, $P($S(__, Pipe, __, PipelineTailItem))), function($skip, $loc, $0, $1, $2) {
|
|
2486
2494
|
var head = $1;
|
|
2487
2495
|
var body = $2;
|
|
2488
|
-
var preTailWS = $3;
|
|
2489
|
-
var tail = $4;
|
|
2490
|
-
let children = head.slice(0, -1).map(module.skipIfOnlyWS);
|
|
2491
|
-
for (const [leadingComment, expr, trailingComment] of body) {
|
|
2492
|
-
children = module.constructPipeStep(
|
|
2493
|
-
{
|
|
2494
|
-
leadingComment: module.skipIfOnlyWS(leadingComment),
|
|
2495
|
-
trailingComment: module.skipIfOnlyWS(trailingComment),
|
|
2496
|
-
expr
|
|
2497
|
-
},
|
|
2498
|
-
{ expr: children }
|
|
2499
|
-
);
|
|
2500
|
-
}
|
|
2501
2496
|
return {
|
|
2502
|
-
|
|
2503
|
-
|
|
2504
|
-
leadingComment: module.skipIfOnlyWS(preTailWS),
|
|
2505
|
-
expr: tail
|
|
2506
|
-
},
|
|
2507
|
-
{ expr: children }
|
|
2508
|
-
)
|
|
2497
|
+
type: "PipelineExpression",
|
|
2498
|
+
children: [head, body]
|
|
2509
2499
|
};
|
|
2510
2500
|
});
|
|
2511
2501
|
function PipelineExpression(state) {
|
|
@@ -3364,8 +3354,8 @@ ${input.slice(result.pos)}
|
|
|
3364
3354
|
return result;
|
|
3365
3355
|
}
|
|
3366
3356
|
}
|
|
3367
|
-
var NonNullAssertion$0 = $T($EXPECT($L14, fail, 'NonNullAssertion "!"'), function(value) {
|
|
3368
|
-
return { "type": "NonNullAssertion", "ts": true, "children": value };
|
|
3357
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L14, fail, 'NonNullAssertion "!"'), $N($EXPECT($L15, fail, 'NonNullAssertion "^"'))), function(value) {
|
|
3358
|
+
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
3369
3359
|
});
|
|
3370
3360
|
function NonNullAssertion(state) {
|
|
3371
3361
|
let eventData;
|
|
@@ -3502,7 +3492,7 @@ ${input.slice(result.pos)}
|
|
|
3502
3492
|
]
|
|
3503
3493
|
};
|
|
3504
3494
|
});
|
|
3505
|
-
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($
|
|
3495
|
+
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($L16, fail, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
3506
3496
|
var dot = $1;
|
|
3507
3497
|
var neg = $2;
|
|
3508
3498
|
var num = $3;
|
|
@@ -3699,7 +3689,7 @@ ${input.slice(result.pos)}
|
|
|
3699
3689
|
}
|
|
3700
3690
|
}
|
|
3701
3691
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
3702
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
3692
|
+
var MetaProperty$1 = $TS($S($EXPECT($L17, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3703
3693
|
return { $loc, token: $1 };
|
|
3704
3694
|
});
|
|
3705
3695
|
function MetaProperty(state) {
|
|
@@ -3725,7 +3715,7 @@ ${input.slice(result.pos)}
|
|
|
3725
3715
|
}
|
|
3726
3716
|
}
|
|
3727
3717
|
var Parameters$0 = NonEmptyParameters;
|
|
3728
|
-
var Parameters$1 = $TV($EXPECT($
|
|
3718
|
+
var Parameters$1 = $TV($EXPECT($L18, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
3729
3719
|
return {
|
|
3730
3720
|
type: "Parameters",
|
|
3731
3721
|
children: [{ $loc, token: "()" }],
|
|
@@ -3886,7 +3876,7 @@ ${input.slice(result.pos)}
|
|
|
3886
3876
|
}
|
|
3887
3877
|
}
|
|
3888
3878
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
3889
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
3879
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L19, fail, 'ParameterElementDelimiter ")"')));
|
|
3890
3880
|
var ParameterElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
3891
3881
|
return value[1];
|
|
3892
3882
|
});
|
|
@@ -4506,7 +4496,7 @@ ${input.slice(result.pos)}
|
|
|
4506
4496
|
children: $0
|
|
4507
4497
|
};
|
|
4508
4498
|
});
|
|
4509
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
4499
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
4510
4500
|
return {
|
|
4511
4501
|
children: [{
|
|
4512
4502
|
type: "ElisionElement",
|
|
@@ -4579,7 +4569,7 @@ ${input.slice(result.pos)}
|
|
|
4579
4569
|
return result;
|
|
4580
4570
|
}
|
|
4581
4571
|
}
|
|
4582
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
4572
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L18, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
4583
4573
|
const ref = {
|
|
4584
4574
|
type: "Ref",
|
|
4585
4575
|
base: "ref",
|
|
@@ -5055,7 +5045,7 @@ ${input.slice(result.pos)}
|
|
|
5055
5045
|
children: [ws, binding]
|
|
5056
5046
|
};
|
|
5057
5047
|
});
|
|
5058
|
-
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($
|
|
5048
|
+
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($L20, fail, 'MatchingElement ","'))), function($skip, $loc, $0, $1) {
|
|
5059
5049
|
return {
|
|
5060
5050
|
children: [{
|
|
5061
5051
|
type: "ElisionElement",
|
|
@@ -5449,7 +5439,7 @@ ${input.slice(result.pos)}
|
|
|
5449
5439
|
return result;
|
|
5450
5440
|
}
|
|
5451
5441
|
}
|
|
5452
|
-
var Arrow$0 = $TV($EXPECT($
|
|
5442
|
+
var Arrow$0 = $TV($EXPECT($L21, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
5453
5443
|
return { $loc, token: $1 };
|
|
5454
5444
|
});
|
|
5455
5445
|
function Arrow(state) {
|
|
@@ -5683,7 +5673,7 @@ ${input.slice(result.pos)}
|
|
|
5683
5673
|
return result;
|
|
5684
5674
|
}
|
|
5685
5675
|
}
|
|
5686
|
-
var EmptyBareBlock$0 = $TV($EXPECT($
|
|
5676
|
+
var EmptyBareBlock$0 = $TV($EXPECT($L18, fail, 'EmptyBareBlock ""'), function($skip, $loc, $0, $1) {
|
|
5687
5677
|
const expressions = [];
|
|
5688
5678
|
return {
|
|
5689
5679
|
type: "BlockStatement",
|
|
@@ -5906,7 +5896,7 @@ ${input.slice(result.pos)}
|
|
|
5906
5896
|
children: [$1, expressions]
|
|
5907
5897
|
};
|
|
5908
5898
|
});
|
|
5909
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
5899
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L22, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
5910
5900
|
const expressions = [];
|
|
5911
5901
|
return {
|
|
5912
5902
|
type: "BlockStatement",
|
|
@@ -6051,7 +6041,7 @@ ${input.slice(result.pos)}
|
|
|
6051
6041
|
return result;
|
|
6052
6042
|
}
|
|
6053
6043
|
}
|
|
6054
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
6044
|
+
var NullLiteral$0 = $TS($S($EXPECT($L23, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6055
6045
|
return { $loc, token: $1 };
|
|
6056
6046
|
});
|
|
6057
6047
|
function NullLiteral(state) {
|
|
@@ -6079,7 +6069,7 @@ ${input.slice(result.pos)}
|
|
|
6079
6069
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
6080
6070
|
return value[1];
|
|
6081
6071
|
});
|
|
6082
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6072
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L24, fail, 'BooleanLiteral "true"'), $EXPECT($L25, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6083
6073
|
return { $loc, token: $1 };
|
|
6084
6074
|
});
|
|
6085
6075
|
function BooleanLiteral(state) {
|
|
@@ -6104,10 +6094,10 @@ ${input.slice(result.pos)}
|
|
|
6104
6094
|
return result;
|
|
6105
6095
|
}
|
|
6106
6096
|
}
|
|
6107
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
6097
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L26, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L27, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6108
6098
|
return { $loc, token: "true" };
|
|
6109
6099
|
});
|
|
6110
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6100
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L28, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L29, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6111
6101
|
return { $loc, token: "false" };
|
|
6112
6102
|
});
|
|
6113
6103
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -6213,7 +6203,7 @@ ${input.slice(result.pos)}
|
|
|
6213
6203
|
return result;
|
|
6214
6204
|
}
|
|
6215
6205
|
}
|
|
6216
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($
|
|
6206
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L1, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L1, fail, 'UpcomingAssignment "="'), $EXPECT($L30, fail, 'UpcomingAssignment ">"')))));
|
|
6217
6207
|
function UpcomingAssignment(state) {
|
|
6218
6208
|
let eventData;
|
|
6219
6209
|
if (state.events) {
|
|
@@ -6486,7 +6476,7 @@ ${input.slice(result.pos)}
|
|
|
6486
6476
|
}
|
|
6487
6477
|
}
|
|
6488
6478
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
6489
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6479
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L31, fail, 'ArrayElementDelimiter "]"')));
|
|
6490
6480
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6491
6481
|
return value[1];
|
|
6492
6482
|
});
|
|
@@ -6912,7 +6902,7 @@ ${input.slice(result.pos)}
|
|
|
6912
6902
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
|
|
6913
6903
|
return value[1];
|
|
6914
6904
|
});
|
|
6915
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
6905
|
+
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) {
|
|
6916
6906
|
return "";
|
|
6917
6907
|
});
|
|
6918
6908
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -6941,7 +6931,7 @@ ${input.slice(result.pos)}
|
|
|
6941
6931
|
}
|
|
6942
6932
|
}
|
|
6943
6933
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
6944
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6934
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L22, fail, 'ObjectPropertyDelimiter "}"')));
|
|
6945
6935
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6946
6936
|
return value[1];
|
|
6947
6937
|
});
|
|
@@ -7216,7 +7206,7 @@ ${input.slice(result.pos)}
|
|
|
7216
7206
|
expression
|
|
7217
7207
|
};
|
|
7218
7208
|
});
|
|
7219
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7209
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L16, fail, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7220
7210
|
return {
|
|
7221
7211
|
type: "ComputedPropertyName",
|
|
7222
7212
|
children: $0
|
|
@@ -7522,7 +7512,21 @@ ${input.slice(result.pos)}
|
|
|
7522
7512
|
return result;
|
|
7523
7513
|
}
|
|
7524
7514
|
}
|
|
7525
|
-
var OperatorAssignmentOp$0 = $TS($S(
|
|
7515
|
+
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7516
|
+
return {
|
|
7517
|
+
special: true,
|
|
7518
|
+
call: module.getRef("xor"),
|
|
7519
|
+
children: [$2, ...$4]
|
|
7520
|
+
};
|
|
7521
|
+
});
|
|
7522
|
+
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7523
|
+
return {
|
|
7524
|
+
special: true,
|
|
7525
|
+
call: module.getRef("xnor"),
|
|
7526
|
+
children: [$2, ...$4]
|
|
7527
|
+
};
|
|
7528
|
+
});
|
|
7529
|
+
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L1, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7526
7530
|
return {
|
|
7527
7531
|
special: true,
|
|
7528
7532
|
call: $1,
|
|
@@ -7540,33 +7544,33 @@ ${input.slice(result.pos)}
|
|
|
7540
7544
|
}
|
|
7541
7545
|
}
|
|
7542
7546
|
if (state.tokenize) {
|
|
7543
|
-
const result = $TOKEN("OperatorAssignmentOp", state, OperatorAssignmentOp$0(state));
|
|
7547
|
+
const result = $TOKEN("OperatorAssignmentOp", state, OperatorAssignmentOp$0(state) || OperatorAssignmentOp$1(state) || OperatorAssignmentOp$2(state));
|
|
7544
7548
|
if (state.events)
|
|
7545
7549
|
state.events.exit?.("OperatorAssignmentOp", state, result, eventData);
|
|
7546
7550
|
return result;
|
|
7547
7551
|
} else {
|
|
7548
|
-
const result = OperatorAssignmentOp$0(state);
|
|
7552
|
+
const result = OperatorAssignmentOp$0(state) || OperatorAssignmentOp$1(state) || OperatorAssignmentOp$2(state);
|
|
7549
7553
|
if (state.events)
|
|
7550
7554
|
state.events.exit?.("OperatorAssignmentOp", state, result, eventData);
|
|
7551
7555
|
return result;
|
|
7552
7556
|
}
|
|
7553
7557
|
}
|
|
7554
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
7555
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
7556
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
7557
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
7558
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
7559
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
7560
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
7561
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
7562
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
7563
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
7564
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
7565
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
7566
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
7567
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
7568
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
7569
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
7558
|
+
var AssignmentOpSymbol$0 = $EXPECT($L33, fail, 'AssignmentOpSymbol "**="');
|
|
7559
|
+
var AssignmentOpSymbol$1 = $EXPECT($L34, fail, 'AssignmentOpSymbol "*="');
|
|
7560
|
+
var AssignmentOpSymbol$2 = $EXPECT($L35, fail, 'AssignmentOpSymbol "/="');
|
|
7561
|
+
var AssignmentOpSymbol$3 = $EXPECT($L36, fail, 'AssignmentOpSymbol "%="');
|
|
7562
|
+
var AssignmentOpSymbol$4 = $EXPECT($L37, fail, 'AssignmentOpSymbol "+="');
|
|
7563
|
+
var AssignmentOpSymbol$5 = $EXPECT($L38, fail, 'AssignmentOpSymbol "-="');
|
|
7564
|
+
var AssignmentOpSymbol$6 = $EXPECT($L39, fail, 'AssignmentOpSymbol "<<="');
|
|
7565
|
+
var AssignmentOpSymbol$7 = $EXPECT($L40, fail, 'AssignmentOpSymbol ">>>="');
|
|
7566
|
+
var AssignmentOpSymbol$8 = $EXPECT($L41, fail, 'AssignmentOpSymbol ">>="');
|
|
7567
|
+
var AssignmentOpSymbol$9 = $EXPECT($L42, fail, 'AssignmentOpSymbol "&&="');
|
|
7568
|
+
var AssignmentOpSymbol$10 = $EXPECT($L43, fail, 'AssignmentOpSymbol "&="');
|
|
7569
|
+
var AssignmentOpSymbol$11 = $EXPECT($L44, fail, 'AssignmentOpSymbol "^="');
|
|
7570
|
+
var AssignmentOpSymbol$12 = $EXPECT($L45, fail, 'AssignmentOpSymbol "||="');
|
|
7571
|
+
var AssignmentOpSymbol$13 = $EXPECT($L46, fail, 'AssignmentOpSymbol "|="');
|
|
7572
|
+
var AssignmentOpSymbol$14 = $EXPECT($L47, fail, 'AssignmentOpSymbol "??="');
|
|
7573
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L48, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
7570
7574
|
return "??=";
|
|
7571
7575
|
});
|
|
7572
7576
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L1, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L1, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -7597,10 +7601,10 @@ ${input.slice(result.pos)}
|
|
|
7597
7601
|
return result;
|
|
7598
7602
|
}
|
|
7599
7603
|
}
|
|
7600
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
7604
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L49, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
7601
7605
|
return "&&=";
|
|
7602
7606
|
});
|
|
7603
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
7607
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L50, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
7604
7608
|
return "||=";
|
|
7605
7609
|
});
|
|
7606
7610
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -7639,7 +7643,7 @@ ${input.slice(result.pos)}
|
|
|
7639
7643
|
special: true
|
|
7640
7644
|
};
|
|
7641
7645
|
});
|
|
7642
|
-
var BinaryOp$2 = $TS($S($EXPECT($
|
|
7646
|
+
var BinaryOp$2 = $TS($S($EXPECT($L51, fail, 'BinaryOp "not"'), NonIdContinue, __, Identifier), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7643
7647
|
var id = $4;
|
|
7644
7648
|
if (!module.operators.has(id.name))
|
|
7645
7649
|
return $skip;
|
|
@@ -7671,21 +7675,21 @@ ${input.slice(result.pos)}
|
|
|
7671
7675
|
return result;
|
|
7672
7676
|
}
|
|
7673
7677
|
}
|
|
7674
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
7675
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
7676
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
7677
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
7678
|
+
var BinaryOpSymbol$0 = $EXPECT($L52, fail, 'BinaryOpSymbol "**"');
|
|
7679
|
+
var BinaryOpSymbol$1 = $EXPECT($L53, fail, 'BinaryOpSymbol "*"');
|
|
7680
|
+
var BinaryOpSymbol$2 = $EXPECT($L54, fail, 'BinaryOpSymbol "/"');
|
|
7681
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L55, fail, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
7678
7682
|
return {
|
|
7679
7683
|
call: module.getRef("modulo"),
|
|
7680
7684
|
special: true
|
|
7681
7685
|
};
|
|
7682
7686
|
});
|
|
7683
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
7684
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
7685
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
7686
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
7687
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
7688
|
-
var BinaryOpSymbol$9 = $TV($EXPECT($
|
|
7687
|
+
var BinaryOpSymbol$4 = $EXPECT($L56, fail, 'BinaryOpSymbol "%"');
|
|
7688
|
+
var BinaryOpSymbol$5 = $EXPECT($L57, fail, 'BinaryOpSymbol "+"');
|
|
7689
|
+
var BinaryOpSymbol$6 = $EXPECT($L16, fail, 'BinaryOpSymbol "-"');
|
|
7690
|
+
var BinaryOpSymbol$7 = $EXPECT($L58, fail, 'BinaryOpSymbol "<="');
|
|
7691
|
+
var BinaryOpSymbol$8 = $EXPECT($L59, fail, 'BinaryOpSymbol ">="');
|
|
7692
|
+
var BinaryOpSymbol$9 = $TV($EXPECT($L60, fail, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
7689
7693
|
return {
|
|
7690
7694
|
$loc,
|
|
7691
7695
|
token: "instanceof",
|
|
@@ -7693,7 +7697,7 @@ ${input.slice(result.pos)}
|
|
|
7693
7697
|
special: true
|
|
7694
7698
|
};
|
|
7695
7699
|
});
|
|
7696
|
-
var BinaryOpSymbol$10 = $TV($EXPECT($
|
|
7700
|
+
var BinaryOpSymbol$10 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
7697
7701
|
return {
|
|
7698
7702
|
$loc,
|
|
7699
7703
|
token: "instanceof",
|
|
@@ -7702,46 +7706,58 @@ ${input.slice(result.pos)}
|
|
|
7702
7706
|
negated: true
|
|
7703
7707
|
};
|
|
7704
7708
|
});
|
|
7705
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
7709
|
+
var BinaryOpSymbol$11 = $EXPECT($L62, fail, 'BinaryOpSymbol "<<"');
|
|
7706
7710
|
var BinaryOpSymbol$12 = $TR($EXPECT($R6, fail, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7707
7711
|
return "<";
|
|
7708
7712
|
});
|
|
7709
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
7710
|
-
var BinaryOpSymbol$14 = $EXPECT($
|
|
7711
|
-
var BinaryOpSymbol$15 = $EXPECT($
|
|
7712
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
7713
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
7713
|
+
var BinaryOpSymbol$13 = $EXPECT($L63, fail, 'BinaryOpSymbol ">>>"');
|
|
7714
|
+
var BinaryOpSymbol$14 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>"');
|
|
7715
|
+
var BinaryOpSymbol$15 = $EXPECT($L30, fail, 'BinaryOpSymbol ">"');
|
|
7716
|
+
var BinaryOpSymbol$16 = $EXPECT($L65, fail, 'BinaryOpSymbol "!=="');
|
|
7717
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L66, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
7714
7718
|
if (module.config.coffeeEq)
|
|
7715
7719
|
return "!==";
|
|
7716
7720
|
return $1;
|
|
7717
7721
|
});
|
|
7718
|
-
var BinaryOpSymbol$18 = $TS($S($EXPECT($
|
|
7722
|
+
var BinaryOpSymbol$18 = $TS($S($EXPECT($L67, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7719
7723
|
if (module.config.coffeeIsnt)
|
|
7720
7724
|
return "!==";
|
|
7721
7725
|
return $skip;
|
|
7722
7726
|
});
|
|
7723
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
7724
|
-
var BinaryOpSymbol$20 = $TV($EXPECT($
|
|
7727
|
+
var BinaryOpSymbol$19 = $EXPECT($L68, fail, 'BinaryOpSymbol "==="');
|
|
7728
|
+
var BinaryOpSymbol$20 = $TV($EXPECT($L69, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
7725
7729
|
if (module.config.coffeeEq)
|
|
7726
7730
|
return "===";
|
|
7727
7731
|
return $1;
|
|
7728
7732
|
});
|
|
7729
|
-
var BinaryOpSymbol$21 = $T($S($EXPECT($
|
|
7733
|
+
var BinaryOpSymbol$21 = $T($S($EXPECT($L70, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
7730
7734
|
return "&&";
|
|
7731
7735
|
});
|
|
7732
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
7733
|
-
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
7736
|
+
var BinaryOpSymbol$22 = $EXPECT($L71, fail, 'BinaryOpSymbol "&&"');
|
|
7737
|
+
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($L72, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
7734
7738
|
return "in";
|
|
7735
7739
|
});
|
|
7736
|
-
var BinaryOpSymbol$24 = $T($S($EXPECT($
|
|
7740
|
+
var BinaryOpSymbol$24 = $T($S($EXPECT($L73, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
7737
7741
|
return "||";
|
|
7738
7742
|
});
|
|
7739
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
7740
|
-
var BinaryOpSymbol$26 = $EXPECT($
|
|
7741
|
-
|
|
7743
|
+
var BinaryOpSymbol$25 = $EXPECT($L74, fail, 'BinaryOpSymbol "||"');
|
|
7744
|
+
var BinaryOpSymbol$26 = $TV($C($EXPECT($L75, fail, 'BinaryOpSymbol "^^"'), $S($EXPECT($L76, fail, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7745
|
+
return {
|
|
7746
|
+
call: module.getRef("xor"),
|
|
7747
|
+
special: true
|
|
7748
|
+
};
|
|
7749
|
+
});
|
|
7750
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($R7, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L77, fail, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7751
|
+
return {
|
|
7752
|
+
call: module.getRef("xnor"),
|
|
7753
|
+
special: true
|
|
7754
|
+
};
|
|
7755
|
+
});
|
|
7756
|
+
var BinaryOpSymbol$28 = $EXPECT($L78, fail, 'BinaryOpSymbol "??"');
|
|
7757
|
+
var BinaryOpSymbol$29 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L3, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
7742
7758
|
return "??";
|
|
7743
7759
|
});
|
|
7744
|
-
var BinaryOpSymbol$
|
|
7760
|
+
var BinaryOpSymbol$30 = $TS($S($EXPECT($L79, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7745
7761
|
return {
|
|
7746
7762
|
$loc,
|
|
7747
7763
|
token: $1,
|
|
@@ -7749,7 +7765,7 @@ ${input.slice(result.pos)}
|
|
|
7749
7765
|
special: true
|
|
7750
7766
|
};
|
|
7751
7767
|
});
|
|
7752
|
-
var BinaryOpSymbol$
|
|
7768
|
+
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) {
|
|
7753
7769
|
return {
|
|
7754
7770
|
$loc,
|
|
7755
7771
|
token: "instanceof",
|
|
@@ -7758,7 +7774,7 @@ ${input.slice(result.pos)}
|
|
|
7758
7774
|
negated: true
|
|
7759
7775
|
};
|
|
7760
7776
|
});
|
|
7761
|
-
var BinaryOpSymbol$
|
|
7777
|
+
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) {
|
|
7762
7778
|
return {
|
|
7763
7779
|
$loc,
|
|
7764
7780
|
token: "in",
|
|
@@ -7766,7 +7782,7 @@ ${input.slice(result.pos)}
|
|
|
7766
7782
|
negated: true
|
|
7767
7783
|
};
|
|
7768
7784
|
});
|
|
7769
|
-
var BinaryOpSymbol$
|
|
7785
|
+
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) {
|
|
7770
7786
|
return {
|
|
7771
7787
|
method: "includes",
|
|
7772
7788
|
relational: true,
|
|
@@ -7774,7 +7790,7 @@ ${input.slice(result.pos)}
|
|
|
7774
7790
|
special: true
|
|
7775
7791
|
};
|
|
7776
7792
|
});
|
|
7777
|
-
var BinaryOpSymbol$
|
|
7793
|
+
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
7778
7794
|
return {
|
|
7779
7795
|
call: [module.getRef("indexOf"), ".call"],
|
|
7780
7796
|
relational: true,
|
|
@@ -7783,7 +7799,7 @@ ${input.slice(result.pos)}
|
|
|
7783
7799
|
special: true
|
|
7784
7800
|
};
|
|
7785
7801
|
});
|
|
7786
|
-
var BinaryOpSymbol$
|
|
7802
|
+
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) {
|
|
7787
7803
|
return {
|
|
7788
7804
|
method: "includes",
|
|
7789
7805
|
relational: true,
|
|
@@ -7792,7 +7808,7 @@ ${input.slice(result.pos)}
|
|
|
7792
7808
|
negated: true
|
|
7793
7809
|
};
|
|
7794
7810
|
});
|
|
7795
|
-
var BinaryOpSymbol$
|
|
7811
|
+
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) {
|
|
7796
7812
|
return {
|
|
7797
7813
|
call: [module.getRef("indexOf"), ".call"],
|
|
7798
7814
|
relational: true,
|
|
@@ -7801,7 +7817,7 @@ ${input.slice(result.pos)}
|
|
|
7801
7817
|
special: true
|
|
7802
7818
|
};
|
|
7803
7819
|
});
|
|
7804
|
-
var BinaryOpSymbol$
|
|
7820
|
+
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) {
|
|
7805
7821
|
if (module.config.objectIs) {
|
|
7806
7822
|
return {
|
|
7807
7823
|
call: module.getRef("is"),
|
|
@@ -7813,7 +7829,7 @@ ${input.slice(result.pos)}
|
|
|
7813
7829
|
}
|
|
7814
7830
|
return "!==";
|
|
7815
7831
|
});
|
|
7816
|
-
var BinaryOpSymbol$
|
|
7832
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7817
7833
|
if (module.config.objectIs) {
|
|
7818
7834
|
return {
|
|
7819
7835
|
call: module.getRef("is"),
|
|
@@ -7824,12 +7840,12 @@ ${input.slice(result.pos)}
|
|
|
7824
7840
|
}
|
|
7825
7841
|
return "===";
|
|
7826
7842
|
});
|
|
7827
|
-
var BinaryOpSymbol$
|
|
7843
|
+
var BinaryOpSymbol$39 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7828
7844
|
return $1;
|
|
7829
7845
|
});
|
|
7830
|
-
var BinaryOpSymbol$
|
|
7831
|
-
var BinaryOpSymbol$
|
|
7832
|
-
var BinaryOpSymbol$
|
|
7846
|
+
var BinaryOpSymbol$40 = $EXPECT($L82, fail, 'BinaryOpSymbol "&"');
|
|
7847
|
+
var BinaryOpSymbol$41 = $EXPECT($L15, fail, 'BinaryOpSymbol "^"');
|
|
7848
|
+
var BinaryOpSymbol$42 = $EXPECT($L83, fail, 'BinaryOpSymbol "|"');
|
|
7833
7849
|
function BinaryOpSymbol(state) {
|
|
7834
7850
|
let eventData;
|
|
7835
7851
|
if (state.events) {
|
|
@@ -7841,18 +7857,66 @@ ${input.slice(result.pos)}
|
|
|
7841
7857
|
}
|
|
7842
7858
|
}
|
|
7843
7859
|
if (state.tokenize) {
|
|
7844
|
-
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));
|
|
7860
|
+
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));
|
|
7845
7861
|
if (state.events)
|
|
7846
7862
|
state.events.exit?.("BinaryOpSymbol", state, result, eventData);
|
|
7847
7863
|
return result;
|
|
7848
7864
|
} else {
|
|
7849
|
-
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);
|
|
7865
|
+
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);
|
|
7850
7866
|
if (state.events)
|
|
7851
7867
|
state.events.exit?.("BinaryOpSymbol", state, result, eventData);
|
|
7852
7868
|
return result;
|
|
7853
7869
|
}
|
|
7854
7870
|
}
|
|
7855
|
-
var
|
|
7871
|
+
var Xor$0 = $EXPECT($L75, fail, 'Xor "^^"');
|
|
7872
|
+
var Xor$1 = $S($EXPECT($L76, fail, 'Xor "xor"'), NonIdContinue);
|
|
7873
|
+
function Xor(state) {
|
|
7874
|
+
let eventData;
|
|
7875
|
+
if (state.events) {
|
|
7876
|
+
const result = state.events.enter?.("Xor", state);
|
|
7877
|
+
if (result) {
|
|
7878
|
+
if (result.cache)
|
|
7879
|
+
return result.cache;
|
|
7880
|
+
eventData = result.data;
|
|
7881
|
+
}
|
|
7882
|
+
}
|
|
7883
|
+
if (state.tokenize) {
|
|
7884
|
+
const result = $TOKEN("Xor", state, Xor$0(state) || Xor$1(state));
|
|
7885
|
+
if (state.events)
|
|
7886
|
+
state.events.exit?.("Xor", state, result, eventData);
|
|
7887
|
+
return result;
|
|
7888
|
+
} else {
|
|
7889
|
+
const result = Xor$0(state) || Xor$1(state);
|
|
7890
|
+
if (state.events)
|
|
7891
|
+
state.events.exit?.("Xor", state, result, eventData);
|
|
7892
|
+
return result;
|
|
7893
|
+
}
|
|
7894
|
+
}
|
|
7895
|
+
var Xnor$0 = $R$0($EXPECT($R7, fail, "Xnor /!\\^\\^?/"));
|
|
7896
|
+
var Xnor$1 = $EXPECT($L77, fail, 'Xnor "xnor"');
|
|
7897
|
+
function Xnor(state) {
|
|
7898
|
+
let eventData;
|
|
7899
|
+
if (state.events) {
|
|
7900
|
+
const result = state.events.enter?.("Xnor", state);
|
|
7901
|
+
if (result) {
|
|
7902
|
+
if (result.cache)
|
|
7903
|
+
return result.cache;
|
|
7904
|
+
eventData = result.data;
|
|
7905
|
+
}
|
|
7906
|
+
}
|
|
7907
|
+
if (state.tokenize) {
|
|
7908
|
+
const result = $TOKEN("Xnor", state, Xnor$0(state) || Xnor$1(state));
|
|
7909
|
+
if (state.events)
|
|
7910
|
+
state.events.exit?.("Xnor", state, result, eventData);
|
|
7911
|
+
return result;
|
|
7912
|
+
} else {
|
|
7913
|
+
const result = Xnor$0(state) || Xnor$1(state);
|
|
7914
|
+
if (state.events)
|
|
7915
|
+
state.events.exit?.("Xnor", state, result, eventData);
|
|
7916
|
+
return result;
|
|
7917
|
+
}
|
|
7918
|
+
}
|
|
7919
|
+
var UnaryOp$0 = $TR($EXPECT($R8, fail, "UnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7856
7920
|
return { $loc, token: $0 };
|
|
7857
7921
|
});
|
|
7858
7922
|
var UnaryOp$1 = $S($C(Await, Delete, Void, Typeof), __);
|
|
@@ -8049,7 +8113,7 @@ ${input.slice(result.pos)}
|
|
|
8049
8113
|
return result;
|
|
8050
8114
|
}
|
|
8051
8115
|
}
|
|
8052
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
8116
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L84, fail, 'EmptyStatement ";"'))), function(value) {
|
|
8053
8117
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
8054
8118
|
});
|
|
8055
8119
|
function EmptyStatement(state) {
|
|
@@ -9004,7 +9068,7 @@ ${input.slice(result.pos)}
|
|
|
9004
9068
|
return result;
|
|
9005
9069
|
}
|
|
9006
9070
|
}
|
|
9007
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
9071
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L85, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
9008
9072
|
var own = $1;
|
|
9009
9073
|
var binding = $2;
|
|
9010
9074
|
return {
|
|
@@ -9127,7 +9191,7 @@ ${input.slice(result.pos)}
|
|
|
9127
9191
|
names: binding.names
|
|
9128
9192
|
};
|
|
9129
9193
|
});
|
|
9130
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
9194
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R9, fail, "ForDeclaration /(?=[\\s\\)])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
9131
9195
|
var c = $1;
|
|
9132
9196
|
var binding = $2;
|
|
9133
9197
|
return {
|
|
@@ -9485,7 +9549,7 @@ ${input.slice(result.pos)}
|
|
|
9485
9549
|
}
|
|
9486
9550
|
}
|
|
9487
9551
|
var ImpliedColon$0 = $S(__, Colon);
|
|
9488
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
9552
|
+
var ImpliedColon$1 = $TV($EXPECT($L18, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
9489
9553
|
return { $loc, token: ":" };
|
|
9490
9554
|
});
|
|
9491
9555
|
function ImpliedColon(state) {
|
|
@@ -9739,7 +9803,7 @@ ${input.slice(result.pos)}
|
|
|
9739
9803
|
return result;
|
|
9740
9804
|
}
|
|
9741
9805
|
}
|
|
9742
|
-
var SuppressIndentedApplication$0 = $TV($EXPECT($
|
|
9806
|
+
var SuppressIndentedApplication$0 = $TV($EXPECT($L18, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
9743
9807
|
module.suppressIndentedApplication = true;
|
|
9744
9808
|
});
|
|
9745
9809
|
function SuppressIndentedApplication(state) {
|
|
@@ -9764,7 +9828,7 @@ ${input.slice(result.pos)}
|
|
|
9764
9828
|
return result;
|
|
9765
9829
|
}
|
|
9766
9830
|
}
|
|
9767
|
-
var IndentedApplicationAllowed$0 = $TV($EXPECT($
|
|
9831
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L18, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
9768
9832
|
if (module.suppressIndentedApplication)
|
|
9769
9833
|
return $skip;
|
|
9770
9834
|
return;
|
|
@@ -9791,7 +9855,7 @@ ${input.slice(result.pos)}
|
|
|
9791
9855
|
return result;
|
|
9792
9856
|
}
|
|
9793
9857
|
}
|
|
9794
|
-
var SuppressTrailingMemberProperty$0 = $TV($EXPECT($
|
|
9858
|
+
var SuppressTrailingMemberProperty$0 = $TV($EXPECT($L18, fail, 'SuppressTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
9795
9859
|
module.suppressTrailingMemberProperty.push(true);
|
|
9796
9860
|
});
|
|
9797
9861
|
function SuppressTrailingMemberProperty(state) {
|
|
@@ -9816,7 +9880,7 @@ ${input.slice(result.pos)}
|
|
|
9816
9880
|
return result;
|
|
9817
9881
|
}
|
|
9818
9882
|
}
|
|
9819
|
-
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($
|
|
9883
|
+
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($L18, fail, 'TrailingMemberPropertyAllowed ""'), function($skip, $loc, $0, $1) {
|
|
9820
9884
|
if (module.trailingMemberPropertySuppressed)
|
|
9821
9885
|
return $skip;
|
|
9822
9886
|
});
|
|
@@ -9865,13 +9929,13 @@ ${input.slice(result.pos)}
|
|
|
9865
9929
|
return result;
|
|
9866
9930
|
}
|
|
9867
9931
|
}
|
|
9868
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
9932
|
+
var KeywordStatement$0 = $T($S($EXPECT($L86, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
9869
9933
|
return { "type": "BreakStatement", "children": value };
|
|
9870
9934
|
});
|
|
9871
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
9935
|
+
var KeywordStatement$1 = $T($S($EXPECT($L87, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
9872
9936
|
return { "type": "ContinueStatement", "children": value };
|
|
9873
9937
|
});
|
|
9874
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
9938
|
+
var KeywordStatement$2 = $T($S($EXPECT($L88, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
9875
9939
|
return { "type": "DebuggerStatement", "children": value };
|
|
9876
9940
|
});
|
|
9877
9941
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -9902,7 +9966,7 @@ ${input.slice(result.pos)}
|
|
|
9902
9966
|
return result;
|
|
9903
9967
|
}
|
|
9904
9968
|
}
|
|
9905
|
-
var DebuggerExpression$0 = $TS($S($EXPECT($
|
|
9969
|
+
var DebuggerExpression$0 = $TS($S($EXPECT($L88, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9906
9970
|
return {
|
|
9907
9971
|
type: "DebuggerExpression",
|
|
9908
9972
|
children: ["(()=>{", $1, "})()"]
|
|
@@ -10030,7 +10094,7 @@ ${input.slice(result.pos)}
|
|
|
10030
10094
|
return result;
|
|
10031
10095
|
}
|
|
10032
10096
|
}
|
|
10033
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
10097
|
+
var ImpliedImport$0 = $TV($EXPECT($L18, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
10034
10098
|
return { $loc, token: "import " };
|
|
10035
10099
|
});
|
|
10036
10100
|
function ImpliedImport(state) {
|
|
@@ -10179,7 +10243,7 @@ ${input.slice(result.pos)}
|
|
|
10179
10243
|
return result;
|
|
10180
10244
|
}
|
|
10181
10245
|
}
|
|
10182
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10246
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L89, fail, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10183
10247
|
function ImportAssertion(state) {
|
|
10184
10248
|
let eventData;
|
|
10185
10249
|
if (state.events) {
|
|
@@ -10395,7 +10459,7 @@ ${input.slice(result.pos)}
|
|
|
10395
10459
|
return result;
|
|
10396
10460
|
}
|
|
10397
10461
|
}
|
|
10398
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
10462
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R10, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
10399
10463
|
var spec = $0;
|
|
10400
10464
|
return { $loc, token: `"${spec}"` };
|
|
10401
10465
|
});
|
|
@@ -10783,7 +10847,7 @@ ${input.slice(result.pos)}
|
|
|
10783
10847
|
return result;
|
|
10784
10848
|
}
|
|
10785
10849
|
}
|
|
10786
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
10850
|
+
var ConstAssignment$0 = $TV($EXPECT($L90, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
10787
10851
|
return { $loc, token: "=" };
|
|
10788
10852
|
});
|
|
10789
10853
|
function ConstAssignment(state) {
|
|
@@ -10808,7 +10872,7 @@ ${input.slice(result.pos)}
|
|
|
10808
10872
|
return result;
|
|
10809
10873
|
}
|
|
10810
10874
|
}
|
|
10811
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
10875
|
+
var LetAssignment$0 = $TV($EXPECT($L91, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10812
10876
|
return { $loc, token: "=" };
|
|
10813
10877
|
});
|
|
10814
10878
|
function LetAssignment(state) {
|
|
@@ -11057,7 +11121,7 @@ ${input.slice(result.pos)}
|
|
|
11057
11121
|
return result;
|
|
11058
11122
|
}
|
|
11059
11123
|
}
|
|
11060
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
11124
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R11, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
11061
11125
|
function DecimalBigIntegerLiteral(state) {
|
|
11062
11126
|
let eventData;
|
|
11063
11127
|
if (state.events) {
|
|
@@ -11080,11 +11144,11 @@ ${input.slice(result.pos)}
|
|
|
11080
11144
|
return result;
|
|
11081
11145
|
}
|
|
11082
11146
|
}
|
|
11083
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
11147
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R12, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
11084
11148
|
return $1 + ".";
|
|
11085
11149
|
});
|
|
11086
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
11087
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
11150
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R13, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
11151
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R14, fail, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
11088
11152
|
function DecimalLiteral(state) {
|
|
11089
11153
|
let eventData;
|
|
11090
11154
|
if (state.events) {
|
|
@@ -11107,7 +11171,7 @@ ${input.slice(result.pos)}
|
|
|
11107
11171
|
return result;
|
|
11108
11172
|
}
|
|
11109
11173
|
}
|
|
11110
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
11174
|
+
var ExponentPart$0 = $R$0($EXPECT($R15, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
11111
11175
|
function ExponentPart(state) {
|
|
11112
11176
|
let eventData;
|
|
11113
11177
|
if (state.events) {
|
|
@@ -11130,7 +11194,7 @@ ${input.slice(result.pos)}
|
|
|
11130
11194
|
return result;
|
|
11131
11195
|
}
|
|
11132
11196
|
}
|
|
11133
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
11197
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R16, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
11134
11198
|
function BinaryIntegerLiteral(state) {
|
|
11135
11199
|
let eventData;
|
|
11136
11200
|
if (state.events) {
|
|
@@ -11153,7 +11217,7 @@ ${input.slice(result.pos)}
|
|
|
11153
11217
|
return result;
|
|
11154
11218
|
}
|
|
11155
11219
|
}
|
|
11156
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11220
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R17, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
11157
11221
|
function OctalIntegerLiteral(state) {
|
|
11158
11222
|
let eventData;
|
|
11159
11223
|
if (state.events) {
|
|
@@ -11176,7 +11240,7 @@ ${input.slice(result.pos)}
|
|
|
11176
11240
|
return result;
|
|
11177
11241
|
}
|
|
11178
11242
|
}
|
|
11179
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
11243
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R18, fail, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
11180
11244
|
function HexIntegerLiteral(state) {
|
|
11181
11245
|
let eventData;
|
|
11182
11246
|
if (state.events) {
|
|
@@ -11251,7 +11315,7 @@ ${input.slice(result.pos)}
|
|
|
11251
11315
|
return result;
|
|
11252
11316
|
}
|
|
11253
11317
|
}
|
|
11254
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11318
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R19, fail, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
11255
11319
|
function DecimalIntegerLiteral(state) {
|
|
11256
11320
|
let eventData;
|
|
11257
11321
|
if (state.events) {
|
|
@@ -11312,7 +11376,7 @@ ${input.slice(result.pos)}
|
|
|
11312
11376
|
return result;
|
|
11313
11377
|
}
|
|
11314
11378
|
}
|
|
11315
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
11379
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R20, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11316
11380
|
return { $loc, token: $0 };
|
|
11317
11381
|
});
|
|
11318
11382
|
function DoubleStringCharacters(state) {
|
|
@@ -11337,7 +11401,7 @@ ${input.slice(result.pos)}
|
|
|
11337
11401
|
return result;
|
|
11338
11402
|
}
|
|
11339
11403
|
}
|
|
11340
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
11404
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R21, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11341
11405
|
return { $loc, token: $0 };
|
|
11342
11406
|
});
|
|
11343
11407
|
function SingleStringCharacters(state) {
|
|
@@ -11362,7 +11426,7 @@ ${input.slice(result.pos)}
|
|
|
11362
11426
|
return result;
|
|
11363
11427
|
}
|
|
11364
11428
|
}
|
|
11365
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
11429
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R22, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11366
11430
|
return { $loc, token: $0 };
|
|
11367
11431
|
});
|
|
11368
11432
|
function TripleDoubleStringCharacters(state) {
|
|
@@ -11387,7 +11451,7 @@ ${input.slice(result.pos)}
|
|
|
11387
11451
|
return result;
|
|
11388
11452
|
}
|
|
11389
11453
|
}
|
|
11390
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
11454
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R23, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11391
11455
|
return { $loc, token: $0 };
|
|
11392
11456
|
});
|
|
11393
11457
|
function TripleSingleStringCharacters(state) {
|
|
@@ -11480,7 +11544,7 @@ ${input.slice(result.pos)}
|
|
|
11480
11544
|
return result;
|
|
11481
11545
|
}
|
|
11482
11546
|
}
|
|
11483
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
11547
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R24, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11484
11548
|
return { $loc, token: $0 };
|
|
11485
11549
|
});
|
|
11486
11550
|
function CoffeeDoubleQuotedStringCharacters(state) {
|
|
@@ -11506,7 +11570,7 @@ ${input.slice(result.pos)}
|
|
|
11506
11570
|
}
|
|
11507
11571
|
}
|
|
11508
11572
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
11509
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
11573
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L54, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L54, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
11510
11574
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
11511
11575
|
});
|
|
11512
11576
|
function RegularExpressionLiteral(state) {
|
|
@@ -11556,7 +11620,7 @@ ${input.slice(result.pos)}
|
|
|
11556
11620
|
return result;
|
|
11557
11621
|
}
|
|
11558
11622
|
}
|
|
11559
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
11623
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R25, fail, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11560
11624
|
return { $loc, token: $0 };
|
|
11561
11625
|
});
|
|
11562
11626
|
function RegularExpressionClassCharacters(state) {
|
|
@@ -11666,7 +11730,7 @@ ${input.slice(result.pos)}
|
|
|
11666
11730
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
11667
11731
|
return { "type": "Substitution", "children": value[0] };
|
|
11668
11732
|
});
|
|
11669
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
11733
|
+
var HeregexPart$3 = $TR($EXPECT($R26, fail, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11670
11734
|
let token = $0;
|
|
11671
11735
|
switch ($0[1]) {
|
|
11672
11736
|
case "\n":
|
|
@@ -11684,13 +11748,13 @@ ${input.slice(result.pos)}
|
|
|
11684
11748
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
11685
11749
|
return { $loc, token: "" };
|
|
11686
11750
|
});
|
|
11687
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
11751
|
+
var HeregexPart$5 = $TR($EXPECT($R27, fail, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11688
11752
|
return { $loc, token: "" };
|
|
11689
11753
|
});
|
|
11690
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
11754
|
+
var HeregexPart$6 = $TR($EXPECT($R28, fail, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11691
11755
|
return { $loc, token: "\\/" };
|
|
11692
11756
|
});
|
|
11693
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
11757
|
+
var HeregexPart$7 = $TR($EXPECT($R29, fail, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11694
11758
|
return { $loc, token: $0 };
|
|
11695
11759
|
});
|
|
11696
11760
|
function HeregexPart(state) {
|
|
@@ -11739,7 +11803,7 @@ ${input.slice(result.pos)}
|
|
|
11739
11803
|
return result;
|
|
11740
11804
|
}
|
|
11741
11805
|
}
|
|
11742
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
11806
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R30, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
11743
11807
|
function RegularExpressionBody(state) {
|
|
11744
11808
|
let eventData;
|
|
11745
11809
|
if (state.events) {
|
|
@@ -11762,7 +11826,31 @@ ${input.slice(result.pos)}
|
|
|
11762
11826
|
return result;
|
|
11763
11827
|
}
|
|
11764
11828
|
}
|
|
11765
|
-
var
|
|
11829
|
+
var RegExpPart$0 = RegularExpressionClass;
|
|
11830
|
+
var RegExpPart$1 = RegExpCharacter;
|
|
11831
|
+
function RegExpPart(state) {
|
|
11832
|
+
let eventData;
|
|
11833
|
+
if (state.events) {
|
|
11834
|
+
const result = state.events.enter?.("RegExpPart", state);
|
|
11835
|
+
if (result) {
|
|
11836
|
+
if (result.cache)
|
|
11837
|
+
return result.cache;
|
|
11838
|
+
eventData = result.data;
|
|
11839
|
+
}
|
|
11840
|
+
}
|
|
11841
|
+
if (state.tokenize) {
|
|
11842
|
+
const result = $TOKEN("RegExpPart", state, RegExpPart$0(state) || RegExpPart$1(state));
|
|
11843
|
+
if (state.events)
|
|
11844
|
+
state.events.exit?.("RegExpPart", state, result, eventData);
|
|
11845
|
+
return result;
|
|
11846
|
+
} else {
|
|
11847
|
+
const result = RegExpPart$0(state) || RegExpPart$1(state);
|
|
11848
|
+
if (state.events)
|
|
11849
|
+
state.events.exit?.("RegExpPart", state, result, eventData);
|
|
11850
|
+
return result;
|
|
11851
|
+
}
|
|
11852
|
+
}
|
|
11853
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R31, fail, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
11766
11854
|
function RegExpCharacter(state) {
|
|
11767
11855
|
let eventData;
|
|
11768
11856
|
if (state.events) {
|
|
@@ -11785,7 +11873,7 @@ ${input.slice(result.pos)}
|
|
|
11785
11873
|
return result;
|
|
11786
11874
|
}
|
|
11787
11875
|
}
|
|
11788
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
11876
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R32, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
11789
11877
|
function RegularExpressionFlags(state) {
|
|
11790
11878
|
let eventData;
|
|
11791
11879
|
if (state.events) {
|
|
@@ -11875,7 +11963,7 @@ ${input.slice(result.pos)}
|
|
|
11875
11963
|
return result;
|
|
11876
11964
|
}
|
|
11877
11965
|
}
|
|
11878
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
11966
|
+
var TemplateCharacters$0 = $TR($EXPECT($R33, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11879
11967
|
return { $loc, token: $0 };
|
|
11880
11968
|
});
|
|
11881
11969
|
function TemplateCharacters(state) {
|
|
@@ -11900,7 +11988,7 @@ ${input.slice(result.pos)}
|
|
|
11900
11988
|
return result;
|
|
11901
11989
|
}
|
|
11902
11990
|
}
|
|
11903
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
11991
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R34, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11904
11992
|
return { $loc, token: $0 };
|
|
11905
11993
|
});
|
|
11906
11994
|
function TemplateBlockCharacters(state) {
|
|
@@ -11925,11 +12013,11 @@ ${input.slice(result.pos)}
|
|
|
11925
12013
|
return result;
|
|
11926
12014
|
}
|
|
11927
12015
|
}
|
|
11928
|
-
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($
|
|
11929
|
-
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($
|
|
11930
|
-
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($
|
|
11931
|
-
var ReservedWord$3 = $S(CoffeeOfEnabled, $R$0($EXPECT($
|
|
11932
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
12016
|
+
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R35, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
|
|
12017
|
+
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($R36, fail, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")));
|
|
12018
|
+
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($R37, fail, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")));
|
|
12019
|
+
var ReservedWord$3 = $S(CoffeeOfEnabled, $R$0($EXPECT($R38, fail, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")));
|
|
12020
|
+
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})/"));
|
|
11933
12021
|
function ReservedWord(state) {
|
|
11934
12022
|
let eventData;
|
|
11935
12023
|
if (state.events) {
|
|
@@ -12000,7 +12088,7 @@ ${input.slice(result.pos)}
|
|
|
12000
12088
|
return result;
|
|
12001
12089
|
}
|
|
12002
12090
|
}
|
|
12003
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
12091
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R40, fail, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12004
12092
|
return { $loc, token: $0 };
|
|
12005
12093
|
});
|
|
12006
12094
|
function JSSingleLineComment(state) {
|
|
@@ -12049,7 +12137,7 @@ ${input.slice(result.pos)}
|
|
|
12049
12137
|
return result;
|
|
12050
12138
|
}
|
|
12051
12139
|
}
|
|
12052
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12140
|
+
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) {
|
|
12053
12141
|
return { $loc, token: $1 };
|
|
12054
12142
|
});
|
|
12055
12143
|
function JSMultiLineComment(state) {
|
|
@@ -12074,7 +12162,7 @@ ${input.slice(result.pos)}
|
|
|
12074
12162
|
return result;
|
|
12075
12163
|
}
|
|
12076
12164
|
}
|
|
12077
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
12165
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R42, fail, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12078
12166
|
return { $loc, token: `//${$1}` };
|
|
12079
12167
|
});
|
|
12080
12168
|
function CoffeeSingleLineComment(state) {
|
|
@@ -12099,7 +12187,7 @@ ${input.slice(result.pos)}
|
|
|
12099
12187
|
return result;
|
|
12100
12188
|
}
|
|
12101
12189
|
}
|
|
12102
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
12190
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R43, fail, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
12103
12191
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
12104
12192
|
return { $loc, token: `/*${$2}*/` };
|
|
12105
12193
|
});
|
|
@@ -12125,7 +12213,7 @@ ${input.slice(result.pos)}
|
|
|
12125
12213
|
return result;
|
|
12126
12214
|
}
|
|
12127
12215
|
}
|
|
12128
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
12216
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R44, fail, "CoffeeHereCommentStart /###(?!#)/"));
|
|
12129
12217
|
function CoffeeHereCommentStart(state) {
|
|
12130
12218
|
let eventData;
|
|
12131
12219
|
if (state.events) {
|
|
@@ -12148,7 +12236,7 @@ ${input.slice(result.pos)}
|
|
|
12148
12236
|
return result;
|
|
12149
12237
|
}
|
|
12150
12238
|
}
|
|
12151
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
12239
|
+
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) {
|
|
12152
12240
|
return { $loc, token: $1 };
|
|
12153
12241
|
});
|
|
12154
12242
|
function InlineComment(state) {
|
|
@@ -12244,10 +12332,10 @@ ${input.slice(result.pos)}
|
|
|
12244
12332
|
return result;
|
|
12245
12333
|
}
|
|
12246
12334
|
}
|
|
12247
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
12335
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R46, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12248
12336
|
return { $loc, token: $0 };
|
|
12249
12337
|
});
|
|
12250
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
12338
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L94, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
12251
12339
|
return "";
|
|
12252
12340
|
});
|
|
12253
12341
|
function NonNewlineWhitespace(state) {
|
|
@@ -12321,7 +12409,7 @@ ${input.slice(result.pos)}
|
|
|
12321
12409
|
return result;
|
|
12322
12410
|
}
|
|
12323
12411
|
}
|
|
12324
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
12412
|
+
var Whitespace$0 = $TR($EXPECT($R27, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12325
12413
|
return { $loc, token: $0 };
|
|
12326
12414
|
});
|
|
12327
12415
|
function Whitespace(state) {
|
|
@@ -12399,7 +12487,7 @@ ${input.slice(result.pos)}
|
|
|
12399
12487
|
}
|
|
12400
12488
|
}
|
|
12401
12489
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
12402
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($
|
|
12490
|
+
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);
|
|
12403
12491
|
var StatementDelimiter$2 = $Y(EOS);
|
|
12404
12492
|
function StatementDelimiter(state) {
|
|
12405
12493
|
let eventData;
|
|
@@ -12451,7 +12539,7 @@ ${input.slice(result.pos)}
|
|
|
12451
12539
|
return result;
|
|
12452
12540
|
}
|
|
12453
12541
|
}
|
|
12454
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
12542
|
+
var NonIdContinue$0 = $R$0($EXPECT($R47, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
12455
12543
|
function NonIdContinue(state) {
|
|
12456
12544
|
let eventData;
|
|
12457
12545
|
if (state.events) {
|
|
@@ -12474,7 +12562,7 @@ ${input.slice(result.pos)}
|
|
|
12474
12562
|
return result;
|
|
12475
12563
|
}
|
|
12476
12564
|
}
|
|
12477
|
-
var Loc$0 = $TV($EXPECT($
|
|
12565
|
+
var Loc$0 = $TV($EXPECT($L18, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
12478
12566
|
return { $loc, token: "" };
|
|
12479
12567
|
});
|
|
12480
12568
|
function Loc(state) {
|
|
@@ -12499,7 +12587,7 @@ ${input.slice(result.pos)}
|
|
|
12499
12587
|
return result;
|
|
12500
12588
|
}
|
|
12501
12589
|
}
|
|
12502
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
12590
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L97, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L8, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
12503
12591
|
return { $loc, token: $1, ts: true };
|
|
12504
12592
|
});
|
|
12505
12593
|
function Abstract(state) {
|
|
@@ -12524,7 +12612,7 @@ ${input.slice(result.pos)}
|
|
|
12524
12612
|
return result;
|
|
12525
12613
|
}
|
|
12526
12614
|
}
|
|
12527
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
12615
|
+
var Ampersand$0 = $TV($EXPECT($L82, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
12528
12616
|
return { $loc, token: $1 };
|
|
12529
12617
|
});
|
|
12530
12618
|
function Ampersand(state) {
|
|
@@ -12549,7 +12637,7 @@ ${input.slice(result.pos)}
|
|
|
12549
12637
|
return result;
|
|
12550
12638
|
}
|
|
12551
12639
|
}
|
|
12552
|
-
var As$0 = $TS($S($EXPECT($
|
|
12640
|
+
var As$0 = $TS($S($EXPECT($L98, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12553
12641
|
return { $loc, token: $1 };
|
|
12554
12642
|
});
|
|
12555
12643
|
function As(state) {
|
|
@@ -12574,7 +12662,7 @@ ${input.slice(result.pos)}
|
|
|
12574
12662
|
return result;
|
|
12575
12663
|
}
|
|
12576
12664
|
}
|
|
12577
|
-
var At$0 = $TV($EXPECT($
|
|
12665
|
+
var At$0 = $TV($EXPECT($L99, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
12578
12666
|
return { $loc, token: $1 };
|
|
12579
12667
|
});
|
|
12580
12668
|
function At(state) {
|
|
@@ -12599,7 +12687,7 @@ ${input.slice(result.pos)}
|
|
|
12599
12687
|
return result;
|
|
12600
12688
|
}
|
|
12601
12689
|
}
|
|
12602
|
-
var AtAt$0 = $TV($EXPECT($
|
|
12690
|
+
var AtAt$0 = $TV($EXPECT($L100, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
12603
12691
|
return { $loc, token: "@" };
|
|
12604
12692
|
});
|
|
12605
12693
|
function AtAt(state) {
|
|
@@ -12624,7 +12712,7 @@ ${input.slice(result.pos)}
|
|
|
12624
12712
|
return result;
|
|
12625
12713
|
}
|
|
12626
12714
|
}
|
|
12627
|
-
var Async$0 = $TS($S($EXPECT($
|
|
12715
|
+
var Async$0 = $TS($S($EXPECT($L101, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12628
12716
|
return { $loc, token: $1, type: "Async" };
|
|
12629
12717
|
});
|
|
12630
12718
|
function Async(state) {
|
|
@@ -12649,7 +12737,7 @@ ${input.slice(result.pos)}
|
|
|
12649
12737
|
return result;
|
|
12650
12738
|
}
|
|
12651
12739
|
}
|
|
12652
|
-
var Await$0 = $TS($S($EXPECT($
|
|
12740
|
+
var Await$0 = $TS($S($EXPECT($L102, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12653
12741
|
return { $loc, token: $1 };
|
|
12654
12742
|
});
|
|
12655
12743
|
function Await(state) {
|
|
@@ -12674,7 +12762,7 @@ ${input.slice(result.pos)}
|
|
|
12674
12762
|
return result;
|
|
12675
12763
|
}
|
|
12676
12764
|
}
|
|
12677
|
-
var Backtick$0 = $TV($EXPECT($
|
|
12765
|
+
var Backtick$0 = $TV($EXPECT($L96, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
12678
12766
|
return { $loc, token: $1 };
|
|
12679
12767
|
});
|
|
12680
12768
|
function Backtick(state) {
|
|
@@ -12699,7 +12787,7 @@ ${input.slice(result.pos)}
|
|
|
12699
12787
|
return result;
|
|
12700
12788
|
}
|
|
12701
12789
|
}
|
|
12702
|
-
var By$0 = $TS($S($EXPECT($
|
|
12790
|
+
var By$0 = $TS($S($EXPECT($L103, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12703
12791
|
return { $loc, token: $1 };
|
|
12704
12792
|
});
|
|
12705
12793
|
function By(state) {
|
|
@@ -12724,7 +12812,7 @@ ${input.slice(result.pos)}
|
|
|
12724
12812
|
return result;
|
|
12725
12813
|
}
|
|
12726
12814
|
}
|
|
12727
|
-
var Case$0 = $TS($S($EXPECT($
|
|
12815
|
+
var Case$0 = $TS($S($EXPECT($L104, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12728
12816
|
return { $loc, token: $1 };
|
|
12729
12817
|
});
|
|
12730
12818
|
function Case(state) {
|
|
@@ -12749,7 +12837,7 @@ ${input.slice(result.pos)}
|
|
|
12749
12837
|
return result;
|
|
12750
12838
|
}
|
|
12751
12839
|
}
|
|
12752
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
12840
|
+
var Catch$0 = $TS($S($EXPECT($L105, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12753
12841
|
return { $loc, token: $1 };
|
|
12754
12842
|
});
|
|
12755
12843
|
function Catch(state) {
|
|
@@ -12774,7 +12862,7 @@ ${input.slice(result.pos)}
|
|
|
12774
12862
|
return result;
|
|
12775
12863
|
}
|
|
12776
12864
|
}
|
|
12777
|
-
var Class$0 = $TS($S($EXPECT($
|
|
12865
|
+
var Class$0 = $TS($S($EXPECT($L106, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12778
12866
|
return { $loc, token: $1 };
|
|
12779
12867
|
});
|
|
12780
12868
|
function Class(state) {
|
|
@@ -12799,7 +12887,7 @@ ${input.slice(result.pos)}
|
|
|
12799
12887
|
return result;
|
|
12800
12888
|
}
|
|
12801
12889
|
}
|
|
12802
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
12890
|
+
var CloseBrace$0 = $TV($EXPECT($L22, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
12803
12891
|
return { $loc, token: $1 };
|
|
12804
12892
|
});
|
|
12805
12893
|
function CloseBrace(state) {
|
|
@@ -12824,7 +12912,7 @@ ${input.slice(result.pos)}
|
|
|
12824
12912
|
return result;
|
|
12825
12913
|
}
|
|
12826
12914
|
}
|
|
12827
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
12915
|
+
var CloseBracket$0 = $TV($EXPECT($L31, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
12828
12916
|
return { $loc, token: $1 };
|
|
12829
12917
|
});
|
|
12830
12918
|
function CloseBracket(state) {
|
|
@@ -12849,7 +12937,7 @@ ${input.slice(result.pos)}
|
|
|
12849
12937
|
return result;
|
|
12850
12938
|
}
|
|
12851
12939
|
}
|
|
12852
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
12940
|
+
var CloseParen$0 = $TV($EXPECT($L19, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
12853
12941
|
return { $loc, token: $1 };
|
|
12854
12942
|
});
|
|
12855
12943
|
function CloseParen(state) {
|
|
@@ -12874,7 +12962,7 @@ ${input.slice(result.pos)}
|
|
|
12874
12962
|
return result;
|
|
12875
12963
|
}
|
|
12876
12964
|
}
|
|
12877
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
12965
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L107, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
12878
12966
|
return { $loc, token: "${" };
|
|
12879
12967
|
});
|
|
12880
12968
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -12899,7 +12987,7 @@ ${input.slice(result.pos)}
|
|
|
12899
12987
|
return result;
|
|
12900
12988
|
}
|
|
12901
12989
|
}
|
|
12902
|
-
var Colon$0 = $TV($EXPECT($
|
|
12990
|
+
var Colon$0 = $TV($EXPECT($L32, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
12903
12991
|
return { $loc, token: $1 };
|
|
12904
12992
|
});
|
|
12905
12993
|
function Colon(state) {
|
|
@@ -12924,7 +13012,7 @@ ${input.slice(result.pos)}
|
|
|
12924
13012
|
return result;
|
|
12925
13013
|
}
|
|
12926
13014
|
}
|
|
12927
|
-
var Comma$0 = $TV($EXPECT($
|
|
13015
|
+
var Comma$0 = $TV($EXPECT($L20, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
12928
13016
|
return { $loc, token: $1 };
|
|
12929
13017
|
});
|
|
12930
13018
|
function Comma(state) {
|
|
@@ -12949,7 +13037,7 @@ ${input.slice(result.pos)}
|
|
|
12949
13037
|
return result;
|
|
12950
13038
|
}
|
|
12951
13039
|
}
|
|
12952
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
13040
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L99, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
12953
13041
|
return { $loc, token: "constructor" };
|
|
12954
13042
|
});
|
|
12955
13043
|
function ConstructorShorthand(state) {
|
|
@@ -12974,7 +13062,7 @@ ${input.slice(result.pos)}
|
|
|
12974
13062
|
return result;
|
|
12975
13063
|
}
|
|
12976
13064
|
}
|
|
12977
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
13065
|
+
var Declare$0 = $TS($S($EXPECT($L108, fail, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12978
13066
|
return { $loc, token: $1 };
|
|
12979
13067
|
});
|
|
12980
13068
|
function Declare(state) {
|
|
@@ -12999,7 +13087,7 @@ ${input.slice(result.pos)}
|
|
|
12999
13087
|
return result;
|
|
13000
13088
|
}
|
|
13001
13089
|
}
|
|
13002
|
-
var Default$0 = $TS($S($EXPECT($
|
|
13090
|
+
var Default$0 = $TS($S($EXPECT($L109, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13003
13091
|
return { $loc, token: $1 };
|
|
13004
13092
|
});
|
|
13005
13093
|
function Default(state) {
|
|
@@ -13024,7 +13112,7 @@ ${input.slice(result.pos)}
|
|
|
13024
13112
|
return result;
|
|
13025
13113
|
}
|
|
13026
13114
|
}
|
|
13027
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
13115
|
+
var Delete$0 = $TS($S($EXPECT($L110, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13028
13116
|
return { $loc, token: $1 };
|
|
13029
13117
|
});
|
|
13030
13118
|
function Delete(state) {
|
|
@@ -13049,7 +13137,7 @@ ${input.slice(result.pos)}
|
|
|
13049
13137
|
return result;
|
|
13050
13138
|
}
|
|
13051
13139
|
}
|
|
13052
|
-
var Do$0 = $TS($S($EXPECT($
|
|
13140
|
+
var Do$0 = $TS($S($EXPECT($L111, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13053
13141
|
return { $loc, token: $1 };
|
|
13054
13142
|
});
|
|
13055
13143
|
function Do(state) {
|
|
@@ -13099,7 +13187,7 @@ ${input.slice(result.pos)}
|
|
|
13099
13187
|
return result;
|
|
13100
13188
|
}
|
|
13101
13189
|
}
|
|
13102
|
-
var DotDot$0 = $TV($EXPECT($
|
|
13190
|
+
var DotDot$0 = $TV($EXPECT($L112, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
13103
13191
|
return { $loc, token: $1 };
|
|
13104
13192
|
});
|
|
13105
13193
|
function DotDot(state) {
|
|
@@ -13124,7 +13212,7 @@ ${input.slice(result.pos)}
|
|
|
13124
13212
|
return result;
|
|
13125
13213
|
}
|
|
13126
13214
|
}
|
|
13127
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
13215
|
+
var DotDotDot$0 = $TV($EXPECT($L113, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
13128
13216
|
return { $loc, token: $1 };
|
|
13129
13217
|
});
|
|
13130
13218
|
function DotDotDot(state) {
|
|
@@ -13149,7 +13237,7 @@ ${input.slice(result.pos)}
|
|
|
13149
13237
|
return result;
|
|
13150
13238
|
}
|
|
13151
13239
|
}
|
|
13152
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
13240
|
+
var DoubleColon$0 = $TV($EXPECT($L114, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
13153
13241
|
return { $loc, token: $1 };
|
|
13154
13242
|
});
|
|
13155
13243
|
function DoubleColon(state) {
|
|
@@ -13174,7 +13262,7 @@ ${input.slice(result.pos)}
|
|
|
13174
13262
|
return result;
|
|
13175
13263
|
}
|
|
13176
13264
|
}
|
|
13177
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
13265
|
+
var DoubleQuote$0 = $TV($EXPECT($L115, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
13178
13266
|
return { $loc, token: $1 };
|
|
13179
13267
|
});
|
|
13180
13268
|
function DoubleQuote(state) {
|
|
@@ -13199,7 +13287,7 @@ ${input.slice(result.pos)}
|
|
|
13199
13287
|
return result;
|
|
13200
13288
|
}
|
|
13201
13289
|
}
|
|
13202
|
-
var Else$0 = $TS($S($EXPECT($
|
|
13290
|
+
var Else$0 = $TS($S($EXPECT($L116, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13203
13291
|
return { $loc, token: $1 };
|
|
13204
13292
|
});
|
|
13205
13293
|
function Else(state) {
|
|
@@ -13249,7 +13337,7 @@ ${input.slice(result.pos)}
|
|
|
13249
13337
|
return result;
|
|
13250
13338
|
}
|
|
13251
13339
|
}
|
|
13252
|
-
var Export$0 = $TS($S($EXPECT($
|
|
13340
|
+
var Export$0 = $TS($S($EXPECT($L117, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13253
13341
|
return { $loc, token: $1 };
|
|
13254
13342
|
});
|
|
13255
13343
|
function Export(state) {
|
|
@@ -13274,7 +13362,7 @@ ${input.slice(result.pos)}
|
|
|
13274
13362
|
return result;
|
|
13275
13363
|
}
|
|
13276
13364
|
}
|
|
13277
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
13365
|
+
var Extends$0 = $TS($S($EXPECT($L118, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13278
13366
|
return { $loc, token: $1 };
|
|
13279
13367
|
});
|
|
13280
13368
|
function Extends(state) {
|
|
@@ -13299,7 +13387,7 @@ ${input.slice(result.pos)}
|
|
|
13299
13387
|
return result;
|
|
13300
13388
|
}
|
|
13301
13389
|
}
|
|
13302
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
13390
|
+
var Finally$0 = $TS($S($EXPECT($L119, fail, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13303
13391
|
return { $loc, token: $1 };
|
|
13304
13392
|
});
|
|
13305
13393
|
function Finally(state) {
|
|
@@ -13324,7 +13412,7 @@ ${input.slice(result.pos)}
|
|
|
13324
13412
|
return result;
|
|
13325
13413
|
}
|
|
13326
13414
|
}
|
|
13327
|
-
var For$0 = $TS($S($EXPECT($
|
|
13415
|
+
var For$0 = $TS($S($EXPECT($L120, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13328
13416
|
return { $loc, token: $1 };
|
|
13329
13417
|
});
|
|
13330
13418
|
function For(state) {
|
|
@@ -13349,7 +13437,7 @@ ${input.slice(result.pos)}
|
|
|
13349
13437
|
return result;
|
|
13350
13438
|
}
|
|
13351
13439
|
}
|
|
13352
|
-
var From$0 = $TS($S($EXPECT($
|
|
13440
|
+
var From$0 = $TS($S($EXPECT($L121, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13353
13441
|
return { $loc, token: $1 };
|
|
13354
13442
|
});
|
|
13355
13443
|
function From(state) {
|
|
@@ -13374,7 +13462,7 @@ ${input.slice(result.pos)}
|
|
|
13374
13462
|
return result;
|
|
13375
13463
|
}
|
|
13376
13464
|
}
|
|
13377
|
-
var Function$0 = $TS($S($EXPECT($
|
|
13465
|
+
var Function$0 = $TS($S($EXPECT($L122, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13378
13466
|
return { $loc, token: $1 };
|
|
13379
13467
|
});
|
|
13380
13468
|
function Function(state) {
|
|
@@ -13399,7 +13487,7 @@ ${input.slice(result.pos)}
|
|
|
13399
13487
|
return result;
|
|
13400
13488
|
}
|
|
13401
13489
|
}
|
|
13402
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
13490
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L123, fail, 'GetOrSet "get"'), $EXPECT($L124, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13403
13491
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
13404
13492
|
});
|
|
13405
13493
|
function GetOrSet(state) {
|
|
@@ -13424,7 +13512,7 @@ ${input.slice(result.pos)}
|
|
|
13424
13512
|
return result;
|
|
13425
13513
|
}
|
|
13426
13514
|
}
|
|
13427
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
13515
|
+
var If$0 = $TV($TEXT($S($EXPECT($L125, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L8, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
13428
13516
|
return { $loc, token: $1 };
|
|
13429
13517
|
});
|
|
13430
13518
|
function If(state) {
|
|
@@ -13449,7 +13537,7 @@ ${input.slice(result.pos)}
|
|
|
13449
13537
|
return result;
|
|
13450
13538
|
}
|
|
13451
13539
|
}
|
|
13452
|
-
var Import$0 = $TS($S($EXPECT($L13, fail, 'Import "import"'), $Y($EXPECT($
|
|
13540
|
+
var Import$0 = $TS($S($EXPECT($L13, fail, 'Import "import"'), $Y($EXPECT($R48, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
13453
13541
|
return { $loc, token: $1 };
|
|
13454
13542
|
});
|
|
13455
13543
|
function Import(state) {
|
|
@@ -13474,7 +13562,7 @@ ${input.slice(result.pos)}
|
|
|
13474
13562
|
return result;
|
|
13475
13563
|
}
|
|
13476
13564
|
}
|
|
13477
|
-
var In$0 = $TS($S($EXPECT($
|
|
13565
|
+
var In$0 = $TS($S($EXPECT($L80, fail, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13478
13566
|
return { $loc, token: $1 };
|
|
13479
13567
|
});
|
|
13480
13568
|
function In(state) {
|
|
@@ -13499,7 +13587,7 @@ ${input.slice(result.pos)}
|
|
|
13499
13587
|
return result;
|
|
13500
13588
|
}
|
|
13501
13589
|
}
|
|
13502
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
13590
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L126, fail, 'LetOrConst "let"'), $EXPECT($L127, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13503
13591
|
return { $loc, token: $1 };
|
|
13504
13592
|
});
|
|
13505
13593
|
function LetOrConst(state) {
|
|
@@ -13524,7 +13612,7 @@ ${input.slice(result.pos)}
|
|
|
13524
13612
|
return result;
|
|
13525
13613
|
}
|
|
13526
13614
|
}
|
|
13527
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
13615
|
+
var Loop$0 = $TS($S($EXPECT($L128, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13528
13616
|
return { $loc, token: "while(true)" };
|
|
13529
13617
|
});
|
|
13530
13618
|
function Loop(state) {
|
|
@@ -13549,7 +13637,7 @@ ${input.slice(result.pos)}
|
|
|
13549
13637
|
return result;
|
|
13550
13638
|
}
|
|
13551
13639
|
}
|
|
13552
|
-
var New$0 = $TS($S($EXPECT($
|
|
13640
|
+
var New$0 = $TS($S($EXPECT($L129, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13553
13641
|
return { $loc, token: $1 };
|
|
13554
13642
|
});
|
|
13555
13643
|
function New(state) {
|
|
@@ -13574,7 +13662,7 @@ ${input.slice(result.pos)}
|
|
|
13574
13662
|
return result;
|
|
13575
13663
|
}
|
|
13576
13664
|
}
|
|
13577
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
13665
|
+
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) {
|
|
13578
13666
|
return { $loc, token: "!" };
|
|
13579
13667
|
});
|
|
13580
13668
|
function Not(state) {
|
|
@@ -13599,7 +13687,7 @@ ${input.slice(result.pos)}
|
|
|
13599
13687
|
return result;
|
|
13600
13688
|
}
|
|
13601
13689
|
}
|
|
13602
|
-
var Of$0 = $TS($S($EXPECT($
|
|
13690
|
+
var Of$0 = $TS($S($EXPECT($L72, fail, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13603
13691
|
return { $loc, token: $1 };
|
|
13604
13692
|
});
|
|
13605
13693
|
function Of(state) {
|
|
@@ -13624,7 +13712,7 @@ ${input.slice(result.pos)}
|
|
|
13624
13712
|
return result;
|
|
13625
13713
|
}
|
|
13626
13714
|
}
|
|
13627
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
13715
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L130, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
13628
13716
|
return { $loc, token: $1 };
|
|
13629
13717
|
});
|
|
13630
13718
|
function OpenAngleBracket(state) {
|
|
@@ -13649,7 +13737,7 @@ ${input.slice(result.pos)}
|
|
|
13649
13737
|
return result;
|
|
13650
13738
|
}
|
|
13651
13739
|
}
|
|
13652
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
13740
|
+
var OpenBrace$0 = $TV($EXPECT($L131, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
13653
13741
|
return { $loc, token: $1 };
|
|
13654
13742
|
});
|
|
13655
13743
|
function OpenBrace(state) {
|
|
@@ -13674,7 +13762,7 @@ ${input.slice(result.pos)}
|
|
|
13674
13762
|
return result;
|
|
13675
13763
|
}
|
|
13676
13764
|
}
|
|
13677
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
13765
|
+
var OpenBracket$0 = $TV($EXPECT($L95, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
13678
13766
|
return { $loc, token: $1 };
|
|
13679
13767
|
});
|
|
13680
13768
|
function OpenBracket(state) {
|
|
@@ -13724,7 +13812,7 @@ ${input.slice(result.pos)}
|
|
|
13724
13812
|
return result;
|
|
13725
13813
|
}
|
|
13726
13814
|
}
|
|
13727
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
13815
|
+
var Operator$0 = $TS($S($EXPECT($L132, fail, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13728
13816
|
return { $loc, token: $1 };
|
|
13729
13817
|
});
|
|
13730
13818
|
function Operator(state) {
|
|
@@ -13749,7 +13837,7 @@ ${input.slice(result.pos)}
|
|
|
13749
13837
|
return result;
|
|
13750
13838
|
}
|
|
13751
13839
|
}
|
|
13752
|
-
var Public$0 = $TS($S($EXPECT($
|
|
13840
|
+
var Public$0 = $TS($S($EXPECT($L133, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13753
13841
|
return { $loc, token: $1 };
|
|
13754
13842
|
});
|
|
13755
13843
|
function Public(state) {
|
|
@@ -13774,7 +13862,7 @@ ${input.slice(result.pos)}
|
|
|
13774
13862
|
return result;
|
|
13775
13863
|
}
|
|
13776
13864
|
}
|
|
13777
|
-
var Private$0 = $TS($S($EXPECT($
|
|
13865
|
+
var Private$0 = $TS($S($EXPECT($L134, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13778
13866
|
return { $loc, token: $1 };
|
|
13779
13867
|
});
|
|
13780
13868
|
function Private(state) {
|
|
@@ -13799,7 +13887,7 @@ ${input.slice(result.pos)}
|
|
|
13799
13887
|
return result;
|
|
13800
13888
|
}
|
|
13801
13889
|
}
|
|
13802
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
13890
|
+
var Protected$0 = $TS($S($EXPECT($L135, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13803
13891
|
return { $loc, token: $1 };
|
|
13804
13892
|
});
|
|
13805
13893
|
function Protected(state) {
|
|
@@ -13824,7 +13912,13 @@ ${input.slice(result.pos)}
|
|
|
13824
13912
|
return result;
|
|
13825
13913
|
}
|
|
13826
13914
|
}
|
|
13827
|
-
var Pipe$0 = $TV($EXPECT($
|
|
13915
|
+
var Pipe$0 = $TV($EXPECT($L136, fail, 'Pipe "||>"'), function($skip, $loc, $0, $1) {
|
|
13916
|
+
return { $loc, token: $1 };
|
|
13917
|
+
});
|
|
13918
|
+
var Pipe$1 = $TV($EXPECT($L137, fail, 'Pipe "|>="'), function($skip, $loc, $0, $1) {
|
|
13919
|
+
return { $loc, token: $1 };
|
|
13920
|
+
});
|
|
13921
|
+
var Pipe$2 = $TV($EXPECT($L138, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
13828
13922
|
return { $loc, token: $1 };
|
|
13829
13923
|
});
|
|
13830
13924
|
function Pipe(state) {
|
|
@@ -13838,12 +13932,12 @@ ${input.slice(result.pos)}
|
|
|
13838
13932
|
}
|
|
13839
13933
|
}
|
|
13840
13934
|
if (state.tokenize) {
|
|
13841
|
-
const result = $TOKEN("Pipe", state, Pipe$0(state));
|
|
13935
|
+
const result = $TOKEN("Pipe", state, Pipe$0(state) || Pipe$1(state) || Pipe$2(state));
|
|
13842
13936
|
if (state.events)
|
|
13843
13937
|
state.events.exit?.("Pipe", state, result, eventData);
|
|
13844
13938
|
return result;
|
|
13845
13939
|
} else {
|
|
13846
|
-
const result = Pipe$0(state);
|
|
13940
|
+
const result = Pipe$0(state) || Pipe$1(state) || Pipe$2(state);
|
|
13847
13941
|
if (state.events)
|
|
13848
13942
|
state.events.exit?.("Pipe", state, result, eventData);
|
|
13849
13943
|
return result;
|
|
@@ -13874,7 +13968,7 @@ ${input.slice(result.pos)}
|
|
|
13874
13968
|
return result;
|
|
13875
13969
|
}
|
|
13876
13970
|
}
|
|
13877
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
13971
|
+
var Readonly$0 = $TS($S($EXPECT($L139, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13878
13972
|
return { $loc, token: $1, ts: true };
|
|
13879
13973
|
});
|
|
13880
13974
|
function Readonly(state) {
|
|
@@ -13899,7 +13993,7 @@ ${input.slice(result.pos)}
|
|
|
13899
13993
|
return result;
|
|
13900
13994
|
}
|
|
13901
13995
|
}
|
|
13902
|
-
var Return$0 = $TS($S($EXPECT($
|
|
13996
|
+
var Return$0 = $TS($S($EXPECT($L140, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13903
13997
|
return { $loc, token: $1 };
|
|
13904
13998
|
});
|
|
13905
13999
|
function Return(state) {
|
|
@@ -13924,7 +14018,7 @@ ${input.slice(result.pos)}
|
|
|
13924
14018
|
return result;
|
|
13925
14019
|
}
|
|
13926
14020
|
}
|
|
13927
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
14021
|
+
var Satisfies$0 = $TS($S($EXPECT($L141, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13928
14022
|
return { $loc, token: $1 };
|
|
13929
14023
|
});
|
|
13930
14024
|
function Satisfies(state) {
|
|
@@ -13949,7 +14043,7 @@ ${input.slice(result.pos)}
|
|
|
13949
14043
|
return result;
|
|
13950
14044
|
}
|
|
13951
14045
|
}
|
|
13952
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
14046
|
+
var Semicolon$0 = $TV($EXPECT($L84, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
13953
14047
|
return { $loc, token: $1 };
|
|
13954
14048
|
});
|
|
13955
14049
|
function Semicolon(state) {
|
|
@@ -13974,7 +14068,7 @@ ${input.slice(result.pos)}
|
|
|
13974
14068
|
return result;
|
|
13975
14069
|
}
|
|
13976
14070
|
}
|
|
13977
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
14071
|
+
var SingleQuote$0 = $TV($EXPECT($L142, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
13978
14072
|
return { $loc, token: $1 };
|
|
13979
14073
|
});
|
|
13980
14074
|
function SingleQuote(state) {
|
|
@@ -13999,7 +14093,7 @@ ${input.slice(result.pos)}
|
|
|
13999
14093
|
return result;
|
|
14000
14094
|
}
|
|
14001
14095
|
}
|
|
14002
|
-
var Star$0 = $TV($EXPECT($
|
|
14096
|
+
var Star$0 = $TV($EXPECT($L53, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
14003
14097
|
return { $loc, token: $1 };
|
|
14004
14098
|
});
|
|
14005
14099
|
function Star(state) {
|
|
@@ -14024,10 +14118,10 @@ ${input.slice(result.pos)}
|
|
|
14024
14118
|
return result;
|
|
14025
14119
|
}
|
|
14026
14120
|
}
|
|
14027
|
-
var Static$0 = $TS($S($EXPECT($
|
|
14121
|
+
var Static$0 = $TS($S($EXPECT($L143, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14028
14122
|
return { $loc, token: $1 };
|
|
14029
14123
|
});
|
|
14030
|
-
var Static$1 = $TS($S($EXPECT($
|
|
14124
|
+
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) {
|
|
14031
14125
|
return { $loc, token: "static " };
|
|
14032
14126
|
});
|
|
14033
14127
|
function Static(state) {
|
|
@@ -14052,7 +14146,7 @@ ${input.slice(result.pos)}
|
|
|
14052
14146
|
return result;
|
|
14053
14147
|
}
|
|
14054
14148
|
}
|
|
14055
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
14149
|
+
var SubstitutionStart$0 = $TV($EXPECT($L144, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
14056
14150
|
return { $loc, token: $1 };
|
|
14057
14151
|
});
|
|
14058
14152
|
function SubstitutionStart(state) {
|
|
@@ -14077,7 +14171,7 @@ ${input.slice(result.pos)}
|
|
|
14077
14171
|
return result;
|
|
14078
14172
|
}
|
|
14079
14173
|
}
|
|
14080
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
14174
|
+
var Switch$0 = $TS($S($EXPECT($L145, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14081
14175
|
return { $loc, token: $1 };
|
|
14082
14176
|
});
|
|
14083
14177
|
function Switch(state) {
|
|
@@ -14102,7 +14196,7 @@ ${input.slice(result.pos)}
|
|
|
14102
14196
|
return result;
|
|
14103
14197
|
}
|
|
14104
14198
|
}
|
|
14105
|
-
var Target$0 = $TS($S($EXPECT($
|
|
14199
|
+
var Target$0 = $TS($S($EXPECT($L146, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14106
14200
|
return { $loc, token: $1 };
|
|
14107
14201
|
});
|
|
14108
14202
|
function Target(state) {
|
|
@@ -14127,7 +14221,7 @@ ${input.slice(result.pos)}
|
|
|
14127
14221
|
return result;
|
|
14128
14222
|
}
|
|
14129
14223
|
}
|
|
14130
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
14224
|
+
var Then$0 = $TS($S(__, $EXPECT($L147, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
14131
14225
|
return { $loc, token: "" };
|
|
14132
14226
|
});
|
|
14133
14227
|
function Then(state) {
|
|
@@ -14152,7 +14246,7 @@ ${input.slice(result.pos)}
|
|
|
14152
14246
|
return result;
|
|
14153
14247
|
}
|
|
14154
14248
|
}
|
|
14155
|
-
var This$0 = $TS($S($EXPECT($
|
|
14249
|
+
var This$0 = $TS($S($EXPECT($L148, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14156
14250
|
return { $loc, token: $1 };
|
|
14157
14251
|
});
|
|
14158
14252
|
function This(state) {
|
|
@@ -14177,7 +14271,7 @@ ${input.slice(result.pos)}
|
|
|
14177
14271
|
return result;
|
|
14178
14272
|
}
|
|
14179
14273
|
}
|
|
14180
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
14274
|
+
var Throw$0 = $TS($S($EXPECT($L149, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14181
14275
|
return { $loc, token: $1 };
|
|
14182
14276
|
});
|
|
14183
14277
|
function Throw(state) {
|
|
@@ -14202,7 +14296,7 @@ ${input.slice(result.pos)}
|
|
|
14202
14296
|
return result;
|
|
14203
14297
|
}
|
|
14204
14298
|
}
|
|
14205
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
14299
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L150, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
14206
14300
|
return { $loc, token: "`" };
|
|
14207
14301
|
});
|
|
14208
14302
|
function TripleDoubleQuote(state) {
|
|
@@ -14227,7 +14321,7 @@ ${input.slice(result.pos)}
|
|
|
14227
14321
|
return result;
|
|
14228
14322
|
}
|
|
14229
14323
|
}
|
|
14230
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
14324
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L151, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
14231
14325
|
return { $loc, token: "`" };
|
|
14232
14326
|
});
|
|
14233
14327
|
function TripleSingleQuote(state) {
|
|
@@ -14252,7 +14346,7 @@ ${input.slice(result.pos)}
|
|
|
14252
14346
|
return result;
|
|
14253
14347
|
}
|
|
14254
14348
|
}
|
|
14255
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
14349
|
+
var TripleSlash$0 = $TV($EXPECT($L152, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
14256
14350
|
return { $loc, token: "/" };
|
|
14257
14351
|
});
|
|
14258
14352
|
function TripleSlash(state) {
|
|
@@ -14277,7 +14371,7 @@ ${input.slice(result.pos)}
|
|
|
14277
14371
|
return result;
|
|
14278
14372
|
}
|
|
14279
14373
|
}
|
|
14280
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
14374
|
+
var TripleTick$0 = $TV($EXPECT($L153, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
14281
14375
|
return { $loc, token: "`" };
|
|
14282
14376
|
});
|
|
14283
14377
|
function TripleTick(state) {
|
|
@@ -14302,7 +14396,7 @@ ${input.slice(result.pos)}
|
|
|
14302
14396
|
return result;
|
|
14303
14397
|
}
|
|
14304
14398
|
}
|
|
14305
|
-
var Try$0 = $TS($S($EXPECT($
|
|
14399
|
+
var Try$0 = $TS($S($EXPECT($L154, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14306
14400
|
return { $loc, token: $1 };
|
|
14307
14401
|
});
|
|
14308
14402
|
function Try(state) {
|
|
@@ -14327,7 +14421,7 @@ ${input.slice(result.pos)}
|
|
|
14327
14421
|
return result;
|
|
14328
14422
|
}
|
|
14329
14423
|
}
|
|
14330
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
14424
|
+
var Typeof$0 = $TS($S($EXPECT($L155, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14331
14425
|
return { $loc, token: $1 };
|
|
14332
14426
|
});
|
|
14333
14427
|
function Typeof(state) {
|
|
@@ -14352,7 +14446,7 @@ ${input.slice(result.pos)}
|
|
|
14352
14446
|
return result;
|
|
14353
14447
|
}
|
|
14354
14448
|
}
|
|
14355
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
14449
|
+
var Unless$0 = $TS($S($EXPECT($L156, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14356
14450
|
return { $loc, token: $1 };
|
|
14357
14451
|
});
|
|
14358
14452
|
function Unless(state) {
|
|
@@ -14377,7 +14471,7 @@ ${input.slice(result.pos)}
|
|
|
14377
14471
|
return result;
|
|
14378
14472
|
}
|
|
14379
14473
|
}
|
|
14380
|
-
var Until$0 = $TS($S($EXPECT($
|
|
14474
|
+
var Until$0 = $TS($S($EXPECT($L157, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14381
14475
|
return { $loc, token: $1 };
|
|
14382
14476
|
});
|
|
14383
14477
|
function Until(state) {
|
|
@@ -14402,7 +14496,7 @@ ${input.slice(result.pos)}
|
|
|
14402
14496
|
return result;
|
|
14403
14497
|
}
|
|
14404
14498
|
}
|
|
14405
|
-
var Var$0 = $TS($S($EXPECT($
|
|
14499
|
+
var Var$0 = $TS($S($EXPECT($L158, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14406
14500
|
return { $loc, token: $1 };
|
|
14407
14501
|
});
|
|
14408
14502
|
function Var(state) {
|
|
@@ -14427,7 +14521,7 @@ ${input.slice(result.pos)}
|
|
|
14427
14521
|
return result;
|
|
14428
14522
|
}
|
|
14429
14523
|
}
|
|
14430
|
-
var Void$0 = $TS($S($EXPECT($
|
|
14524
|
+
var Void$0 = $TS($S($EXPECT($L159, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14431
14525
|
return { $loc, token: $1 };
|
|
14432
14526
|
});
|
|
14433
14527
|
function Void(state) {
|
|
@@ -14452,7 +14546,7 @@ ${input.slice(result.pos)}
|
|
|
14452
14546
|
return result;
|
|
14453
14547
|
}
|
|
14454
14548
|
}
|
|
14455
|
-
var When$0 = $TS($S($EXPECT($
|
|
14549
|
+
var When$0 = $TS($S($EXPECT($L160, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14456
14550
|
return { $loc, token: "case" };
|
|
14457
14551
|
});
|
|
14458
14552
|
function When(state) {
|
|
@@ -14477,7 +14571,7 @@ ${input.slice(result.pos)}
|
|
|
14477
14571
|
return result;
|
|
14478
14572
|
}
|
|
14479
14573
|
}
|
|
14480
|
-
var While$0 = $TS($S($EXPECT($
|
|
14574
|
+
var While$0 = $TS($S($EXPECT($L161, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14481
14575
|
return { $loc, token: $1 };
|
|
14482
14576
|
});
|
|
14483
14577
|
function While(state) {
|
|
@@ -14502,7 +14596,7 @@ ${input.slice(result.pos)}
|
|
|
14502
14596
|
return result;
|
|
14503
14597
|
}
|
|
14504
14598
|
}
|
|
14505
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
14599
|
+
var Yield$0 = $TS($S($EXPECT($L162, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14506
14600
|
return { $loc, token: $1 };
|
|
14507
14601
|
});
|
|
14508
14602
|
function Yield(state) {
|
|
@@ -14648,7 +14742,7 @@ ${input.slice(result.pos)}
|
|
|
14648
14742
|
return result;
|
|
14649
14743
|
}
|
|
14650
14744
|
}
|
|
14651
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
14745
|
+
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) {
|
|
14652
14746
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
14653
14747
|
});
|
|
14654
14748
|
function JSXSelfClosingElement(state) {
|
|
@@ -14699,7 +14793,7 @@ ${input.slice(result.pos)}
|
|
|
14699
14793
|
return result;
|
|
14700
14794
|
}
|
|
14701
14795
|
}
|
|
14702
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
14796
|
+
var JSXOpeningElement$0 = $S($EXPECT($L130, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L30, fail, 'JSXOpeningElement ">"'));
|
|
14703
14797
|
function JSXOpeningElement(state) {
|
|
14704
14798
|
let eventData;
|
|
14705
14799
|
if (state.events) {
|
|
@@ -14728,7 +14822,7 @@ ${input.slice(result.pos)}
|
|
|
14728
14822
|
return $skip;
|
|
14729
14823
|
return $0;
|
|
14730
14824
|
});
|
|
14731
|
-
var JSXOptionalClosingElement$1 = $EXPECT($
|
|
14825
|
+
var JSXOptionalClosingElement$1 = $EXPECT($L18, fail, 'JSXOptionalClosingElement ""');
|
|
14732
14826
|
function JSXOptionalClosingElement(state) {
|
|
14733
14827
|
let eventData;
|
|
14734
14828
|
if (state.events) {
|
|
@@ -14751,7 +14845,7 @@ ${input.slice(result.pos)}
|
|
|
14751
14845
|
return result;
|
|
14752
14846
|
}
|
|
14753
14847
|
}
|
|
14754
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
14848
|
+
var JSXClosingElement$0 = $S($EXPECT($L164, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L30, fail, 'JSXClosingElement ">"'));
|
|
14755
14849
|
function JSXClosingElement(state) {
|
|
14756
14850
|
let eventData;
|
|
14757
14851
|
if (state.events) {
|
|
@@ -14790,7 +14884,7 @@ ${input.slice(result.pos)}
|
|
|
14790
14884
|
];
|
|
14791
14885
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
14792
14886
|
});
|
|
14793
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
14887
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L165, fail, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
14794
14888
|
var children = $3;
|
|
14795
14889
|
$0 = $0.slice(1);
|
|
14796
14890
|
return {
|
|
@@ -14821,7 +14915,7 @@ ${input.slice(result.pos)}
|
|
|
14821
14915
|
return result;
|
|
14822
14916
|
}
|
|
14823
14917
|
}
|
|
14824
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
14918
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L165, fail, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
14825
14919
|
module.JSXTagStack.push("");
|
|
14826
14920
|
return $1;
|
|
14827
14921
|
});
|
|
@@ -14852,7 +14946,7 @@ ${input.slice(result.pos)}
|
|
|
14852
14946
|
return $skip;
|
|
14853
14947
|
return $0;
|
|
14854
14948
|
});
|
|
14855
|
-
var JSXOptionalClosingFragment$1 = $EXPECT($
|
|
14949
|
+
var JSXOptionalClosingFragment$1 = $EXPECT($L18, fail, 'JSXOptionalClosingFragment ""');
|
|
14856
14950
|
function JSXOptionalClosingFragment(state) {
|
|
14857
14951
|
let eventData;
|
|
14858
14952
|
if (state.events) {
|
|
@@ -14875,7 +14969,7 @@ ${input.slice(result.pos)}
|
|
|
14875
14969
|
return result;
|
|
14876
14970
|
}
|
|
14877
14971
|
}
|
|
14878
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
14972
|
+
var JSXClosingFragment$0 = $EXPECT($L166, fail, 'JSXClosingFragment "</>"');
|
|
14879
14973
|
function JSXClosingFragment(state) {
|
|
14880
14974
|
let eventData;
|
|
14881
14975
|
if (state.events) {
|
|
@@ -14921,7 +15015,7 @@ ${input.slice(result.pos)}
|
|
|
14921
15015
|
return result;
|
|
14922
15016
|
}
|
|
14923
15017
|
}
|
|
14924
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
15018
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R49, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
14925
15019
|
function JSXIdentifierName(state) {
|
|
14926
15020
|
let eventData;
|
|
14927
15021
|
if (state.events) {
|
|
@@ -15137,7 +15231,7 @@ ${input.slice(result.pos)}
|
|
|
15137
15231
|
return result;
|
|
15138
15232
|
}
|
|
15139
15233
|
}
|
|
15140
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
15234
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R50, fail, "JSXAttributeSpace /[\\s>]/"));
|
|
15141
15235
|
function JSXAttributeSpace(state) {
|
|
15142
15236
|
let eventData;
|
|
15143
15237
|
if (state.events) {
|
|
@@ -15160,7 +15254,7 @@ ${input.slice(result.pos)}
|
|
|
15160
15254
|
return result;
|
|
15161
15255
|
}
|
|
15162
15256
|
}
|
|
15163
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
15257
|
+
var JSXShorthandString$0 = $TR($EXPECT($R51, fail, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15164
15258
|
return module.quoteString($0);
|
|
15165
15259
|
});
|
|
15166
15260
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -15296,7 +15390,7 @@ ${input.slice(result.pos)}
|
|
|
15296
15390
|
return result;
|
|
15297
15391
|
}
|
|
15298
15392
|
}
|
|
15299
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
15393
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R52, fail, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
15300
15394
|
var op = $2;
|
|
15301
15395
|
var rhs = $3;
|
|
15302
15396
|
return [[], op, [], rhs];
|
|
@@ -15351,7 +15445,7 @@ ${input.slice(result.pos)}
|
|
|
15351
15445
|
return result;
|
|
15352
15446
|
}
|
|
15353
15447
|
}
|
|
15354
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
15448
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R8, fail, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15355
15449
|
return { $loc, token: $0 };
|
|
15356
15450
|
});
|
|
15357
15451
|
function InlineJSXUnaryOp(state) {
|
|
@@ -15642,7 +15736,7 @@ ${input.slice(result.pos)}
|
|
|
15642
15736
|
}
|
|
15643
15737
|
return $skip;
|
|
15644
15738
|
});
|
|
15645
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
15739
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L22, fail, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
15646
15740
|
return { children: [], jsxChildren: [] };
|
|
15647
15741
|
});
|
|
15648
15742
|
function JSXNestedChildren(state) {
|
|
@@ -15771,7 +15865,7 @@ ${input.slice(result.pos)}
|
|
|
15771
15865
|
return result;
|
|
15772
15866
|
}
|
|
15773
15867
|
}
|
|
15774
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
15868
|
+
var JSXComment$0 = $TS($S($EXPECT($L167, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L168, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
15775
15869
|
return ["{/*", $2, "*/}"];
|
|
15776
15870
|
});
|
|
15777
15871
|
function JSXComment(state) {
|
|
@@ -15796,7 +15890,7 @@ ${input.slice(result.pos)}
|
|
|
15796
15890
|
return result;
|
|
15797
15891
|
}
|
|
15798
15892
|
}
|
|
15799
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
15893
|
+
var JSXCommentContent$0 = $TR($EXPECT($R53, fail, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15800
15894
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
15801
15895
|
});
|
|
15802
15896
|
function JSXCommentContent(state) {
|
|
@@ -15821,7 +15915,7 @@ ${input.slice(result.pos)}
|
|
|
15821
15915
|
return result;
|
|
15822
15916
|
}
|
|
15823
15917
|
}
|
|
15824
|
-
var JSXText$0 = $TR($EXPECT($
|
|
15918
|
+
var JSXText$0 = $TR($EXPECT($R54, fail, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
15825
15919
|
return {
|
|
15826
15920
|
type: "JSXText",
|
|
15827
15921
|
token: $0,
|
|
@@ -16069,7 +16163,7 @@ ${input.slice(result.pos)}
|
|
|
16069
16163
|
return result;
|
|
16070
16164
|
}
|
|
16071
16165
|
}
|
|
16072
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
16166
|
+
var TypeKeyword$0 = $S($EXPECT($L169, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
16073
16167
|
function TypeKeyword(state) {
|
|
16074
16168
|
let eventData;
|
|
16075
16169
|
if (state.events) {
|
|
@@ -16092,7 +16186,7 @@ ${input.slice(result.pos)}
|
|
|
16092
16186
|
return result;
|
|
16093
16187
|
}
|
|
16094
16188
|
}
|
|
16095
|
-
var Interface$0 = $S($EXPECT($
|
|
16189
|
+
var Interface$0 = $S($EXPECT($L170, fail, 'Interface "interface"'), NonIdContinue);
|
|
16096
16190
|
function Interface(state) {
|
|
16097
16191
|
let eventData;
|
|
16098
16192
|
if (state.events) {
|
|
@@ -16115,7 +16209,7 @@ ${input.slice(result.pos)}
|
|
|
16115
16209
|
return result;
|
|
16116
16210
|
}
|
|
16117
16211
|
}
|
|
16118
|
-
var Namespace$0 = $S($EXPECT($
|
|
16212
|
+
var Namespace$0 = $S($EXPECT($L171, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
16119
16213
|
function Namespace(state) {
|
|
16120
16214
|
let eventData;
|
|
16121
16215
|
if (state.events) {
|
|
@@ -16363,7 +16457,7 @@ ${input.slice(result.pos)}
|
|
|
16363
16457
|
return result;
|
|
16364
16458
|
}
|
|
16365
16459
|
}
|
|
16366
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
16460
|
+
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)));
|
|
16367
16461
|
function TypeIndexSignature(state) {
|
|
16368
16462
|
let eventData;
|
|
16369
16463
|
if (state.events) {
|
|
@@ -16435,7 +16529,7 @@ ${input.slice(result.pos)}
|
|
|
16435
16529
|
return result;
|
|
16436
16530
|
}
|
|
16437
16531
|
}
|
|
16438
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
16532
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L172, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
16439
16533
|
const children = [...$1, $2];
|
|
16440
16534
|
if ($3)
|
|
16441
16535
|
children.push($3);
|
|
@@ -16468,7 +16562,7 @@ ${input.slice(result.pos)}
|
|
|
16468
16562
|
return result;
|
|
16469
16563
|
}
|
|
16470
16564
|
}
|
|
16471
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
16565
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L81, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
16472
16566
|
if (!$2)
|
|
16473
16567
|
return $1;
|
|
16474
16568
|
return $0;
|
|
@@ -16594,10 +16688,10 @@ ${input.slice(result.pos)}
|
|
|
16594
16688
|
return result;
|
|
16595
16689
|
}
|
|
16596
16690
|
}
|
|
16597
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
16598
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
16599
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
16600
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
16691
|
+
var TypeUnaryOp$0 = $S($EXPECT($L173, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
16692
|
+
var TypeUnaryOp$1 = $S($EXPECT($L155, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
16693
|
+
var TypeUnaryOp$2 = $S($EXPECT($L174, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
16694
|
+
var TypeUnaryOp$3 = $S($EXPECT($L139, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
16601
16695
|
function TypeUnaryOp(state) {
|
|
16602
16696
|
let eventData;
|
|
16603
16697
|
if (state.events) {
|
|
@@ -16795,7 +16889,7 @@ ${input.slice(result.pos)}
|
|
|
16795
16889
|
return result;
|
|
16796
16890
|
}
|
|
16797
16891
|
}
|
|
16798
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
16892
|
+
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) {
|
|
16799
16893
|
if ($2)
|
|
16800
16894
|
return $0;
|
|
16801
16895
|
return $1;
|
|
@@ -16824,10 +16918,10 @@ ${input.slice(result.pos)}
|
|
|
16824
16918
|
}
|
|
16825
16919
|
var TypeLiteral$0 = TemplateLiteral;
|
|
16826
16920
|
var TypeLiteral$1 = Literal;
|
|
16827
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
16921
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L159, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
16828
16922
|
return { $loc, token: "void" };
|
|
16829
16923
|
});
|
|
16830
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
16924
|
+
var TypeLiteral$3 = $TV($EXPECT($L175, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
16831
16925
|
return { $loc, token: "[]" };
|
|
16832
16926
|
});
|
|
16833
16927
|
function TypeLiteral(state) {
|
|
@@ -16902,7 +16996,7 @@ ${input.slice(result.pos)}
|
|
|
16902
16996
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
16903
16997
|
return value[1];
|
|
16904
16998
|
});
|
|
16905
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
16999
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L32, fail, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L19, fail, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L31, fail, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L22, fail, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
16906
17000
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
16907
17001
|
function InlineInterfacePropertyDelimiter(state) {
|
|
16908
17002
|
let eventData;
|
|
@@ -16926,10 +17020,10 @@ ${input.slice(result.pos)}
|
|
|
16926
17020
|
return result;
|
|
16927
17021
|
}
|
|
16928
17022
|
}
|
|
16929
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
17023
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L83, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
16930
17024
|
return { $loc, token: "|" };
|
|
16931
17025
|
});
|
|
16932
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
17026
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L82, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
16933
17027
|
return { $loc, token: "&" };
|
|
16934
17028
|
});
|
|
16935
17029
|
function TypeBinaryOp(state) {
|
|
@@ -16986,7 +17080,7 @@ ${input.slice(result.pos)}
|
|
|
16986
17080
|
var TypeArrowFunction$0 = $TV($EXPECT($L7, fail, 'TypeArrowFunction "=>"'), function($skip, $loc, $0, $1) {
|
|
16987
17081
|
return { $loc, token: "=>" };
|
|
16988
17082
|
});
|
|
16989
|
-
var TypeArrowFunction$1 = $TV($EXPECT($
|
|
17083
|
+
var TypeArrowFunction$1 = $TV($EXPECT($L21, fail, 'TypeArrowFunction "->"'), function($skip, $loc, $0, $1) {
|
|
16990
17084
|
return { $loc, token: "=>" };
|
|
16991
17085
|
});
|
|
16992
17086
|
function TypeArrowFunction(state) {
|
|
@@ -17011,7 +17105,7 @@ ${input.slice(result.pos)}
|
|
|
17011
17105
|
return result;
|
|
17012
17106
|
}
|
|
17013
17107
|
}
|
|
17014
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
17108
|
+
var TypeArguments$0 = $TS($S($EXPECT($L130, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L30, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
17015
17109
|
return { ts: true, children: $0 };
|
|
17016
17110
|
});
|
|
17017
17111
|
function TypeArguments(state) {
|
|
@@ -17082,7 +17176,7 @@ ${input.slice(result.pos)}
|
|
|
17082
17176
|
return result;
|
|
17083
17177
|
}
|
|
17084
17178
|
}
|
|
17085
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
17179
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L130, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L30, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
17086
17180
|
var parameters = $3;
|
|
17087
17181
|
return {
|
|
17088
17182
|
type: "TypeParameters",
|
|
@@ -17136,7 +17230,7 @@ ${input.slice(result.pos)}
|
|
|
17136
17230
|
return result;
|
|
17137
17231
|
}
|
|
17138
17232
|
}
|
|
17139
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
17233
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L118, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
17140
17234
|
function TypeConstraint(state) {
|
|
17141
17235
|
let eventData;
|
|
17142
17236
|
if (state.events) {
|
|
@@ -17183,7 +17277,7 @@ ${input.slice(result.pos)}
|
|
|
17183
17277
|
}
|
|
17184
17278
|
}
|
|
17185
17279
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
17186
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
17280
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L30, fail, 'TypeParameterDelimiter ">"')));
|
|
17187
17281
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
17188
17282
|
return value[1];
|
|
17189
17283
|
});
|
|
@@ -17234,7 +17328,7 @@ ${input.slice(result.pos)}
|
|
|
17234
17328
|
return result;
|
|
17235
17329
|
}
|
|
17236
17330
|
}
|
|
17237
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
17331
|
+
var Shebang$0 = $S($R$0($EXPECT($R57, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
17238
17332
|
function Shebang(state) {
|
|
17239
17333
|
let eventData;
|
|
17240
17334
|
if (state.events) {
|
|
@@ -17257,11 +17351,11 @@ ${input.slice(result.pos)}
|
|
|
17257
17351
|
return result;
|
|
17258
17352
|
}
|
|
17259
17353
|
}
|
|
17260
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
17354
|
+
var CivetPrologue$0 = $T($S($EXPECT($R58, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
|
|
17261
17355
|
var content = value[2];
|
|
17262
17356
|
return content;
|
|
17263
17357
|
});
|
|
17264
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
17358
|
+
var CivetPrologue$1 = $T($S($EXPECT($R58, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(SimpleStatementDelimiter), $E(EOS)), function(value) {
|
|
17265
17359
|
var content = value[2];
|
|
17266
17360
|
return content;
|
|
17267
17361
|
});
|
|
@@ -17287,7 +17381,7 @@ ${input.slice(result.pos)}
|
|
|
17287
17381
|
return result;
|
|
17288
17382
|
}
|
|
17289
17383
|
}
|
|
17290
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
17384
|
+
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) {
|
|
17291
17385
|
var options = $3;
|
|
17292
17386
|
return {
|
|
17293
17387
|
type: "CivetPrologue",
|
|
@@ -17317,7 +17411,7 @@ ${input.slice(result.pos)}
|
|
|
17317
17411
|
return result;
|
|
17318
17412
|
}
|
|
17319
17413
|
}
|
|
17320
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
17414
|
+
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) {
|
|
17321
17415
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
17322
17416
|
if (l)
|
|
17323
17417
|
return l.toUpperCase();
|
|
@@ -17353,7 +17447,7 @@ ${input.slice(result.pos)}
|
|
|
17353
17447
|
return result;
|
|
17354
17448
|
}
|
|
17355
17449
|
}
|
|
17356
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
17450
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R58, fail, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
17357
17451
|
function UnknownPrologue(state) {
|
|
17358
17452
|
let eventData;
|
|
17359
17453
|
if (state.events) {
|
|
@@ -17423,7 +17517,7 @@ ${input.slice(result.pos)}
|
|
|
17423
17517
|
return result;
|
|
17424
17518
|
}
|
|
17425
17519
|
}
|
|
17426
|
-
var EOL$0 = $TR($EXPECT($
|
|
17520
|
+
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) {
|
|
17427
17521
|
return { $loc, token: $0 };
|
|
17428
17522
|
});
|
|
17429
17523
|
function EOL(state) {
|
|
@@ -17448,7 +17542,7 @@ ${input.slice(result.pos)}
|
|
|
17448
17542
|
return result;
|
|
17449
17543
|
}
|
|
17450
17544
|
}
|
|
17451
|
-
var Debugger$0 = $TV($EXPECT($
|
|
17545
|
+
var Debugger$0 = $TV($EXPECT($L18, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
17452
17546
|
debugger;
|
|
17453
17547
|
});
|
|
17454
17548
|
function Debugger(state) {
|
|
@@ -17473,7 +17567,7 @@ ${input.slice(result.pos)}
|
|
|
17473
17567
|
return result;
|
|
17474
17568
|
}
|
|
17475
17569
|
}
|
|
17476
|
-
var InsertSemicolon$0 = $TV($EXPECT($
|
|
17570
|
+
var InsertSemicolon$0 = $TV($EXPECT($L18, fail, 'InsertSemicolon ""'), function($skip, $loc, $0, $1) {
|
|
17477
17571
|
return { $loc, token: ";" };
|
|
17478
17572
|
});
|
|
17479
17573
|
function InsertSemicolon(state) {
|
|
@@ -17498,7 +17592,7 @@ ${input.slice(result.pos)}
|
|
|
17498
17592
|
return result;
|
|
17499
17593
|
}
|
|
17500
17594
|
}
|
|
17501
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
17595
|
+
var InsertOpenParen$0 = $TV($EXPECT($L18, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
17502
17596
|
return { $loc, token: "(" };
|
|
17503
17597
|
});
|
|
17504
17598
|
function InsertOpenParen(state) {
|
|
@@ -17523,7 +17617,7 @@ ${input.slice(result.pos)}
|
|
|
17523
17617
|
return result;
|
|
17524
17618
|
}
|
|
17525
17619
|
}
|
|
17526
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
17620
|
+
var InsertCloseParen$0 = $TV($EXPECT($L18, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
17527
17621
|
return { $loc, token: ")" };
|
|
17528
17622
|
});
|
|
17529
17623
|
function InsertCloseParen(state) {
|
|
@@ -17548,7 +17642,7 @@ ${input.slice(result.pos)}
|
|
|
17548
17642
|
return result;
|
|
17549
17643
|
}
|
|
17550
17644
|
}
|
|
17551
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
17645
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L18, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
17552
17646
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
17553
17647
|
});
|
|
17554
17648
|
function InsertOpenBrace(state) {
|
|
@@ -17573,7 +17667,7 @@ ${input.slice(result.pos)}
|
|
|
17573
17667
|
return result;
|
|
17574
17668
|
}
|
|
17575
17669
|
}
|
|
17576
|
-
var InsertInlineOpenBrace$0 = $TV($EXPECT($
|
|
17670
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L18, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
17577
17671
|
return { $loc, token: "{" };
|
|
17578
17672
|
});
|
|
17579
17673
|
function InsertInlineOpenBrace(state) {
|
|
@@ -17598,7 +17692,7 @@ ${input.slice(result.pos)}
|
|
|
17598
17692
|
return result;
|
|
17599
17693
|
}
|
|
17600
17694
|
}
|
|
17601
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
17695
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L18, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
17602
17696
|
return { $loc, token: "}" };
|
|
17603
17697
|
});
|
|
17604
17698
|
function InsertCloseBrace(state) {
|
|
@@ -17623,7 +17717,7 @@ ${input.slice(result.pos)}
|
|
|
17623
17717
|
return result;
|
|
17624
17718
|
}
|
|
17625
17719
|
}
|
|
17626
|
-
var InsertOpenBracket$0 = $TV($EXPECT($
|
|
17720
|
+
var InsertOpenBracket$0 = $TV($EXPECT($L18, fail, 'InsertOpenBracket ""'), function($skip, $loc, $0, $1) {
|
|
17627
17721
|
return { $loc, token: "[" };
|
|
17628
17722
|
});
|
|
17629
17723
|
function InsertOpenBracket(state) {
|
|
@@ -17648,7 +17742,7 @@ ${input.slice(result.pos)}
|
|
|
17648
17742
|
return result;
|
|
17649
17743
|
}
|
|
17650
17744
|
}
|
|
17651
|
-
var InsertCloseBracket$0 = $TV($EXPECT($
|
|
17745
|
+
var InsertCloseBracket$0 = $TV($EXPECT($L18, fail, 'InsertCloseBracket ""'), function($skip, $loc, $0, $1) {
|
|
17652
17746
|
return { $loc, token: "]" };
|
|
17653
17747
|
});
|
|
17654
17748
|
function InsertCloseBracket(state) {
|
|
@@ -17673,7 +17767,7 @@ ${input.slice(result.pos)}
|
|
|
17673
17767
|
return result;
|
|
17674
17768
|
}
|
|
17675
17769
|
}
|
|
17676
|
-
var InsertComma$0 = $TV($EXPECT($
|
|
17770
|
+
var InsertComma$0 = $TV($EXPECT($L18, fail, 'InsertComma ""'), function($skip, $loc, $0, $1) {
|
|
17677
17771
|
return { $loc, token: "," };
|
|
17678
17772
|
});
|
|
17679
17773
|
function InsertComma(state) {
|
|
@@ -17698,7 +17792,7 @@ ${input.slice(result.pos)}
|
|
|
17698
17792
|
return result;
|
|
17699
17793
|
}
|
|
17700
17794
|
}
|
|
17701
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
17795
|
+
var InsertConst$0 = $TV($EXPECT($L18, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
17702
17796
|
return { $loc, token: "const " };
|
|
17703
17797
|
});
|
|
17704
17798
|
function InsertConst(state) {
|
|
@@ -17723,7 +17817,7 @@ ${input.slice(result.pos)}
|
|
|
17723
17817
|
return result;
|
|
17724
17818
|
}
|
|
17725
17819
|
}
|
|
17726
|
-
var InsertLet$0 = $TV($EXPECT($
|
|
17820
|
+
var InsertLet$0 = $TV($EXPECT($L18, fail, 'InsertLet ""'), function($skip, $loc, $0, $1) {
|
|
17727
17821
|
return { $loc, token: "let " };
|
|
17728
17822
|
});
|
|
17729
17823
|
function InsertLet(state) {
|
|
@@ -17748,7 +17842,7 @@ ${input.slice(result.pos)}
|
|
|
17748
17842
|
return result;
|
|
17749
17843
|
}
|
|
17750
17844
|
}
|
|
17751
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
17845
|
+
var InsertReadonly$0 = $TV($EXPECT($L18, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
17752
17846
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
17753
17847
|
});
|
|
17754
17848
|
function InsertReadonly(state) {
|
|
@@ -17773,7 +17867,7 @@ ${input.slice(result.pos)}
|
|
|
17773
17867
|
return result;
|
|
17774
17868
|
}
|
|
17775
17869
|
}
|
|
17776
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
17870
|
+
var InsertNewline$0 = $TV($EXPECT($L18, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
17777
17871
|
return "\n";
|
|
17778
17872
|
});
|
|
17779
17873
|
function InsertNewline(state) {
|
|
@@ -17798,7 +17892,7 @@ ${input.slice(result.pos)}
|
|
|
17798
17892
|
return result;
|
|
17799
17893
|
}
|
|
17800
17894
|
}
|
|
17801
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
17895
|
+
var InsertIndent$0 = $TV($EXPECT($L18, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
17802
17896
|
return module.currentIndent.token;
|
|
17803
17897
|
});
|
|
17804
17898
|
function InsertIndent(state) {
|
|
@@ -17823,7 +17917,7 @@ ${input.slice(result.pos)}
|
|
|
17823
17917
|
return result;
|
|
17824
17918
|
}
|
|
17825
17919
|
}
|
|
17826
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
17920
|
+
var InsertSpace$0 = $TV($EXPECT($L18, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
17827
17921
|
return { $loc, token: " " };
|
|
17828
17922
|
});
|
|
17829
17923
|
function InsertSpace(state) {
|
|
@@ -17848,7 +17942,7 @@ ${input.slice(result.pos)}
|
|
|
17848
17942
|
return result;
|
|
17849
17943
|
}
|
|
17850
17944
|
}
|
|
17851
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
17945
|
+
var InsertDot$0 = $TV($EXPECT($L18, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
17852
17946
|
return { $loc, token: "." };
|
|
17853
17947
|
});
|
|
17854
17948
|
function InsertDot(state) {
|
|
@@ -17873,7 +17967,7 @@ ${input.slice(result.pos)}
|
|
|
17873
17967
|
return result;
|
|
17874
17968
|
}
|
|
17875
17969
|
}
|
|
17876
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
17970
|
+
var InsertBreak$0 = $TV($EXPECT($L18, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
17877
17971
|
return { $loc, token: ";break;" };
|
|
17878
17972
|
});
|
|
17879
17973
|
function InsertBreak(state) {
|
|
@@ -17898,7 +17992,7 @@ ${input.slice(result.pos)}
|
|
|
17898
17992
|
return result;
|
|
17899
17993
|
}
|
|
17900
17994
|
}
|
|
17901
|
-
var InsertVar$0 = $TV($EXPECT($
|
|
17995
|
+
var InsertVar$0 = $TV($EXPECT($L18, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
17902
17996
|
return { $loc, token: "var " };
|
|
17903
17997
|
});
|
|
17904
17998
|
function InsertVar(state) {
|
|
@@ -17923,7 +18017,7 @@ ${input.slice(result.pos)}
|
|
|
17923
18017
|
return result;
|
|
17924
18018
|
}
|
|
17925
18019
|
}
|
|
17926
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
18020
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
17927
18021
|
if (module.config.coffeeBinaryExistential)
|
|
17928
18022
|
return;
|
|
17929
18023
|
return $skip;
|
|
@@ -17950,7 +18044,7 @@ ${input.slice(result.pos)}
|
|
|
17950
18044
|
return result;
|
|
17951
18045
|
}
|
|
17952
18046
|
}
|
|
17953
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
18047
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
17954
18048
|
if (module.config.coffeeBooleans)
|
|
17955
18049
|
return;
|
|
17956
18050
|
return $skip;
|
|
@@ -17977,7 +18071,7 @@ ${input.slice(result.pos)}
|
|
|
17977
18071
|
return result;
|
|
17978
18072
|
}
|
|
17979
18073
|
}
|
|
17980
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
18074
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
17981
18075
|
if (module.config.coffeeClasses)
|
|
17982
18076
|
return;
|
|
17983
18077
|
return $skip;
|
|
@@ -18004,7 +18098,7 @@ ${input.slice(result.pos)}
|
|
|
18004
18098
|
return result;
|
|
18005
18099
|
}
|
|
18006
18100
|
}
|
|
18007
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
18101
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18008
18102
|
if (module.config.coffeeComment)
|
|
18009
18103
|
return;
|
|
18010
18104
|
return $skip;
|
|
@@ -18031,7 +18125,7 @@ ${input.slice(result.pos)}
|
|
|
18031
18125
|
return result;
|
|
18032
18126
|
}
|
|
18033
18127
|
}
|
|
18034
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
18128
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18035
18129
|
if (module.config.coffeeDo)
|
|
18036
18130
|
return;
|
|
18037
18131
|
return $skip;
|
|
@@ -18058,7 +18152,7 @@ ${input.slice(result.pos)}
|
|
|
18058
18152
|
return result;
|
|
18059
18153
|
}
|
|
18060
18154
|
}
|
|
18061
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
18155
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18062
18156
|
if (module.config.coffeeForLoops)
|
|
18063
18157
|
return;
|
|
18064
18158
|
return $skip;
|
|
@@ -18085,7 +18179,7 @@ ${input.slice(result.pos)}
|
|
|
18085
18179
|
return result;
|
|
18086
18180
|
}
|
|
18087
18181
|
}
|
|
18088
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
18182
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18089
18183
|
if (module.config.coffeeInterpolation)
|
|
18090
18184
|
return;
|
|
18091
18185
|
return $skip;
|
|
@@ -18112,7 +18206,7 @@ ${input.slice(result.pos)}
|
|
|
18112
18206
|
return result;
|
|
18113
18207
|
}
|
|
18114
18208
|
}
|
|
18115
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
18209
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18116
18210
|
if (module.config.coffeeIsnt)
|
|
18117
18211
|
return;
|
|
18118
18212
|
return $skip;
|
|
@@ -18139,7 +18233,7 @@ ${input.slice(result.pos)}
|
|
|
18139
18233
|
return result;
|
|
18140
18234
|
}
|
|
18141
18235
|
}
|
|
18142
|
-
var CoffeeJSXEnabled$0 = $TV($EXPECT($
|
|
18236
|
+
var CoffeeJSXEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeJSXEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18143
18237
|
if (module.config.coffeeJSX)
|
|
18144
18238
|
return;
|
|
18145
18239
|
return $skip;
|
|
@@ -18166,7 +18260,7 @@ ${input.slice(result.pos)}
|
|
|
18166
18260
|
return result;
|
|
18167
18261
|
}
|
|
18168
18262
|
}
|
|
18169
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
18263
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18170
18264
|
if (module.config.coffeeLineContinuation)
|
|
18171
18265
|
return;
|
|
18172
18266
|
return $skip;
|
|
@@ -18193,7 +18287,7 @@ ${input.slice(result.pos)}
|
|
|
18193
18287
|
return result;
|
|
18194
18288
|
}
|
|
18195
18289
|
}
|
|
18196
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
18290
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18197
18291
|
if (module.config.coffeeNot)
|
|
18198
18292
|
return;
|
|
18199
18293
|
return $skip;
|
|
@@ -18220,7 +18314,7 @@ ${input.slice(result.pos)}
|
|
|
18220
18314
|
return result;
|
|
18221
18315
|
}
|
|
18222
18316
|
}
|
|
18223
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
18317
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18224
18318
|
if (module.config.coffeeOf)
|
|
18225
18319
|
return;
|
|
18226
18320
|
return $skip;
|
|
@@ -18247,7 +18341,7 @@ ${input.slice(result.pos)}
|
|
|
18247
18341
|
return result;
|
|
18248
18342
|
}
|
|
18249
18343
|
}
|
|
18250
|
-
var CoffeePrototypeEnabled$0 = $TV($EXPECT($
|
|
18344
|
+
var CoffeePrototypeEnabled$0 = $TV($EXPECT($L18, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18251
18345
|
if (module.config.coffeePrototype)
|
|
18252
18346
|
return;
|
|
18253
18347
|
return $skip;
|
|
@@ -18274,7 +18368,7 @@ ${input.slice(result.pos)}
|
|
|
18274
18368
|
return result;
|
|
18275
18369
|
}
|
|
18276
18370
|
}
|
|
18277
|
-
var ObjectIsEnabled$0 = $TV($EXPECT($
|
|
18371
|
+
var ObjectIsEnabled$0 = $TV($EXPECT($L18, fail, 'ObjectIsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
18278
18372
|
if (module.config.objectIs)
|
|
18279
18373
|
return;
|
|
18280
18374
|
return $skip;
|
|
@@ -18301,7 +18395,7 @@ ${input.slice(result.pos)}
|
|
|
18301
18395
|
return result;
|
|
18302
18396
|
}
|
|
18303
18397
|
}
|
|
18304
|
-
var Reset$0 = $TV($EXPECT($
|
|
18398
|
+
var Reset$0 = $TV($EXPECT($L18, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
18305
18399
|
module.indentLevels = [{
|
|
18306
18400
|
level: 0,
|
|
18307
18401
|
token: ""
|
|
@@ -18374,28 +18468,42 @@ ${input.slice(result.pos)}
|
|
|
18374
18468
|
ts: true,
|
|
18375
18469
|
children: [": <T>(this: T[], searchElement: T) => boolean"]
|
|
18376
18470
|
};
|
|
18377
|
-
module.prelude.push(["", ["const ", indexOfRef, typeSuffix, " = [].indexOf", module.asAny, "
|
|
18471
|
+
module.prelude.push(["", ["const ", indexOfRef, typeSuffix, " = [].indexOf", module.asAny, ";\n"]]);
|
|
18378
18472
|
},
|
|
18379
18473
|
hasProp(hasPropRef) {
|
|
18380
18474
|
const typeSuffix = {
|
|
18381
18475
|
ts: true,
|
|
18382
18476
|
children: [": <T>(this: T, prop: keyof T) => boolean"]
|
|
18383
18477
|
};
|
|
18384
|
-
module.prelude.push(["", ["const ", hasPropRef, typeSuffix, " = {}.hasOwnProperty", module.asAny, "
|
|
18478
|
+
module.prelude.push(["", ["const ", hasPropRef, typeSuffix, " = {}.hasOwnProperty", module.asAny, ";\n"]]);
|
|
18385
18479
|
},
|
|
18386
18480
|
is(isRef) {
|
|
18387
18481
|
const typeSuffix = {
|
|
18388
18482
|
ts: true,
|
|
18389
18483
|
children: [": { <B, A extends B> (a: A, b: B): b is A, <A, B> (a: A, b: B): a is A & B }"]
|
|
18390
18484
|
};
|
|
18391
|
-
module.prelude.push(["", ["const ", isRef, typeSuffix, " = Object.is", module.asAny, "
|
|
18485
|
+
module.prelude.push(["", ["const ", isRef, typeSuffix, " = Object.is", module.asAny, ";\n"]]);
|
|
18392
18486
|
},
|
|
18393
18487
|
modulo(moduloRef) {
|
|
18394
18488
|
const typeSuffix = {
|
|
18395
18489
|
ts: true,
|
|
18396
18490
|
children: [": (a: number, b: number) => number"]
|
|
18397
18491
|
};
|
|
18398
|
-
module.prelude.push(["", ["const ", moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b", "\n"]]);
|
|
18492
|
+
module.prelude.push(["", ["const ", moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
|
|
18493
|
+
},
|
|
18494
|
+
xor(xorRef) {
|
|
18495
|
+
const typeSuffix = {
|
|
18496
|
+
ts: true,
|
|
18497
|
+
children: [": (a: unknown, b: unknown) => boolean"]
|
|
18498
|
+
};
|
|
18499
|
+
module.prelude.push(["", ["const ", xorRef, typeSuffix, " = (a, b) => a && b ? false : a || b;", "\n"]]);
|
|
18500
|
+
},
|
|
18501
|
+
xnor(xnorRef) {
|
|
18502
|
+
const typeSuffix = {
|
|
18503
|
+
ts: true,
|
|
18504
|
+
children: [": (a: unknown, b: unknown) => boolean"]
|
|
18505
|
+
};
|
|
18506
|
+
module.prelude.push(["", ["const ", xnorRef, typeSuffix, " = (a, b) => a || b ? a && b : true;", "\n"]]);
|
|
18399
18507
|
},
|
|
18400
18508
|
returnSymbol(ref) {
|
|
18401
18509
|
module.prelude.push({
|
|
@@ -18579,7 +18687,7 @@ ${input.slice(result.pos)}
|
|
|
18579
18687
|
return result;
|
|
18580
18688
|
}
|
|
18581
18689
|
}
|
|
18582
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
18690
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L18, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
18583
18691
|
var directives = $2;
|
|
18584
18692
|
directives.forEach((directive) => {
|
|
18585
18693
|
if (directive.type === "CivetPrologue") {
|
|
@@ -19768,7 +19876,52 @@ ${input.slice(result.pos)}
|
|
|
19768
19876
|
s.children = [root];
|
|
19769
19877
|
});
|
|
19770
19878
|
}
|
|
19879
|
+
function processPipelineExpressions(statements) {
|
|
19880
|
+
gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
|
|
19881
|
+
const [, body] = s.children;
|
|
19882
|
+
let [arg] = s.children;
|
|
19883
|
+
let i = 0, l = body.length;
|
|
19884
|
+
const children = [];
|
|
19885
|
+
for (i = 0; i < l; i++) {
|
|
19886
|
+
const step = body[i];
|
|
19887
|
+
const [leadingComment, pipe, trailingComment, expr] = step;
|
|
19888
|
+
const returns = pipe.token === "||>";
|
|
19889
|
+
if (pipe.token === "|>=") {
|
|
19890
|
+
if (i === 0) {
|
|
19891
|
+
children.push(arg, " = ");
|
|
19892
|
+
} else {
|
|
19893
|
+
children.push({
|
|
19894
|
+
type: "Error",
|
|
19895
|
+
message: "Can't use |>= in the middle of a pipeline"
|
|
19896
|
+
});
|
|
19897
|
+
}
|
|
19898
|
+
}
|
|
19899
|
+
const [result, returning] = module.constructPipeStep(
|
|
19900
|
+
{
|
|
19901
|
+
leadingComment: module.skipIfOnlyWS(leadingComment),
|
|
19902
|
+
trailingComment: module.skipIfOnlyWS(trailingComment),
|
|
19903
|
+
expr
|
|
19904
|
+
},
|
|
19905
|
+
arg,
|
|
19906
|
+
returns ? arg : null
|
|
19907
|
+
);
|
|
19908
|
+
if (result.type === "ReturnStatement") {
|
|
19909
|
+
arg = result;
|
|
19910
|
+
break;
|
|
19911
|
+
}
|
|
19912
|
+
if (returning) {
|
|
19913
|
+
arg = returning;
|
|
19914
|
+
children.push(result, ",");
|
|
19915
|
+
} else {
|
|
19916
|
+
arg = result;
|
|
19917
|
+
}
|
|
19918
|
+
}
|
|
19919
|
+
children.push(arg);
|
|
19920
|
+
s.children = children;
|
|
19921
|
+
});
|
|
19922
|
+
}
|
|
19771
19923
|
module.processProgram = function(statements) {
|
|
19924
|
+
processPipelineExpressions(statements);
|
|
19772
19925
|
processAssignments(statements);
|
|
19773
19926
|
processFunctions(statements);
|
|
19774
19927
|
processSwitchExpressions(statements);
|
|
@@ -19981,20 +20134,56 @@ ${input.slice(result.pos)}
|
|
|
19981
20134
|
return [splices, thisAssignments];
|
|
19982
20135
|
}
|
|
19983
20136
|
module.gatherBindingCode = gatherBindingCode;
|
|
19984
|
-
module.constructInvocation = function(
|
|
19985
|
-
const
|
|
19986
|
-
const
|
|
19987
|
-
|
|
19988
|
-
|
|
19989
|
-
|
|
19990
|
-
|
|
20137
|
+
module.constructInvocation = function(fn, arg) {
|
|
20138
|
+
const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
|
|
20139
|
+
const lhs = module.makeLeftHandSideExpression(fn.expr);
|
|
20140
|
+
let comment = module.skipIfOnlyWS(fn.trailingComment);
|
|
20141
|
+
if (comment)
|
|
20142
|
+
lhs.children.splice(2, 0, comment);
|
|
20143
|
+
comment = module.skipIfOnlyWS(fn.leadingComment);
|
|
20144
|
+
if (comment)
|
|
20145
|
+
lhs.children.splice(1, 0, comment);
|
|
20146
|
+
switch (arg.type) {
|
|
20147
|
+
case "CommaExpression":
|
|
20148
|
+
arg = {
|
|
20149
|
+
type: "ParenthesizedExpression",
|
|
20150
|
+
children: ["(", arg, ")"]
|
|
20151
|
+
};
|
|
20152
|
+
break;
|
|
19991
20153
|
}
|
|
20154
|
+
return {
|
|
20155
|
+
type: "CallExpression",
|
|
20156
|
+
children: [lhs, "(", arg, ")"]
|
|
20157
|
+
};
|
|
19992
20158
|
};
|
|
19993
|
-
module.constructPipeStep = function(
|
|
19994
|
-
|
|
19995
|
-
|
|
20159
|
+
module.constructPipeStep = function(fn, arg, returning) {
|
|
20160
|
+
const children = [[fn.leadingComment, fn.expr, fn.trailingComment].map(module.skipIfOnlyWS), " ", arg];
|
|
20161
|
+
switch (fn.expr.token) {
|
|
20162
|
+
case "yield":
|
|
20163
|
+
case "await":
|
|
20164
|
+
if (returning) {
|
|
20165
|
+
return [
|
|
20166
|
+
children,
|
|
20167
|
+
returning
|
|
20168
|
+
];
|
|
20169
|
+
}
|
|
20170
|
+
return [
|
|
20171
|
+
children,
|
|
20172
|
+
null
|
|
20173
|
+
];
|
|
20174
|
+
case "return":
|
|
20175
|
+
return [{
|
|
20176
|
+
type: "ReturnStatement",
|
|
20177
|
+
children
|
|
20178
|
+
}, null];
|
|
20179
|
+
}
|
|
20180
|
+
if (returning) {
|
|
20181
|
+
return [
|
|
20182
|
+
module.constructInvocation(fn, arg),
|
|
20183
|
+
returning
|
|
20184
|
+
];
|
|
19996
20185
|
}
|
|
19997
|
-
return module.constructInvocation(
|
|
20186
|
+
return [module.constructInvocation(fn, arg), null];
|
|
19998
20187
|
};
|
|
19999
20188
|
return $0;
|
|
20000
20189
|
});
|
|
@@ -20020,7 +20209,7 @@ ${input.slice(result.pos)}
|
|
|
20020
20209
|
return result;
|
|
20021
20210
|
}
|
|
20022
20211
|
}
|
|
20023
|
-
var Indent$0 = $TR($EXPECT($
|
|
20212
|
+
var Indent$0 = $TR($EXPECT($R62, fail, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
20024
20213
|
let level;
|
|
20025
20214
|
if (module.config.tab) {
|
|
20026
20215
|
const tabs = $0.match(/\t/g);
|
|
@@ -20175,7 +20364,7 @@ ${input.slice(result.pos)}
|
|
|
20175
20364
|
return result;
|
|
20176
20365
|
}
|
|
20177
20366
|
}
|
|
20178
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
20367
|
+
var PopIndent$0 = $TV($EXPECT($L18, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
20179
20368
|
if (module.config.verbose) {
|
|
20180
20369
|
console.log("popping indent", module.indentLevels[module.indentLevels.length - 1], "->", module.indentLevels[module.indentLevels.length - 2]);
|
|
20181
20370
|
}
|