@danielx/civet 0.4.19-pre.12 → 0.4.19-pre.14
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/LICENSE +21 -0
- package/README.md +3 -2
- package/dist/browser.js +652 -432
- package/dist/esbuild-plugin.js +1 -1
- package/dist/main.js +652 -432
- package/package.json +2 -2
package/dist/browser.js
CHANGED
|
@@ -516,6 +516,7 @@ ${input.slice(result.pos)}
|
|
|
516
516
|
NestedPropertyDefinitions,
|
|
517
517
|
NestedPropertyDefinition,
|
|
518
518
|
InlineObjectLiteral,
|
|
519
|
+
ImplicitInlineObjectPropertyDelimiter,
|
|
519
520
|
ObjectPropertyDelimiter,
|
|
520
521
|
PropertyDefinitionList,
|
|
521
522
|
PropertyDefinition,
|
|
@@ -529,6 +530,7 @@ ${input.slice(result.pos)}
|
|
|
529
530
|
PrivateIdentifier,
|
|
530
531
|
AssignmentOp,
|
|
531
532
|
AssignmentOpSymbol,
|
|
533
|
+
CoffeeWordAssignmentOp,
|
|
532
534
|
BinaryOp,
|
|
533
535
|
BinaryOpSymbol,
|
|
534
536
|
UnaryOp,
|
|
@@ -851,137 +853,139 @@ ${input.slice(result.pos)}
|
|
|
851
853
|
var $L23 = $L("off");
|
|
852
854
|
var $L24 = $L(",");
|
|
853
855
|
var $L25 = $L("]");
|
|
854
|
-
var $L26 = $L("
|
|
855
|
-
var $L27 = $L("
|
|
856
|
-
var $L28 = $L("
|
|
857
|
-
var $L29 = $L("
|
|
858
|
-
var $L30 = $L("
|
|
859
|
-
var $L31 = $L("
|
|
860
|
-
var $L32 = $L("
|
|
861
|
-
var $L33 = $L("
|
|
862
|
-
var $L34 = $L("
|
|
863
|
-
var $L35 = $L("
|
|
864
|
-
var $L36 = $L("
|
|
865
|
-
var $L37 = $L("
|
|
866
|
-
var $L38 = $L("
|
|
867
|
-
var $L39 = $L("
|
|
868
|
-
var $L40 = $L("
|
|
869
|
-
var $L41 = $L("
|
|
870
|
-
var $L42 = $L("
|
|
871
|
-
var $L43 = $L("
|
|
872
|
-
var $L44 = $L("
|
|
873
|
-
var $L45 = $L("
|
|
874
|
-
var $L46 = $L("
|
|
875
|
-
var $L47 = $L("
|
|
876
|
-
var $L48 = $L("
|
|
877
|
-
var $L49 = $L("
|
|
878
|
-
var $L50 = $L("
|
|
879
|
-
var $L51 = $L("
|
|
880
|
-
var $L52 = $L("
|
|
881
|
-
var $L53 = $L("
|
|
882
|
-
var $L54 = $L("
|
|
883
|
-
var $L55 = $L("
|
|
884
|
-
var $L56 = $L("
|
|
885
|
-
var $L57 = $L("
|
|
886
|
-
var $L58 = $L("
|
|
887
|
-
var $L59 = $L("
|
|
888
|
-
var $L60 = $L("
|
|
889
|
-
var $L61 = $L("
|
|
890
|
-
var $L62 = $L("
|
|
891
|
-
var $L63 = $L("
|
|
892
|
-
var $L64 = $L("
|
|
893
|
-
var $L65 = $L("
|
|
894
|
-
var $L66 = $L("
|
|
895
|
-
var $L67 = $L("
|
|
896
|
-
var $L68 = $L("
|
|
897
|
-
var $L69 = $L("
|
|
898
|
-
var $L70 = $L("
|
|
899
|
-
var $L71 = $L("
|
|
900
|
-
var $L72 = $L("
|
|
901
|
-
var $L73 = $L("
|
|
902
|
-
var $L74 = $L("
|
|
903
|
-
var $L75 = $L("
|
|
904
|
-
var $L76 = $L("
|
|
905
|
-
var $L77 = $L("
|
|
906
|
-
var $L78 = $L("
|
|
907
|
-
var $L79 = $L("
|
|
908
|
-
var $L80 = $L("
|
|
909
|
-
var $L81 = $L("
|
|
910
|
-
var $L82 = $L("
|
|
911
|
-
var $L83 = $L("
|
|
912
|
-
var $L84 = $L("
|
|
913
|
-
var $L85 = $L("
|
|
914
|
-
var $L86 = $L("
|
|
915
|
-
var $L87 = $L("
|
|
916
|
-
var $L88 = $L("
|
|
917
|
-
var $L89 = $L("
|
|
918
|
-
var $L90 = $L("
|
|
919
|
-
var $L91 = $L("
|
|
920
|
-
var $L92 = $L("
|
|
921
|
-
var $L93 = $L("
|
|
922
|
-
var $L94 = $L("
|
|
923
|
-
var $L95 = $L("
|
|
924
|
-
var $L96 = $L("
|
|
925
|
-
var $L97 = $L("
|
|
926
|
-
var $L98 = $L("
|
|
927
|
-
var $L99 = $L("
|
|
928
|
-
var $L100 = $L("
|
|
929
|
-
var $L101 = $L("
|
|
930
|
-
var $L102 = $L("
|
|
931
|
-
var $L103 = $L("
|
|
932
|
-
var $L104 = $L(
|
|
933
|
-
var $L105 = $L("
|
|
934
|
-
var $L106 = $L("
|
|
935
|
-
var $L107 = $L("
|
|
936
|
-
var $L108 = $L("
|
|
937
|
-
var $L109 = $L("
|
|
938
|
-
var $L110 = $L("
|
|
939
|
-
var $L111 = $L("
|
|
940
|
-
var $L112 = $L("
|
|
941
|
-
var $L113 = $L("
|
|
942
|
-
var $L114 = $L("
|
|
943
|
-
var $L115 = $L("
|
|
944
|
-
var $L116 = $L("
|
|
945
|
-
var $L117 = $L("
|
|
946
|
-
var $L118 = $L("
|
|
947
|
-
var $L119 = $L("
|
|
948
|
-
var $L120 = $L("
|
|
949
|
-
var $L121 = $L("
|
|
950
|
-
var $L122 = $L("
|
|
951
|
-
var $L123 = $L("
|
|
952
|
-
var $L124 = $L("
|
|
953
|
-
var $L125 = $L("
|
|
954
|
-
var $L126 = $L("
|
|
955
|
-
var $L127 = $L("
|
|
956
|
-
var $L128 = $L(
|
|
957
|
-
var $L129 = $L("
|
|
958
|
-
var $L130 = $L("
|
|
959
|
-
var $L131 = $L("
|
|
960
|
-
var $L132 = $L("
|
|
961
|
-
var $L133 = $L("
|
|
962
|
-
var $L134 = $L("
|
|
963
|
-
var $L135 = $L("
|
|
964
|
-
var $L136 = $L("
|
|
965
|
-
var $L137 = $L("
|
|
966
|
-
var $L138 = $L("
|
|
967
|
-
var $L139 = $L("
|
|
968
|
-
var $L140 = $L("
|
|
969
|
-
var $L141 = $L("
|
|
970
|
-
var $L142 = $L("
|
|
971
|
-
var $L143 = $L("
|
|
972
|
-
var $L144 = $L("
|
|
973
|
-
var $L145 = $L("
|
|
974
|
-
var $L146 = $L("
|
|
975
|
-
var $L147 = $L("
|
|
976
|
-
var $L148 = $L("
|
|
977
|
-
var $L149 = $L("
|
|
978
|
-
var $L150 = $L("
|
|
979
|
-
var $L151 = $L("
|
|
980
|
-
var $L152 = $L("
|
|
981
|
-
var $L153 = $L("
|
|
982
|
-
var $L154 = $L("
|
|
983
|
-
var $L155 = $L("
|
|
984
|
-
var $L156 = $L("
|
|
856
|
+
var $L26 = $L(":");
|
|
857
|
+
var $L27 = $L("}");
|
|
858
|
+
var $L28 = $L("**=");
|
|
859
|
+
var $L29 = $L("*=");
|
|
860
|
+
var $L30 = $L("/=");
|
|
861
|
+
var $L31 = $L("%=");
|
|
862
|
+
var $L32 = $L("+=");
|
|
863
|
+
var $L33 = $L("-=");
|
|
864
|
+
var $L34 = $L("<<=");
|
|
865
|
+
var $L35 = $L(">>>=");
|
|
866
|
+
var $L36 = $L(">>=");
|
|
867
|
+
var $L37 = $L("&&=");
|
|
868
|
+
var $L38 = $L("&=");
|
|
869
|
+
var $L39 = $L("^=");
|
|
870
|
+
var $L40 = $L("||=");
|
|
871
|
+
var $L41 = $L("|=");
|
|
872
|
+
var $L42 = $L("??=");
|
|
873
|
+
var $L43 = $L("?=");
|
|
874
|
+
var $L44 = $L("=");
|
|
875
|
+
var $L45 = $L("and=");
|
|
876
|
+
var $L46 = $L("or=");
|
|
877
|
+
var $L47 = $L("**");
|
|
878
|
+
var $L48 = $L("*");
|
|
879
|
+
var $L49 = $L("/");
|
|
880
|
+
var $L50 = $L("%");
|
|
881
|
+
var $L51 = $L("+");
|
|
882
|
+
var $L52 = $L("-");
|
|
883
|
+
var $L53 = $L("<=");
|
|
884
|
+
var $L54 = $L(">=");
|
|
885
|
+
var $L55 = $L("<<");
|
|
886
|
+
var $L56 = $L(">>>");
|
|
887
|
+
var $L57 = $L(">>");
|
|
888
|
+
var $L58 = $L(">");
|
|
889
|
+
var $L59 = $L("!==");
|
|
890
|
+
var $L60 = $L("!=");
|
|
891
|
+
var $L61 = $L("isnt");
|
|
892
|
+
var $L62 = $L("is");
|
|
893
|
+
var $L63 = $L("===");
|
|
894
|
+
var $L64 = $L("==");
|
|
895
|
+
var $L65 = $L("and");
|
|
896
|
+
var $L66 = $L("&&");
|
|
897
|
+
var $L67 = $L("of");
|
|
898
|
+
var $L68 = $L("or");
|
|
899
|
+
var $L69 = $L("||");
|
|
900
|
+
var $L70 = $L("??");
|
|
901
|
+
var $L71 = $L("?");
|
|
902
|
+
var $L72 = $L("instanceof");
|
|
903
|
+
var $L73 = $L("in");
|
|
904
|
+
var $L74 = $L("not");
|
|
905
|
+
var $L75 = $L("&");
|
|
906
|
+
var $L76 = $L("^");
|
|
907
|
+
var $L77 = $L("|");
|
|
908
|
+
var $L78 = $L(";");
|
|
909
|
+
var $L79 = $L("own");
|
|
910
|
+
var $L80 = $L("finally");
|
|
911
|
+
var $L81 = $L("break");
|
|
912
|
+
var $L82 = $L("continue");
|
|
913
|
+
var $L83 = $L("debugger");
|
|
914
|
+
var $L84 = $L("import type");
|
|
915
|
+
var $L85 = $L("default");
|
|
916
|
+
var $L86 = $L(":=");
|
|
917
|
+
var $L87 = $L("/*");
|
|
918
|
+
var $L88 = $L("*/");
|
|
919
|
+
var $L89 = $L("###");
|
|
920
|
+
var $L90 = $L("\\");
|
|
921
|
+
var $L91 = $L("as");
|
|
922
|
+
var $L92 = $L("@");
|
|
923
|
+
var $L93 = $L("async");
|
|
924
|
+
var $L94 = $L("await");
|
|
925
|
+
var $L95 = $L("`");
|
|
926
|
+
var $L96 = $L("by");
|
|
927
|
+
var $L97 = $L("case");
|
|
928
|
+
var $L98 = $L("catch");
|
|
929
|
+
var $L99 = $L("class");
|
|
930
|
+
var $L100 = $L("#{");
|
|
931
|
+
var $L101 = $L("delete");
|
|
932
|
+
var $L102 = $L("do");
|
|
933
|
+
var $L103 = $L("..");
|
|
934
|
+
var $L104 = $L("...");
|
|
935
|
+
var $L105 = $L("::");
|
|
936
|
+
var $L106 = $L('"');
|
|
937
|
+
var $L107 = $L("else");
|
|
938
|
+
var $L108 = $L("export");
|
|
939
|
+
var $L109 = $L("for");
|
|
940
|
+
var $L110 = $L("from");
|
|
941
|
+
var $L111 = $L("function");
|
|
942
|
+
var $L112 = $L("get");
|
|
943
|
+
var $L113 = $L("set");
|
|
944
|
+
var $L114 = $L("if");
|
|
945
|
+
var $L115 = $L("let");
|
|
946
|
+
var $L116 = $L("const");
|
|
947
|
+
var $L117 = $L("loop");
|
|
948
|
+
var $L118 = $L("new");
|
|
949
|
+
var $L119 = $L("{");
|
|
950
|
+
var $L120 = $L("[");
|
|
951
|
+
var $L121 = $L("(");
|
|
952
|
+
var $L122 = $L("return");
|
|
953
|
+
var $L123 = $L("'");
|
|
954
|
+
var $L124 = $L("static");
|
|
955
|
+
var $L125 = $L("${");
|
|
956
|
+
var $L126 = $L("switch");
|
|
957
|
+
var $L127 = $L("target");
|
|
958
|
+
var $L128 = $L("then");
|
|
959
|
+
var $L129 = $L("throw");
|
|
960
|
+
var $L130 = $L('"""');
|
|
961
|
+
var $L131 = $L("'''");
|
|
962
|
+
var $L132 = $L("///");
|
|
963
|
+
var $L133 = $L("```");
|
|
964
|
+
var $L134 = $L("try");
|
|
965
|
+
var $L135 = $L("typeof");
|
|
966
|
+
var $L136 = $L("unless");
|
|
967
|
+
var $L137 = $L("until");
|
|
968
|
+
var $L138 = $L("var");
|
|
969
|
+
var $L139 = $L("void");
|
|
970
|
+
var $L140 = $L("when");
|
|
971
|
+
var $L141 = $L("while");
|
|
972
|
+
var $L142 = $L("yield");
|
|
973
|
+
var $L143 = $L("/>");
|
|
974
|
+
var $L144 = $L("</");
|
|
975
|
+
var $L145 = $L("<>");
|
|
976
|
+
var $L146 = $L("</>");
|
|
977
|
+
var $L147 = $L("declare");
|
|
978
|
+
var $L148 = $L("type");
|
|
979
|
+
var $L149 = $L("interface");
|
|
980
|
+
var $L150 = $L("namespace");
|
|
981
|
+
var $L151 = $L("readonly");
|
|
982
|
+
var $L152 = $L("asserts");
|
|
983
|
+
var $L153 = $L("keyof");
|
|
984
|
+
var $L154 = $L("infer");
|
|
985
|
+
var $L155 = $L("[]");
|
|
986
|
+
var $L156 = $L("civet");
|
|
987
|
+
var $L157 = $L(" ");
|
|
988
|
+
var $L158 = $L(" ");
|
|
985
989
|
var $R0 = $R(new RegExp("(for|of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
986
990
|
var $R1 = $R(new RegExp("[&]", "suy"));
|
|
987
991
|
var $R2 = $R(new RegExp("[!~+-]+", "suy"));
|
|
@@ -1015,7 +1019,7 @@ ${input.slice(result.pos)}
|
|
|
1015
1019
|
var $R30 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
1016
1020
|
var $R31 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
1017
1021
|
var $R32 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
1018
|
-
var $R33 = $R(new RegExp("(?:and|as|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|loop|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
1022
|
+
var $R33 = $R(new RegExp("(?:and|as|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|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
1019
1023
|
var $R34 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
1020
1024
|
var $R35 = $R(new RegExp(".", "suy"));
|
|
1021
1025
|
var $R36 = $R(new RegExp("#(?!##)([^\\r\\n]*)", "suy"));
|
|
@@ -1076,12 +1080,18 @@ ${input.slice(result.pos)}
|
|
|
1076
1080
|
return result;
|
|
1077
1081
|
}
|
|
1078
1082
|
}
|
|
1079
|
-
var ExtendedExpression$0 = $TS($S(
|
|
1083
|
+
var ExtendedExpression$0 = $TS($S($Y(EOS), PushIndent, $E($S(Nested, ExpressionizedStatement)), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1084
|
+
var expression = $3;
|
|
1085
|
+
if (expression)
|
|
1086
|
+
return expression;
|
|
1087
|
+
return $skip;
|
|
1088
|
+
});
|
|
1089
|
+
var ExtendedExpression$1 = $TS($S(__, ExpressionizedStatement), function($skip, $loc, $0, $1, $2) {
|
|
1080
1090
|
return Object.assign({}, $2, {
|
|
1081
1091
|
children: [...$1, ...$2.children]
|
|
1082
1092
|
});
|
|
1083
1093
|
});
|
|
1084
|
-
var ExtendedExpression$
|
|
1094
|
+
var ExtendedExpression$2 = AssignmentExpression;
|
|
1085
1095
|
function ExtendedExpression(state) {
|
|
1086
1096
|
if (state.events) {
|
|
1087
1097
|
const result = state.events.enter?.("ExtendedExpression", state);
|
|
@@ -1089,12 +1099,12 @@ ${input.slice(result.pos)}
|
|
|
1089
1099
|
return result.cache;
|
|
1090
1100
|
}
|
|
1091
1101
|
if (state.tokenize) {
|
|
1092
|
-
const result = $TOKEN("ExtendedExpression", state, ExtendedExpression$0(state) || ExtendedExpression$1(state));
|
|
1102
|
+
const result = $TOKEN("ExtendedExpression", state, ExtendedExpression$0(state) || ExtendedExpression$1(state) || ExtendedExpression$2(state));
|
|
1093
1103
|
if (state.events)
|
|
1094
1104
|
state.events.exit?.("ExtendedExpression", state, result);
|
|
1095
1105
|
return result;
|
|
1096
1106
|
} else {
|
|
1097
|
-
const result = ExtendedExpression$0(state) || ExtendedExpression$1(state);
|
|
1107
|
+
const result = ExtendedExpression$0(state) || ExtendedExpression$1(state) || ExtendedExpression$2(state);
|
|
1098
1108
|
if (state.events)
|
|
1099
1109
|
state.events.exit?.("ExtendedExpression", state, result);
|
|
1100
1110
|
return result;
|
|
@@ -1601,56 +1611,10 @@ ${input.slice(result.pos)}
|
|
|
1601
1611
|
}
|
|
1602
1612
|
}
|
|
1603
1613
|
var ActualAssignment$0 = $TS($S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), ExtendedExpression), function($skip, $loc, $0, $1, $2) {
|
|
1604
|
-
let tail = [], i = 0, len = $1.length;
|
|
1605
|
-
while (i < len) {
|
|
1606
|
-
const lastAssignment = $1[i++];
|
|
1607
|
-
const [, lhs, , op] = lastAssignment;
|
|
1608
|
-
if (op.token !== "=")
|
|
1609
|
-
continue;
|
|
1610
|
-
if (lhs.type === "ObjectExpression") {
|
|
1611
|
-
lhs.children.splice(0, 0, "(");
|
|
1612
|
-
tail.push(")");
|
|
1613
|
-
break;
|
|
1614
|
-
}
|
|
1615
|
-
}
|
|
1616
|
-
i = len - 1;
|
|
1617
|
-
while (i >= 0) {
|
|
1618
|
-
const lastAssignment = $1[i];
|
|
1619
|
-
if (lastAssignment[3].token === "=") {
|
|
1620
|
-
const lhs = lastAssignment[1];
|
|
1621
|
-
if (Array.isArray(lhs) && lhs.length > 1) {
|
|
1622
|
-
const props = lhs[lhs.length - 1];
|
|
1623
|
-
if (Array.isArray(props)) {
|
|
1624
|
-
const lastProp = props[props.length - 1];
|
|
1625
|
-
if (lastProp.type === "SliceExpression") {
|
|
1626
|
-
const { start, end, children: c } = lastProp;
|
|
1627
|
-
c[0].token = ".splice(";
|
|
1628
|
-
c[1] = start;
|
|
1629
|
-
c[2] = ", ";
|
|
1630
|
-
if (end)
|
|
1631
|
-
c[3] = [end, " - ", start];
|
|
1632
|
-
else
|
|
1633
|
-
c[3] = ["1/0"];
|
|
1634
|
-
c[4] = [", ...", $2];
|
|
1635
|
-
c[5] = ")";
|
|
1636
|
-
lastAssignment.pop();
|
|
1637
|
-
if (module.isWhitespaceOrEmpty(lastAssignment[2]))
|
|
1638
|
-
lastAssignment.pop();
|
|
1639
|
-
if ($1.length > 1) {
|
|
1640
|
-
throw new Error("Not implemented yet! TODO: Handle multiple splice assignments");
|
|
1641
|
-
}
|
|
1642
|
-
return $1;
|
|
1643
|
-
}
|
|
1644
|
-
}
|
|
1645
|
-
}
|
|
1646
|
-
}
|
|
1647
|
-
i--;
|
|
1648
|
-
}
|
|
1649
|
-
const names = $1.flatMap(([, l]) => l.names || []);
|
|
1650
1614
|
return {
|
|
1651
1615
|
type: "AssignmentExpression",
|
|
1652
|
-
children:
|
|
1653
|
-
names
|
|
1616
|
+
children: $0,
|
|
1617
|
+
names: null
|
|
1654
1618
|
};
|
|
1655
1619
|
});
|
|
1656
1620
|
function ActualAssignment(state) {
|
|
@@ -2694,10 +2658,25 @@ ${input.slice(result.pos)}
|
|
|
2694
2658
|
return result;
|
|
2695
2659
|
}
|
|
2696
2660
|
}
|
|
2697
|
-
var BindingIdentifier$0 = $TS($S(__, Identifier), function($skip, $loc, $0, $1, $2) {
|
|
2698
|
-
|
|
2699
|
-
|
|
2700
|
-
|
|
2661
|
+
var BindingIdentifier$0 = $TS($S(__, $E(At), Identifier), function($skip, $loc, $0, $1, $2, $3) {
|
|
2662
|
+
var ws = $1;
|
|
2663
|
+
var at = $2;
|
|
2664
|
+
var id = $3;
|
|
2665
|
+
if (at) {
|
|
2666
|
+
const ref = {
|
|
2667
|
+
type: "Ref",
|
|
2668
|
+
base: id.name
|
|
2669
|
+
};
|
|
2670
|
+
return {
|
|
2671
|
+
type: "AtBinding",
|
|
2672
|
+
children: [...ws, ref],
|
|
2673
|
+
ref
|
|
2674
|
+
};
|
|
2675
|
+
}
|
|
2676
|
+
return {
|
|
2677
|
+
...id,
|
|
2678
|
+
children: [...ws, ...id.children]
|
|
2679
|
+
};
|
|
2701
2680
|
});
|
|
2702
2681
|
function BindingIdentifier(state) {
|
|
2703
2682
|
if (state.events) {
|
|
@@ -2775,14 +2754,16 @@ ${input.slice(result.pos)}
|
|
|
2775
2754
|
}
|
|
2776
2755
|
}
|
|
2777
2756
|
var ObjectBindingPatternContent$0 = NestedBindingProperties;
|
|
2778
|
-
var ObjectBindingPatternContent$1 = $TS($S($Q(BindingProperty), $E($
|
|
2757
|
+
var ObjectBindingPatternContent$1 = $TS($S($Q(BindingProperty), $E(BindingRestProperty), $Q(BindingProperty)), function($skip, $loc, $0, $1, $2, $3) {
|
|
2779
2758
|
var props = $1;
|
|
2780
2759
|
var rest = $2;
|
|
2760
|
+
var after = $3;
|
|
2781
2761
|
const names = props.flatMap((p) => p.names);
|
|
2782
2762
|
const children = [...props];
|
|
2783
2763
|
if (rest) {
|
|
2784
|
-
|
|
2785
|
-
|
|
2764
|
+
[rest, after] = module.reorderBindingRestProperty(rest, after);
|
|
2765
|
+
children.push(...after, rest);
|
|
2766
|
+
names.push(...after.flatMap((p) => p.names), ...rest.names);
|
|
2786
2767
|
}
|
|
2787
2768
|
return {
|
|
2788
2769
|
names,
|
|
@@ -2884,16 +2865,18 @@ ${input.slice(result.pos)}
|
|
|
2884
2865
|
return result;
|
|
2885
2866
|
}
|
|
2886
2867
|
}
|
|
2887
|
-
var NestedBindingProperties$0 = $TS($S(PushIndent, $Q(NestedBindingProperty), $E(NestedBindingRestProperty), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2868
|
+
var NestedBindingProperties$0 = $TS($S(PushIndent, $Q(NestedBindingProperty), $E(NestedBindingRestProperty), $Q(NestedBindingProperty), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
2888
2869
|
var props = $2;
|
|
2889
2870
|
var rest = $3;
|
|
2871
|
+
var after = $4;
|
|
2890
2872
|
if (!(props.length || rest))
|
|
2891
2873
|
return $skip;
|
|
2892
2874
|
const names = props.flatMap((p) => p.names);
|
|
2893
2875
|
const children = [...props];
|
|
2894
2876
|
if (rest) {
|
|
2895
|
-
|
|
2896
|
-
|
|
2877
|
+
[rest, after] = module.reorderBindingRestProperty(rest, after);
|
|
2878
|
+
children.push(...after, rest);
|
|
2879
|
+
names.push(...after.flatMap((p) => p.names), ...rest.names);
|
|
2897
2880
|
}
|
|
2898
2881
|
return {
|
|
2899
2882
|
children,
|
|
@@ -2921,9 +2904,10 @@ ${input.slice(result.pos)}
|
|
|
2921
2904
|
var NestedBindingProperty$0 = $TS($S(Nested, BindingProperty), function($skip, $loc, $0, $1, $2) {
|
|
2922
2905
|
var indent = $1;
|
|
2923
2906
|
var prop = $2;
|
|
2924
|
-
return
|
|
2925
|
-
|
|
2926
|
-
|
|
2907
|
+
return {
|
|
2908
|
+
...prop,
|
|
2909
|
+
children: [...indent, ...prop.children]
|
|
2910
|
+
};
|
|
2927
2911
|
});
|
|
2928
2912
|
function NestedBindingProperty(state) {
|
|
2929
2913
|
if (state.events) {
|
|
@@ -2952,6 +2936,14 @@ ${input.slice(result.pos)}
|
|
|
2952
2936
|
});
|
|
2953
2937
|
var BindingProperty$1 = $TS($S(BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
|
|
2954
2938
|
var b = $1;
|
|
2939
|
+
if (b.type === "AtBinding") {
|
|
2940
|
+
return {
|
|
2941
|
+
type: "AtBindingProperty",
|
|
2942
|
+
ref: b.ref,
|
|
2943
|
+
names: [],
|
|
2944
|
+
children: $0
|
|
2945
|
+
};
|
|
2946
|
+
}
|
|
2955
2947
|
return {
|
|
2956
2948
|
names: b.names,
|
|
2957
2949
|
children: $0
|
|
@@ -2978,9 +2970,10 @@ ${input.slice(result.pos)}
|
|
|
2978
2970
|
var NestedBindingRestProperty$0 = $TS($S(Nested, BindingRestProperty), function($skip, $loc, $0, $1, $2) {
|
|
2979
2971
|
var indent = $1;
|
|
2980
2972
|
var prop = $2;
|
|
2981
|
-
return
|
|
2973
|
+
return {
|
|
2974
|
+
...prop,
|
|
2982
2975
|
children: [indent, ...prop.children]
|
|
2983
|
-
}
|
|
2976
|
+
};
|
|
2984
2977
|
});
|
|
2985
2978
|
function NestedBindingRestProperty(state) {
|
|
2986
2979
|
if (state.events) {
|
|
@@ -3000,12 +2993,15 @@ ${input.slice(result.pos)}
|
|
|
3000
2993
|
return result;
|
|
3001
2994
|
}
|
|
3002
2995
|
}
|
|
3003
|
-
var BindingRestProperty$0 = $TS($S(DotDotDot, BindingIdentifier), function($skip, $loc, $0, $1, $2) {
|
|
3004
|
-
var
|
|
3005
|
-
var
|
|
3006
|
-
|
|
3007
|
-
|
|
3008
|
-
|
|
2996
|
+
var BindingRestProperty$0 = $TS($S(__, DotDotDot, BindingIdentifier, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2997
|
+
var ws = $1;
|
|
2998
|
+
var d = $2;
|
|
2999
|
+
var id = $3;
|
|
3000
|
+
var delimiter = $4;
|
|
3001
|
+
return {
|
|
3002
|
+
...id,
|
|
3003
|
+
children: [...ws, d, ...id.children, delimiter]
|
|
3004
|
+
};
|
|
3009
3005
|
});
|
|
3010
3006
|
function BindingRestProperty(state) {
|
|
3011
3007
|
if (state.events) {
|
|
@@ -3062,9 +3058,10 @@ ${input.slice(result.pos)}
|
|
|
3062
3058
|
var NestedBindingElement$0 = $TS($S(Nested, BindingElement), function($skip, $loc, $0, $1, $2) {
|
|
3063
3059
|
var indent = $1;
|
|
3064
3060
|
var element = $2;
|
|
3065
|
-
return
|
|
3061
|
+
return {
|
|
3062
|
+
...element,
|
|
3066
3063
|
children: [indent, ...element.children]
|
|
3067
|
-
}
|
|
3064
|
+
};
|
|
3068
3065
|
});
|
|
3069
3066
|
function NestedBindingElement(state) {
|
|
3070
3067
|
if (state.events) {
|
|
@@ -3428,8 +3425,14 @@ ${input.slice(result.pos)}
|
|
|
3428
3425
|
return result;
|
|
3429
3426
|
}
|
|
3430
3427
|
}
|
|
3431
|
-
var EmptyBlock$0 = $
|
|
3432
|
-
|
|
3428
|
+
var EmptyBlock$0 = $TS($S(InsertOpenBrace, InsertCloseBrace), function($skip, $loc, $0, $1, $2) {
|
|
3429
|
+
const expressions = [];
|
|
3430
|
+
return {
|
|
3431
|
+
type: "BlockStatement",
|
|
3432
|
+
expressions,
|
|
3433
|
+
children: [$1, expressions, $2],
|
|
3434
|
+
bare: false
|
|
3435
|
+
};
|
|
3433
3436
|
});
|
|
3434
3437
|
function EmptyBlock(state) {
|
|
3435
3438
|
if (state.events) {
|
|
@@ -4070,13 +4073,27 @@ ${input.slice(result.pos)}
|
|
|
4070
4073
|
var exp = $1;
|
|
4071
4074
|
var ws = $2;
|
|
4072
4075
|
var dots = $3;
|
|
4073
|
-
return
|
|
4076
|
+
return {
|
|
4077
|
+
type: "SpreadElement",
|
|
4078
|
+
children: [...ws, dots, exp],
|
|
4079
|
+
names: exp.names
|
|
4080
|
+
};
|
|
4074
4081
|
});
|
|
4075
|
-
var ArrayElementExpression$1 = $
|
|
4076
|
-
|
|
4077
|
-
|
|
4082
|
+
var ArrayElementExpression$1 = $TS($S($E($S($E($S(DotDotDot, __)), ExtendedExpression)), $Y(ArrayElementDelimiter)), function($skip, $loc, $0, $1, $2) {
|
|
4083
|
+
var expMaybeSpread = $1;
|
|
4084
|
+
if (expMaybeSpread) {
|
|
4085
|
+
const [spread, exp] = expMaybeSpread;
|
|
4086
|
+
if (!spread) {
|
|
4087
|
+
return exp;
|
|
4088
|
+
} else {
|
|
4089
|
+
return {
|
|
4090
|
+
type: "SpreadElement",
|
|
4091
|
+
children: [...spread, exp],
|
|
4092
|
+
names: exp.names
|
|
4093
|
+
};
|
|
4094
|
+
}
|
|
4078
4095
|
}
|
|
4079
|
-
return
|
|
4096
|
+
return void 0;
|
|
4080
4097
|
});
|
|
4081
4098
|
function ArrayElementExpression(state) {
|
|
4082
4099
|
if (state.events) {
|
|
@@ -4117,9 +4134,12 @@ ${input.slice(result.pos)}
|
|
|
4117
4134
|
return result;
|
|
4118
4135
|
}
|
|
4119
4136
|
}
|
|
4120
|
-
var BracedObjectLiteral$0 = $TS($S(OpenBrace, $E(BracedObjectLiteralContent), __, CloseBrace), function($skip, $loc, $0, $1, $2, $3
|
|
4121
|
-
|
|
4122
|
-
|
|
4137
|
+
var BracedObjectLiteral$0 = $TS($S(OpenBrace, $E(BracedObjectLiteralContent), $S(__, CloseBrace)), function($skip, $loc, $0, $1, $2, $3) {
|
|
4138
|
+
var open = $1;
|
|
4139
|
+
var content = $2;
|
|
4140
|
+
var close = $3;
|
|
4141
|
+
if (content) {
|
|
4142
|
+
const children = [open, ...content, close];
|
|
4123
4143
|
return {
|
|
4124
4144
|
type: "ObjectExpression",
|
|
4125
4145
|
children,
|
|
@@ -4130,7 +4150,7 @@ ${input.slice(result.pos)}
|
|
|
4130
4150
|
}
|
|
4131
4151
|
return {
|
|
4132
4152
|
type: "ObjectExpression",
|
|
4133
|
-
children: [
|
|
4153
|
+
children: [open, close],
|
|
4134
4154
|
names: []
|
|
4135
4155
|
};
|
|
4136
4156
|
});
|
|
@@ -4153,13 +4173,7 @@ ${input.slice(result.pos)}
|
|
|
4153
4173
|
}
|
|
4154
4174
|
}
|
|
4155
4175
|
var BracedObjectLiteralContent$0 = NestedPropertyDefinitions;
|
|
4156
|
-
var BracedObjectLiteralContent$1 =
|
|
4157
|
-
const result = [...$1, ...$2];
|
|
4158
|
-
if ($3) {
|
|
4159
|
-
result.push(...$3[0], $3[1]);
|
|
4160
|
-
}
|
|
4161
|
-
return result;
|
|
4162
|
-
});
|
|
4176
|
+
var BracedObjectLiteralContent$1 = PropertyDefinitionList;
|
|
4163
4177
|
function BracedObjectLiteralContent(state) {
|
|
4164
4178
|
if (state.events) {
|
|
4165
4179
|
const result = state.events.enter?.("BracedObjectLiteralContent", state);
|
|
@@ -4227,11 +4241,13 @@ ${input.slice(result.pos)}
|
|
|
4227
4241
|
}
|
|
4228
4242
|
}
|
|
4229
4243
|
var NestedImplicitPropertyDefinition$0 = $TS($S(Nested, NamedProperty, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
|
|
4230
|
-
|
|
4231
|
-
|
|
4232
|
-
|
|
4233
|
-
|
|
4234
|
-
|
|
4244
|
+
var ws = $1;
|
|
4245
|
+
var prop = $2;
|
|
4246
|
+
var delimiter = $3;
|
|
4247
|
+
return {
|
|
4248
|
+
...prop,
|
|
4249
|
+
children: [...ws, ...prop.children, delimiter]
|
|
4250
|
+
};
|
|
4235
4251
|
});
|
|
4236
4252
|
function NestedImplicitPropertyDefinition(state) {
|
|
4237
4253
|
if (state.events) {
|
|
@@ -4276,11 +4292,13 @@ ${input.slice(result.pos)}
|
|
|
4276
4292
|
}
|
|
4277
4293
|
}
|
|
4278
4294
|
var NestedPropertyDefinition$0 = $TS($S(Nested, PropertyDefinition, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
|
|
4279
|
-
|
|
4280
|
-
|
|
4281
|
-
|
|
4282
|
-
|
|
4283
|
-
|
|
4295
|
+
var ws = $1;
|
|
4296
|
+
var prop = $2;
|
|
4297
|
+
var delimiter = $3;
|
|
4298
|
+
return {
|
|
4299
|
+
...prop,
|
|
4300
|
+
children: [...ws, ...prop.children, delimiter]
|
|
4301
|
+
};
|
|
4284
4302
|
});
|
|
4285
4303
|
function NestedPropertyDefinition(state) {
|
|
4286
4304
|
if (state.events) {
|
|
@@ -4300,8 +4318,10 @@ ${input.slice(result.pos)}
|
|
|
4300
4318
|
return result;
|
|
4301
4319
|
}
|
|
4302
4320
|
}
|
|
4303
|
-
var InlineObjectLiteral$0 = $TS($S(InsertOpenBrace, SnugNamedProperty, $Q($S(
|
|
4304
|
-
|
|
4321
|
+
var InlineObjectLiteral$0 = $TS($S(InsertOpenBrace, SnugNamedProperty, ImplicitInlineObjectPropertyDelimiter, $Q($S(NamedProperty, ImplicitInlineObjectPropertyDelimiter)), InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
4322
|
+
var open = $1;
|
|
4323
|
+
var close = $5;
|
|
4324
|
+
return [open[1], $2, $3, ...$4, close];
|
|
4305
4325
|
});
|
|
4306
4326
|
function InlineObjectLiteral(state) {
|
|
4307
4327
|
if (state.events) {
|
|
@@ -4321,8 +4341,35 @@ ${input.slice(result.pos)}
|
|
|
4321
4341
|
return result;
|
|
4322
4342
|
}
|
|
4323
4343
|
}
|
|
4344
|
+
var ImplicitInlineObjectPropertyDelimiter$0 = $T($Y($S(EOS, NamedProperty)), function(value) {
|
|
4345
|
+
return ",";
|
|
4346
|
+
});
|
|
4347
|
+
var ImplicitInlineObjectPropertyDelimiter$1 = $T($Y($S(__, $EXPECT($L26, fail, 'ImplicitInlineObjectPropertyDelimiter ":"'))), function(value) {
|
|
4348
|
+
return "";
|
|
4349
|
+
});
|
|
4350
|
+
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y(EOS), function(value) {
|
|
4351
|
+
return "";
|
|
4352
|
+
});
|
|
4353
|
+
function ImplicitInlineObjectPropertyDelimiter(state) {
|
|
4354
|
+
if (state.events) {
|
|
4355
|
+
const result = state.events.enter?.("ImplicitInlineObjectPropertyDelimiter", state);
|
|
4356
|
+
if (result)
|
|
4357
|
+
return result.cache;
|
|
4358
|
+
}
|
|
4359
|
+
if (state.tokenize) {
|
|
4360
|
+
const result = $TOKEN("ImplicitInlineObjectPropertyDelimiter", state, ImplicitInlineObjectPropertyDelimiter$0(state) || ImplicitInlineObjectPropertyDelimiter$1(state) || ImplicitInlineObjectPropertyDelimiter$2(state));
|
|
4361
|
+
if (state.events)
|
|
4362
|
+
state.events.exit?.("ImplicitInlineObjectPropertyDelimiter", state, result);
|
|
4363
|
+
return result;
|
|
4364
|
+
} else {
|
|
4365
|
+
const result = ImplicitInlineObjectPropertyDelimiter$0(state) || ImplicitInlineObjectPropertyDelimiter$1(state) || ImplicitInlineObjectPropertyDelimiter$2(state);
|
|
4366
|
+
if (state.events)
|
|
4367
|
+
state.events.exit?.("ImplicitInlineObjectPropertyDelimiter", state, result);
|
|
4368
|
+
return result;
|
|
4369
|
+
}
|
|
4370
|
+
}
|
|
4324
4371
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
4325
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
4372
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L27, fail, 'ObjectPropertyDelimiter "}"')));
|
|
4326
4373
|
var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
4327
4374
|
return { $loc, token: "," };
|
|
4328
4375
|
});
|
|
@@ -4344,14 +4391,13 @@ ${input.slice(result.pos)}
|
|
|
4344
4391
|
return result;
|
|
4345
4392
|
}
|
|
4346
4393
|
}
|
|
4347
|
-
var PropertyDefinitionList$0 = $
|
|
4348
|
-
|
|
4349
|
-
return
|
|
4350
|
-
|
|
4351
|
-
|
|
4352
|
-
|
|
4353
|
-
}
|
|
4354
|
-
return [];
|
|
4394
|
+
var PropertyDefinitionList$0 = $TV($P($S(PropertyDefinition, ObjectPropertyDelimiter)), function($skip, $loc, $0, $1) {
|
|
4395
|
+
return $0.map(([prop, delim]) => {
|
|
4396
|
+
return {
|
|
4397
|
+
...prop,
|
|
4398
|
+
children: [...prop.children, delim]
|
|
4399
|
+
};
|
|
4400
|
+
});
|
|
4355
4401
|
});
|
|
4356
4402
|
function PropertyDefinitionList(state) {
|
|
4357
4403
|
if (state.events) {
|
|
@@ -4371,20 +4417,33 @@ ${input.slice(result.pos)}
|
|
|
4371
4417
|
return result;
|
|
4372
4418
|
}
|
|
4373
4419
|
}
|
|
4374
|
-
var PropertyDefinition$0 = $TS($S(At, IdentifierReference
|
|
4375
|
-
var
|
|
4376
|
-
var
|
|
4377
|
-
|
|
4420
|
+
var PropertyDefinition$0 = $TS($S(__, At, IdentifierReference), function($skip, $loc, $0, $1, $2, $3) {
|
|
4421
|
+
var ws = $1;
|
|
4422
|
+
var at = $2;
|
|
4423
|
+
var id = $3;
|
|
4378
4424
|
return {
|
|
4379
4425
|
type: "Property",
|
|
4380
|
-
children: [id, ": ", at, id],
|
|
4426
|
+
children: [...ws, id, ": ", { ...at, token: "this." }, id],
|
|
4381
4427
|
names: id.names
|
|
4382
4428
|
};
|
|
4383
4429
|
});
|
|
4384
4430
|
var PropertyDefinition$1 = NamedProperty;
|
|
4385
4431
|
var PropertyDefinition$2 = MethodDefinition;
|
|
4386
|
-
var PropertyDefinition$3 = $S(DotDotDot, ExtendedExpression)
|
|
4387
|
-
|
|
4432
|
+
var PropertyDefinition$3 = $TS($S(__, DotDotDot, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
4433
|
+
var ws = $1;
|
|
4434
|
+
var dots = $2;
|
|
4435
|
+
var exp = $3;
|
|
4436
|
+
return {
|
|
4437
|
+
type: "SpreadProperty",
|
|
4438
|
+
children: [...ws, dots, exp],
|
|
4439
|
+
names: exp.names
|
|
4440
|
+
};
|
|
4441
|
+
});
|
|
4442
|
+
var PropertyDefinition$4 = $TS($S(__, IdentifierReference), function($skip, $loc, $0, $1, $2) {
|
|
4443
|
+
var ws = $1;
|
|
4444
|
+
var id = $2;
|
|
4445
|
+
return { ...id, children: [...ws, ...id.children] };
|
|
4446
|
+
});
|
|
4388
4447
|
function PropertyDefinition(state) {
|
|
4389
4448
|
if (state.events) {
|
|
4390
4449
|
const result = state.events.enter?.("PropertyDefinition", state);
|
|
@@ -4403,8 +4462,8 @@ ${input.slice(result.pos)}
|
|
|
4403
4462
|
return result;
|
|
4404
4463
|
}
|
|
4405
4464
|
}
|
|
4406
|
-
var NamedProperty$0 = $TS($S(PropertyName, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
4407
|
-
var exp = $
|
|
4465
|
+
var NamedProperty$0 = $TS($S(__, PropertyName, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
4466
|
+
var exp = $5;
|
|
4408
4467
|
return {
|
|
4409
4468
|
type: "Property",
|
|
4410
4469
|
children: $0,
|
|
@@ -4643,25 +4702,28 @@ ${input.slice(result.pos)}
|
|
|
4643
4702
|
return result;
|
|
4644
4703
|
}
|
|
4645
4704
|
}
|
|
4646
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
4647
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
4648
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
4649
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
4650
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
4651
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
4652
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
4653
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
4654
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
4655
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
4656
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
4657
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
4658
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
4659
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
4660
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
4661
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
4705
|
+
var AssignmentOpSymbol$0 = $EXPECT($L28, fail, 'AssignmentOpSymbol "**="');
|
|
4706
|
+
var AssignmentOpSymbol$1 = $EXPECT($L29, fail, 'AssignmentOpSymbol "*="');
|
|
4707
|
+
var AssignmentOpSymbol$2 = $EXPECT($L30, fail, 'AssignmentOpSymbol "/="');
|
|
4708
|
+
var AssignmentOpSymbol$3 = $EXPECT($L31, fail, 'AssignmentOpSymbol "%="');
|
|
4709
|
+
var AssignmentOpSymbol$4 = $EXPECT($L32, fail, 'AssignmentOpSymbol "+="');
|
|
4710
|
+
var AssignmentOpSymbol$5 = $EXPECT($L33, fail, 'AssignmentOpSymbol "-="');
|
|
4711
|
+
var AssignmentOpSymbol$6 = $EXPECT($L34, fail, 'AssignmentOpSymbol "<<="');
|
|
4712
|
+
var AssignmentOpSymbol$7 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>>="');
|
|
4713
|
+
var AssignmentOpSymbol$8 = $EXPECT($L36, fail, 'AssignmentOpSymbol ">>="');
|
|
4714
|
+
var AssignmentOpSymbol$9 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&&="');
|
|
4715
|
+
var AssignmentOpSymbol$10 = $EXPECT($L38, fail, 'AssignmentOpSymbol "&="');
|
|
4716
|
+
var AssignmentOpSymbol$11 = $EXPECT($L39, fail, 'AssignmentOpSymbol "^="');
|
|
4717
|
+
var AssignmentOpSymbol$12 = $EXPECT($L40, fail, 'AssignmentOpSymbol "||="');
|
|
4718
|
+
var AssignmentOpSymbol$13 = $EXPECT($L41, fail, 'AssignmentOpSymbol "|="');
|
|
4719
|
+
var AssignmentOpSymbol$14 = $EXPECT($L42, fail, 'AssignmentOpSymbol "??="');
|
|
4720
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L43, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
4662
4721
|
return "??=";
|
|
4663
4722
|
});
|
|
4664
|
-
var AssignmentOpSymbol$16 = $EXPECT($
|
|
4723
|
+
var AssignmentOpSymbol$16 = $EXPECT($L44, fail, 'AssignmentOpSymbol "="');
|
|
4724
|
+
var AssignmentOpSymbol$17 = $T($S(CoffeeWordAssignmentOp), function(value) {
|
|
4725
|
+
return value[0];
|
|
4726
|
+
});
|
|
4665
4727
|
function AssignmentOpSymbol(state) {
|
|
4666
4728
|
if (state.events) {
|
|
4667
4729
|
const result = state.events.enter?.("AssignmentOpSymbol", state);
|
|
@@ -4669,17 +4731,41 @@ ${input.slice(result.pos)}
|
|
|
4669
4731
|
return result.cache;
|
|
4670
4732
|
}
|
|
4671
4733
|
if (state.tokenize) {
|
|
4672
|
-
const result = $TOKEN("AssignmentOpSymbol", state, AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state) || AssignmentOpSymbol$16(state));
|
|
4734
|
+
const result = $TOKEN("AssignmentOpSymbol", state, AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state) || AssignmentOpSymbol$16(state) || AssignmentOpSymbol$17(state));
|
|
4673
4735
|
if (state.events)
|
|
4674
4736
|
state.events.exit?.("AssignmentOpSymbol", state, result);
|
|
4675
4737
|
return result;
|
|
4676
4738
|
} else {
|
|
4677
|
-
const result = AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state) || AssignmentOpSymbol$16(state);
|
|
4739
|
+
const result = AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state) || AssignmentOpSymbol$16(state) || AssignmentOpSymbol$17(state);
|
|
4678
4740
|
if (state.events)
|
|
4679
4741
|
state.events.exit?.("AssignmentOpSymbol", state, result);
|
|
4680
4742
|
return result;
|
|
4681
4743
|
}
|
|
4682
4744
|
}
|
|
4745
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L45, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
4746
|
+
return "&&=";
|
|
4747
|
+
});
|
|
4748
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L46, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
4749
|
+
return "||=";
|
|
4750
|
+
});
|
|
4751
|
+
function CoffeeWordAssignmentOp(state) {
|
|
4752
|
+
if (state.events) {
|
|
4753
|
+
const result = state.events.enter?.("CoffeeWordAssignmentOp", state);
|
|
4754
|
+
if (result)
|
|
4755
|
+
return result.cache;
|
|
4756
|
+
}
|
|
4757
|
+
if (state.tokenize) {
|
|
4758
|
+
const result = $TOKEN("CoffeeWordAssignmentOp", state, CoffeeWordAssignmentOp$0(state) || CoffeeWordAssignmentOp$1(state));
|
|
4759
|
+
if (state.events)
|
|
4760
|
+
state.events.exit?.("CoffeeWordAssignmentOp", state, result);
|
|
4761
|
+
return result;
|
|
4762
|
+
} else {
|
|
4763
|
+
const result = CoffeeWordAssignmentOp$0(state) || CoffeeWordAssignmentOp$1(state);
|
|
4764
|
+
if (state.events)
|
|
4765
|
+
state.events.exit?.("CoffeeWordAssignmentOp", state, result);
|
|
4766
|
+
return result;
|
|
4767
|
+
}
|
|
4768
|
+
}
|
|
4683
4769
|
var BinaryOp$0 = $TS($S(BinaryOpSymbol), function($skip, $loc, $0, $1) {
|
|
4684
4770
|
if (typeof $1 === "string")
|
|
4685
4771
|
return { $loc, token: $1 };
|
|
@@ -4703,75 +4789,75 @@ ${input.slice(result.pos)}
|
|
|
4703
4789
|
return result;
|
|
4704
4790
|
}
|
|
4705
4791
|
}
|
|
4706
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
4707
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
4708
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
4709
|
-
var BinaryOpSymbol$3 = $EXPECT($
|
|
4710
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
4711
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
4712
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
4713
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
4714
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
4792
|
+
var BinaryOpSymbol$0 = $EXPECT($L47, fail, 'BinaryOpSymbol "**"');
|
|
4793
|
+
var BinaryOpSymbol$1 = $EXPECT($L48, fail, 'BinaryOpSymbol "*"');
|
|
4794
|
+
var BinaryOpSymbol$2 = $EXPECT($L49, fail, 'BinaryOpSymbol "/"');
|
|
4795
|
+
var BinaryOpSymbol$3 = $EXPECT($L50, fail, 'BinaryOpSymbol "%"');
|
|
4796
|
+
var BinaryOpSymbol$4 = $EXPECT($L51, fail, 'BinaryOpSymbol "+"');
|
|
4797
|
+
var BinaryOpSymbol$5 = $EXPECT($L52, fail, 'BinaryOpSymbol "-"');
|
|
4798
|
+
var BinaryOpSymbol$6 = $EXPECT($L53, fail, 'BinaryOpSymbol "<="');
|
|
4799
|
+
var BinaryOpSymbol$7 = $EXPECT($L54, fail, 'BinaryOpSymbol ">="');
|
|
4800
|
+
var BinaryOpSymbol$8 = $EXPECT($L55, fail, 'BinaryOpSymbol "<<"');
|
|
4715
4801
|
var BinaryOpSymbol$9 = $EXPECT($L4, fail, 'BinaryOpSymbol "<"');
|
|
4716
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
4717
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
4718
|
-
var BinaryOpSymbol$12 = $EXPECT($
|
|
4719
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
4720
|
-
var BinaryOpSymbol$14 = $TV($EXPECT($
|
|
4802
|
+
var BinaryOpSymbol$10 = $EXPECT($L56, fail, 'BinaryOpSymbol ">>>"');
|
|
4803
|
+
var BinaryOpSymbol$11 = $EXPECT($L57, fail, 'BinaryOpSymbol ">>"');
|
|
4804
|
+
var BinaryOpSymbol$12 = $EXPECT($L58, fail, 'BinaryOpSymbol ">"');
|
|
4805
|
+
var BinaryOpSymbol$13 = $EXPECT($L59, fail, 'BinaryOpSymbol "!=="');
|
|
4806
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L60, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
4721
4807
|
if (module.config.coffeeEq)
|
|
4722
4808
|
return "!==";
|
|
4723
4809
|
return $1;
|
|
4724
4810
|
});
|
|
4725
|
-
var BinaryOpSymbol$15 = $TS($S($EXPECT($
|
|
4811
|
+
var BinaryOpSymbol$15 = $TS($S($EXPECT($L61, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4726
4812
|
if (module.config.coffeeIsnt)
|
|
4727
4813
|
return "!==";
|
|
4728
4814
|
return $skip;
|
|
4729
4815
|
});
|
|
4730
|
-
var BinaryOpSymbol$16 = $T($S($EXPECT($
|
|
4816
|
+
var BinaryOpSymbol$16 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
4731
4817
|
return "===";
|
|
4732
4818
|
});
|
|
4733
|
-
var BinaryOpSymbol$17 = $EXPECT($
|
|
4734
|
-
var BinaryOpSymbol$18 = $TV($EXPECT($
|
|
4819
|
+
var BinaryOpSymbol$17 = $EXPECT($L63, fail, 'BinaryOpSymbol "==="');
|
|
4820
|
+
var BinaryOpSymbol$18 = $TV($EXPECT($L64, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
4735
4821
|
if (module.config.coffeeEq)
|
|
4736
4822
|
return "===";
|
|
4737
4823
|
return $1;
|
|
4738
4824
|
});
|
|
4739
|
-
var BinaryOpSymbol$19 = $T($S($EXPECT($
|
|
4825
|
+
var BinaryOpSymbol$19 = $T($S($EXPECT($L65, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
4740
4826
|
return "&&";
|
|
4741
4827
|
});
|
|
4742
|
-
var BinaryOpSymbol$20 = $EXPECT($
|
|
4743
|
-
var BinaryOpSymbol$21 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
4828
|
+
var BinaryOpSymbol$20 = $EXPECT($L66, fail, 'BinaryOpSymbol "&&"');
|
|
4829
|
+
var BinaryOpSymbol$21 = $T($S(CoffeeOfEnabled, $EXPECT($L67, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
4744
4830
|
return "in";
|
|
4745
4831
|
});
|
|
4746
|
-
var BinaryOpSymbol$22 = $T($S($EXPECT($
|
|
4832
|
+
var BinaryOpSymbol$22 = $T($S($EXPECT($L68, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
4747
4833
|
return "||";
|
|
4748
4834
|
});
|
|
4749
|
-
var BinaryOpSymbol$23 = $EXPECT($
|
|
4750
|
-
var BinaryOpSymbol$24 = $EXPECT($
|
|
4751
|
-
var BinaryOpSymbol$25 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($
|
|
4835
|
+
var BinaryOpSymbol$23 = $EXPECT($L69, fail, 'BinaryOpSymbol "||"');
|
|
4836
|
+
var BinaryOpSymbol$24 = $EXPECT($L70, fail, 'BinaryOpSymbol "??"');
|
|
4837
|
+
var BinaryOpSymbol$25 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L71, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
4752
4838
|
return "??";
|
|
4753
4839
|
});
|
|
4754
|
-
var BinaryOpSymbol$26 = $TS($S($EXPECT($
|
|
4840
|
+
var BinaryOpSymbol$26 = $TS($S($EXPECT($L72, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4755
4841
|
return $1;
|
|
4756
4842
|
});
|
|
4757
|
-
var BinaryOpSymbol$27 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
4843
|
+
var BinaryOpSymbol$27 = $TS($S(CoffeeOfEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
4758
4844
|
return {
|
|
4759
4845
|
ref: module.getIndexOfRef(),
|
|
4760
4846
|
suffix: " >= 0"
|
|
4761
4847
|
};
|
|
4762
4848
|
});
|
|
4763
|
-
var BinaryOpSymbol$28 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
4849
|
+
var BinaryOpSymbol$28 = $TS($S(CoffeeOfEnabled, $EXPECT($L74, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L73, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
4764
4850
|
return {
|
|
4765
4851
|
ref: module.getIndexOfRef(),
|
|
4766
4852
|
suffix: " < 0"
|
|
4767
4853
|
};
|
|
4768
4854
|
});
|
|
4769
|
-
var BinaryOpSymbol$29 = $TS($S($EXPECT($
|
|
4855
|
+
var BinaryOpSymbol$29 = $TS($S($EXPECT($L73, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4770
4856
|
return $1;
|
|
4771
4857
|
});
|
|
4772
|
-
var BinaryOpSymbol$30 = $EXPECT($
|
|
4773
|
-
var BinaryOpSymbol$31 = $EXPECT($
|
|
4774
|
-
var BinaryOpSymbol$32 = $EXPECT($
|
|
4858
|
+
var BinaryOpSymbol$30 = $EXPECT($L75, fail, 'BinaryOpSymbol "&"');
|
|
4859
|
+
var BinaryOpSymbol$31 = $EXPECT($L76, fail, 'BinaryOpSymbol "^"');
|
|
4860
|
+
var BinaryOpSymbol$32 = $EXPECT($L77, fail, 'BinaryOpSymbol "|"');
|
|
4775
4861
|
function BinaryOpSymbol(state) {
|
|
4776
4862
|
if (state.events) {
|
|
4777
4863
|
const result = state.events.enter?.("BinaryOpSymbol", state);
|
|
@@ -4910,7 +4996,7 @@ ${input.slice(result.pos)}
|
|
|
4910
4996
|
return result;
|
|
4911
4997
|
}
|
|
4912
4998
|
}
|
|
4913
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
4999
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L78, fail, 'EmptyStatement ";"'))), function(value) {
|
|
4914
5000
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
4915
5001
|
});
|
|
4916
5002
|
function EmptyStatement(state) {
|
|
@@ -4931,7 +5017,7 @@ ${input.slice(result.pos)}
|
|
|
4931
5017
|
return result;
|
|
4932
5018
|
}
|
|
4933
5019
|
}
|
|
4934
|
-
var BlockStatement$0 = $T($S(ExplicitBlock, $N($S(__, $EXPECT($
|
|
5020
|
+
var BlockStatement$0 = $T($S(ExplicitBlock, $N($S(__, $EXPECT($L44, fail, 'BlockStatement "="')))), function(value) {
|
|
4935
5021
|
return value[0];
|
|
4936
5022
|
});
|
|
4937
5023
|
function BlockStatement(state) {
|
|
@@ -5123,6 +5209,14 @@ ${input.slice(result.pos)}
|
|
|
5123
5209
|
}
|
|
5124
5210
|
var ExpressionBlock$0 = $TS($S(InsertOpenParen, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5125
5211
|
var exps = $2;
|
|
5212
|
+
if (exps.length === 1) {
|
|
5213
|
+
let [ws, exp] = exps[0];
|
|
5214
|
+
switch (exp.type) {
|
|
5215
|
+
case "Identifier":
|
|
5216
|
+
case "Literal":
|
|
5217
|
+
return [ws, exp];
|
|
5218
|
+
}
|
|
5219
|
+
}
|
|
5126
5220
|
exps = exps.map((e, i) => {
|
|
5127
5221
|
if (i === exps.length - 1) {
|
|
5128
5222
|
return e.slice(0, -1);
|
|
@@ -5156,6 +5250,14 @@ ${input.slice(result.pos)}
|
|
|
5156
5250
|
}
|
|
5157
5251
|
var ElseExpressionBlock$0 = $TS($S(InsertOpenParen, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5158
5252
|
var exps = $2;
|
|
5253
|
+
if (exps.length === 1) {
|
|
5254
|
+
let [ws, exp] = exps[0];
|
|
5255
|
+
switch (exp.type) {
|
|
5256
|
+
case "Identifier":
|
|
5257
|
+
case "Literal":
|
|
5258
|
+
return [ws, exp];
|
|
5259
|
+
}
|
|
5260
|
+
}
|
|
5159
5261
|
exps = exps.map((e, i) => {
|
|
5160
5262
|
if (i === exps.length - 1) {
|
|
5161
5263
|
return e.slice(0, -1);
|
|
@@ -5708,7 +5810,7 @@ ${input.slice(result.pos)}
|
|
|
5708
5810
|
return result;
|
|
5709
5811
|
}
|
|
5710
5812
|
}
|
|
5711
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
5813
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L79, fail, 'CoffeeForDeclaration "own"'))), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
5712
5814
|
var own = $1;
|
|
5713
5815
|
var binding = $2;
|
|
5714
5816
|
if (own) {
|
|
@@ -6245,7 +6347,7 @@ ${input.slice(result.pos)}
|
|
|
6245
6347
|
return result;
|
|
6246
6348
|
}
|
|
6247
6349
|
}
|
|
6248
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
6350
|
+
var Finally$0 = $S(__, $EXPECT($L80, fail, 'Finally "finally"'), BracedBlock);
|
|
6249
6351
|
function Finally(state) {
|
|
6250
6352
|
if (state.events) {
|
|
6251
6353
|
const result = state.events.enter?.("Finally", state);
|
|
@@ -6335,13 +6437,13 @@ ${input.slice(result.pos)}
|
|
|
6335
6437
|
return result;
|
|
6336
6438
|
}
|
|
6337
6439
|
}
|
|
6338
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
6440
|
+
var KeywordStatement$0 = $T($S($EXPECT($L81, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
6339
6441
|
return { "type": "BreakStatement", "children": value };
|
|
6340
6442
|
});
|
|
6341
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
6443
|
+
var KeywordStatement$1 = $T($S($EXPECT($L82, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
6342
6444
|
return { "type": "ContinueStatement", "children": value };
|
|
6343
6445
|
});
|
|
6344
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
6446
|
+
var KeywordStatement$2 = $T($S($EXPECT($L83, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
6345
6447
|
return { "type": "DebuggerStatement", "children": value };
|
|
6346
6448
|
});
|
|
6347
6449
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -6368,7 +6470,7 @@ ${input.slice(result.pos)}
|
|
|
6368
6470
|
return result;
|
|
6369
6471
|
}
|
|
6370
6472
|
}
|
|
6371
|
-
var DebuggerExpression$0 = $TS($S($EXPECT($
|
|
6473
|
+
var DebuggerExpression$0 = $TS($S($EXPECT($L83, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6372
6474
|
return {
|
|
6373
6475
|
type: "DebuggerExpression",
|
|
6374
6476
|
children: ["(()=>{", $1, "})()"]
|
|
@@ -6440,7 +6542,7 @@ ${input.slice(result.pos)}
|
|
|
6440
6542
|
return result;
|
|
6441
6543
|
}
|
|
6442
6544
|
}
|
|
6443
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
6545
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L84, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
6444
6546
|
return { "ts": true, "children": value };
|
|
6445
6547
|
});
|
|
6446
6548
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
@@ -6740,7 +6842,7 @@ ${input.slice(result.pos)}
|
|
|
6740
6842
|
return result;
|
|
6741
6843
|
}
|
|
6742
6844
|
}
|
|
6743
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
6845
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L85, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression));
|
|
6744
6846
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
6745
6847
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
6746
6848
|
function ExportDeclaration(state) {
|
|
@@ -6925,7 +7027,7 @@ ${input.slice(result.pos)}
|
|
|
6925
7027
|
return result;
|
|
6926
7028
|
}
|
|
6927
7029
|
}
|
|
6928
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
7030
|
+
var ConstAssignment$0 = $TV($EXPECT($L86, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
6929
7031
|
return { $loc, token: "=" };
|
|
6930
7032
|
});
|
|
6931
7033
|
function ConstAssignment(state) {
|
|
@@ -7484,7 +7586,7 @@ ${input.slice(result.pos)}
|
|
|
7484
7586
|
}
|
|
7485
7587
|
}
|
|
7486
7588
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
7487
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
7589
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L49, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L49, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
7488
7590
|
return { $loc, token: $1 };
|
|
7489
7591
|
});
|
|
7490
7592
|
function RegularExpressionLiteral(state) {
|
|
@@ -7552,7 +7654,6 @@ ${input.slice(result.pos)}
|
|
|
7552
7654
|
var body = $2;
|
|
7553
7655
|
var close = $3;
|
|
7554
7656
|
var flags = $4;
|
|
7555
|
-
debugger;
|
|
7556
7657
|
let hasSubstitutions = body.some((part) => part.type === "Substitution");
|
|
7557
7658
|
if (hasSubstitutions) {
|
|
7558
7659
|
const result = [
|
|
@@ -7830,7 +7931,7 @@ ${input.slice(result.pos)}
|
|
|
7830
7931
|
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R30, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
|
|
7831
7932
|
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($R31, fail, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")));
|
|
7832
7933
|
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($R32, fail, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")));
|
|
7833
|
-
var ReservedWord$3 = $R$0($EXPECT($R33, fail, "ReservedWord /(?:and|as|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|loop|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
7934
|
+
var ReservedWord$3 = $R$0($EXPECT($R33, fail, "ReservedWord /(?:and|as|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|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
7834
7935
|
function ReservedWord(state) {
|
|
7835
7936
|
if (state.events) {
|
|
7836
7937
|
const result = state.events.enter?.("ReservedWord", state);
|
|
@@ -7930,7 +8031,7 @@ ${input.slice(result.pos)}
|
|
|
7930
8031
|
return result;
|
|
7931
8032
|
}
|
|
7932
8033
|
}
|
|
7933
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
8034
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L87, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L88, fail, 'JSMultiLineComment "*/"')), $EXPECT($R35, fail, "JSMultiLineComment /./"))), $EXPECT($L88, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
7934
8035
|
return { $loc, token: $1 };
|
|
7935
8036
|
});
|
|
7936
8037
|
function JSMultiLineComment(state) {
|
|
@@ -7972,7 +8073,7 @@ ${input.slice(result.pos)}
|
|
|
7972
8073
|
return result;
|
|
7973
8074
|
}
|
|
7974
8075
|
}
|
|
7975
|
-
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($
|
|
8076
|
+
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L89, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L89, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L88, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R35, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L89, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
7976
8077
|
return { $loc, token: `/*${$2}*/` };
|
|
7977
8078
|
});
|
|
7978
8079
|
function CoffeeMultiLineComment(state) {
|
|
@@ -7993,7 +8094,7 @@ ${input.slice(result.pos)}
|
|
|
7993
8094
|
return result;
|
|
7994
8095
|
}
|
|
7995
8096
|
}
|
|
7996
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
8097
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L87, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L88, fail, 'InlineComment "*/"')), $EXPECT($R37, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L88, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
7997
8098
|
return { $loc, token: $1 };
|
|
7998
8099
|
});
|
|
7999
8100
|
function InlineComment(state) {
|
|
@@ -8076,7 +8177,7 @@ ${input.slice(result.pos)}
|
|
|
8076
8177
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R38, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8077
8178
|
return { $loc, token: $0 };
|
|
8078
8179
|
});
|
|
8079
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
8180
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L90, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
8080
8181
|
return "";
|
|
8081
8182
|
});
|
|
8082
8183
|
function NonNewlineWhitespace(state) {
|
|
@@ -8222,7 +8323,7 @@ ${input.slice(result.pos)}
|
|
|
8222
8323
|
return result;
|
|
8223
8324
|
}
|
|
8224
8325
|
}
|
|
8225
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
8326
|
+
var Ampersand$0 = $TV($EXPECT($L75, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
8226
8327
|
return { $loc, token: $1 };
|
|
8227
8328
|
});
|
|
8228
8329
|
function Ampersand(state) {
|
|
@@ -8243,7 +8344,7 @@ ${input.slice(result.pos)}
|
|
|
8243
8344
|
return result;
|
|
8244
8345
|
}
|
|
8245
8346
|
}
|
|
8246
|
-
var As$0 = $TS($S($EXPECT($
|
|
8347
|
+
var As$0 = $TS($S($EXPECT($L91, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8247
8348
|
return { $loc, token: $1 };
|
|
8248
8349
|
});
|
|
8249
8350
|
function As(state) {
|
|
@@ -8264,7 +8365,7 @@ ${input.slice(result.pos)}
|
|
|
8264
8365
|
return result;
|
|
8265
8366
|
}
|
|
8266
8367
|
}
|
|
8267
|
-
var At$0 = $TV($EXPECT($
|
|
8368
|
+
var At$0 = $TV($EXPECT($L92, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
8268
8369
|
return { $loc, token: $1 };
|
|
8269
8370
|
});
|
|
8270
8371
|
function At(state) {
|
|
@@ -8285,7 +8386,7 @@ ${input.slice(result.pos)}
|
|
|
8285
8386
|
return result;
|
|
8286
8387
|
}
|
|
8287
8388
|
}
|
|
8288
|
-
var Async$0 = $TV($EXPECT($
|
|
8389
|
+
var Async$0 = $TV($EXPECT($L93, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
|
|
8289
8390
|
return { $loc, token: $1 };
|
|
8290
8391
|
});
|
|
8291
8392
|
function Async(state) {
|
|
@@ -8306,7 +8407,7 @@ ${input.slice(result.pos)}
|
|
|
8306
8407
|
return result;
|
|
8307
8408
|
}
|
|
8308
8409
|
}
|
|
8309
|
-
var Await$0 = $TS($S($EXPECT($
|
|
8410
|
+
var Await$0 = $TS($S($EXPECT($L94, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8310
8411
|
return { $loc, token: $1 };
|
|
8311
8412
|
});
|
|
8312
8413
|
function Await(state) {
|
|
@@ -8327,7 +8428,7 @@ ${input.slice(result.pos)}
|
|
|
8327
8428
|
return result;
|
|
8328
8429
|
}
|
|
8329
8430
|
}
|
|
8330
|
-
var Backtick$0 = $TV($EXPECT($
|
|
8431
|
+
var Backtick$0 = $TV($EXPECT($L95, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
8331
8432
|
return { $loc, token: $1 };
|
|
8332
8433
|
});
|
|
8333
8434
|
function Backtick(state) {
|
|
@@ -8348,7 +8449,7 @@ ${input.slice(result.pos)}
|
|
|
8348
8449
|
return result;
|
|
8349
8450
|
}
|
|
8350
8451
|
}
|
|
8351
|
-
var By$0 = $TS($S($EXPECT($
|
|
8452
|
+
var By$0 = $TS($S($EXPECT($L96, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8352
8453
|
return { $loc, token: $1 };
|
|
8353
8454
|
});
|
|
8354
8455
|
function By(state) {
|
|
@@ -8369,7 +8470,7 @@ ${input.slice(result.pos)}
|
|
|
8369
8470
|
return result;
|
|
8370
8471
|
}
|
|
8371
8472
|
}
|
|
8372
|
-
var Case$0 = $TS($S($EXPECT($
|
|
8473
|
+
var Case$0 = $TS($S($EXPECT($L97, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8373
8474
|
return { $loc, token: $1 };
|
|
8374
8475
|
});
|
|
8375
8476
|
function Case(state) {
|
|
@@ -8390,7 +8491,7 @@ ${input.slice(result.pos)}
|
|
|
8390
8491
|
return result;
|
|
8391
8492
|
}
|
|
8392
8493
|
}
|
|
8393
|
-
var Catch$0 = $TV($EXPECT($
|
|
8494
|
+
var Catch$0 = $TV($EXPECT($L98, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
8394
8495
|
return { $loc, token: $1 };
|
|
8395
8496
|
});
|
|
8396
8497
|
function Catch(state) {
|
|
@@ -8411,7 +8512,7 @@ ${input.slice(result.pos)}
|
|
|
8411
8512
|
return result;
|
|
8412
8513
|
}
|
|
8413
8514
|
}
|
|
8414
|
-
var Class$0 = $TV($EXPECT($
|
|
8515
|
+
var Class$0 = $TV($EXPECT($L99, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
8415
8516
|
return { $loc, token: $1 };
|
|
8416
8517
|
});
|
|
8417
8518
|
function Class(state) {
|
|
@@ -8432,7 +8533,7 @@ ${input.slice(result.pos)}
|
|
|
8432
8533
|
return result;
|
|
8433
8534
|
}
|
|
8434
8535
|
}
|
|
8435
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
8536
|
+
var CloseBrace$0 = $TV($EXPECT($L27, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
8436
8537
|
return { $loc, token: $1 };
|
|
8437
8538
|
});
|
|
8438
8539
|
function CloseBrace(state) {
|
|
@@ -8495,7 +8596,7 @@ ${input.slice(result.pos)}
|
|
|
8495
8596
|
return result;
|
|
8496
8597
|
}
|
|
8497
8598
|
}
|
|
8498
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
8599
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L100, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
8499
8600
|
return { $loc, token: "${" };
|
|
8500
8601
|
});
|
|
8501
8602
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -8516,7 +8617,7 @@ ${input.slice(result.pos)}
|
|
|
8516
8617
|
return result;
|
|
8517
8618
|
}
|
|
8518
8619
|
}
|
|
8519
|
-
var Colon$0 = $TV($EXPECT($
|
|
8620
|
+
var Colon$0 = $TV($EXPECT($L26, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
8520
8621
|
return { $loc, token: $1 };
|
|
8521
8622
|
});
|
|
8522
8623
|
function Colon(state) {
|
|
@@ -8537,7 +8638,7 @@ ${input.slice(result.pos)}
|
|
|
8537
8638
|
return result;
|
|
8538
8639
|
}
|
|
8539
8640
|
}
|
|
8540
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
8641
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L92, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
8541
8642
|
return { $loc, token: "constructor" };
|
|
8542
8643
|
});
|
|
8543
8644
|
function ConstructorShorthand(state) {
|
|
@@ -8558,7 +8659,7 @@ ${input.slice(result.pos)}
|
|
|
8558
8659
|
return result;
|
|
8559
8660
|
}
|
|
8560
8661
|
}
|
|
8561
|
-
var Default$0 = $TS($S($EXPECT($
|
|
8662
|
+
var Default$0 = $TS($S($EXPECT($L85, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8562
8663
|
return { $loc, token: $1 };
|
|
8563
8664
|
});
|
|
8564
8665
|
function Default(state) {
|
|
@@ -8579,7 +8680,7 @@ ${input.slice(result.pos)}
|
|
|
8579
8680
|
return result;
|
|
8580
8681
|
}
|
|
8581
8682
|
}
|
|
8582
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
8683
|
+
var Delete$0 = $TS($S($EXPECT($L101, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8583
8684
|
return { $loc, token: $1 };
|
|
8584
8685
|
});
|
|
8585
8686
|
function Delete(state) {
|
|
@@ -8600,7 +8701,7 @@ ${input.slice(result.pos)}
|
|
|
8600
8701
|
return result;
|
|
8601
8702
|
}
|
|
8602
8703
|
}
|
|
8603
|
-
var Do$0 = $TS($S($EXPECT($
|
|
8704
|
+
var Do$0 = $TS($S($EXPECT($L102, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8604
8705
|
return { $loc, token: $1 };
|
|
8605
8706
|
});
|
|
8606
8707
|
function Do(state) {
|
|
@@ -8642,7 +8743,7 @@ ${input.slice(result.pos)}
|
|
|
8642
8743
|
return result;
|
|
8643
8744
|
}
|
|
8644
8745
|
}
|
|
8645
|
-
var DotDot$0 = $TV($EXPECT($
|
|
8746
|
+
var DotDot$0 = $TV($EXPECT($L103, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
8646
8747
|
return { $loc, token: $1 };
|
|
8647
8748
|
});
|
|
8648
8749
|
function DotDot(state) {
|
|
@@ -8663,7 +8764,7 @@ ${input.slice(result.pos)}
|
|
|
8663
8764
|
return result;
|
|
8664
8765
|
}
|
|
8665
8766
|
}
|
|
8666
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
8767
|
+
var DotDotDot$0 = $TV($EXPECT($L104, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
8667
8768
|
return { $loc, token: $1 };
|
|
8668
8769
|
});
|
|
8669
8770
|
function DotDotDot(state) {
|
|
@@ -8684,7 +8785,7 @@ ${input.slice(result.pos)}
|
|
|
8684
8785
|
return result;
|
|
8685
8786
|
}
|
|
8686
8787
|
}
|
|
8687
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
8788
|
+
var DoubleColon$0 = $TV($EXPECT($L105, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
8688
8789
|
return { $loc, token: $1 };
|
|
8689
8790
|
});
|
|
8690
8791
|
function DoubleColon(state) {
|
|
@@ -8705,7 +8806,7 @@ ${input.slice(result.pos)}
|
|
|
8705
8806
|
return result;
|
|
8706
8807
|
}
|
|
8707
8808
|
}
|
|
8708
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
8809
|
+
var DoubleQuote$0 = $TV($EXPECT($L106, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
8709
8810
|
return { $loc, token: $1 };
|
|
8710
8811
|
});
|
|
8711
8812
|
function DoubleQuote(state) {
|
|
@@ -8726,7 +8827,7 @@ ${input.slice(result.pos)}
|
|
|
8726
8827
|
return result;
|
|
8727
8828
|
}
|
|
8728
8829
|
}
|
|
8729
|
-
var Else$0 = $TV($EXPECT($
|
|
8830
|
+
var Else$0 = $TV($EXPECT($L107, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
8730
8831
|
return { $loc, token: $1 };
|
|
8731
8832
|
});
|
|
8732
8833
|
function Else(state) {
|
|
@@ -8747,7 +8848,7 @@ ${input.slice(result.pos)}
|
|
|
8747
8848
|
return result;
|
|
8748
8849
|
}
|
|
8749
8850
|
}
|
|
8750
|
-
var Equals$0 = $TV($EXPECT($
|
|
8851
|
+
var Equals$0 = $TV($EXPECT($L44, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
8751
8852
|
return { $loc, token: $1 };
|
|
8752
8853
|
});
|
|
8753
8854
|
function Equals(state) {
|
|
@@ -8768,7 +8869,7 @@ ${input.slice(result.pos)}
|
|
|
8768
8869
|
return result;
|
|
8769
8870
|
}
|
|
8770
8871
|
}
|
|
8771
|
-
var Export$0 = $TS($S($EXPECT($
|
|
8872
|
+
var Export$0 = $TS($S($EXPECT($L108, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8772
8873
|
return { $loc, token: $1 };
|
|
8773
8874
|
});
|
|
8774
8875
|
function Export(state) {
|
|
@@ -8789,7 +8890,7 @@ ${input.slice(result.pos)}
|
|
|
8789
8890
|
return result;
|
|
8790
8891
|
}
|
|
8791
8892
|
}
|
|
8792
|
-
var For$0 = $TS($S($EXPECT($
|
|
8893
|
+
var For$0 = $TS($S($EXPECT($L109, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8793
8894
|
return { $loc, token: $1 };
|
|
8794
8895
|
});
|
|
8795
8896
|
function For(state) {
|
|
@@ -8810,7 +8911,7 @@ ${input.slice(result.pos)}
|
|
|
8810
8911
|
return result;
|
|
8811
8912
|
}
|
|
8812
8913
|
}
|
|
8813
|
-
var From$0 = $TS($S($EXPECT($
|
|
8914
|
+
var From$0 = $TS($S($EXPECT($L110, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8814
8915
|
return { $loc, token: $1 };
|
|
8815
8916
|
});
|
|
8816
8917
|
function From(state) {
|
|
@@ -8831,7 +8932,7 @@ ${input.slice(result.pos)}
|
|
|
8831
8932
|
return result;
|
|
8832
8933
|
}
|
|
8833
8934
|
}
|
|
8834
|
-
var Function$0 = $TV($EXPECT($
|
|
8935
|
+
var Function$0 = $TV($EXPECT($L111, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
8835
8936
|
return { $loc, token: $1 };
|
|
8836
8937
|
});
|
|
8837
8938
|
function Function(state) {
|
|
@@ -8852,7 +8953,7 @@ ${input.slice(result.pos)}
|
|
|
8852
8953
|
return result;
|
|
8853
8954
|
}
|
|
8854
8955
|
}
|
|
8855
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
8956
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L112, fail, 'GetOrSet "get"'), $EXPECT($L113, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8856
8957
|
return { $loc, token: $1 };
|
|
8857
8958
|
});
|
|
8858
8959
|
function GetOrSet(state) {
|
|
@@ -8873,7 +8974,7 @@ ${input.slice(result.pos)}
|
|
|
8873
8974
|
return result;
|
|
8874
8975
|
}
|
|
8875
8976
|
}
|
|
8876
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
8977
|
+
var If$0 = $TV($TEXT($S($EXPECT($L114, fail, 'If "if"'), $E($EXPECT($L3, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
8877
8978
|
return { $loc, token: $1 };
|
|
8878
8979
|
});
|
|
8879
8980
|
function If(state) {
|
|
@@ -8915,7 +9016,7 @@ ${input.slice(result.pos)}
|
|
|
8915
9016
|
return result;
|
|
8916
9017
|
}
|
|
8917
9018
|
}
|
|
8918
|
-
var In$0 = $TV($EXPECT($
|
|
9019
|
+
var In$0 = $TV($EXPECT($L73, fail, 'In "in"'), function($skip, $loc, $0, $1) {
|
|
8919
9020
|
return { $loc, token: $1 };
|
|
8920
9021
|
});
|
|
8921
9022
|
function In(state) {
|
|
@@ -8936,7 +9037,7 @@ ${input.slice(result.pos)}
|
|
|
8936
9037
|
return result;
|
|
8937
9038
|
}
|
|
8938
9039
|
}
|
|
8939
|
-
var LetOrConst$0 = $TV($C($EXPECT($
|
|
9040
|
+
var LetOrConst$0 = $TV($C($EXPECT($L115, fail, 'LetOrConst "let"'), $EXPECT($L116, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
8940
9041
|
return { $loc, token: $1 };
|
|
8941
9042
|
});
|
|
8942
9043
|
function LetOrConst(state) {
|
|
@@ -8957,7 +9058,7 @@ ${input.slice(result.pos)}
|
|
|
8957
9058
|
return result;
|
|
8958
9059
|
}
|
|
8959
9060
|
}
|
|
8960
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
9061
|
+
var Loop$0 = $TS($S($EXPECT($L117, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8961
9062
|
return { $loc, token: "while(true)" };
|
|
8962
9063
|
});
|
|
8963
9064
|
function Loop(state) {
|
|
@@ -8978,7 +9079,7 @@ ${input.slice(result.pos)}
|
|
|
8978
9079
|
return result;
|
|
8979
9080
|
}
|
|
8980
9081
|
}
|
|
8981
|
-
var New$0 = $TV($EXPECT($
|
|
9082
|
+
var New$0 = $TV($EXPECT($L118, fail, 'New "new"'), function($skip, $loc, $0, $1) {
|
|
8982
9083
|
return { $loc, token: $1 };
|
|
8983
9084
|
});
|
|
8984
9085
|
function New(state) {
|
|
@@ -8999,7 +9100,7 @@ ${input.slice(result.pos)}
|
|
|
8999
9100
|
return result;
|
|
9000
9101
|
}
|
|
9001
9102
|
}
|
|
9002
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
9103
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L74, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L3, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
9003
9104
|
return { $loc, token: "!" };
|
|
9004
9105
|
});
|
|
9005
9106
|
function Not(state) {
|
|
@@ -9020,7 +9121,7 @@ ${input.slice(result.pos)}
|
|
|
9020
9121
|
return result;
|
|
9021
9122
|
}
|
|
9022
9123
|
}
|
|
9023
|
-
var Of$0 = $TV($EXPECT($
|
|
9124
|
+
var Of$0 = $TV($EXPECT($L67, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
9024
9125
|
return { $loc, token: $1 };
|
|
9025
9126
|
});
|
|
9026
9127
|
function Of(state) {
|
|
@@ -9041,7 +9142,7 @@ ${input.slice(result.pos)}
|
|
|
9041
9142
|
return result;
|
|
9042
9143
|
}
|
|
9043
9144
|
}
|
|
9044
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
9145
|
+
var OpenBrace$0 = $TV($EXPECT($L119, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
9045
9146
|
return { $loc, token: $1 };
|
|
9046
9147
|
});
|
|
9047
9148
|
function OpenBrace(state) {
|
|
@@ -9062,7 +9163,7 @@ ${input.slice(result.pos)}
|
|
|
9062
9163
|
return result;
|
|
9063
9164
|
}
|
|
9064
9165
|
}
|
|
9065
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
9166
|
+
var OpenBracket$0 = $TV($EXPECT($L120, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
9066
9167
|
return { $loc, token: $1 };
|
|
9067
9168
|
});
|
|
9068
9169
|
function OpenBracket(state) {
|
|
@@ -9083,7 +9184,7 @@ ${input.slice(result.pos)}
|
|
|
9083
9184
|
return result;
|
|
9084
9185
|
}
|
|
9085
9186
|
}
|
|
9086
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
9187
|
+
var OpenParen$0 = $TV($EXPECT($L121, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
9087
9188
|
return { $loc, token: $1 };
|
|
9088
9189
|
});
|
|
9089
9190
|
function OpenParen(state) {
|
|
@@ -9104,7 +9205,7 @@ ${input.slice(result.pos)}
|
|
|
9104
9205
|
return result;
|
|
9105
9206
|
}
|
|
9106
9207
|
}
|
|
9107
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
9208
|
+
var QuestionMark$0 = $TV($EXPECT($L71, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
9108
9209
|
return { $loc, token: $1 };
|
|
9109
9210
|
});
|
|
9110
9211
|
function QuestionMark(state) {
|
|
@@ -9125,7 +9226,7 @@ ${input.slice(result.pos)}
|
|
|
9125
9226
|
return result;
|
|
9126
9227
|
}
|
|
9127
9228
|
}
|
|
9128
|
-
var Return$0 = $TS($S($EXPECT($
|
|
9229
|
+
var Return$0 = $TS($S($EXPECT($L122, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9129
9230
|
return { $loc, token: $1 };
|
|
9130
9231
|
});
|
|
9131
9232
|
function Return(state) {
|
|
@@ -9146,7 +9247,7 @@ ${input.slice(result.pos)}
|
|
|
9146
9247
|
return result;
|
|
9147
9248
|
}
|
|
9148
9249
|
}
|
|
9149
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
9250
|
+
var Semicolon$0 = $TV($EXPECT($L78, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
9150
9251
|
return { $loc, token: $1 };
|
|
9151
9252
|
});
|
|
9152
9253
|
function Semicolon(state) {
|
|
@@ -9167,7 +9268,7 @@ ${input.slice(result.pos)}
|
|
|
9167
9268
|
return result;
|
|
9168
9269
|
}
|
|
9169
9270
|
}
|
|
9170
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
9271
|
+
var SingleQuote$0 = $TV($EXPECT($L123, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
9171
9272
|
return { $loc, token: $1 };
|
|
9172
9273
|
});
|
|
9173
9274
|
function SingleQuote(state) {
|
|
@@ -9188,7 +9289,7 @@ ${input.slice(result.pos)}
|
|
|
9188
9289
|
return result;
|
|
9189
9290
|
}
|
|
9190
9291
|
}
|
|
9191
|
-
var Star$0 = $TV($EXPECT($
|
|
9292
|
+
var Star$0 = $TV($EXPECT($L48, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
9192
9293
|
return { $loc, token: $1 };
|
|
9193
9294
|
});
|
|
9194
9295
|
function Star(state) {
|
|
@@ -9209,10 +9310,10 @@ ${input.slice(result.pos)}
|
|
|
9209
9310
|
return result;
|
|
9210
9311
|
}
|
|
9211
9312
|
}
|
|
9212
|
-
var Static$0 = $TV($EXPECT($
|
|
9313
|
+
var Static$0 = $TV($EXPECT($L124, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
9213
9314
|
return { $loc, token: $1 };
|
|
9214
9315
|
});
|
|
9215
|
-
var Static$1 = $TS($S($EXPECT($
|
|
9316
|
+
var Static$1 = $TS($S($EXPECT($L92, fail, 'Static "@"'), $N($EXPECT($L121, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
|
|
9216
9317
|
return { $loc, token: "static " };
|
|
9217
9318
|
});
|
|
9218
9319
|
function Static(state) {
|
|
@@ -9233,7 +9334,7 @@ ${input.slice(result.pos)}
|
|
|
9233
9334
|
return result;
|
|
9234
9335
|
}
|
|
9235
9336
|
}
|
|
9236
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
9337
|
+
var SubstitutionStart$0 = $TV($EXPECT($L125, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
9237
9338
|
return { $loc, token: $1 };
|
|
9238
9339
|
});
|
|
9239
9340
|
function SubstitutionStart(state) {
|
|
@@ -9254,7 +9355,7 @@ ${input.slice(result.pos)}
|
|
|
9254
9355
|
return result;
|
|
9255
9356
|
}
|
|
9256
9357
|
}
|
|
9257
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
9358
|
+
var Switch$0 = $TS($S($EXPECT($L126, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9258
9359
|
return { $loc, token: $1 };
|
|
9259
9360
|
});
|
|
9260
9361
|
function Switch(state) {
|
|
@@ -9275,7 +9376,7 @@ ${input.slice(result.pos)}
|
|
|
9275
9376
|
return result;
|
|
9276
9377
|
}
|
|
9277
9378
|
}
|
|
9278
|
-
var Target$0 = $TV($EXPECT($
|
|
9379
|
+
var Target$0 = $TV($EXPECT($L127, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
|
|
9279
9380
|
return { $loc, token: $1 };
|
|
9280
9381
|
});
|
|
9281
9382
|
function Target(state) {
|
|
@@ -9296,7 +9397,7 @@ ${input.slice(result.pos)}
|
|
|
9296
9397
|
return result;
|
|
9297
9398
|
}
|
|
9298
9399
|
}
|
|
9299
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
9400
|
+
var Then$0 = $TS($S(__, $EXPECT($L128, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
9300
9401
|
return { $loc, token: "" };
|
|
9301
9402
|
});
|
|
9302
9403
|
function Then(state) {
|
|
@@ -9317,7 +9418,7 @@ ${input.slice(result.pos)}
|
|
|
9317
9418
|
return result;
|
|
9318
9419
|
}
|
|
9319
9420
|
}
|
|
9320
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
9421
|
+
var Throw$0 = $TS($S($EXPECT($L129, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9321
9422
|
return { $loc, token: $1 };
|
|
9322
9423
|
});
|
|
9323
9424
|
function Throw(state) {
|
|
@@ -9338,7 +9439,7 @@ ${input.slice(result.pos)}
|
|
|
9338
9439
|
return result;
|
|
9339
9440
|
}
|
|
9340
9441
|
}
|
|
9341
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
9442
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L130, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
9342
9443
|
return { $loc, token: "`" };
|
|
9343
9444
|
});
|
|
9344
9445
|
function TripleDoubleQuote(state) {
|
|
@@ -9359,7 +9460,7 @@ ${input.slice(result.pos)}
|
|
|
9359
9460
|
return result;
|
|
9360
9461
|
}
|
|
9361
9462
|
}
|
|
9362
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
9463
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L131, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
9363
9464
|
return { $loc, token: "`" };
|
|
9364
9465
|
});
|
|
9365
9466
|
function TripleSingleQuote(state) {
|
|
@@ -9380,7 +9481,7 @@ ${input.slice(result.pos)}
|
|
|
9380
9481
|
return result;
|
|
9381
9482
|
}
|
|
9382
9483
|
}
|
|
9383
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
9484
|
+
var TripleSlash$0 = $TV($EXPECT($L132, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
9384
9485
|
return { $loc, token: "/" };
|
|
9385
9486
|
});
|
|
9386
9487
|
function TripleSlash(state) {
|
|
@@ -9401,7 +9502,7 @@ ${input.slice(result.pos)}
|
|
|
9401
9502
|
return result;
|
|
9402
9503
|
}
|
|
9403
9504
|
}
|
|
9404
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
9505
|
+
var TripleTick$0 = $TV($EXPECT($L133, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
9405
9506
|
return { $loc, token: "`" };
|
|
9406
9507
|
});
|
|
9407
9508
|
function TripleTick(state) {
|
|
@@ -9422,7 +9523,7 @@ ${input.slice(result.pos)}
|
|
|
9422
9523
|
return result;
|
|
9423
9524
|
}
|
|
9424
9525
|
}
|
|
9425
|
-
var Try$0 = $TV($EXPECT($
|
|
9526
|
+
var Try$0 = $TV($EXPECT($L134, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
9426
9527
|
return { $loc, token: $1 };
|
|
9427
9528
|
});
|
|
9428
9529
|
function Try(state) {
|
|
@@ -9443,7 +9544,7 @@ ${input.slice(result.pos)}
|
|
|
9443
9544
|
return result;
|
|
9444
9545
|
}
|
|
9445
9546
|
}
|
|
9446
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
9547
|
+
var Typeof$0 = $TS($S($EXPECT($L135, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9447
9548
|
return { $loc, token: $1 };
|
|
9448
9549
|
});
|
|
9449
9550
|
function Typeof(state) {
|
|
@@ -9464,7 +9565,7 @@ ${input.slice(result.pos)}
|
|
|
9464
9565
|
return result;
|
|
9465
9566
|
}
|
|
9466
9567
|
}
|
|
9467
|
-
var Unless$0 = $TV($EXPECT($
|
|
9568
|
+
var Unless$0 = $TV($EXPECT($L136, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
9468
9569
|
return { $loc, token: $1 };
|
|
9469
9570
|
});
|
|
9470
9571
|
function Unless(state) {
|
|
@@ -9485,7 +9586,7 @@ ${input.slice(result.pos)}
|
|
|
9485
9586
|
return result;
|
|
9486
9587
|
}
|
|
9487
9588
|
}
|
|
9488
|
-
var Until$0 = $TS($S($EXPECT($
|
|
9589
|
+
var Until$0 = $TS($S($EXPECT($L137, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9489
9590
|
return { $loc, token: $1 };
|
|
9490
9591
|
});
|
|
9491
9592
|
function Until(state) {
|
|
@@ -9506,7 +9607,7 @@ ${input.slice(result.pos)}
|
|
|
9506
9607
|
return result;
|
|
9507
9608
|
}
|
|
9508
9609
|
}
|
|
9509
|
-
var Var$0 = $TV($EXPECT($
|
|
9610
|
+
var Var$0 = $TV($EXPECT($L138, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
9510
9611
|
return { $loc, token: $1 };
|
|
9511
9612
|
});
|
|
9512
9613
|
function Var(state) {
|
|
@@ -9527,7 +9628,7 @@ ${input.slice(result.pos)}
|
|
|
9527
9628
|
return result;
|
|
9528
9629
|
}
|
|
9529
9630
|
}
|
|
9530
|
-
var Void$0 = $TS($S($EXPECT($
|
|
9631
|
+
var Void$0 = $TS($S($EXPECT($L139, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9531
9632
|
return { $loc, token: $1 };
|
|
9532
9633
|
});
|
|
9533
9634
|
function Void(state) {
|
|
@@ -9548,7 +9649,7 @@ ${input.slice(result.pos)}
|
|
|
9548
9649
|
return result;
|
|
9549
9650
|
}
|
|
9550
9651
|
}
|
|
9551
|
-
var When$0 = $TS($S($EXPECT($
|
|
9652
|
+
var When$0 = $TS($S($EXPECT($L140, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9552
9653
|
return { $loc, token: "case" };
|
|
9553
9654
|
});
|
|
9554
9655
|
function When(state) {
|
|
@@ -9569,7 +9670,7 @@ ${input.slice(result.pos)}
|
|
|
9569
9670
|
return result;
|
|
9570
9671
|
}
|
|
9571
9672
|
}
|
|
9572
|
-
var While$0 = $TS($S($EXPECT($
|
|
9673
|
+
var While$0 = $TS($S($EXPECT($L141, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9573
9674
|
return { $loc, token: $1 };
|
|
9574
9675
|
});
|
|
9575
9676
|
function While(state) {
|
|
@@ -9590,7 +9691,7 @@ ${input.slice(result.pos)}
|
|
|
9590
9691
|
return result;
|
|
9591
9692
|
}
|
|
9592
9693
|
}
|
|
9593
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
9694
|
+
var Yield$0 = $TS($S($EXPECT($L142, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9594
9695
|
return { $loc, token: $1 };
|
|
9595
9696
|
});
|
|
9596
9697
|
function Yield(state) {
|
|
@@ -9636,7 +9737,7 @@ ${input.slice(result.pos)}
|
|
|
9636
9737
|
return result;
|
|
9637
9738
|
}
|
|
9638
9739
|
}
|
|
9639
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
9740
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L143, fail, 'JSXSelfClosingElement "/>"'));
|
|
9640
9741
|
function JSXSelfClosingElement(state) {
|
|
9641
9742
|
if (state.events) {
|
|
9642
9743
|
const result = state.events.enter?.("JSXSelfClosingElement", state);
|
|
@@ -9655,7 +9756,7 @@ ${input.slice(result.pos)}
|
|
|
9655
9756
|
return result;
|
|
9656
9757
|
}
|
|
9657
9758
|
}
|
|
9658
|
-
var JSXOpeningElement$0 = $S($EXPECT($L4, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
9759
|
+
var JSXOpeningElement$0 = $S($EXPECT($L4, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L58, fail, 'JSXOpeningElement ">"'));
|
|
9659
9760
|
function JSXOpeningElement(state) {
|
|
9660
9761
|
if (state.events) {
|
|
9661
9762
|
const result = state.events.enter?.("JSXOpeningElement", state);
|
|
@@ -9674,7 +9775,7 @@ ${input.slice(result.pos)}
|
|
|
9674
9775
|
return result;
|
|
9675
9776
|
}
|
|
9676
9777
|
}
|
|
9677
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
9778
|
+
var JSXClosingElement$0 = $S($EXPECT($L144, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L58, fail, 'JSXClosingElement ">"'));
|
|
9678
9779
|
function JSXClosingElement(state) {
|
|
9679
9780
|
if (state.events) {
|
|
9680
9781
|
const result = state.events.enter?.("JSXClosingElement", state);
|
|
@@ -9693,7 +9794,7 @@ ${input.slice(result.pos)}
|
|
|
9693
9794
|
return result;
|
|
9694
9795
|
}
|
|
9695
9796
|
}
|
|
9696
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
9797
|
+
var JSXFragment$0 = $S($EXPECT($L145, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L146, fail, 'JSXFragment "</>"'));
|
|
9697
9798
|
function JSXFragment(state) {
|
|
9698
9799
|
if (state.events) {
|
|
9699
9800
|
const result = state.events.enter?.("JSXFragment", state);
|
|
@@ -9950,7 +10051,7 @@ ${input.slice(result.pos)}
|
|
|
9950
10051
|
return result;
|
|
9951
10052
|
}
|
|
9952
10053
|
}
|
|
9953
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
10054
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L147, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
9954
10055
|
var TypeDeclarationModifier$1 = Export;
|
|
9955
10056
|
function TypeDeclarationModifier(state) {
|
|
9956
10057
|
if (state.events) {
|
|
@@ -9992,7 +10093,7 @@ ${input.slice(result.pos)}
|
|
|
9992
10093
|
return result;
|
|
9993
10094
|
}
|
|
9994
10095
|
}
|
|
9995
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
10096
|
+
var TypeKeyword$0 = $S($EXPECT($L148, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
9996
10097
|
function TypeKeyword(state) {
|
|
9997
10098
|
if (state.events) {
|
|
9998
10099
|
const result = state.events.enter?.("TypeKeyword", state);
|
|
@@ -10011,7 +10112,7 @@ ${input.slice(result.pos)}
|
|
|
10011
10112
|
return result;
|
|
10012
10113
|
}
|
|
10013
10114
|
}
|
|
10014
|
-
var Interface$0 = $S($EXPECT($
|
|
10115
|
+
var Interface$0 = $S($EXPECT($L149, fail, 'Interface "interface"'), NonIdContinue);
|
|
10015
10116
|
function Interface(state) {
|
|
10016
10117
|
if (state.events) {
|
|
10017
10118
|
const result = state.events.enter?.("Interface", state);
|
|
@@ -10030,7 +10131,7 @@ ${input.slice(result.pos)}
|
|
|
10030
10131
|
return result;
|
|
10031
10132
|
}
|
|
10032
10133
|
}
|
|
10033
|
-
var Namespace$0 = $S($EXPECT($
|
|
10134
|
+
var Namespace$0 = $S($EXPECT($L150, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
10034
10135
|
function Namespace(state) {
|
|
10035
10136
|
if (state.events) {
|
|
10036
10137
|
const result = state.events.enter?.("Namespace", state);
|
|
@@ -10219,7 +10320,7 @@ ${input.slice(result.pos)}
|
|
|
10219
10320
|
return result;
|
|
10220
10321
|
}
|
|
10221
10322
|
}
|
|
10222
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R45, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($
|
|
10323
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R45, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L151, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R46, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
10223
10324
|
function TypeIndexSignature(state) {
|
|
10224
10325
|
if (state.events) {
|
|
10225
10326
|
const result = state.events.enter?.("TypeIndexSignature", state);
|
|
@@ -10279,7 +10380,7 @@ ${input.slice(result.pos)}
|
|
|
10279
10380
|
return result;
|
|
10280
10381
|
}
|
|
10281
10382
|
}
|
|
10282
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
10383
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L152, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
10283
10384
|
const children = [...$1, $2];
|
|
10284
10385
|
if ($3)
|
|
10285
10386
|
children.push($3);
|
|
@@ -10308,7 +10409,7 @@ ${input.slice(result.pos)}
|
|
|
10308
10409
|
return result;
|
|
10309
10410
|
}
|
|
10310
10411
|
}
|
|
10311
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
10412
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L62, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
10312
10413
|
if (!$2)
|
|
10313
10414
|
return $1;
|
|
10314
10415
|
return $0;
|
|
@@ -10414,9 +10515,9 @@ ${input.slice(result.pos)}
|
|
|
10414
10515
|
return result;
|
|
10415
10516
|
}
|
|
10416
10517
|
}
|
|
10417
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
10418
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
10419
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
10518
|
+
var TypeUnaryOp$0 = $EXPECT($L153, fail, 'TypeUnaryOp "keyof"');
|
|
10519
|
+
var TypeUnaryOp$1 = $EXPECT($L135, fail, 'TypeUnaryOp "typeof"');
|
|
10520
|
+
var TypeUnaryOp$2 = $EXPECT($L154, fail, 'TypeUnaryOp "infer"');
|
|
10420
10521
|
function TypeUnaryOp(state) {
|
|
10421
10522
|
if (state.events) {
|
|
10422
10523
|
const result = state.events.enter?.("TypeUnaryOp", state);
|
|
@@ -10584,10 +10685,10 @@ ${input.slice(result.pos)}
|
|
|
10584
10685
|
}
|
|
10585
10686
|
}
|
|
10586
10687
|
var TypeLiteral$0 = Literal;
|
|
10587
|
-
var TypeLiteral$1 = $TV($EXPECT($
|
|
10688
|
+
var TypeLiteral$1 = $TV($EXPECT($L139, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
|
|
10588
10689
|
return { $loc, token: "void" };
|
|
10589
10690
|
});
|
|
10590
|
-
var TypeLiteral$2 = $TV($EXPECT($
|
|
10691
|
+
var TypeLiteral$2 = $TV($EXPECT($L155, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
10591
10692
|
return { $loc, token: "[]" };
|
|
10592
10693
|
});
|
|
10593
10694
|
function TypeLiteral(state) {
|
|
@@ -10608,10 +10709,10 @@ ${input.slice(result.pos)}
|
|
|
10608
10709
|
return result;
|
|
10609
10710
|
}
|
|
10610
10711
|
}
|
|
10611
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
10712
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L77, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
10612
10713
|
return { $loc, token: "|" };
|
|
10613
10714
|
});
|
|
10614
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
10715
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L75, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
10615
10716
|
return { $loc, token: "&" };
|
|
10616
10717
|
});
|
|
10617
10718
|
function TypeBinaryOp(state) {
|
|
@@ -10651,7 +10752,7 @@ ${input.slice(result.pos)}
|
|
|
10651
10752
|
return result;
|
|
10652
10753
|
}
|
|
10653
10754
|
}
|
|
10654
|
-
var TypeArguments$0 = $S(__, $EXPECT($L4, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
10755
|
+
var TypeArguments$0 = $S(__, $EXPECT($L4, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L58, fail, 'TypeArguments ">"'));
|
|
10655
10756
|
function TypeArguments(state) {
|
|
10656
10757
|
if (state.events) {
|
|
10657
10758
|
const result = state.events.enter?.("TypeArguments", state);
|
|
@@ -10670,7 +10771,7 @@ ${input.slice(result.pos)}
|
|
|
10670
10771
|
return result;
|
|
10671
10772
|
}
|
|
10672
10773
|
}
|
|
10673
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($L4, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
10774
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L4, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L58, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
10674
10775
|
return { ts: true, children: $0 };
|
|
10675
10776
|
});
|
|
10676
10777
|
function TypeParameters(state) {
|
|
@@ -10730,8 +10831,8 @@ ${input.slice(result.pos)}
|
|
|
10730
10831
|
}
|
|
10731
10832
|
}
|
|
10732
10833
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
10733
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
10734
|
-
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($
|
|
10834
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L58, fail, 'TypeParameterDelimiter ">"')));
|
|
10835
|
+
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L58, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
|
|
10735
10836
|
return { $loc, token: "," };
|
|
10736
10837
|
});
|
|
10737
10838
|
var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
@@ -10800,7 +10901,7 @@ ${input.slice(result.pos)}
|
|
|
10800
10901
|
return result;
|
|
10801
10902
|
}
|
|
10802
10903
|
}
|
|
10803
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
10904
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L156, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R49, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
10804
10905
|
var options = $2;
|
|
10805
10906
|
return {
|
|
10806
10907
|
type: "CivetPrologue",
|
|
@@ -11571,11 +11672,11 @@ ${input.slice(result.pos)}
|
|
|
11571
11672
|
});
|
|
11572
11673
|
module.expressionizeIfClause = function(clause, b, e) {
|
|
11573
11674
|
const children = clause.children.slice(1);
|
|
11574
|
-
children.push("?", b
|
|
11675
|
+
children.push("?", b);
|
|
11575
11676
|
if (e) {
|
|
11576
|
-
children.push(e[0], ...e.slice(2));
|
|
11677
|
+
children.push(e[0], ":", ...e.slice(2));
|
|
11577
11678
|
} else {
|
|
11578
|
-
children.push("void 0");
|
|
11679
|
+
children.push(":void 0");
|
|
11579
11680
|
}
|
|
11580
11681
|
return {
|
|
11581
11682
|
type: "IfExpression",
|
|
@@ -11952,6 +12053,14 @@ ${input.slice(result.pos)}
|
|
|
11952
12053
|
token: str
|
|
11953
12054
|
};
|
|
11954
12055
|
};
|
|
12056
|
+
module.reorderBindingRestProperty = function(rest, after) {
|
|
12057
|
+
if (after.length) {
|
|
12058
|
+
const [restDelim] = rest.children.slice(-1), lastAfterProp = after[after.length - 1], lastAfterChildren = lastAfterProp.children, [lastDelim] = lastAfterChildren.slice(-1);
|
|
12059
|
+
rest = { ...rest, children: [...rest.children.slice(0, -1), lastDelim] };
|
|
12060
|
+
after = [...after.slice(0, -1), { ...lastAfterProp, children: [...lastAfterChildren.slice(0, -1), restDelim] }];
|
|
12061
|
+
}
|
|
12062
|
+
return [rest, after];
|
|
12063
|
+
};
|
|
11955
12064
|
function gatherNodes(node, predicate) {
|
|
11956
12065
|
if (node == null)
|
|
11957
12066
|
return [];
|
|
@@ -11999,39 +12108,149 @@ ${input.slice(result.pos)}
|
|
|
11999
12108
|
}
|
|
12000
12109
|
return nodes;
|
|
12001
12110
|
}
|
|
12002
|
-
function
|
|
12003
|
-
|
|
12004
|
-
|
|
12111
|
+
function processAtParams(f) {
|
|
12112
|
+
const { parameters, block } = f;
|
|
12113
|
+
if (!block)
|
|
12114
|
+
return;
|
|
12115
|
+
const { expressions } = block;
|
|
12116
|
+
if (!expressions)
|
|
12117
|
+
return;
|
|
12118
|
+
let indent;
|
|
12119
|
+
if (expressions.length === 0) {
|
|
12120
|
+
indent = "";
|
|
12121
|
+
} else {
|
|
12122
|
+
indent = expressions[0][0];
|
|
12123
|
+
}
|
|
12124
|
+
const thisAssignments = gatherRecursiveAll(parameters, (n) => n.type === "Ref").map((ref) => {
|
|
12125
|
+
const { base: name } = ref;
|
|
12126
|
+
return [indent, [`this.${name} = `, ref], ";\n"];
|
|
12005
12127
|
});
|
|
12006
|
-
|
|
12007
|
-
|
|
12008
|
-
|
|
12009
|
-
|
|
12010
|
-
|
|
12128
|
+
block.expressions.unshift(...thisAssignments);
|
|
12129
|
+
}
|
|
12130
|
+
function adjustAtBindings(statements) {
|
|
12131
|
+
gatherRecursiveAll(statements, (n) => n.type === "AtBindingProperty").forEach((binding) => {
|
|
12132
|
+
const { ref } = binding;
|
|
12133
|
+
if (ref.names[0] !== ref.base) {
|
|
12134
|
+
binding.children.unshift(ref.base, ": ");
|
|
12011
12135
|
}
|
|
12012
12136
|
});
|
|
12013
|
-
|
|
12014
|
-
|
|
12015
|
-
|
|
12016
|
-
|
|
12017
|
-
|
|
12018
|
-
|
|
12137
|
+
}
|
|
12138
|
+
function processFunctions(statements) {
|
|
12139
|
+
gatherRecursiveAll(statements, (n) => {
|
|
12140
|
+
return n.type === "FunctionExpression" || n.type === "ArrowFunction";
|
|
12141
|
+
}).forEach((f) => {
|
|
12142
|
+
processAtParams(f);
|
|
12143
|
+
const { block, returnType } = f;
|
|
12144
|
+
if (module.config.implicitReturns) {
|
|
12145
|
+
const isVoid = returnType === "void";
|
|
12146
|
+
const isBlock = block?.type === "BlockStatement";
|
|
12147
|
+
if (!isVoid && isBlock) {
|
|
12148
|
+
insertReturn(block);
|
|
12149
|
+
}
|
|
12019
12150
|
}
|
|
12020
12151
|
});
|
|
12021
|
-
gatherRecursiveAll(statements, (n) => n.type === "
|
|
12022
|
-
|
|
12152
|
+
gatherRecursiveAll(statements, (n) => n.type === "MethodDefinition").forEach((f) => {
|
|
12153
|
+
processAtParams(f);
|
|
12154
|
+
const { children: [sig, block] } = f;
|
|
12155
|
+
if (module.config.implicitReturns) {
|
|
12156
|
+
const isConstructor = sig.name === "constructor";
|
|
12157
|
+
const isVoid = sig.returnType === "void";
|
|
12158
|
+
const isSet = sig.modifier === "set";
|
|
12159
|
+
if (!isConstructor && !isSet && !isVoid) {
|
|
12160
|
+
insertReturn(block);
|
|
12161
|
+
}
|
|
12162
|
+
}
|
|
12023
12163
|
});
|
|
12024
12164
|
}
|
|
12025
|
-
|
|
12165
|
+
function processSwitchExpressions(statements) {
|
|
12026
12166
|
if (module.config.implicitReturns) {
|
|
12027
|
-
|
|
12167
|
+
gatherRecursiveAll(statements, (n) => n.type === "SwitchExpression").forEach(({ block }) => {
|
|
12168
|
+
insertReturn(block);
|
|
12169
|
+
});
|
|
12028
12170
|
}
|
|
12171
|
+
}
|
|
12172
|
+
function processAssignments(statements) {
|
|
12173
|
+
gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" && n.names === null).forEach((exp) => {
|
|
12174
|
+
let $02 = exp.children, [$12, $22] = $02, tail = [], i = 0, len = $12.length;
|
|
12175
|
+
let wrapped = false;
|
|
12176
|
+
while (i < len) {
|
|
12177
|
+
const lastAssignment = $12[i++];
|
|
12178
|
+
const [, lhs, , op] = lastAssignment;
|
|
12179
|
+
if (op.token !== "=")
|
|
12180
|
+
continue;
|
|
12181
|
+
if (lhs.type === "ObjectExpression") {
|
|
12182
|
+
const spreadIndex = lhs.children.findIndex((child) => child.type === "SpreadProperty"), hasSpread = spreadIndex >= 0;
|
|
12183
|
+
if (hasSpread) {
|
|
12184
|
+
const len2 = lhs.children.length, after = lhs.children.splice(spreadIndex + 1, len2 - spreadIndex - 2);
|
|
12185
|
+
if (after.length) {
|
|
12186
|
+
if (after.some((child) => child.type === "SpreadProperty")) {
|
|
12187
|
+
throw new Error("Cannot have multiple spread properties in object destructuring");
|
|
12188
|
+
}
|
|
12189
|
+
debugger;
|
|
12190
|
+
const lastAfterChildren = after[after.length - 1].children, afterDelimiter = lastAfterChildren.pop(), spread = lhs.children[spreadIndex], spreadDelimiter = spread.children.pop();
|
|
12191
|
+
spread.children.push(afterDelimiter);
|
|
12192
|
+
lastAfterChildren.push(spreadDelimiter);
|
|
12193
|
+
lhs.children.splice(spreadIndex, 0, ...after);
|
|
12194
|
+
}
|
|
12195
|
+
}
|
|
12196
|
+
if (!wrapped) {
|
|
12197
|
+
wrapped = true;
|
|
12198
|
+
lhs.children.splice(0, 0, "(");
|
|
12199
|
+
tail.push(")");
|
|
12200
|
+
}
|
|
12201
|
+
}
|
|
12202
|
+
}
|
|
12203
|
+
i = len - 1;
|
|
12204
|
+
while (i >= 0) {
|
|
12205
|
+
const lastAssignment = $12[i];
|
|
12206
|
+
if (lastAssignment[3].token === "=") {
|
|
12207
|
+
const lhs = lastAssignment[1];
|
|
12208
|
+
if (Array.isArray(lhs) && lhs.length > 1) {
|
|
12209
|
+
const props = lhs[lhs.length - 1];
|
|
12210
|
+
if (Array.isArray(props)) {
|
|
12211
|
+
const lastProp = props[props.length - 1];
|
|
12212
|
+
if (lastProp.type === "SliceExpression") {
|
|
12213
|
+
const { start, end, children: c } = lastProp;
|
|
12214
|
+
c[0].token = ".splice(";
|
|
12215
|
+
c[1] = start;
|
|
12216
|
+
c[2] = ", ";
|
|
12217
|
+
if (end)
|
|
12218
|
+
c[3] = [end, " - ", start];
|
|
12219
|
+
else
|
|
12220
|
+
c[3] = ["1/0"];
|
|
12221
|
+
c[4] = [", ...", $22];
|
|
12222
|
+
c[5] = ")";
|
|
12223
|
+
lastAssignment.pop();
|
|
12224
|
+
if (module.isWhitespaceOrEmpty(lastAssignment[2]))
|
|
12225
|
+
lastAssignment.pop();
|
|
12226
|
+
if ($12.length > 1) {
|
|
12227
|
+
throw new Error("Not implemented yet! TODO: Handle multiple splice assignments");
|
|
12228
|
+
}
|
|
12229
|
+
exp.children = [$12];
|
|
12230
|
+
exp.names = [];
|
|
12231
|
+
return;
|
|
12232
|
+
}
|
|
12233
|
+
}
|
|
12234
|
+
}
|
|
12235
|
+
}
|
|
12236
|
+
i--;
|
|
12237
|
+
}
|
|
12238
|
+
const names = $12.flatMap(([, l]) => l.names || []);
|
|
12239
|
+
exp.children = [$12, $22, ...tail];
|
|
12240
|
+
exp.names = names;
|
|
12241
|
+
});
|
|
12242
|
+
}
|
|
12243
|
+
module.processProgram = function(statements) {
|
|
12244
|
+
processAssignments(statements);
|
|
12245
|
+
processFunctions(statements);
|
|
12246
|
+
processSwitchExpressions(statements);
|
|
12029
12247
|
gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
|
|
12030
12248
|
statements.unshift(...module.prelude);
|
|
12031
12249
|
if (module.config.autoVar) {
|
|
12032
12250
|
createVarDecs(statements, []);
|
|
12033
12251
|
}
|
|
12034
12252
|
populateRefs(statements);
|
|
12253
|
+
adjustAtBindings(statements);
|
|
12035
12254
|
};
|
|
12036
12255
|
function findDecs(statements) {
|
|
12037
12256
|
const declarationNames = gatherNodes(statements, (node) => {
|
|
@@ -12144,7 +12363,7 @@ ${input.slice(result.pos)}
|
|
|
12144
12363
|
return result;
|
|
12145
12364
|
}
|
|
12146
12365
|
}
|
|
12147
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
12366
|
+
var Indent$0 = $TV($Q($C($EXPECT($L157, fail, 'Indent " "'), $EXPECT($L158, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
12148
12367
|
const level = $1.length;
|
|
12149
12368
|
return {
|
|
12150
12369
|
$loc,
|
|
@@ -12837,6 +13056,7 @@ ${"//#"} sourceMappingURL=data:application/json;base64,${base64Encode(JSON.strin
|
|
|
12837
13056
|
case "AssignmentExpression":
|
|
12838
13057
|
case "ExtendedExpression":
|
|
12839
13058
|
case "Expression":
|
|
13059
|
+
case "MemberExpressionRest":
|
|
12840
13060
|
case "ElseClause":
|
|
12841
13061
|
case "CoffeeCommentEnabled":
|
|
12842
13062
|
case "SingleLineComment":
|