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