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