@danielx/civet 0.5.36 → 0.5.38
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/browser.js +644 -652
- package/dist/main.js +644 -652
- package/dist/main.mjs +644 -652
- package/package.json +1 -1
package/dist/main.mjs
CHANGED
|
@@ -433,6 +433,7 @@ ${input.slice(result.pos)}
|
|
|
433
433
|
Arguments,
|
|
434
434
|
ExplicitArguments,
|
|
435
435
|
ApplicationStart,
|
|
436
|
+
ForbiddenImplicitCalls,
|
|
436
437
|
IndentedApplicationAllowed,
|
|
437
438
|
ArgumentsWithTrailingMemberExpressions,
|
|
438
439
|
ArgumentList,
|
|
@@ -491,7 +492,6 @@ ${input.slice(result.pos)}
|
|
|
491
492
|
CallExpressionRest,
|
|
492
493
|
OptionalShorthand,
|
|
493
494
|
NonNullAssertion,
|
|
494
|
-
AdditionalReservedWords,
|
|
495
495
|
MemberExpression,
|
|
496
496
|
MemberExpressionRest,
|
|
497
497
|
MemberBracketContent,
|
|
@@ -725,6 +725,7 @@ ${input.slice(result.pos)}
|
|
|
725
725
|
TrailingComment,
|
|
726
726
|
_,
|
|
727
727
|
NonNewlineWhitespace,
|
|
728
|
+
Trimmed_,
|
|
728
729
|
__,
|
|
729
730
|
Whitespace,
|
|
730
731
|
ExpressionDelimiter,
|
|
@@ -848,6 +849,8 @@ ${input.slice(result.pos)}
|
|
|
848
849
|
TypeDeclaration,
|
|
849
850
|
TypeDeclarationModifier,
|
|
850
851
|
TypeDeclarationRest,
|
|
852
|
+
InterfaceExtendsClause,
|
|
853
|
+
InterfaceExtendsTarget,
|
|
851
854
|
TypeKeyword,
|
|
852
855
|
Interface,
|
|
853
856
|
Namespace,
|
|
@@ -871,6 +874,7 @@ ${input.slice(result.pos)}
|
|
|
871
874
|
TypeUnaryOp,
|
|
872
875
|
TypeIndexedAccess,
|
|
873
876
|
TypePrimary,
|
|
877
|
+
ImportType,
|
|
874
878
|
TypeTuple,
|
|
875
879
|
TypeList,
|
|
876
880
|
NestedTypeList,
|
|
@@ -880,10 +884,6 @@ ${input.slice(result.pos)}
|
|
|
880
884
|
TypeBinaryOp,
|
|
881
885
|
FunctionType,
|
|
882
886
|
TypeArguments,
|
|
883
|
-
InlineTypeArguments,
|
|
884
|
-
InlineTypeArgument,
|
|
885
|
-
InlineTypeArgumentDelimiter,
|
|
886
|
-
CompactTypeArguments,
|
|
887
887
|
TypeArgument,
|
|
888
888
|
TypeArgumentDelimiter,
|
|
889
889
|
TypeParameters,
|
|
@@ -937,174 +937,176 @@ ${input.slice(result.pos)}
|
|
|
937
937
|
PopIndent,
|
|
938
938
|
Nested
|
|
939
939
|
});
|
|
940
|
-
var $L0 = $L("");
|
|
941
|
-
var $L1 = $L("
|
|
942
|
-
var $L2 = $L("
|
|
943
|
-
var $L3 = $L("
|
|
944
|
-
var $L4 = $L("
|
|
945
|
-
var $L5 = $L("
|
|
946
|
-
var $L6 = $L("
|
|
947
|
-
var $L7 = $L("
|
|
948
|
-
var $L8 = $L("
|
|
949
|
-
var $L9 = $L("
|
|
950
|
-
var $L10 = $L("
|
|
951
|
-
var $L11 = $L("
|
|
952
|
-
var $L12 = $L("
|
|
953
|
-
var $L13 = $L("
|
|
954
|
-
var $L14 = $L("
|
|
955
|
-
var $L15 = $L("
|
|
956
|
-
var $L16 = $L("
|
|
957
|
-
var $L17 = $L("
|
|
958
|
-
var $L18 = $L("
|
|
959
|
-
var $L19 = $L("
|
|
960
|
-
var $L20 = $L("
|
|
961
|
-
var $L21 = $L("
|
|
962
|
-
var $L22 = $L("
|
|
963
|
-
var $L23 = $L("
|
|
964
|
-
var $L24 = $L("
|
|
965
|
-
var $L25 = $L("
|
|
966
|
-
var $L26 = $L("
|
|
967
|
-
var $L27 = $L("
|
|
968
|
-
var $L28 = $L("
|
|
969
|
-
var $L29 = $L("
|
|
970
|
-
var $L30 = $L("
|
|
971
|
-
var $L31 = $L("
|
|
972
|
-
var $L32 = $L("
|
|
973
|
-
var $L33 = $L("
|
|
974
|
-
var $L34 = $L("
|
|
975
|
-
var $L35 = $L("
|
|
976
|
-
var $L36 = $L("
|
|
977
|
-
var $L37 = $L("
|
|
978
|
-
var $L38 = $L("
|
|
979
|
-
var $L39 = $L("
|
|
980
|
-
var $L40 = $L("
|
|
981
|
-
var $L41 = $L("
|
|
982
|
-
var $L42 = $L("
|
|
983
|
-
var $L43 = $L("
|
|
984
|
-
var $L44 = $L("
|
|
985
|
-
var $L45 = $L("
|
|
986
|
-
var $L46 = $L("
|
|
987
|
-
var $L47 = $L("
|
|
988
|
-
var $L48 = $L("
|
|
989
|
-
var $L49 = $L("
|
|
990
|
-
var $L50 = $L("
|
|
991
|
-
var $L51 = $L("
|
|
992
|
-
var $L52 = $L("
|
|
993
|
-
var $L53 = $L("
|
|
994
|
-
var $L54 = $L("
|
|
995
|
-
var $L55 = $L("
|
|
996
|
-
var $L56 = $L("
|
|
997
|
-
var $L57 = $L("
|
|
998
|
-
var $L58 = $L("
|
|
999
|
-
var $L59 = $L("
|
|
1000
|
-
var $L60 = $L("
|
|
1001
|
-
var $L61 = $L("
|
|
1002
|
-
var $L62 = $L("
|
|
1003
|
-
var $L63 = $L("
|
|
1004
|
-
var $L64 = $L("
|
|
1005
|
-
var $L65 = $L("
|
|
1006
|
-
var $L66 = $L("
|
|
1007
|
-
var $L67 = $L("
|
|
1008
|
-
var $L68 = $L("
|
|
1009
|
-
var $L69 = $L("
|
|
1010
|
-
var $L70 = $L("
|
|
1011
|
-
var $L71 = $L("
|
|
1012
|
-
var $L72 = $L("
|
|
1013
|
-
var $L73 = $L("
|
|
1014
|
-
var $L74 = $L("
|
|
1015
|
-
var $L75 = $L("
|
|
1016
|
-
var $L76 = $L("
|
|
1017
|
-
var $L77 = $L("
|
|
1018
|
-
var $L78 = $L("
|
|
1019
|
-
var $L79 = $L("
|
|
1020
|
-
var $L80 = $L("
|
|
1021
|
-
var $L81 = $L("
|
|
1022
|
-
var $L82 = $L("
|
|
1023
|
-
var $L83 = $L("
|
|
1024
|
-
var $L84 = $L("
|
|
1025
|
-
var $L85 = $L("
|
|
1026
|
-
var $L86 = $L("
|
|
1027
|
-
var $L87 = $L("
|
|
1028
|
-
var $L88 = $L("
|
|
1029
|
-
var $L89 = $L("
|
|
1030
|
-
var $L90 = $L("
|
|
1031
|
-
var $L91 = $L("
|
|
1032
|
-
var $L92 = $L("
|
|
1033
|
-
var $L93 = $L("
|
|
1034
|
-
var $L94 = $L("
|
|
1035
|
-
var $L95 = $L("
|
|
1036
|
-
var $L96 = $L("
|
|
1037
|
-
var $L97 = $L("
|
|
1038
|
-
var $L98 = $L("
|
|
1039
|
-
var $L99 = $L("
|
|
1040
|
-
var $L100 = $L("
|
|
1041
|
-
var $L101 = $L("
|
|
1042
|
-
var $L102 = $L("
|
|
1043
|
-
var $L103 = $L("
|
|
1044
|
-
var $L104 = $L("
|
|
1045
|
-
var $L105 = $L("
|
|
1046
|
-
var $L106 = $L(
|
|
1047
|
-
var $L107 = $L("
|
|
1048
|
-
var $L108 = $L("
|
|
1049
|
-
var $L109 = $L("
|
|
1050
|
-
var $L110 = $L("
|
|
1051
|
-
var $L111 = $L("
|
|
1052
|
-
var $L112 = $L("
|
|
1053
|
-
var $L113 = $L("
|
|
1054
|
-
var $L114 = $L("
|
|
1055
|
-
var $L115 = $L("
|
|
1056
|
-
var $L116 = $L("
|
|
1057
|
-
var $L117 = $L("
|
|
1058
|
-
var $L118 = $L("
|
|
1059
|
-
var $L119 = $L("
|
|
1060
|
-
var $L120 = $L("
|
|
1061
|
-
var $L121 = $L("
|
|
1062
|
-
var $L122 = $L("
|
|
1063
|
-
var $L123 = $L("
|
|
1064
|
-
var $L124 = $L("
|
|
1065
|
-
var $L125 = $L("
|
|
1066
|
-
var $L126 = $L("
|
|
1067
|
-
var $L127 = $L("
|
|
1068
|
-
var $L128 = $L("
|
|
1069
|
-
var $L129 = $L("
|
|
1070
|
-
var $L130 = $L("
|
|
1071
|
-
var $L131 = $L("
|
|
1072
|
-
var $L132 = $L("
|
|
1073
|
-
var $L133 = $L("
|
|
1074
|
-
var $L134 = $L("
|
|
1075
|
-
var $L135 = $L("
|
|
1076
|
-
var $L136 = $L("
|
|
1077
|
-
var $L137 = $L("
|
|
1078
|
-
var $L138 = $L("
|
|
1079
|
-
var $L139 = $L(
|
|
1080
|
-
var $L140 = $L("
|
|
1081
|
-
var $L141 = $L("
|
|
1082
|
-
var $L142 = $L("
|
|
1083
|
-
var $L143 = $L("
|
|
1084
|
-
var $L144 = $L("
|
|
1085
|
-
var $L145 = $L("
|
|
1086
|
-
var $L146 = $L("
|
|
1087
|
-
var $L147 = $L("
|
|
1088
|
-
var $L148 = $L("
|
|
1089
|
-
var $L149 = $L("
|
|
1090
|
-
var $L150 = $L("
|
|
1091
|
-
var $L151 = $L("
|
|
1092
|
-
var $L152 = $L("
|
|
1093
|
-
var $L153 = $L("
|
|
1094
|
-
var $L154 = $L("
|
|
1095
|
-
var $L155 = $L("
|
|
1096
|
-
var $L156 = $L("
|
|
1097
|
-
var $L157 = $L("
|
|
1098
|
-
var $L158 = $L("
|
|
1099
|
-
var $L159 = $L("
|
|
1100
|
-
var $L160 = $L("
|
|
1101
|
-
var $L161 = $L("
|
|
1102
|
-
var $L162 = $L("
|
|
1103
|
-
var $L163 = $L("
|
|
1104
|
-
var $L164 = $L("
|
|
1105
|
-
var $L165 = $L("
|
|
1106
|
-
var $L166 = $L("
|
|
1107
|
-
var $
|
|
940
|
+
var $L0 = $L("/ ");
|
|
941
|
+
var $L1 = $L("");
|
|
942
|
+
var $L2 = $L(".");
|
|
943
|
+
var $L3 = $L("++");
|
|
944
|
+
var $L4 = $L("--");
|
|
945
|
+
var $L5 = $L("=>");
|
|
946
|
+
var $L6 = $L(" ");
|
|
947
|
+
var $L7 = $L("implements");
|
|
948
|
+
var $L8 = $L("#");
|
|
949
|
+
var $L9 = $L("super");
|
|
950
|
+
var $L10 = $L("import");
|
|
951
|
+
var $L11 = $L("!");
|
|
952
|
+
var $L12 = $L("super[");
|
|
953
|
+
var $L13 = $L("import.meta");
|
|
954
|
+
var $L14 = $L(")");
|
|
955
|
+
var $L15 = $L("->");
|
|
956
|
+
var $L16 = $L("}");
|
|
957
|
+
var $L17 = $L("null");
|
|
958
|
+
var $L18 = $L("true");
|
|
959
|
+
var $L19 = $L("false");
|
|
960
|
+
var $L20 = $L("yes");
|
|
961
|
+
var $L21 = $L("on");
|
|
962
|
+
var $L22 = $L("no");
|
|
963
|
+
var $L23 = $L("off");
|
|
964
|
+
var $L24 = $L(",");
|
|
965
|
+
var $L25 = $L("=");
|
|
966
|
+
var $L26 = $L(">");
|
|
967
|
+
var $L27 = $L("]");
|
|
968
|
+
var $L28 = $L(":");
|
|
969
|
+
var $L29 = $L("**=");
|
|
970
|
+
var $L30 = $L("*=");
|
|
971
|
+
var $L31 = $L("/=");
|
|
972
|
+
var $L32 = $L("%=");
|
|
973
|
+
var $L33 = $L("+=");
|
|
974
|
+
var $L34 = $L("-=");
|
|
975
|
+
var $L35 = $L("<<=");
|
|
976
|
+
var $L36 = $L(">>>=");
|
|
977
|
+
var $L37 = $L(">>=");
|
|
978
|
+
var $L38 = $L("&&=");
|
|
979
|
+
var $L39 = $L("&=");
|
|
980
|
+
var $L40 = $L("^=");
|
|
981
|
+
var $L41 = $L("||=");
|
|
982
|
+
var $L42 = $L("|=");
|
|
983
|
+
var $L43 = $L("??=");
|
|
984
|
+
var $L44 = $L("?=");
|
|
985
|
+
var $L45 = $L("and=");
|
|
986
|
+
var $L46 = $L("or=");
|
|
987
|
+
var $L47 = $L("**");
|
|
988
|
+
var $L48 = $L("*");
|
|
989
|
+
var $L49 = $L("/");
|
|
990
|
+
var $L50 = $L("%%");
|
|
991
|
+
var $L51 = $L("%");
|
|
992
|
+
var $L52 = $L("+");
|
|
993
|
+
var $L53 = $L("-");
|
|
994
|
+
var $L54 = $L("<=");
|
|
995
|
+
var $L55 = $L(">=");
|
|
996
|
+
var $L56 = $L("<?");
|
|
997
|
+
var $L57 = $L("<<");
|
|
998
|
+
var $L58 = $L(">>>");
|
|
999
|
+
var $L59 = $L(">>");
|
|
1000
|
+
var $L60 = $L("!==");
|
|
1001
|
+
var $L61 = $L("!=");
|
|
1002
|
+
var $L62 = $L("isnt");
|
|
1003
|
+
var $L63 = $L("===");
|
|
1004
|
+
var $L64 = $L("==");
|
|
1005
|
+
var $L65 = $L("and");
|
|
1006
|
+
var $L66 = $L("&&");
|
|
1007
|
+
var $L67 = $L("of");
|
|
1008
|
+
var $L68 = $L("or");
|
|
1009
|
+
var $L69 = $L("||");
|
|
1010
|
+
var $L70 = $L("??");
|
|
1011
|
+
var $L71 = $L("?");
|
|
1012
|
+
var $L72 = $L("instanceof");
|
|
1013
|
+
var $L73 = $L("not");
|
|
1014
|
+
var $L74 = $L("in");
|
|
1015
|
+
var $L75 = $L("is");
|
|
1016
|
+
var $L76 = $L("&");
|
|
1017
|
+
var $L77 = $L("^");
|
|
1018
|
+
var $L78 = $L("|");
|
|
1019
|
+
var $L79 = $L(";");
|
|
1020
|
+
var $L80 = $L("own");
|
|
1021
|
+
var $L81 = $L("finally");
|
|
1022
|
+
var $L82 = $L("break");
|
|
1023
|
+
var $L83 = $L("continue");
|
|
1024
|
+
var $L84 = $L("debugger");
|
|
1025
|
+
var $L85 = $L("default");
|
|
1026
|
+
var $L86 = $L(":=");
|
|
1027
|
+
var $L87 = $L(".=");
|
|
1028
|
+
var $L88 = $L("/*");
|
|
1029
|
+
var $L89 = $L("*/");
|
|
1030
|
+
var $L90 = $L("\\");
|
|
1031
|
+
var $L91 = $L("abstract");
|
|
1032
|
+
var $L92 = $L("as");
|
|
1033
|
+
var $L93 = $L("@");
|
|
1034
|
+
var $L94 = $L("@@");
|
|
1035
|
+
var $L95 = $L("async");
|
|
1036
|
+
var $L96 = $L("await");
|
|
1037
|
+
var $L97 = $L("`");
|
|
1038
|
+
var $L98 = $L("by");
|
|
1039
|
+
var $L99 = $L("case");
|
|
1040
|
+
var $L100 = $L("catch");
|
|
1041
|
+
var $L101 = $L("class");
|
|
1042
|
+
var $L102 = $L("#{");
|
|
1043
|
+
var $L103 = $L("delete");
|
|
1044
|
+
var $L104 = $L("do");
|
|
1045
|
+
var $L105 = $L("..");
|
|
1046
|
+
var $L106 = $L("...");
|
|
1047
|
+
var $L107 = $L("::");
|
|
1048
|
+
var $L108 = $L('"');
|
|
1049
|
+
var $L109 = $L("else");
|
|
1050
|
+
var $L110 = $L("export");
|
|
1051
|
+
var $L111 = $L("extends");
|
|
1052
|
+
var $L112 = $L("for");
|
|
1053
|
+
var $L113 = $L("from");
|
|
1054
|
+
var $L114 = $L("function");
|
|
1055
|
+
var $L115 = $L("get");
|
|
1056
|
+
var $L116 = $L("set");
|
|
1057
|
+
var $L117 = $L("if");
|
|
1058
|
+
var $L118 = $L("let");
|
|
1059
|
+
var $L119 = $L("const");
|
|
1060
|
+
var $L120 = $L("loop");
|
|
1061
|
+
var $L121 = $L("new");
|
|
1062
|
+
var $L122 = $L("<");
|
|
1063
|
+
var $L123 = $L("{");
|
|
1064
|
+
var $L124 = $L("[");
|
|
1065
|
+
var $L125 = $L("(");
|
|
1066
|
+
var $L126 = $L("public");
|
|
1067
|
+
var $L127 = $L("private");
|
|
1068
|
+
var $L128 = $L("protected");
|
|
1069
|
+
var $L129 = $L("|>");
|
|
1070
|
+
var $L130 = $L("readonly");
|
|
1071
|
+
var $L131 = $L("return");
|
|
1072
|
+
var $L132 = $L("satisfies");
|
|
1073
|
+
var $L133 = $L("'");
|
|
1074
|
+
var $L134 = $L("static");
|
|
1075
|
+
var $L135 = $L("${");
|
|
1076
|
+
var $L136 = $L("switch");
|
|
1077
|
+
var $L137 = $L("target");
|
|
1078
|
+
var $L138 = $L("then");
|
|
1079
|
+
var $L139 = $L("this");
|
|
1080
|
+
var $L140 = $L("throw");
|
|
1081
|
+
var $L141 = $L('"""');
|
|
1082
|
+
var $L142 = $L("'''");
|
|
1083
|
+
var $L143 = $L("///");
|
|
1084
|
+
var $L144 = $L("```");
|
|
1085
|
+
var $L145 = $L("try");
|
|
1086
|
+
var $L146 = $L("typeof");
|
|
1087
|
+
var $L147 = $L("unless");
|
|
1088
|
+
var $L148 = $L("until");
|
|
1089
|
+
var $L149 = $L("var");
|
|
1090
|
+
var $L150 = $L("void");
|
|
1091
|
+
var $L151 = $L("when");
|
|
1092
|
+
var $L152 = $L("while");
|
|
1093
|
+
var $L153 = $L("yield");
|
|
1094
|
+
var $L154 = $L("/>");
|
|
1095
|
+
var $L155 = $L("</");
|
|
1096
|
+
var $L156 = $L("<>");
|
|
1097
|
+
var $L157 = $L("</>");
|
|
1098
|
+
var $L158 = $L("<!--");
|
|
1099
|
+
var $L159 = $L("-->");
|
|
1100
|
+
var $L160 = $L("declare");
|
|
1101
|
+
var $L161 = $L("type");
|
|
1102
|
+
var $L162 = $L("interface");
|
|
1103
|
+
var $L163 = $L("namespace");
|
|
1104
|
+
var $L164 = $L("asserts");
|
|
1105
|
+
var $L165 = $L("keyof");
|
|
1106
|
+
var $L166 = $L("infer");
|
|
1107
|
+
var $L167 = $L("[]");
|
|
1108
|
+
var $L168 = $L("civet");
|
|
1109
|
+
var $R0 = $R(new RegExp("(as|for|of|satisfies|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1108
1110
|
var $R1 = $R(new RegExp("[&]", "suy"));
|
|
1109
1111
|
var $R2 = $R(new RegExp("[!~+-]+", "suy"));
|
|
1110
1112
|
var $R3 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
@@ -1141,7 +1143,7 @@ ${input.slice(result.pos)}
|
|
|
1141
1143
|
var $R34 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
1142
1144
|
var $R35 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
1143
1145
|
var $R36 = $R(new RegExp("(?:not)(?!\\p{ID_Continue})", "suy"));
|
|
1144
|
-
var $R37 = $R(new RegExp("(?:and|
|
|
1146
|
+
var $R37 = $R(new RegExp("(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
1145
1147
|
var $R38 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
1146
1148
|
var $R39 = $R(new RegExp(".", "suy"));
|
|
1147
1149
|
var $R40 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
@@ -1351,7 +1353,7 @@ ${input.slice(result.pos)}
|
|
|
1351
1353
|
}
|
|
1352
1354
|
}
|
|
1353
1355
|
var Arguments$0 = ExplicitArguments;
|
|
1354
|
-
var Arguments$1 = $TS($S($E($S(
|
|
1356
|
+
var Arguments$1 = $TS($S($E($S(TypeArguments, $N($S(__, ImplementsToken)))), ApplicationStart, InsertOpenParen, $Q(_), ArgumentList, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
1355
1357
|
var ta = $1;
|
|
1356
1358
|
var open = $3;
|
|
1357
1359
|
var ws = $4;
|
|
@@ -1405,7 +1407,7 @@ ${input.slice(result.pos)}
|
|
|
1405
1407
|
}
|
|
1406
1408
|
}
|
|
1407
1409
|
var ApplicationStart$0 = $S(IndentedApplicationAllowed, $Y(NestedImplicitObjectLiteral));
|
|
1408
|
-
var ApplicationStart$1 = $S($N(EOS), $Y($S($P(_), $N(
|
|
1410
|
+
var ApplicationStart$1 = $S($N(EOS), $Y($S($P(_), $N(ForbiddenImplicitCalls))));
|
|
1409
1411
|
function ApplicationStart(state) {
|
|
1410
1412
|
let eventData;
|
|
1411
1413
|
if (state.events) {
|
|
@@ -1428,7 +1430,32 @@ ${input.slice(result.pos)}
|
|
|
1428
1430
|
return result;
|
|
1429
1431
|
}
|
|
1430
1432
|
}
|
|
1431
|
-
var
|
|
1433
|
+
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|for|of|satisfies|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
1434
|
+
var ForbiddenImplicitCalls$1 = $EXPECT($L0, fail, 'ForbiddenImplicitCalls "/ "');
|
|
1435
|
+
var ForbiddenImplicitCalls$2 = AtAt;
|
|
1436
|
+
function ForbiddenImplicitCalls(state) {
|
|
1437
|
+
let eventData;
|
|
1438
|
+
if (state.events) {
|
|
1439
|
+
const result = state.events.enter?.("ForbiddenImplicitCalls", state);
|
|
1440
|
+
if (result) {
|
|
1441
|
+
if (result.cache)
|
|
1442
|
+
return result.cache;
|
|
1443
|
+
eventData = result.data;
|
|
1444
|
+
}
|
|
1445
|
+
}
|
|
1446
|
+
if (state.tokenize) {
|
|
1447
|
+
const result = $TOKEN("ForbiddenImplicitCalls", state, ForbiddenImplicitCalls$0(state) || ForbiddenImplicitCalls$1(state) || ForbiddenImplicitCalls$2(state));
|
|
1448
|
+
if (state.events)
|
|
1449
|
+
state.events.exit?.("ForbiddenImplicitCalls", state, result, eventData);
|
|
1450
|
+
return result;
|
|
1451
|
+
} else {
|
|
1452
|
+
const result = ForbiddenImplicitCalls$0(state) || ForbiddenImplicitCalls$1(state) || ForbiddenImplicitCalls$2(state);
|
|
1453
|
+
if (state.events)
|
|
1454
|
+
state.events.exit?.("ForbiddenImplicitCalls", state, result, eventData);
|
|
1455
|
+
return result;
|
|
1456
|
+
}
|
|
1457
|
+
}
|
|
1458
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L1, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
1432
1459
|
if (module.suppressIndentedApplication)
|
|
1433
1460
|
return $skip;
|
|
1434
1461
|
return;
|
|
@@ -1455,7 +1482,7 @@ ${input.slice(result.pos)}
|
|
|
1455
1482
|
return result;
|
|
1456
1483
|
}
|
|
1457
1484
|
}
|
|
1458
|
-
var ArgumentsWithTrailingMemberExpressions$0 = $S(Arguments, $Q($S(Samedent, $Y($EXPECT($
|
|
1485
|
+
var ArgumentsWithTrailingMemberExpressions$0 = $S(Arguments, $Q($S(Samedent, $Y($EXPECT($L2, fail, 'ArgumentsWithTrailingMemberExpressions "."')), MemberExpressionRest)));
|
|
1459
1486
|
function ArgumentsWithTrailingMemberExpressions(state) {
|
|
1460
1487
|
let eventData;
|
|
1461
1488
|
if (state.events) {
|
|
@@ -1798,7 +1825,7 @@ ${input.slice(result.pos)}
|
|
|
1798
1825
|
return result;
|
|
1799
1826
|
}
|
|
1800
1827
|
}
|
|
1801
|
-
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($
|
|
1828
|
+
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L3, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L4, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
|
|
1802
1829
|
return { $loc, token: $1 };
|
|
1803
1830
|
});
|
|
1804
1831
|
function UpdateExpressionSymbol(state) {
|
|
@@ -2090,7 +2117,7 @@ ${input.slice(result.pos)}
|
|
|
2090
2117
|
return result;
|
|
2091
2118
|
}
|
|
2092
2119
|
}
|
|
2093
|
-
var FatArrow$0 = $TS($S(__, $EXPECT($
|
|
2120
|
+
var FatArrow$0 = $TS($S(__, $EXPECT($L5, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
|
|
2094
2121
|
var ws = $1;
|
|
2095
2122
|
if (!ws.length)
|
|
2096
2123
|
return " =>";
|
|
@@ -2173,7 +2200,7 @@ ${input.slice(result.pos)}
|
|
|
2173
2200
|
}
|
|
2174
2201
|
}
|
|
2175
2202
|
var TernaryRest$0 = NestedTernaryRest;
|
|
2176
|
-
var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($
|
|
2203
|
+
var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($L6, fail, 'TernaryRest " "')), $Q(TrailingComment), QuestionMark, ExtendedExpression, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
2177
2204
|
return $0.slice(2);
|
|
2178
2205
|
});
|
|
2179
2206
|
function TernaryRest(state) {
|
|
@@ -2533,7 +2560,7 @@ ${input.slice(result.pos)}
|
|
|
2533
2560
|
return result;
|
|
2534
2561
|
}
|
|
2535
2562
|
}
|
|
2536
|
-
var ExtendsToken$0 = $TS($S(Loc, __, OpenAngleBracket, $E($EXPECT($
|
|
2563
|
+
var ExtendsToken$0 = $TS($S(Loc, __, OpenAngleBracket, $E($EXPECT($L6, fail, 'ExtendsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2537
2564
|
var l = $1;
|
|
2538
2565
|
var ws = $2;
|
|
2539
2566
|
var lt = $3;
|
|
@@ -2629,7 +2656,7 @@ ${input.slice(result.pos)}
|
|
|
2629
2656
|
return result;
|
|
2630
2657
|
}
|
|
2631
2658
|
}
|
|
2632
|
-
var ImplementsToken$0 = $TS($S($EXPECT($
|
|
2659
|
+
var ImplementsToken$0 = $TS($S($EXPECT($L7, fail, 'ImplementsToken "implements"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2633
2660
|
return { $loc, token: $1 };
|
|
2634
2661
|
});
|
|
2635
2662
|
function ImplementsToken(state) {
|
|
@@ -2878,7 +2905,7 @@ ${input.slice(result.pos)}
|
|
|
2878
2905
|
}
|
|
2879
2906
|
}
|
|
2880
2907
|
var ThisLiteral$0 = This;
|
|
2881
|
-
var ThisLiteral$1 = $TS($S(At, $TEXT($S($E($EXPECT($
|
|
2908
|
+
var ThisLiteral$1 = $TS($S(At, $TEXT($S($E($EXPECT($L8, fail, 'ThisLiteral "#"')), IdentifierName))), function($skip, $loc, $0, $1, $2) {
|
|
2882
2909
|
var t = $1;
|
|
2883
2910
|
var id = $2;
|
|
2884
2911
|
return [{ ...t, token: "this." }, id];
|
|
@@ -2909,7 +2936,7 @@ ${input.slice(result.pos)}
|
|
|
2909
2936
|
return result;
|
|
2910
2937
|
}
|
|
2911
2938
|
}
|
|
2912
|
-
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($
|
|
2939
|
+
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($L2, fail, 'LeftHandSideExpression "."')), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
2913
2940
|
if ($1.length)
|
|
2914
2941
|
return $0;
|
|
2915
2942
|
return $2;
|
|
@@ -2936,8 +2963,8 @@ ${input.slice(result.pos)}
|
|
|
2936
2963
|
return result;
|
|
2937
2964
|
}
|
|
2938
2965
|
}
|
|
2939
|
-
var CallExpression$0 = $S($EXPECT($
|
|
2940
|
-
var CallExpression$1 = $TS($S($EXPECT($
|
|
2966
|
+
var CallExpression$0 = $S($EXPECT($L9, fail, 'CallExpression "super"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest));
|
|
2967
|
+
var CallExpression$1 = $TS($S($EXPECT($L10, fail, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
2941
2968
|
return {
|
|
2942
2969
|
type: "CallExpression",
|
|
2943
2970
|
children: $0
|
|
@@ -3022,7 +3049,7 @@ ${input.slice(result.pos)}
|
|
|
3022
3049
|
return result;
|
|
3023
3050
|
}
|
|
3024
3051
|
}
|
|
3025
|
-
var NonNullAssertion$0 = $T($EXPECT($
|
|
3052
|
+
var NonNullAssertion$0 = $T($EXPECT($L11, fail, 'NonNullAssertion "!"'), function(value) {
|
|
3026
3053
|
return { "ts": true, "children": value };
|
|
3027
3054
|
});
|
|
3028
3055
|
function NonNullAssertion(state) {
|
|
@@ -3047,30 +3074,6 @@ ${input.slice(result.pos)}
|
|
|
3047
3074
|
return result;
|
|
3048
3075
|
}
|
|
3049
3076
|
}
|
|
3050
|
-
var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(for|of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
3051
|
-
var AdditionalReservedWords$1 = AtAt;
|
|
3052
|
-
function AdditionalReservedWords(state) {
|
|
3053
|
-
let eventData;
|
|
3054
|
-
if (state.events) {
|
|
3055
|
-
const result = state.events.enter?.("AdditionalReservedWords", state);
|
|
3056
|
-
if (result) {
|
|
3057
|
-
if (result.cache)
|
|
3058
|
-
return result.cache;
|
|
3059
|
-
eventData = result.data;
|
|
3060
|
-
}
|
|
3061
|
-
}
|
|
3062
|
-
if (state.tokenize) {
|
|
3063
|
-
const result = $TOKEN("AdditionalReservedWords", state, AdditionalReservedWords$0(state) || AdditionalReservedWords$1(state));
|
|
3064
|
-
if (state.events)
|
|
3065
|
-
state.events.exit?.("AdditionalReservedWords", state, result, eventData);
|
|
3066
|
-
return result;
|
|
3067
|
-
} else {
|
|
3068
|
-
const result = AdditionalReservedWords$0(state) || AdditionalReservedWords$1(state);
|
|
3069
|
-
if (state.events)
|
|
3070
|
-
state.events.exit?.("AdditionalReservedWords", state, result, eventData);
|
|
3071
|
-
return result;
|
|
3072
|
-
}
|
|
3073
|
-
}
|
|
3074
3077
|
var MemberExpression$0 = $TS($S(PrimaryExpression, $Q(MemberExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
3075
3078
|
var rest = $2;
|
|
3076
3079
|
if (rest.length) {
|
|
@@ -3296,8 +3299,8 @@ ${input.slice(result.pos)}
|
|
|
3296
3299
|
return result;
|
|
3297
3300
|
}
|
|
3298
3301
|
}
|
|
3299
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
3300
|
-
var SuperProperty$1 = $S($EXPECT($
|
|
3302
|
+
var SuperProperty$0 = $S($EXPECT($L12, fail, 'SuperProperty "super["'), ExtendedExpression, __, CloseBracket);
|
|
3303
|
+
var SuperProperty$1 = $S($EXPECT($L9, fail, 'SuperProperty "super"'), $N($C(QuestionMark, NonNullAssertion)), PropertyAccess);
|
|
3301
3304
|
function SuperProperty(state) {
|
|
3302
3305
|
let eventData;
|
|
3303
3306
|
if (state.events) {
|
|
@@ -3321,7 +3324,7 @@ ${input.slice(result.pos)}
|
|
|
3321
3324
|
}
|
|
3322
3325
|
}
|
|
3323
3326
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
3324
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
3327
|
+
var MetaProperty$1 = $TS($S($EXPECT($L13, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3325
3328
|
return { $loc, token: $1 };
|
|
3326
3329
|
});
|
|
3327
3330
|
function MetaProperty(state) {
|
|
@@ -3347,7 +3350,7 @@ ${input.slice(result.pos)}
|
|
|
3347
3350
|
}
|
|
3348
3351
|
}
|
|
3349
3352
|
var Parameters$0 = NonEmptyParameters;
|
|
3350
|
-
var Parameters$1 = $TV($EXPECT($
|
|
3353
|
+
var Parameters$1 = $TV($EXPECT($L1, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
3351
3354
|
return {
|
|
3352
3355
|
type: "Parameters",
|
|
3353
3356
|
children: [{ $loc, token: "()" }],
|
|
@@ -3506,7 +3509,7 @@ ${input.slice(result.pos)}
|
|
|
3506
3509
|
}
|
|
3507
3510
|
}
|
|
3508
3511
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
3509
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
3512
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L14, fail, 'ParameterElementDelimiter ")"')));
|
|
3510
3513
|
var ParameterElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
3511
3514
|
return value[1];
|
|
3512
3515
|
});
|
|
@@ -4179,7 +4182,7 @@ ${input.slice(result.pos)}
|
|
|
4179
4182
|
return result;
|
|
4180
4183
|
}
|
|
4181
4184
|
}
|
|
4182
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
4185
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L1, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
4183
4186
|
const ref = {
|
|
4184
4187
|
type: "Ref",
|
|
4185
4188
|
base: "ref",
|
|
@@ -4455,7 +4458,7 @@ ${input.slice(result.pos)}
|
|
|
4455
4458
|
return result;
|
|
4456
4459
|
}
|
|
4457
4460
|
}
|
|
4458
|
-
var Arrow$0 = $TV($EXPECT($
|
|
4461
|
+
var Arrow$0 = $TV($EXPECT($L15, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
4459
4462
|
return { $loc, token: $1 };
|
|
4460
4463
|
});
|
|
4461
4464
|
function Arrow(state) {
|
|
@@ -4574,16 +4577,8 @@ ${input.slice(result.pos)}
|
|
|
4574
4577
|
return result;
|
|
4575
4578
|
}
|
|
4576
4579
|
}
|
|
4577
|
-
var ThenClause$0 = $
|
|
4578
|
-
|
|
4579
|
-
var s = $3;
|
|
4580
|
-
const expressions = [[ws, s]];
|
|
4581
|
-
return {
|
|
4582
|
-
type: "BlockStatement",
|
|
4583
|
-
expressions,
|
|
4584
|
-
children: [expressions],
|
|
4585
|
-
bare: true
|
|
4586
|
-
};
|
|
4580
|
+
var ThenClause$0 = $T($S(Then, SingleLineStatements), function(value) {
|
|
4581
|
+
return value[1];
|
|
4587
4582
|
});
|
|
4588
4583
|
function ThenClause(state) {
|
|
4589
4584
|
let eventData;
|
|
@@ -4688,8 +4683,8 @@ ${input.slice(result.pos)}
|
|
|
4688
4683
|
var c = $5;
|
|
4689
4684
|
return {
|
|
4690
4685
|
type: "BlockStatement",
|
|
4691
|
-
expressions: s,
|
|
4692
|
-
children: [o, s, ws, c]
|
|
4686
|
+
expressions: s.expressions,
|
|
4687
|
+
children: [o, s.children, ws, c]
|
|
4693
4688
|
};
|
|
4694
4689
|
});
|
|
4695
4690
|
function BracedBlock(state) {
|
|
@@ -4714,13 +4709,18 @@ ${input.slice(result.pos)}
|
|
|
4714
4709
|
return result;
|
|
4715
4710
|
}
|
|
4716
4711
|
}
|
|
4717
|
-
var SingleLineStatements$0 = $TS($S($S($Q(
|
|
4718
|
-
var
|
|
4719
|
-
var
|
|
4720
|
-
|
|
4721
|
-
|
|
4722
|
-
|
|
4723
|
-
return
|
|
4712
|
+
var SingleLineStatements$0 = $TS($S($Q($S($Q(_), Statement, SemicolonDelimiter)), $E($S($Q(_), Statement, $E(SemicolonDelimiter)))), function($skip, $loc, $0, $1, $2) {
|
|
4713
|
+
var stmts = $1;
|
|
4714
|
+
var last = $2;
|
|
4715
|
+
const children = [...stmts];
|
|
4716
|
+
if (last)
|
|
4717
|
+
children.push(last);
|
|
4718
|
+
return {
|
|
4719
|
+
type: "BlockStatement",
|
|
4720
|
+
expressions: children,
|
|
4721
|
+
children,
|
|
4722
|
+
bare: true
|
|
4723
|
+
};
|
|
4724
4724
|
});
|
|
4725
4725
|
function SingleLineStatements(state) {
|
|
4726
4726
|
let eventData;
|
|
@@ -4753,7 +4753,7 @@ ${input.slice(result.pos)}
|
|
|
4753
4753
|
children: [$1, expressions]
|
|
4754
4754
|
};
|
|
4755
4755
|
});
|
|
4756
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
4756
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L16, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
4757
4757
|
const expressions = [];
|
|
4758
4758
|
return {
|
|
4759
4759
|
type: "BlockStatement",
|
|
@@ -4898,7 +4898,7 @@ ${input.slice(result.pos)}
|
|
|
4898
4898
|
return result;
|
|
4899
4899
|
}
|
|
4900
4900
|
}
|
|
4901
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
4901
|
+
var NullLiteral$0 = $TS($S($EXPECT($L17, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4902
4902
|
return { $loc, token: $1 };
|
|
4903
4903
|
});
|
|
4904
4904
|
function NullLiteral(state) {
|
|
@@ -4926,7 +4926,7 @@ ${input.slice(result.pos)}
|
|
|
4926
4926
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
4927
4927
|
return value[1];
|
|
4928
4928
|
});
|
|
4929
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
4929
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L18, fail, 'BooleanLiteral "true"'), $EXPECT($L19, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4930
4930
|
return { $loc, token: $1 };
|
|
4931
4931
|
});
|
|
4932
4932
|
function BooleanLiteral(state) {
|
|
@@ -4951,10 +4951,10 @@ ${input.slice(result.pos)}
|
|
|
4951
4951
|
return result;
|
|
4952
4952
|
}
|
|
4953
4953
|
}
|
|
4954
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
4954
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L20, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4955
4955
|
return { $loc, token: "true" };
|
|
4956
4956
|
});
|
|
4957
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
4957
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4958
4958
|
return { $loc, token: "false" };
|
|
4959
4959
|
});
|
|
4960
4960
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -4979,7 +4979,7 @@ ${input.slice(result.pos)}
|
|
|
4979
4979
|
return result;
|
|
4980
4980
|
}
|
|
4981
4981
|
}
|
|
4982
|
-
var Comma$0 = $TV($EXPECT($
|
|
4982
|
+
var Comma$0 = $TV($EXPECT($L24, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
4983
4983
|
return { $loc, token: $1 };
|
|
4984
4984
|
});
|
|
4985
4985
|
function Comma(state) {
|
|
@@ -5085,7 +5085,7 @@ ${input.slice(result.pos)}
|
|
|
5085
5085
|
return result;
|
|
5086
5086
|
}
|
|
5087
5087
|
}
|
|
5088
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($
|
|
5088
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L25, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L25, fail, 'UpcomingAssignment "="'), $EXPECT($L26, fail, 'UpcomingAssignment ">"')))));
|
|
5089
5089
|
function UpcomingAssignment(state) {
|
|
5090
5090
|
let eventData;
|
|
5091
5091
|
if (state.events) {
|
|
@@ -5358,7 +5358,7 @@ ${input.slice(result.pos)}
|
|
|
5358
5358
|
}
|
|
5359
5359
|
}
|
|
5360
5360
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
5361
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
5361
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L27, fail, 'ArrayElementDelimiter "]"')));
|
|
5362
5362
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
5363
5363
|
return value[1];
|
|
5364
5364
|
});
|
|
@@ -5780,7 +5780,7 @@ ${input.slice(result.pos)}
|
|
|
5780
5780
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
|
|
5781
5781
|
return value[1];
|
|
5782
5782
|
});
|
|
5783
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
5783
|
+
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($L28, fail, 'ImplicitInlineObjectPropertyDelimiter ":"'), $EXPECT($L14, fail, 'ImplicitInlineObjectPropertyDelimiter ")"'), $EXPECT($L27, fail, 'ImplicitInlineObjectPropertyDelimiter "]"'), $EXPECT($L16, fail, 'ImplicitInlineObjectPropertyDelimiter "}"'), ReservedWord))), function(value) {
|
|
5784
5784
|
return "";
|
|
5785
5785
|
});
|
|
5786
5786
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -5809,7 +5809,7 @@ ${input.slice(result.pos)}
|
|
|
5809
5809
|
}
|
|
5810
5810
|
}
|
|
5811
5811
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
5812
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
5812
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L16, fail, 'ObjectPropertyDelimiter "}"')));
|
|
5813
5813
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
5814
5814
|
return value[1];
|
|
5815
5815
|
});
|
|
@@ -6252,7 +6252,7 @@ ${input.slice(result.pos)}
|
|
|
6252
6252
|
return result;
|
|
6253
6253
|
}
|
|
6254
6254
|
}
|
|
6255
|
-
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($
|
|
6255
|
+
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
|
|
6256
6256
|
return {
|
|
6257
6257
|
type: "Identifier",
|
|
6258
6258
|
name: $0,
|
|
@@ -6316,25 +6316,25 @@ ${input.slice(result.pos)}
|
|
|
6316
6316
|
return result;
|
|
6317
6317
|
}
|
|
6318
6318
|
}
|
|
6319
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
6320
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
6321
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
6322
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
6323
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
6324
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
6325
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
6326
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
6327
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
6328
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
6329
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
6330
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
6331
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
6332
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
6333
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
6334
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
6319
|
+
var AssignmentOpSymbol$0 = $EXPECT($L29, fail, 'AssignmentOpSymbol "**="');
|
|
6320
|
+
var AssignmentOpSymbol$1 = $EXPECT($L30, fail, 'AssignmentOpSymbol "*="');
|
|
6321
|
+
var AssignmentOpSymbol$2 = $EXPECT($L31, fail, 'AssignmentOpSymbol "/="');
|
|
6322
|
+
var AssignmentOpSymbol$3 = $EXPECT($L32, fail, 'AssignmentOpSymbol "%="');
|
|
6323
|
+
var AssignmentOpSymbol$4 = $EXPECT($L33, fail, 'AssignmentOpSymbol "+="');
|
|
6324
|
+
var AssignmentOpSymbol$5 = $EXPECT($L34, fail, 'AssignmentOpSymbol "-="');
|
|
6325
|
+
var AssignmentOpSymbol$6 = $EXPECT($L35, fail, 'AssignmentOpSymbol "<<="');
|
|
6326
|
+
var AssignmentOpSymbol$7 = $EXPECT($L36, fail, 'AssignmentOpSymbol ">>>="');
|
|
6327
|
+
var AssignmentOpSymbol$8 = $EXPECT($L37, fail, 'AssignmentOpSymbol ">>="');
|
|
6328
|
+
var AssignmentOpSymbol$9 = $EXPECT($L38, fail, 'AssignmentOpSymbol "&&="');
|
|
6329
|
+
var AssignmentOpSymbol$10 = $EXPECT($L39, fail, 'AssignmentOpSymbol "&="');
|
|
6330
|
+
var AssignmentOpSymbol$11 = $EXPECT($L40, fail, 'AssignmentOpSymbol "^="');
|
|
6331
|
+
var AssignmentOpSymbol$12 = $EXPECT($L41, fail, 'AssignmentOpSymbol "||="');
|
|
6332
|
+
var AssignmentOpSymbol$13 = $EXPECT($L42, fail, 'AssignmentOpSymbol "|="');
|
|
6333
|
+
var AssignmentOpSymbol$14 = $EXPECT($L43, fail, 'AssignmentOpSymbol "??="');
|
|
6334
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L44, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
6335
6335
|
return "??=";
|
|
6336
6336
|
});
|
|
6337
|
-
var AssignmentOpSymbol$16 = $T($S($EXPECT($
|
|
6337
|
+
var AssignmentOpSymbol$16 = $T($S($EXPECT($L25, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L25, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
6338
6338
|
return value[0];
|
|
6339
6339
|
});
|
|
6340
6340
|
var AssignmentOpSymbol$17 = $T($S(CoffeeWordAssignmentOp), function(value) {
|
|
@@ -6362,10 +6362,10 @@ ${input.slice(result.pos)}
|
|
|
6362
6362
|
return result;
|
|
6363
6363
|
}
|
|
6364
6364
|
}
|
|
6365
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
6365
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L45, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
6366
6366
|
return "&&=";
|
|
6367
6367
|
});
|
|
6368
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
6368
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L46, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
6369
6369
|
return "||=";
|
|
6370
6370
|
});
|
|
6371
6371
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -6417,77 +6417,80 @@ ${input.slice(result.pos)}
|
|
|
6417
6417
|
return result;
|
|
6418
6418
|
}
|
|
6419
6419
|
}
|
|
6420
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
6421
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
6422
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
6423
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
6420
|
+
var BinaryOpSymbol$0 = $EXPECT($L47, fail, 'BinaryOpSymbol "**"');
|
|
6421
|
+
var BinaryOpSymbol$1 = $EXPECT($L48, fail, 'BinaryOpSymbol "*"');
|
|
6422
|
+
var BinaryOpSymbol$2 = $EXPECT($L49, fail, 'BinaryOpSymbol "/"');
|
|
6423
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L50, fail, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
6424
6424
|
return {
|
|
6425
6425
|
call: module.getRef("modulo"),
|
|
6426
6426
|
special: true
|
|
6427
6427
|
};
|
|
6428
6428
|
});
|
|
6429
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
6430
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
6431
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
6432
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
6433
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
6434
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
6435
|
-
|
|
6429
|
+
var BinaryOpSymbol$4 = $EXPECT($L51, fail, 'BinaryOpSymbol "%"');
|
|
6430
|
+
var BinaryOpSymbol$5 = $EXPECT($L52, fail, 'BinaryOpSymbol "+"');
|
|
6431
|
+
var BinaryOpSymbol$6 = $EXPECT($L53, fail, 'BinaryOpSymbol "-"');
|
|
6432
|
+
var BinaryOpSymbol$7 = $EXPECT($L54, fail, 'BinaryOpSymbol "<="');
|
|
6433
|
+
var BinaryOpSymbol$8 = $EXPECT($L55, fail, 'BinaryOpSymbol ">="');
|
|
6434
|
+
var BinaryOpSymbol$9 = $TS($S($EXPECT($L56, fail, 'BinaryOpSymbol "<?"'), $E($EXPECT($L6, fail, 'BinaryOpSymbol " "'))), function($skip, $loc, $0, $1, $2) {
|
|
6435
|
+
return "instanceof ";
|
|
6436
|
+
});
|
|
6437
|
+
var BinaryOpSymbol$10 = $EXPECT($L57, fail, 'BinaryOpSymbol "<<"');
|
|
6438
|
+
var BinaryOpSymbol$11 = $TR($EXPECT($R5, fail, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
6436
6439
|
return "<";
|
|
6437
6440
|
});
|
|
6438
|
-
var BinaryOpSymbol$
|
|
6439
|
-
var BinaryOpSymbol$
|
|
6440
|
-
var BinaryOpSymbol$
|
|
6441
|
-
var BinaryOpSymbol$
|
|
6442
|
-
var BinaryOpSymbol$
|
|
6441
|
+
var BinaryOpSymbol$12 = $EXPECT($L58, fail, 'BinaryOpSymbol ">>>"');
|
|
6442
|
+
var BinaryOpSymbol$13 = $EXPECT($L59, fail, 'BinaryOpSymbol ">>"');
|
|
6443
|
+
var BinaryOpSymbol$14 = $EXPECT($L26, fail, 'BinaryOpSymbol ">"');
|
|
6444
|
+
var BinaryOpSymbol$15 = $EXPECT($L60, fail, 'BinaryOpSymbol "!=="');
|
|
6445
|
+
var BinaryOpSymbol$16 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
6443
6446
|
if (module.config.coffeeEq)
|
|
6444
6447
|
return "!==";
|
|
6445
6448
|
return $1;
|
|
6446
6449
|
});
|
|
6447
|
-
var BinaryOpSymbol$
|
|
6450
|
+
var BinaryOpSymbol$17 = $TS($S($EXPECT($L62, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6448
6451
|
if (module.config.coffeeIsnt)
|
|
6449
6452
|
return "!==";
|
|
6450
6453
|
return $skip;
|
|
6451
6454
|
});
|
|
6452
|
-
var BinaryOpSymbol$
|
|
6453
|
-
var BinaryOpSymbol$
|
|
6455
|
+
var BinaryOpSymbol$18 = $EXPECT($L63, fail, 'BinaryOpSymbol "==="');
|
|
6456
|
+
var BinaryOpSymbol$19 = $TV($EXPECT($L64, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
6454
6457
|
if (module.config.coffeeEq)
|
|
6455
6458
|
return "===";
|
|
6456
6459
|
return $1;
|
|
6457
6460
|
});
|
|
6458
|
-
var BinaryOpSymbol$
|
|
6461
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L65, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
6459
6462
|
return "&&";
|
|
6460
6463
|
});
|
|
6461
|
-
var BinaryOpSymbol$
|
|
6462
|
-
var BinaryOpSymbol$
|
|
6464
|
+
var BinaryOpSymbol$21 = $EXPECT($L66, fail, 'BinaryOpSymbol "&&"');
|
|
6465
|
+
var BinaryOpSymbol$22 = $T($S(CoffeeOfEnabled, $EXPECT($L67, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
6463
6466
|
return "in";
|
|
6464
6467
|
});
|
|
6465
|
-
var BinaryOpSymbol$
|
|
6468
|
+
var BinaryOpSymbol$23 = $T($S($EXPECT($L68, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
6466
6469
|
return "||";
|
|
6467
6470
|
});
|
|
6468
|
-
var BinaryOpSymbol$
|
|
6469
|
-
var BinaryOpSymbol$
|
|
6470
|
-
var BinaryOpSymbol$
|
|
6471
|
+
var BinaryOpSymbol$24 = $EXPECT($L69, fail, 'BinaryOpSymbol "||"');
|
|
6472
|
+
var BinaryOpSymbol$25 = $EXPECT($L70, fail, 'BinaryOpSymbol "??"');
|
|
6473
|
+
var BinaryOpSymbol$26 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L71, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
6471
6474
|
return "??";
|
|
6472
6475
|
});
|
|
6473
|
-
var BinaryOpSymbol$
|
|
6476
|
+
var BinaryOpSymbol$27 = $TS($S($EXPECT($L72, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6474
6477
|
return $1;
|
|
6475
6478
|
});
|
|
6476
|
-
var BinaryOpSymbol$
|
|
6479
|
+
var BinaryOpSymbol$28 = $TS($S(CoffeeNotEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L72, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
6477
6480
|
return {
|
|
6478
6481
|
$loc,
|
|
6479
6482
|
token: "instanceof",
|
|
6480
6483
|
special: true
|
|
6481
6484
|
};
|
|
6482
6485
|
});
|
|
6483
|
-
var BinaryOpSymbol$
|
|
6486
|
+
var BinaryOpSymbol$29 = $TV($C($S($N(CoffeeOfEnabled), $EXPECT($L73, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L74, fail, 'BinaryOpSymbol "in"'), NonIdContinue), $S(CoffeeOfEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L67, fail, 'BinaryOpSymbol "of"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
6484
6487
|
return {
|
|
6485
6488
|
$loc,
|
|
6486
6489
|
token: "in",
|
|
6487
6490
|
special: true
|
|
6488
6491
|
};
|
|
6489
6492
|
});
|
|
6490
|
-
var BinaryOpSymbol$
|
|
6493
|
+
var BinaryOpSymbol$30 = $TV($C($S($EXPECT($L75, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L74, fail, 'BinaryOpSymbol "in"'), NonIdContinue), $S(CoffeeOfEnabled, $EXPECT($L74, fail, 'BinaryOpSymbol "in"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
6491
6494
|
return {
|
|
6492
6495
|
call: [module.getRef("indexOf"), ".call"],
|
|
6493
6496
|
relational: true,
|
|
@@ -6496,7 +6499,7 @@ ${input.slice(result.pos)}
|
|
|
6496
6499
|
special: true
|
|
6497
6500
|
};
|
|
6498
6501
|
});
|
|
6499
|
-
var BinaryOpSymbol$
|
|
6502
|
+
var BinaryOpSymbol$31 = $TV($C($S($EXPECT($L75, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L73, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L74, fail, 'BinaryOpSymbol "in"'), NonIdContinue), $S(CoffeeOfEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L74, fail, 'BinaryOpSymbol "in"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
6500
6503
|
return {
|
|
6501
6504
|
call: [module.getRef("indexOf"), ".call"],
|
|
6502
6505
|
relational: true,
|
|
@@ -6505,18 +6508,18 @@ ${input.slice(result.pos)}
|
|
|
6505
6508
|
special: true
|
|
6506
6509
|
};
|
|
6507
6510
|
});
|
|
6508
|
-
var BinaryOpSymbol$
|
|
6511
|
+
var BinaryOpSymbol$32 = $T($S($N(CoffeeNotEnabled), $EXPECT($L75, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L73, fail, 'BinaryOpSymbol "not"'), NonIdContinue), function(value) {
|
|
6509
6512
|
return "!==";
|
|
6510
6513
|
});
|
|
6511
|
-
var BinaryOpSymbol$
|
|
6514
|
+
var BinaryOpSymbol$33 = $T($S($EXPECT($L75, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
6512
6515
|
return "===";
|
|
6513
6516
|
});
|
|
6514
|
-
var BinaryOpSymbol$
|
|
6517
|
+
var BinaryOpSymbol$34 = $TS($S($EXPECT($L74, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6515
6518
|
return $1;
|
|
6516
6519
|
});
|
|
6517
|
-
var BinaryOpSymbol$
|
|
6518
|
-
var BinaryOpSymbol$
|
|
6519
|
-
var BinaryOpSymbol$
|
|
6520
|
+
var BinaryOpSymbol$35 = $EXPECT($L76, fail, 'BinaryOpSymbol "&"');
|
|
6521
|
+
var BinaryOpSymbol$36 = $EXPECT($L77, fail, 'BinaryOpSymbol "^"');
|
|
6522
|
+
var BinaryOpSymbol$37 = $EXPECT($L78, fail, 'BinaryOpSymbol "|"');
|
|
6520
6523
|
function BinaryOpSymbol(state) {
|
|
6521
6524
|
let eventData;
|
|
6522
6525
|
if (state.events) {
|
|
@@ -6528,12 +6531,12 @@ ${input.slice(result.pos)}
|
|
|
6528
6531
|
}
|
|
6529
6532
|
}
|
|
6530
6533
|
if (state.tokenize) {
|
|
6531
|
-
const result = $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state));
|
|
6534
|
+
const result = $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state) || BinaryOpSymbol$37(state));
|
|
6532
6535
|
if (state.events)
|
|
6533
6536
|
state.events.exit?.("BinaryOpSymbol", state, result, eventData);
|
|
6534
6537
|
return result;
|
|
6535
6538
|
} else {
|
|
6536
|
-
const result = BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state);
|
|
6539
|
+
const result = BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state) || BinaryOpSymbol$34(state) || BinaryOpSymbol$35(state) || BinaryOpSymbol$36(state) || BinaryOpSymbol$37(state);
|
|
6537
6540
|
if (state.events)
|
|
6538
6541
|
state.events.exit?.("BinaryOpSymbol", state, result, eventData);
|
|
6539
6542
|
return result;
|
|
@@ -6679,7 +6682,7 @@ ${input.slice(result.pos)}
|
|
|
6679
6682
|
return result;
|
|
6680
6683
|
}
|
|
6681
6684
|
}
|
|
6682
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
6685
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L79, fail, 'EmptyStatement ";"'))), function(value) {
|
|
6683
6686
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
6684
6687
|
});
|
|
6685
6688
|
function EmptyStatement(state) {
|
|
@@ -6704,7 +6707,7 @@ ${input.slice(result.pos)}
|
|
|
6704
6707
|
return result;
|
|
6705
6708
|
}
|
|
6706
6709
|
}
|
|
6707
|
-
var BlockStatement$0 = $T($S(ExplicitBlock, $N($S(__, $EXPECT($
|
|
6710
|
+
var BlockStatement$0 = $T($S(ExplicitBlock, $N($S(__, $EXPECT($L25, fail, 'BlockStatement "="')))), function(value) {
|
|
6708
6711
|
return value[0];
|
|
6709
6712
|
});
|
|
6710
6713
|
function BlockStatement(state) {
|
|
@@ -7631,7 +7634,7 @@ ${input.slice(result.pos)}
|
|
|
7631
7634
|
return result;
|
|
7632
7635
|
}
|
|
7633
7636
|
}
|
|
7634
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
7637
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L80, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
7635
7638
|
var own = $1;
|
|
7636
7639
|
var binding = $2;
|
|
7637
7640
|
return {
|
|
@@ -7831,7 +7834,8 @@ ${input.slice(result.pos)}
|
|
|
7831
7834
|
}
|
|
7832
7835
|
return {
|
|
7833
7836
|
type: "SwitchStatement",
|
|
7834
|
-
children: $0
|
|
7837
|
+
children: $0,
|
|
7838
|
+
caseBlock
|
|
7835
7839
|
};
|
|
7836
7840
|
});
|
|
7837
7841
|
function SwitchStatement(state) {
|
|
@@ -7891,8 +7895,8 @@ ${input.slice(result.pos)}
|
|
|
7891
7895
|
var e = $0;
|
|
7892
7896
|
return {
|
|
7893
7897
|
type: "SwitchExpression",
|
|
7894
|
-
|
|
7895
|
-
|
|
7898
|
+
children: ["(()=>{", e.children, "})()"],
|
|
7899
|
+
caseBlock: e.children[2]
|
|
7896
7900
|
};
|
|
7897
7901
|
});
|
|
7898
7902
|
function SwitchExpression(state) {
|
|
@@ -7986,9 +7990,10 @@ ${input.slice(result.pos)}
|
|
|
7986
7990
|
var NestedCaseClause$0 = $TS($S(Nested, CaseClause), function($skip, $loc, $0, $1, $2) {
|
|
7987
7991
|
var indent = $1;
|
|
7988
7992
|
var clause = $2;
|
|
7989
|
-
return
|
|
7993
|
+
return {
|
|
7994
|
+
...clause,
|
|
7990
7995
|
children: [indent, ...clause.children]
|
|
7991
|
-
}
|
|
7996
|
+
};
|
|
7992
7997
|
});
|
|
7993
7998
|
function NestedCaseClause(state) {
|
|
7994
7999
|
let eventData;
|
|
@@ -8013,48 +8018,34 @@ ${input.slice(result.pos)}
|
|
|
8013
8018
|
}
|
|
8014
8019
|
}
|
|
8015
8020
|
var CaseClause$0 = $T($S(Case, CaseExpressionList, $C(NestedBlockStatements, NoExpressions)), function(value) {
|
|
8016
|
-
|
|
8017
|
-
var expressions = value[2];
|
|
8018
|
-
return { "type": "CaseClause", "cases": cases, "expressions": expressions, "children": value };
|
|
8021
|
+
return { "type": "CaseClause", "children": value };
|
|
8019
8022
|
});
|
|
8020
|
-
var CaseClause$1 = $TS($S(When, CaseExpressionList, InsertOpenBrace, $
|
|
8023
|
+
var CaseClause$1 = $TS($S(When, CaseExpressionList, InsertOpenBrace, $C(ThenClause, NestedBlockStatements, NoExpressions), InsertBreak, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
8021
8024
|
var cases = $2;
|
|
8022
|
-
var
|
|
8025
|
+
var block = $4;
|
|
8023
8026
|
var b = $5;
|
|
8024
|
-
let children = $0;
|
|
8025
|
-
if (!expressions) {
|
|
8026
|
-
expressions = [];
|
|
8027
|
-
children = children.map((c, i) => i === 3 ? expressions : c);
|
|
8028
|
-
}
|
|
8029
|
-
if (expressions.expressions) {
|
|
8030
|
-
expressions = expressions.expressions;
|
|
8031
|
-
}
|
|
8032
8027
|
return {
|
|
8033
8028
|
type: "WhenClause",
|
|
8034
8029
|
cases,
|
|
8035
|
-
|
|
8030
|
+
block,
|
|
8036
8031
|
break: b,
|
|
8037
|
-
children
|
|
8032
|
+
children: $0
|
|
8038
8033
|
};
|
|
8039
8034
|
});
|
|
8040
8035
|
var CaseClause$2 = $TS($S(Default, ImpliedColon, $C(NestedBlockStatements, NoExpressions)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8041
|
-
var
|
|
8042
|
-
if (expressions.expressions)
|
|
8043
|
-
expressions = expressions.expressions;
|
|
8036
|
+
var block = $3;
|
|
8044
8037
|
return {
|
|
8045
8038
|
type: "DefaultClause",
|
|
8046
|
-
|
|
8039
|
+
block,
|
|
8047
8040
|
children: $0
|
|
8048
8041
|
};
|
|
8049
8042
|
});
|
|
8050
|
-
var CaseClause$3 = $TS($S(Else, ImpliedColon, InsertOpenBrace, $C(NestedBlockStatements,
|
|
8051
|
-
var
|
|
8043
|
+
var CaseClause$3 = $TS($S(Else, ImpliedColon, InsertOpenBrace, $C(NestedBlockStatements, SingleLineStatements), InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
8044
|
+
var block = $4;
|
|
8052
8045
|
$1.token = "default";
|
|
8053
|
-
if (expressions.expressions)
|
|
8054
|
-
expressions = expressions.expressions;
|
|
8055
8046
|
return {
|
|
8056
8047
|
type: "DefaultClause",
|
|
8057
|
-
|
|
8048
|
+
block,
|
|
8058
8049
|
children: $0
|
|
8059
8050
|
};
|
|
8060
8051
|
});
|
|
@@ -8112,7 +8103,7 @@ ${input.slice(result.pos)}
|
|
|
8112
8103
|
return result;
|
|
8113
8104
|
}
|
|
8114
8105
|
}
|
|
8115
|
-
var NoExpressions$0 = $T($EXPECT($
|
|
8106
|
+
var NoExpressions$0 = $T($EXPECT($L1, fail, 'NoExpressions ""'), function(value) {
|
|
8116
8107
|
return [];
|
|
8117
8108
|
});
|
|
8118
8109
|
function NoExpressions(state) {
|
|
@@ -8138,7 +8129,7 @@ ${input.slice(result.pos)}
|
|
|
8138
8129
|
}
|
|
8139
8130
|
}
|
|
8140
8131
|
var ImpliedColon$0 = $S(__, Colon);
|
|
8141
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
8132
|
+
var ImpliedColon$1 = $TV($EXPECT($L1, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
8142
8133
|
return { $loc, token: ":" };
|
|
8143
8134
|
});
|
|
8144
8135
|
function ImpliedColon(state) {
|
|
@@ -8278,7 +8269,7 @@ ${input.slice(result.pos)}
|
|
|
8278
8269
|
return result;
|
|
8279
8270
|
}
|
|
8280
8271
|
}
|
|
8281
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
8272
|
+
var Finally$0 = $S(__, $EXPECT($L81, fail, 'Finally "finally"'), NonIdContinue, BracedBlock);
|
|
8282
8273
|
function Finally(state) {
|
|
8283
8274
|
let eventData;
|
|
8284
8275
|
if (state.events) {
|
|
@@ -8390,7 +8381,7 @@ ${input.slice(result.pos)}
|
|
|
8390
8381
|
return result;
|
|
8391
8382
|
}
|
|
8392
8383
|
}
|
|
8393
|
-
var SuppressIndentedApplication$0 = $TV($EXPECT($
|
|
8384
|
+
var SuppressIndentedApplication$0 = $TV($EXPECT($L1, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
8394
8385
|
module.suppressIndentedApplication = true;
|
|
8395
8386
|
});
|
|
8396
8387
|
function SuppressIndentedApplication(state) {
|
|
@@ -8438,13 +8429,13 @@ ${input.slice(result.pos)}
|
|
|
8438
8429
|
return result;
|
|
8439
8430
|
}
|
|
8440
8431
|
}
|
|
8441
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
8432
|
+
var KeywordStatement$0 = $T($S($EXPECT($L82, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
8442
8433
|
return { "type": "BreakStatement", "children": value };
|
|
8443
8434
|
});
|
|
8444
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
8435
|
+
var KeywordStatement$1 = $T($S($EXPECT($L83, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
8445
8436
|
return { "type": "ContinueStatement", "children": value };
|
|
8446
8437
|
});
|
|
8447
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
8438
|
+
var KeywordStatement$2 = $T($S($EXPECT($L84, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
8448
8439
|
return { "type": "DebuggerStatement", "children": value };
|
|
8449
8440
|
});
|
|
8450
8441
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -8475,7 +8466,7 @@ ${input.slice(result.pos)}
|
|
|
8475
8466
|
return result;
|
|
8476
8467
|
}
|
|
8477
8468
|
}
|
|
8478
|
-
var DebuggerExpression$0 = $TS($S($EXPECT($
|
|
8469
|
+
var DebuggerExpression$0 = $TS($S($EXPECT($L84, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8479
8470
|
return {
|
|
8480
8471
|
type: "DebuggerExpression",
|
|
8481
8472
|
children: ["(()=>{", $1, "})()"]
|
|
@@ -8598,7 +8589,7 @@ ${input.slice(result.pos)}
|
|
|
8598
8589
|
return result;
|
|
8599
8590
|
}
|
|
8600
8591
|
}
|
|
8601
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
8592
|
+
var ImpliedImport$0 = $TV($EXPECT($L1, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
8602
8593
|
return { $loc, token: "import " };
|
|
8603
8594
|
});
|
|
8604
8595
|
function ImpliedImport(state) {
|
|
@@ -8811,7 +8802,7 @@ ${input.slice(result.pos)}
|
|
|
8811
8802
|
}
|
|
8812
8803
|
}
|
|
8813
8804
|
var ImportAsToken$0 = $S(__, As);
|
|
8814
|
-
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($
|
|
8805
|
+
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($L6, fail, 'ImportAsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8815
8806
|
var l = $1;
|
|
8816
8807
|
var ws = $2;
|
|
8817
8808
|
var c = $3;
|
|
@@ -8971,7 +8962,7 @@ ${input.slice(result.pos)}
|
|
|
8971
8962
|
return result;
|
|
8972
8963
|
}
|
|
8973
8964
|
}
|
|
8974
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
8965
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L85, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression));
|
|
8975
8966
|
var ExportDeclaration$1 = $TS($S(Export, __, ExportFromClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
8976
8967
|
if (!$3.ts)
|
|
8977
8968
|
return $0;
|
|
@@ -9133,7 +9124,7 @@ ${input.slice(result.pos)}
|
|
|
9133
9124
|
return result;
|
|
9134
9125
|
}
|
|
9135
9126
|
}
|
|
9136
|
-
var ImplicitExportSpecifier$0 = $S($N($EXPECT($
|
|
9127
|
+
var ImplicitExportSpecifier$0 = $S($N($EXPECT($L85, fail, 'ImplicitExportSpecifier "default"')), ModuleExportName, $E($S(__, As, __, ModuleExportName)), $C($Y($S(__, From)), ImplicitInlineObjectPropertyDelimiter));
|
|
9137
9128
|
function ImplicitExportSpecifier(state) {
|
|
9138
9129
|
let eventData;
|
|
9139
9130
|
if (state.events) {
|
|
@@ -9304,7 +9295,7 @@ ${input.slice(result.pos)}
|
|
|
9304
9295
|
return result;
|
|
9305
9296
|
}
|
|
9306
9297
|
}
|
|
9307
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
9298
|
+
var ConstAssignment$0 = $TV($EXPECT($L86, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
9308
9299
|
return { $loc, token: "=" };
|
|
9309
9300
|
});
|
|
9310
9301
|
function ConstAssignment(state) {
|
|
@@ -9329,7 +9320,7 @@ ${input.slice(result.pos)}
|
|
|
9329
9320
|
return result;
|
|
9330
9321
|
}
|
|
9331
9322
|
}
|
|
9332
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
9323
|
+
var LetAssignment$0 = $TV($EXPECT($L87, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
9333
9324
|
return { $loc, token: "=" };
|
|
9334
9325
|
});
|
|
9335
9326
|
function LetAssignment(state) {
|
|
@@ -9979,7 +9970,7 @@ ${input.slice(result.pos)}
|
|
|
9979
9970
|
}
|
|
9980
9971
|
}
|
|
9981
9972
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
9982
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
9973
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L49, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L49, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
9983
9974
|
return { $loc, token: $1 };
|
|
9984
9975
|
});
|
|
9985
9976
|
function RegularExpressionLiteral(state) {
|
|
@@ -10382,8 +10373,8 @@ ${input.slice(result.pos)}
|
|
|
10382
10373
|
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($R34, fail, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")));
|
|
10383
10374
|
var ReservedWord$3 = $S(CoffeeOfEnabled, $R$0($EXPECT($R35, fail, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")));
|
|
10384
10375
|
var ReservedWord$4 = $S(CoffeeNotEnabled, $R$0($EXPECT($R36, fail, "ReservedWord /(?:not)(?!\\p{ID_Continue})/")));
|
|
10385
|
-
var ReservedWord$5 = $S($EXPECT($
|
|
10386
|
-
var ReservedWord$6 = $R$0($EXPECT($R37, fail, "ReservedWord /(?:and|
|
|
10376
|
+
var ReservedWord$5 = $S($EXPECT($L73, fail, 'ReservedWord "not"'), NonIdContinue, __, $EXPECT($L74, fail, 'ReservedWord "in"'), NonIdContinue);
|
|
10377
|
+
var ReservedWord$6 = $R$0($EXPECT($R37, fail, "ReservedWord /(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
10387
10378
|
function ReservedWord(state) {
|
|
10388
10379
|
let eventData;
|
|
10389
10380
|
if (state.events) {
|
|
@@ -10503,7 +10494,7 @@ ${input.slice(result.pos)}
|
|
|
10503
10494
|
return result;
|
|
10504
10495
|
}
|
|
10505
10496
|
}
|
|
10506
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
10497
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L88, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L89, fail, 'JSMultiLineComment "*/"')), $EXPECT($R39, fail, "JSMultiLineComment /./"))), $EXPECT($L89, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
10507
10498
|
return { $loc, token: $1 };
|
|
10508
10499
|
});
|
|
10509
10500
|
function JSMultiLineComment(state) {
|
|
@@ -10553,7 +10544,7 @@ ${input.slice(result.pos)}
|
|
|
10553
10544
|
return result;
|
|
10554
10545
|
}
|
|
10555
10546
|
}
|
|
10556
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($Q($S($N($C(CoffeeHereCommentStart, $EXPECT($
|
|
10547
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($Q($S($N($C(CoffeeHereCommentStart, $EXPECT($L89, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R39, fail, "CoffeeMultiLineComment /./")))), CoffeeHereCommentStart), function($skip, $loc, $0, $1, $2, $3) {
|
|
10557
10548
|
return { $loc, token: `/*${$2}*/` };
|
|
10558
10549
|
});
|
|
10559
10550
|
function CoffeeMultiLineComment(state) {
|
|
@@ -10601,7 +10592,7 @@ ${input.slice(result.pos)}
|
|
|
10601
10592
|
return result;
|
|
10602
10593
|
}
|
|
10603
10594
|
}
|
|
10604
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
10595
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L88, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L89, fail, 'InlineComment "*/"')), $EXPECT($R42, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L89, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
10605
10596
|
return { $loc, token: $1 };
|
|
10606
10597
|
});
|
|
10607
10598
|
function InlineComment(state) {
|
|
@@ -10700,7 +10691,7 @@ ${input.slice(result.pos)}
|
|
|
10700
10691
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R43, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10701
10692
|
return { $loc, token: $0 };
|
|
10702
10693
|
});
|
|
10703
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
10694
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L90, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
10704
10695
|
return "";
|
|
10705
10696
|
});
|
|
10706
10697
|
function NonNewlineWhitespace(state) {
|
|
@@ -10725,6 +10716,32 @@ ${input.slice(result.pos)}
|
|
|
10725
10716
|
return result;
|
|
10726
10717
|
}
|
|
10727
10718
|
}
|
|
10719
|
+
var Trimmed_$0 = $TV($Q(_), function($skip, $loc, $0, $1) {
|
|
10720
|
+
var ws = $0;
|
|
10721
|
+
return module.insertTrimmingSpace(ws, "");
|
|
10722
|
+
});
|
|
10723
|
+
function Trimmed_(state) {
|
|
10724
|
+
let eventData;
|
|
10725
|
+
if (state.events) {
|
|
10726
|
+
const result = state.events.enter?.("Trimmed_", state);
|
|
10727
|
+
if (result) {
|
|
10728
|
+
if (result.cache)
|
|
10729
|
+
return result.cache;
|
|
10730
|
+
eventData = result.data;
|
|
10731
|
+
}
|
|
10732
|
+
}
|
|
10733
|
+
if (state.tokenize) {
|
|
10734
|
+
const result = $TOKEN("Trimmed_", state, Trimmed_$0(state));
|
|
10735
|
+
if (state.events)
|
|
10736
|
+
state.events.exit?.("Trimmed_", state, result, eventData);
|
|
10737
|
+
return result;
|
|
10738
|
+
} else {
|
|
10739
|
+
const result = Trimmed_$0(state);
|
|
10740
|
+
if (state.events)
|
|
10741
|
+
state.events.exit?.("Trimmed_", state, result, eventData);
|
|
10742
|
+
return result;
|
|
10743
|
+
}
|
|
10744
|
+
}
|
|
10728
10745
|
var __$0 = $Q($C(Whitespace, Comment));
|
|
10729
10746
|
function __(state) {
|
|
10730
10747
|
let eventData;
|
|
@@ -10876,7 +10893,7 @@ ${input.slice(result.pos)}
|
|
|
10876
10893
|
return result;
|
|
10877
10894
|
}
|
|
10878
10895
|
}
|
|
10879
|
-
var Loc$0 = $TV($EXPECT($
|
|
10896
|
+
var Loc$0 = $TV($EXPECT($L1, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
10880
10897
|
return { $loc, token: "" };
|
|
10881
10898
|
});
|
|
10882
10899
|
function Loc(state) {
|
|
@@ -10901,7 +10918,7 @@ ${input.slice(result.pos)}
|
|
|
10901
10918
|
return result;
|
|
10902
10919
|
}
|
|
10903
10920
|
}
|
|
10904
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
10921
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L91, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L6, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
10905
10922
|
return { $loc, token: $1, ts: true };
|
|
10906
10923
|
});
|
|
10907
10924
|
function Abstract(state) {
|
|
@@ -10926,7 +10943,7 @@ ${input.slice(result.pos)}
|
|
|
10926
10943
|
return result;
|
|
10927
10944
|
}
|
|
10928
10945
|
}
|
|
10929
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
10946
|
+
var Ampersand$0 = $TV($EXPECT($L76, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
10930
10947
|
return { $loc, token: $1 };
|
|
10931
10948
|
});
|
|
10932
10949
|
function Ampersand(state) {
|
|
@@ -10951,7 +10968,7 @@ ${input.slice(result.pos)}
|
|
|
10951
10968
|
return result;
|
|
10952
10969
|
}
|
|
10953
10970
|
}
|
|
10954
|
-
var As$0 = $TS($S($EXPECT($
|
|
10971
|
+
var As$0 = $TS($S($EXPECT($L92, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10955
10972
|
return { $loc, token: $1 };
|
|
10956
10973
|
});
|
|
10957
10974
|
function As(state) {
|
|
@@ -10976,7 +10993,7 @@ ${input.slice(result.pos)}
|
|
|
10976
10993
|
return result;
|
|
10977
10994
|
}
|
|
10978
10995
|
}
|
|
10979
|
-
var At$0 = $TV($EXPECT($
|
|
10996
|
+
var At$0 = $TV($EXPECT($L93, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
10980
10997
|
return { $loc, token: $1 };
|
|
10981
10998
|
});
|
|
10982
10999
|
function At(state) {
|
|
@@ -11001,7 +11018,7 @@ ${input.slice(result.pos)}
|
|
|
11001
11018
|
return result;
|
|
11002
11019
|
}
|
|
11003
11020
|
}
|
|
11004
|
-
var AtAt$0 = $TV($EXPECT($
|
|
11021
|
+
var AtAt$0 = $TV($EXPECT($L94, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
11005
11022
|
return { $loc, token: "@" };
|
|
11006
11023
|
});
|
|
11007
11024
|
function AtAt(state) {
|
|
@@ -11026,7 +11043,7 @@ ${input.slice(result.pos)}
|
|
|
11026
11043
|
return result;
|
|
11027
11044
|
}
|
|
11028
11045
|
}
|
|
11029
|
-
var Async$0 = $TS($S($EXPECT($
|
|
11046
|
+
var Async$0 = $TS($S($EXPECT($L95, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11030
11047
|
return { $loc, token: $1, type: "Async" };
|
|
11031
11048
|
});
|
|
11032
11049
|
function Async(state) {
|
|
@@ -11051,7 +11068,7 @@ ${input.slice(result.pos)}
|
|
|
11051
11068
|
return result;
|
|
11052
11069
|
}
|
|
11053
11070
|
}
|
|
11054
|
-
var Await$0 = $TS($S($EXPECT($
|
|
11071
|
+
var Await$0 = $TS($S($EXPECT($L96, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11055
11072
|
return { $loc, token: $1 };
|
|
11056
11073
|
});
|
|
11057
11074
|
function Await(state) {
|
|
@@ -11076,7 +11093,7 @@ ${input.slice(result.pos)}
|
|
|
11076
11093
|
return result;
|
|
11077
11094
|
}
|
|
11078
11095
|
}
|
|
11079
|
-
var Backtick$0 = $TV($EXPECT($
|
|
11096
|
+
var Backtick$0 = $TV($EXPECT($L97, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
11080
11097
|
return { $loc, token: $1 };
|
|
11081
11098
|
});
|
|
11082
11099
|
function Backtick(state) {
|
|
@@ -11101,7 +11118,7 @@ ${input.slice(result.pos)}
|
|
|
11101
11118
|
return result;
|
|
11102
11119
|
}
|
|
11103
11120
|
}
|
|
11104
|
-
var By$0 = $TS($S($EXPECT($
|
|
11121
|
+
var By$0 = $TS($S($EXPECT($L98, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11105
11122
|
return { $loc, token: $1 };
|
|
11106
11123
|
});
|
|
11107
11124
|
function By(state) {
|
|
@@ -11126,7 +11143,7 @@ ${input.slice(result.pos)}
|
|
|
11126
11143
|
return result;
|
|
11127
11144
|
}
|
|
11128
11145
|
}
|
|
11129
|
-
var Case$0 = $TS($S($EXPECT($
|
|
11146
|
+
var Case$0 = $TS($S($EXPECT($L99, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11130
11147
|
return { $loc, token: $1 };
|
|
11131
11148
|
});
|
|
11132
11149
|
function Case(state) {
|
|
@@ -11151,7 +11168,7 @@ ${input.slice(result.pos)}
|
|
|
11151
11168
|
return result;
|
|
11152
11169
|
}
|
|
11153
11170
|
}
|
|
11154
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
11171
|
+
var Catch$0 = $TS($S($EXPECT($L100, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11155
11172
|
return { $loc, token: $1 };
|
|
11156
11173
|
});
|
|
11157
11174
|
function Catch(state) {
|
|
@@ -11176,7 +11193,7 @@ ${input.slice(result.pos)}
|
|
|
11176
11193
|
return result;
|
|
11177
11194
|
}
|
|
11178
11195
|
}
|
|
11179
|
-
var Class$0 = $TS($S($EXPECT($
|
|
11196
|
+
var Class$0 = $TS($S($EXPECT($L101, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11180
11197
|
return { $loc, token: $1 };
|
|
11181
11198
|
});
|
|
11182
11199
|
function Class(state) {
|
|
@@ -11201,7 +11218,7 @@ ${input.slice(result.pos)}
|
|
|
11201
11218
|
return result;
|
|
11202
11219
|
}
|
|
11203
11220
|
}
|
|
11204
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
11221
|
+
var CloseBrace$0 = $TV($EXPECT($L16, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
11205
11222
|
return { $loc, token: $1 };
|
|
11206
11223
|
});
|
|
11207
11224
|
function CloseBrace(state) {
|
|
@@ -11226,7 +11243,7 @@ ${input.slice(result.pos)}
|
|
|
11226
11243
|
return result;
|
|
11227
11244
|
}
|
|
11228
11245
|
}
|
|
11229
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
11246
|
+
var CloseBracket$0 = $TV($EXPECT($L27, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
11230
11247
|
return { $loc, token: $1 };
|
|
11231
11248
|
});
|
|
11232
11249
|
function CloseBracket(state) {
|
|
@@ -11251,7 +11268,7 @@ ${input.slice(result.pos)}
|
|
|
11251
11268
|
return result;
|
|
11252
11269
|
}
|
|
11253
11270
|
}
|
|
11254
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
11271
|
+
var CloseParen$0 = $TV($EXPECT($L14, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
11255
11272
|
return { $loc, token: $1 };
|
|
11256
11273
|
});
|
|
11257
11274
|
function CloseParen(state) {
|
|
@@ -11276,7 +11293,7 @@ ${input.slice(result.pos)}
|
|
|
11276
11293
|
return result;
|
|
11277
11294
|
}
|
|
11278
11295
|
}
|
|
11279
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
11296
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L102, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
11280
11297
|
return { $loc, token: "${" };
|
|
11281
11298
|
});
|
|
11282
11299
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -11301,7 +11318,7 @@ ${input.slice(result.pos)}
|
|
|
11301
11318
|
return result;
|
|
11302
11319
|
}
|
|
11303
11320
|
}
|
|
11304
|
-
var Colon$0 = $TV($EXPECT($
|
|
11321
|
+
var Colon$0 = $TV($EXPECT($L28, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
11305
11322
|
return { $loc, token: $1 };
|
|
11306
11323
|
});
|
|
11307
11324
|
function Colon(state) {
|
|
@@ -11326,7 +11343,7 @@ ${input.slice(result.pos)}
|
|
|
11326
11343
|
return result;
|
|
11327
11344
|
}
|
|
11328
11345
|
}
|
|
11329
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
11346
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L93, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
11330
11347
|
return { $loc, token: "constructor" };
|
|
11331
11348
|
});
|
|
11332
11349
|
function ConstructorShorthand(state) {
|
|
@@ -11351,7 +11368,7 @@ ${input.slice(result.pos)}
|
|
|
11351
11368
|
return result;
|
|
11352
11369
|
}
|
|
11353
11370
|
}
|
|
11354
|
-
var Default$0 = $TS($S($EXPECT($
|
|
11371
|
+
var Default$0 = $TS($S($EXPECT($L85, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11355
11372
|
return { $loc, token: $1 };
|
|
11356
11373
|
});
|
|
11357
11374
|
function Default(state) {
|
|
@@ -11376,7 +11393,7 @@ ${input.slice(result.pos)}
|
|
|
11376
11393
|
return result;
|
|
11377
11394
|
}
|
|
11378
11395
|
}
|
|
11379
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
11396
|
+
var Delete$0 = $TS($S($EXPECT($L103, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11380
11397
|
return { $loc, token: $1 };
|
|
11381
11398
|
});
|
|
11382
11399
|
function Delete(state) {
|
|
@@ -11401,7 +11418,7 @@ ${input.slice(result.pos)}
|
|
|
11401
11418
|
return result;
|
|
11402
11419
|
}
|
|
11403
11420
|
}
|
|
11404
|
-
var Do$0 = $TS($S($EXPECT($
|
|
11421
|
+
var Do$0 = $TS($S($EXPECT($L104, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11405
11422
|
return { $loc, token: $1 };
|
|
11406
11423
|
});
|
|
11407
11424
|
function Do(state) {
|
|
@@ -11426,7 +11443,7 @@ ${input.slice(result.pos)}
|
|
|
11426
11443
|
return result;
|
|
11427
11444
|
}
|
|
11428
11445
|
}
|
|
11429
|
-
var Dot$0 = $TV($EXPECT($
|
|
11446
|
+
var Dot$0 = $TV($EXPECT($L2, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
11430
11447
|
return { $loc, token: $1 };
|
|
11431
11448
|
});
|
|
11432
11449
|
function Dot(state) {
|
|
@@ -11451,7 +11468,7 @@ ${input.slice(result.pos)}
|
|
|
11451
11468
|
return result;
|
|
11452
11469
|
}
|
|
11453
11470
|
}
|
|
11454
|
-
var DotDot$0 = $TV($EXPECT($
|
|
11471
|
+
var DotDot$0 = $TV($EXPECT($L105, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
11455
11472
|
return { $loc, token: $1 };
|
|
11456
11473
|
});
|
|
11457
11474
|
function DotDot(state) {
|
|
@@ -11476,7 +11493,7 @@ ${input.slice(result.pos)}
|
|
|
11476
11493
|
return result;
|
|
11477
11494
|
}
|
|
11478
11495
|
}
|
|
11479
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
11496
|
+
var DotDotDot$0 = $TV($EXPECT($L106, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
11480
11497
|
return { $loc, token: $1 };
|
|
11481
11498
|
});
|
|
11482
11499
|
function DotDotDot(state) {
|
|
@@ -11501,7 +11518,7 @@ ${input.slice(result.pos)}
|
|
|
11501
11518
|
return result;
|
|
11502
11519
|
}
|
|
11503
11520
|
}
|
|
11504
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
11521
|
+
var DoubleColon$0 = $TV($EXPECT($L107, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
11505
11522
|
return { $loc, token: $1 };
|
|
11506
11523
|
});
|
|
11507
11524
|
function DoubleColon(state) {
|
|
@@ -11526,7 +11543,7 @@ ${input.slice(result.pos)}
|
|
|
11526
11543
|
return result;
|
|
11527
11544
|
}
|
|
11528
11545
|
}
|
|
11529
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
11546
|
+
var DoubleQuote$0 = $TV($EXPECT($L108, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
11530
11547
|
return { $loc, token: $1 };
|
|
11531
11548
|
});
|
|
11532
11549
|
function DoubleQuote(state) {
|
|
@@ -11551,7 +11568,7 @@ ${input.slice(result.pos)}
|
|
|
11551
11568
|
return result;
|
|
11552
11569
|
}
|
|
11553
11570
|
}
|
|
11554
|
-
var Else$0 = $TS($S($EXPECT($
|
|
11571
|
+
var Else$0 = $TS($S($EXPECT($L109, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11555
11572
|
return { $loc, token: $1 };
|
|
11556
11573
|
});
|
|
11557
11574
|
function Else(state) {
|
|
@@ -11576,7 +11593,7 @@ ${input.slice(result.pos)}
|
|
|
11576
11593
|
return result;
|
|
11577
11594
|
}
|
|
11578
11595
|
}
|
|
11579
|
-
var Equals$0 = $TV($EXPECT($
|
|
11596
|
+
var Equals$0 = $TV($EXPECT($L25, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
11580
11597
|
return { $loc, token: $1 };
|
|
11581
11598
|
});
|
|
11582
11599
|
function Equals(state) {
|
|
@@ -11601,7 +11618,7 @@ ${input.slice(result.pos)}
|
|
|
11601
11618
|
return result;
|
|
11602
11619
|
}
|
|
11603
11620
|
}
|
|
11604
|
-
var Export$0 = $TS($S($EXPECT($
|
|
11621
|
+
var Export$0 = $TS($S($EXPECT($L110, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11605
11622
|
return { $loc, token: $1 };
|
|
11606
11623
|
});
|
|
11607
11624
|
function Export(state) {
|
|
@@ -11626,7 +11643,7 @@ ${input.slice(result.pos)}
|
|
|
11626
11643
|
return result;
|
|
11627
11644
|
}
|
|
11628
11645
|
}
|
|
11629
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
11646
|
+
var Extends$0 = $TS($S($EXPECT($L111, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11630
11647
|
return { $loc, token: $1 };
|
|
11631
11648
|
});
|
|
11632
11649
|
function Extends(state) {
|
|
@@ -11651,7 +11668,7 @@ ${input.slice(result.pos)}
|
|
|
11651
11668
|
return result;
|
|
11652
11669
|
}
|
|
11653
11670
|
}
|
|
11654
|
-
var For$0 = $TS($S($EXPECT($
|
|
11671
|
+
var For$0 = $TS($S($EXPECT($L112, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11655
11672
|
return { $loc, token: $1 };
|
|
11656
11673
|
});
|
|
11657
11674
|
function For(state) {
|
|
@@ -11676,7 +11693,7 @@ ${input.slice(result.pos)}
|
|
|
11676
11693
|
return result;
|
|
11677
11694
|
}
|
|
11678
11695
|
}
|
|
11679
|
-
var From$0 = $TS($S($EXPECT($
|
|
11696
|
+
var From$0 = $TS($S($EXPECT($L113, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11680
11697
|
return { $loc, token: $1 };
|
|
11681
11698
|
});
|
|
11682
11699
|
function From(state) {
|
|
@@ -11701,7 +11718,7 @@ ${input.slice(result.pos)}
|
|
|
11701
11718
|
return result;
|
|
11702
11719
|
}
|
|
11703
11720
|
}
|
|
11704
|
-
var Function$0 = $TS($S($EXPECT($
|
|
11721
|
+
var Function$0 = $TS($S($EXPECT($L114, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11705
11722
|
return { $loc, token: $1 };
|
|
11706
11723
|
});
|
|
11707
11724
|
function Function(state) {
|
|
@@ -11726,7 +11743,7 @@ ${input.slice(result.pos)}
|
|
|
11726
11743
|
return result;
|
|
11727
11744
|
}
|
|
11728
11745
|
}
|
|
11729
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
11746
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L115, fail, 'GetOrSet "get"'), $EXPECT($L116, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11730
11747
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
11731
11748
|
});
|
|
11732
11749
|
function GetOrSet(state) {
|
|
@@ -11751,7 +11768,7 @@ ${input.slice(result.pos)}
|
|
|
11751
11768
|
return result;
|
|
11752
11769
|
}
|
|
11753
11770
|
}
|
|
11754
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
11771
|
+
var If$0 = $TV($TEXT($S($EXPECT($L117, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L6, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
11755
11772
|
return { $loc, token: $1 };
|
|
11756
11773
|
});
|
|
11757
11774
|
function If(state) {
|
|
@@ -11776,7 +11793,7 @@ ${input.slice(result.pos)}
|
|
|
11776
11793
|
return result;
|
|
11777
11794
|
}
|
|
11778
11795
|
}
|
|
11779
|
-
var Import$0 = $TS($S($EXPECT($
|
|
11796
|
+
var Import$0 = $TS($S($EXPECT($L10, fail, 'Import "import"'), $Y($EXPECT($R45, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
11780
11797
|
return { $loc, token: $1 };
|
|
11781
11798
|
});
|
|
11782
11799
|
function Import(state) {
|
|
@@ -11801,7 +11818,7 @@ ${input.slice(result.pos)}
|
|
|
11801
11818
|
return result;
|
|
11802
11819
|
}
|
|
11803
11820
|
}
|
|
11804
|
-
var In$0 = $TS($S($EXPECT($
|
|
11821
|
+
var In$0 = $TS($S($EXPECT($L74, fail, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11805
11822
|
return { $loc, token: $1 };
|
|
11806
11823
|
});
|
|
11807
11824
|
function In(state) {
|
|
@@ -11826,7 +11843,7 @@ ${input.slice(result.pos)}
|
|
|
11826
11843
|
return result;
|
|
11827
11844
|
}
|
|
11828
11845
|
}
|
|
11829
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
11846
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L118, fail, 'LetOrConst "let"'), $EXPECT($L119, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11830
11847
|
return { $loc, token: $1 };
|
|
11831
11848
|
});
|
|
11832
11849
|
function LetOrConst(state) {
|
|
@@ -11851,7 +11868,7 @@ ${input.slice(result.pos)}
|
|
|
11851
11868
|
return result;
|
|
11852
11869
|
}
|
|
11853
11870
|
}
|
|
11854
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
11871
|
+
var Loop$0 = $TS($S($EXPECT($L120, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11855
11872
|
return { $loc, token: "while(true)" };
|
|
11856
11873
|
});
|
|
11857
11874
|
function Loop(state) {
|
|
@@ -11876,7 +11893,7 @@ ${input.slice(result.pos)}
|
|
|
11876
11893
|
return result;
|
|
11877
11894
|
}
|
|
11878
11895
|
}
|
|
11879
|
-
var New$0 = $TS($S($EXPECT($
|
|
11896
|
+
var New$0 = $TS($S($EXPECT($L121, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11880
11897
|
return { $loc, token: $1 };
|
|
11881
11898
|
});
|
|
11882
11899
|
function New(state) {
|
|
@@ -11901,7 +11918,7 @@ ${input.slice(result.pos)}
|
|
|
11901
11918
|
return result;
|
|
11902
11919
|
}
|
|
11903
11920
|
}
|
|
11904
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
11921
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L73, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L6, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
11905
11922
|
return { $loc, token: "!" };
|
|
11906
11923
|
});
|
|
11907
11924
|
function Not(state) {
|
|
@@ -11926,7 +11943,7 @@ ${input.slice(result.pos)}
|
|
|
11926
11943
|
return result;
|
|
11927
11944
|
}
|
|
11928
11945
|
}
|
|
11929
|
-
var Of$0 = $TS($S($EXPECT($
|
|
11946
|
+
var Of$0 = $TS($S($EXPECT($L67, fail, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11930
11947
|
return { $loc, token: $1 };
|
|
11931
11948
|
});
|
|
11932
11949
|
function Of(state) {
|
|
@@ -11951,7 +11968,7 @@ ${input.slice(result.pos)}
|
|
|
11951
11968
|
return result;
|
|
11952
11969
|
}
|
|
11953
11970
|
}
|
|
11954
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
11971
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L122, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
11955
11972
|
return { $loc, token: $1 };
|
|
11956
11973
|
});
|
|
11957
11974
|
function OpenAngleBracket(state) {
|
|
@@ -11976,7 +11993,7 @@ ${input.slice(result.pos)}
|
|
|
11976
11993
|
return result;
|
|
11977
11994
|
}
|
|
11978
11995
|
}
|
|
11979
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
11996
|
+
var OpenBrace$0 = $TV($EXPECT($L123, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
11980
11997
|
return { $loc, token: $1 };
|
|
11981
11998
|
});
|
|
11982
11999
|
function OpenBrace(state) {
|
|
@@ -12001,7 +12018,7 @@ ${input.slice(result.pos)}
|
|
|
12001
12018
|
return result;
|
|
12002
12019
|
}
|
|
12003
12020
|
}
|
|
12004
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
12021
|
+
var OpenBracket$0 = $TV($EXPECT($L124, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
12005
12022
|
return { $loc, token: $1 };
|
|
12006
12023
|
});
|
|
12007
12024
|
function OpenBracket(state) {
|
|
@@ -12026,7 +12043,7 @@ ${input.slice(result.pos)}
|
|
|
12026
12043
|
return result;
|
|
12027
12044
|
}
|
|
12028
12045
|
}
|
|
12029
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
12046
|
+
var OpenParen$0 = $TV($EXPECT($L125, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
12030
12047
|
return { $loc, token: $1 };
|
|
12031
12048
|
});
|
|
12032
12049
|
function OpenParen(state) {
|
|
@@ -12051,7 +12068,7 @@ ${input.slice(result.pos)}
|
|
|
12051
12068
|
return result;
|
|
12052
12069
|
}
|
|
12053
12070
|
}
|
|
12054
|
-
var Public$0 = $TS($S($EXPECT($
|
|
12071
|
+
var Public$0 = $TS($S($EXPECT($L126, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12055
12072
|
return { $loc, token: $1 };
|
|
12056
12073
|
});
|
|
12057
12074
|
function Public(state) {
|
|
@@ -12076,7 +12093,7 @@ ${input.slice(result.pos)}
|
|
|
12076
12093
|
return result;
|
|
12077
12094
|
}
|
|
12078
12095
|
}
|
|
12079
|
-
var Private$0 = $TS($S($EXPECT($
|
|
12096
|
+
var Private$0 = $TS($S($EXPECT($L127, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12080
12097
|
return { $loc, token: $1 };
|
|
12081
12098
|
});
|
|
12082
12099
|
function Private(state) {
|
|
@@ -12101,7 +12118,7 @@ ${input.slice(result.pos)}
|
|
|
12101
12118
|
return result;
|
|
12102
12119
|
}
|
|
12103
12120
|
}
|
|
12104
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
12121
|
+
var Protected$0 = $TS($S($EXPECT($L128, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12105
12122
|
return { $loc, token: $1 };
|
|
12106
12123
|
});
|
|
12107
12124
|
function Protected(state) {
|
|
@@ -12126,7 +12143,7 @@ ${input.slice(result.pos)}
|
|
|
12126
12143
|
return result;
|
|
12127
12144
|
}
|
|
12128
12145
|
}
|
|
12129
|
-
var Pipe$0 = $TV($EXPECT($
|
|
12146
|
+
var Pipe$0 = $TV($EXPECT($L129, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
12130
12147
|
return { $loc, token: $1 };
|
|
12131
12148
|
});
|
|
12132
12149
|
function Pipe(state) {
|
|
@@ -12151,7 +12168,7 @@ ${input.slice(result.pos)}
|
|
|
12151
12168
|
return result;
|
|
12152
12169
|
}
|
|
12153
12170
|
}
|
|
12154
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
12171
|
+
var QuestionMark$0 = $TV($EXPECT($L71, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
12155
12172
|
return { $loc, token: $1 };
|
|
12156
12173
|
});
|
|
12157
12174
|
function QuestionMark(state) {
|
|
@@ -12176,7 +12193,7 @@ ${input.slice(result.pos)}
|
|
|
12176
12193
|
return result;
|
|
12177
12194
|
}
|
|
12178
12195
|
}
|
|
12179
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
12196
|
+
var Readonly$0 = $TS($S($EXPECT($L130, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12180
12197
|
return { $loc, token: $1, ts: true };
|
|
12181
12198
|
});
|
|
12182
12199
|
function Readonly(state) {
|
|
@@ -12201,7 +12218,7 @@ ${input.slice(result.pos)}
|
|
|
12201
12218
|
return result;
|
|
12202
12219
|
}
|
|
12203
12220
|
}
|
|
12204
|
-
var Return$0 = $TS($S($EXPECT($
|
|
12221
|
+
var Return$0 = $TS($S($EXPECT($L131, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12205
12222
|
return { $loc, token: $1 };
|
|
12206
12223
|
});
|
|
12207
12224
|
function Return(state) {
|
|
@@ -12226,7 +12243,7 @@ ${input.slice(result.pos)}
|
|
|
12226
12243
|
return result;
|
|
12227
12244
|
}
|
|
12228
12245
|
}
|
|
12229
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
12246
|
+
var Satisfies$0 = $TS($S($EXPECT($L132, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12230
12247
|
return { $loc, token: $1 };
|
|
12231
12248
|
});
|
|
12232
12249
|
function Satisfies(state) {
|
|
@@ -12251,7 +12268,7 @@ ${input.slice(result.pos)}
|
|
|
12251
12268
|
return result;
|
|
12252
12269
|
}
|
|
12253
12270
|
}
|
|
12254
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
12271
|
+
var Semicolon$0 = $TV($EXPECT($L79, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
12255
12272
|
return { $loc, token: $1 };
|
|
12256
12273
|
});
|
|
12257
12274
|
function Semicolon(state) {
|
|
@@ -12276,7 +12293,7 @@ ${input.slice(result.pos)}
|
|
|
12276
12293
|
return result;
|
|
12277
12294
|
}
|
|
12278
12295
|
}
|
|
12279
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
12296
|
+
var SingleQuote$0 = $TV($EXPECT($L133, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
12280
12297
|
return { $loc, token: $1 };
|
|
12281
12298
|
});
|
|
12282
12299
|
function SingleQuote(state) {
|
|
@@ -12301,7 +12318,7 @@ ${input.slice(result.pos)}
|
|
|
12301
12318
|
return result;
|
|
12302
12319
|
}
|
|
12303
12320
|
}
|
|
12304
|
-
var Star$0 = $TV($EXPECT($
|
|
12321
|
+
var Star$0 = $TV($EXPECT($L48, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
12305
12322
|
return { $loc, token: $1 };
|
|
12306
12323
|
});
|
|
12307
12324
|
function Star(state) {
|
|
@@ -12326,10 +12343,10 @@ ${input.slice(result.pos)}
|
|
|
12326
12343
|
return result;
|
|
12327
12344
|
}
|
|
12328
12345
|
}
|
|
12329
|
-
var Static$0 = $TS($S($EXPECT($
|
|
12346
|
+
var Static$0 = $TS($S($EXPECT($L134, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12330
12347
|
return { $loc, token: $1 };
|
|
12331
12348
|
});
|
|
12332
|
-
var Static$1 = $TS($S($EXPECT($
|
|
12349
|
+
var Static$1 = $TS($S($EXPECT($L93, fail, 'Static "@"'), $N($C($EXPECT($L125, fail, 'Static "("'), $EXPECT($L93, fail, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
12333
12350
|
return { $loc, token: "static " };
|
|
12334
12351
|
});
|
|
12335
12352
|
function Static(state) {
|
|
@@ -12354,7 +12371,7 @@ ${input.slice(result.pos)}
|
|
|
12354
12371
|
return result;
|
|
12355
12372
|
}
|
|
12356
12373
|
}
|
|
12357
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
12374
|
+
var SubstitutionStart$0 = $TV($EXPECT($L135, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
12358
12375
|
return { $loc, token: $1 };
|
|
12359
12376
|
});
|
|
12360
12377
|
function SubstitutionStart(state) {
|
|
@@ -12379,7 +12396,7 @@ ${input.slice(result.pos)}
|
|
|
12379
12396
|
return result;
|
|
12380
12397
|
}
|
|
12381
12398
|
}
|
|
12382
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
12399
|
+
var Switch$0 = $TS($S($EXPECT($L136, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12383
12400
|
return { $loc, token: $1 };
|
|
12384
12401
|
});
|
|
12385
12402
|
function Switch(state) {
|
|
@@ -12404,7 +12421,7 @@ ${input.slice(result.pos)}
|
|
|
12404
12421
|
return result;
|
|
12405
12422
|
}
|
|
12406
12423
|
}
|
|
12407
|
-
var Target$0 = $TS($S($EXPECT($
|
|
12424
|
+
var Target$0 = $TS($S($EXPECT($L137, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12408
12425
|
return { $loc, token: $1 };
|
|
12409
12426
|
});
|
|
12410
12427
|
function Target(state) {
|
|
@@ -12429,7 +12446,7 @@ ${input.slice(result.pos)}
|
|
|
12429
12446
|
return result;
|
|
12430
12447
|
}
|
|
12431
12448
|
}
|
|
12432
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
12449
|
+
var Then$0 = $TS($S(__, $EXPECT($L138, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
12433
12450
|
return { $loc, token: "" };
|
|
12434
12451
|
});
|
|
12435
12452
|
function Then(state) {
|
|
@@ -12454,7 +12471,7 @@ ${input.slice(result.pos)}
|
|
|
12454
12471
|
return result;
|
|
12455
12472
|
}
|
|
12456
12473
|
}
|
|
12457
|
-
var This$0 = $TS($S($EXPECT($
|
|
12474
|
+
var This$0 = $TS($S($EXPECT($L139, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12458
12475
|
return { $loc, token: $1 };
|
|
12459
12476
|
});
|
|
12460
12477
|
function This(state) {
|
|
@@ -12479,7 +12496,7 @@ ${input.slice(result.pos)}
|
|
|
12479
12496
|
return result;
|
|
12480
12497
|
}
|
|
12481
12498
|
}
|
|
12482
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
12499
|
+
var Throw$0 = $TS($S($EXPECT($L140, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12483
12500
|
return { $loc, token: $1 };
|
|
12484
12501
|
});
|
|
12485
12502
|
function Throw(state) {
|
|
@@ -12504,7 +12521,7 @@ ${input.slice(result.pos)}
|
|
|
12504
12521
|
return result;
|
|
12505
12522
|
}
|
|
12506
12523
|
}
|
|
12507
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
12524
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L141, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
12508
12525
|
return { $loc, token: "`" };
|
|
12509
12526
|
});
|
|
12510
12527
|
function TripleDoubleQuote(state) {
|
|
@@ -12529,7 +12546,7 @@ ${input.slice(result.pos)}
|
|
|
12529
12546
|
return result;
|
|
12530
12547
|
}
|
|
12531
12548
|
}
|
|
12532
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
12549
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L142, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
12533
12550
|
return { $loc, token: "`" };
|
|
12534
12551
|
});
|
|
12535
12552
|
function TripleSingleQuote(state) {
|
|
@@ -12554,7 +12571,7 @@ ${input.slice(result.pos)}
|
|
|
12554
12571
|
return result;
|
|
12555
12572
|
}
|
|
12556
12573
|
}
|
|
12557
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
12574
|
+
var TripleSlash$0 = $TV($EXPECT($L143, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
12558
12575
|
return { $loc, token: "/" };
|
|
12559
12576
|
});
|
|
12560
12577
|
function TripleSlash(state) {
|
|
@@ -12579,7 +12596,7 @@ ${input.slice(result.pos)}
|
|
|
12579
12596
|
return result;
|
|
12580
12597
|
}
|
|
12581
12598
|
}
|
|
12582
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
12599
|
+
var TripleTick$0 = $TV($EXPECT($L144, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
12583
12600
|
return { $loc, token: "`" };
|
|
12584
12601
|
});
|
|
12585
12602
|
function TripleTick(state) {
|
|
@@ -12604,7 +12621,7 @@ ${input.slice(result.pos)}
|
|
|
12604
12621
|
return result;
|
|
12605
12622
|
}
|
|
12606
12623
|
}
|
|
12607
|
-
var Try$0 = $TS($S($EXPECT($
|
|
12624
|
+
var Try$0 = $TS($S($EXPECT($L145, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12608
12625
|
return { $loc, token: $1 };
|
|
12609
12626
|
});
|
|
12610
12627
|
function Try(state) {
|
|
@@ -12629,7 +12646,7 @@ ${input.slice(result.pos)}
|
|
|
12629
12646
|
return result;
|
|
12630
12647
|
}
|
|
12631
12648
|
}
|
|
12632
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
12649
|
+
var Typeof$0 = $TS($S($EXPECT($L146, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12633
12650
|
return { $loc, token: $1 };
|
|
12634
12651
|
});
|
|
12635
12652
|
function Typeof(state) {
|
|
@@ -12654,7 +12671,7 @@ ${input.slice(result.pos)}
|
|
|
12654
12671
|
return result;
|
|
12655
12672
|
}
|
|
12656
12673
|
}
|
|
12657
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
12674
|
+
var Unless$0 = $TS($S($EXPECT($L147, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12658
12675
|
return { $loc, token: $1 };
|
|
12659
12676
|
});
|
|
12660
12677
|
function Unless(state) {
|
|
@@ -12679,7 +12696,7 @@ ${input.slice(result.pos)}
|
|
|
12679
12696
|
return result;
|
|
12680
12697
|
}
|
|
12681
12698
|
}
|
|
12682
|
-
var Until$0 = $TS($S($EXPECT($
|
|
12699
|
+
var Until$0 = $TS($S($EXPECT($L148, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12683
12700
|
return { $loc, token: $1 };
|
|
12684
12701
|
});
|
|
12685
12702
|
function Until(state) {
|
|
@@ -12704,7 +12721,7 @@ ${input.slice(result.pos)}
|
|
|
12704
12721
|
return result;
|
|
12705
12722
|
}
|
|
12706
12723
|
}
|
|
12707
|
-
var Var$0 = $TS($S($EXPECT($
|
|
12724
|
+
var Var$0 = $TS($S($EXPECT($L149, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12708
12725
|
return { $loc, token: $1 };
|
|
12709
12726
|
});
|
|
12710
12727
|
function Var(state) {
|
|
@@ -12729,7 +12746,7 @@ ${input.slice(result.pos)}
|
|
|
12729
12746
|
return result;
|
|
12730
12747
|
}
|
|
12731
12748
|
}
|
|
12732
|
-
var Void$0 = $TS($S($EXPECT($
|
|
12749
|
+
var Void$0 = $TS($S($EXPECT($L150, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12733
12750
|
return { $loc, token: $1 };
|
|
12734
12751
|
});
|
|
12735
12752
|
function Void(state) {
|
|
@@ -12754,7 +12771,7 @@ ${input.slice(result.pos)}
|
|
|
12754
12771
|
return result;
|
|
12755
12772
|
}
|
|
12756
12773
|
}
|
|
12757
|
-
var When$0 = $TS($S($EXPECT($
|
|
12774
|
+
var When$0 = $TS($S($EXPECT($L151, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12758
12775
|
return { $loc, token: "case" };
|
|
12759
12776
|
});
|
|
12760
12777
|
function When(state) {
|
|
@@ -12779,7 +12796,7 @@ ${input.slice(result.pos)}
|
|
|
12779
12796
|
return result;
|
|
12780
12797
|
}
|
|
12781
12798
|
}
|
|
12782
|
-
var While$0 = $TS($S($EXPECT($
|
|
12799
|
+
var While$0 = $TS($S($EXPECT($L152, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12783
12800
|
return { $loc, token: $1 };
|
|
12784
12801
|
});
|
|
12785
12802
|
function While(state) {
|
|
@@ -12804,7 +12821,7 @@ ${input.slice(result.pos)}
|
|
|
12804
12821
|
return result;
|
|
12805
12822
|
}
|
|
12806
12823
|
}
|
|
12807
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
12824
|
+
var Yield$0 = $TS($S($EXPECT($L153, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12808
12825
|
return { $loc, token: $1 };
|
|
12809
12826
|
});
|
|
12810
12827
|
function Yield(state) {
|
|
@@ -12936,7 +12953,7 @@ ${input.slice(result.pos)}
|
|
|
12936
12953
|
return result;
|
|
12937
12954
|
}
|
|
12938
12955
|
}
|
|
12939
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
12956
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L122, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L154, fail, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
12940
12957
|
return { type: "JSXElement", children: $0 };
|
|
12941
12958
|
});
|
|
12942
12959
|
function JSXSelfClosingElement(state) {
|
|
@@ -12961,7 +12978,7 @@ ${input.slice(result.pos)}
|
|
|
12961
12978
|
return result;
|
|
12962
12979
|
}
|
|
12963
12980
|
}
|
|
12964
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
12981
|
+
var JSXOpeningElement$0 = $S($EXPECT($L122, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L26, fail, 'JSXOpeningElement ">"'));
|
|
12965
12982
|
function JSXOpeningElement(state) {
|
|
12966
12983
|
let eventData;
|
|
12967
12984
|
if (state.events) {
|
|
@@ -12984,7 +13001,7 @@ ${input.slice(result.pos)}
|
|
|
12984
13001
|
return result;
|
|
12985
13002
|
}
|
|
12986
13003
|
}
|
|
12987
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
13004
|
+
var JSXClosingElement$0 = $S($EXPECT($L155, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L26, fail, 'JSXClosingElement ">"'));
|
|
12988
13005
|
function JSXClosingElement(state) {
|
|
12989
13006
|
let eventData;
|
|
12990
13007
|
if (state.events) {
|
|
@@ -13007,14 +13024,14 @@ ${input.slice(result.pos)}
|
|
|
13007
13024
|
return result;
|
|
13008
13025
|
}
|
|
13009
13026
|
}
|
|
13010
|
-
var JSXFragment$0 = $TS($S($EXPECT($
|
|
13027
|
+
var JSXFragment$0 = $TS($S($EXPECT($L156, fail, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), $EXPECT($L157, fail, 'JSXFragment "</>"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
13011
13028
|
if ($2) {
|
|
13012
13029
|
return { type: "JSXFragment", children: $0, jsxChildren: $2.jsxChildren };
|
|
13013
13030
|
} else {
|
|
13014
13031
|
return { type: "JSXFragment", children: $0, jsxChildren: [] };
|
|
13015
13032
|
}
|
|
13016
13033
|
});
|
|
13017
|
-
var JSXFragment$1 = $TS($S($EXPECT($
|
|
13034
|
+
var JSXFragment$1 = $TS($S($EXPECT($L156, fail, 'JSXFragment "<>"'), JSXMixedChildren, InsertNewline, InsertIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
13018
13035
|
return { type: "JSXFragment", children: [...$0, "</>"], jsxChildren: $2.jsxChildren };
|
|
13019
13036
|
});
|
|
13020
13037
|
function JSXFragment(state) {
|
|
@@ -13241,7 +13258,7 @@ ${input.slice(result.pos)}
|
|
|
13241
13258
|
}
|
|
13242
13259
|
});
|
|
13243
13260
|
var JSXAttribute$2 = $S(InsertInlineOpenBrace, DotDotDot, InlineJSXAttributeValue, InsertCloseBrace);
|
|
13244
|
-
var JSXAttribute$3 = $TS($S($EXPECT($
|
|
13261
|
+
var JSXAttribute$3 = $TS($S($EXPECT($L8, fail, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
13245
13262
|
return [" ", "id=", $2];
|
|
13246
13263
|
});
|
|
13247
13264
|
var JSXAttribute$4 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -13548,8 +13565,8 @@ ${input.slice(result.pos)}
|
|
|
13548
13565
|
return result;
|
|
13549
13566
|
}
|
|
13550
13567
|
}
|
|
13551
|
-
var InlineJSXCallExpression$0 = $S($EXPECT($
|
|
13552
|
-
var InlineJSXCallExpression$1 = $S($EXPECT($
|
|
13568
|
+
var InlineJSXCallExpression$0 = $S($EXPECT($L9, fail, 'InlineJSXCallExpression "super"'), ExplicitArguments);
|
|
13569
|
+
var InlineJSXCallExpression$1 = $S($EXPECT($L10, fail, 'InlineJSXCallExpression "import"'), OpenParen, ExtendedExpression, __, CloseParen);
|
|
13553
13570
|
var InlineJSXCallExpression$2 = $TS($S(InlineJSXMemberExpression, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
13554
13571
|
if ($2.length)
|
|
13555
13572
|
return $0;
|
|
@@ -13764,7 +13781,7 @@ ${input.slice(result.pos)}
|
|
|
13764
13781
|
}
|
|
13765
13782
|
return $skip;
|
|
13766
13783
|
});
|
|
13767
|
-
var JSXNestedChildren$1 = $TV($Y($C(EOS, $EXPECT($
|
|
13784
|
+
var JSXNestedChildren$1 = $TV($Y($C(EOS, $EXPECT($L16, fail, 'JSXNestedChildren "}"'))), function($skip, $loc, $0, $1) {
|
|
13768
13785
|
return { children: [], jsxChildren: [] };
|
|
13769
13786
|
});
|
|
13770
13787
|
function JSXNestedChildren(state) {
|
|
@@ -13839,7 +13856,7 @@ ${input.slice(result.pos)}
|
|
|
13839
13856
|
return result;
|
|
13840
13857
|
}
|
|
13841
13858
|
}
|
|
13842
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
13859
|
+
var JSXComment$0 = $TS($S($EXPECT($L158, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L159, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
13843
13860
|
return ["{/*", $2, "*/}"];
|
|
13844
13861
|
});
|
|
13845
13862
|
function JSXComment(state) {
|
|
@@ -14016,7 +14033,7 @@ ${input.slice(result.pos)}
|
|
|
14016
14033
|
return result;
|
|
14017
14034
|
}
|
|
14018
14035
|
}
|
|
14019
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
14036
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L160, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
14020
14037
|
var TypeDeclarationModifier$1 = Export;
|
|
14021
14038
|
function TypeDeclarationModifier(state) {
|
|
14022
14039
|
let eventData;
|
|
@@ -14041,7 +14058,7 @@ ${input.slice(result.pos)}
|
|
|
14041
14058
|
}
|
|
14042
14059
|
}
|
|
14043
14060
|
var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, Equals, __, Type);
|
|
14044
|
-
var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, $E(TypeParameters), InterfaceBlock);
|
|
14061
|
+
var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, $E(TypeParameters), $E(InterfaceExtendsClause), InterfaceBlock);
|
|
14045
14062
|
var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
|
|
14046
14063
|
var TypeDeclarationRest$3 = FunctionSignature;
|
|
14047
14064
|
function TypeDeclarationRest(state) {
|
|
@@ -14066,7 +14083,53 @@ ${input.slice(result.pos)}
|
|
|
14066
14083
|
return result;
|
|
14067
14084
|
}
|
|
14068
14085
|
}
|
|
14069
|
-
var
|
|
14086
|
+
var InterfaceExtendsClause$0 = $S(ExtendsToken, InterfaceExtendsTarget);
|
|
14087
|
+
function InterfaceExtendsClause(state) {
|
|
14088
|
+
let eventData;
|
|
14089
|
+
if (state.events) {
|
|
14090
|
+
const result = state.events.enter?.("InterfaceExtendsClause", state);
|
|
14091
|
+
if (result) {
|
|
14092
|
+
if (result.cache)
|
|
14093
|
+
return result.cache;
|
|
14094
|
+
eventData = result.data;
|
|
14095
|
+
}
|
|
14096
|
+
}
|
|
14097
|
+
if (state.tokenize) {
|
|
14098
|
+
const result = $TOKEN("InterfaceExtendsClause", state, InterfaceExtendsClause$0(state));
|
|
14099
|
+
if (state.events)
|
|
14100
|
+
state.events.exit?.("InterfaceExtendsClause", state, result, eventData);
|
|
14101
|
+
return result;
|
|
14102
|
+
} else {
|
|
14103
|
+
const result = InterfaceExtendsClause$0(state);
|
|
14104
|
+
if (state.events)
|
|
14105
|
+
state.events.exit?.("InterfaceExtendsClause", state, result, eventData);
|
|
14106
|
+
return result;
|
|
14107
|
+
}
|
|
14108
|
+
}
|
|
14109
|
+
var InterfaceExtendsTarget$0 = ImplementsTarget;
|
|
14110
|
+
function InterfaceExtendsTarget(state) {
|
|
14111
|
+
let eventData;
|
|
14112
|
+
if (state.events) {
|
|
14113
|
+
const result = state.events.enter?.("InterfaceExtendsTarget", state);
|
|
14114
|
+
if (result) {
|
|
14115
|
+
if (result.cache)
|
|
14116
|
+
return result.cache;
|
|
14117
|
+
eventData = result.data;
|
|
14118
|
+
}
|
|
14119
|
+
}
|
|
14120
|
+
if (state.tokenize) {
|
|
14121
|
+
const result = $TOKEN("InterfaceExtendsTarget", state, InterfaceExtendsTarget$0(state));
|
|
14122
|
+
if (state.events)
|
|
14123
|
+
state.events.exit?.("InterfaceExtendsTarget", state, result, eventData);
|
|
14124
|
+
return result;
|
|
14125
|
+
} else {
|
|
14126
|
+
const result = InterfaceExtendsTarget$0(state);
|
|
14127
|
+
if (state.events)
|
|
14128
|
+
state.events.exit?.("InterfaceExtendsTarget", state, result, eventData);
|
|
14129
|
+
return result;
|
|
14130
|
+
}
|
|
14131
|
+
}
|
|
14132
|
+
var TypeKeyword$0 = $S($EXPECT($L161, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
14070
14133
|
function TypeKeyword(state) {
|
|
14071
14134
|
let eventData;
|
|
14072
14135
|
if (state.events) {
|
|
@@ -14089,7 +14152,7 @@ ${input.slice(result.pos)}
|
|
|
14089
14152
|
return result;
|
|
14090
14153
|
}
|
|
14091
14154
|
}
|
|
14092
|
-
var Interface$0 = $S($EXPECT($
|
|
14155
|
+
var Interface$0 = $S($EXPECT($L162, fail, 'Interface "interface"'), NonIdContinue);
|
|
14093
14156
|
function Interface(state) {
|
|
14094
14157
|
let eventData;
|
|
14095
14158
|
if (state.events) {
|
|
@@ -14112,7 +14175,7 @@ ${input.slice(result.pos)}
|
|
|
14112
14175
|
return result;
|
|
14113
14176
|
}
|
|
14114
14177
|
}
|
|
14115
|
-
var Namespace$0 = $S($EXPECT($
|
|
14178
|
+
var Namespace$0 = $S($EXPECT($L163, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
14116
14179
|
function Namespace(state) {
|
|
14117
14180
|
let eventData;
|
|
14118
14181
|
if (state.events) {
|
|
@@ -14337,7 +14400,7 @@ ${input.slice(result.pos)}
|
|
|
14337
14400
|
return result;
|
|
14338
14401
|
}
|
|
14339
14402
|
}
|
|
14340
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R50, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($
|
|
14403
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R50, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L130, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R51, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
14341
14404
|
function TypeIndexSignature(state) {
|
|
14342
14405
|
let eventData;
|
|
14343
14406
|
if (state.events) {
|
|
@@ -14409,7 +14472,7 @@ ${input.slice(result.pos)}
|
|
|
14409
14472
|
return result;
|
|
14410
14473
|
}
|
|
14411
14474
|
}
|
|
14412
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
14475
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L164, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
14413
14476
|
const children = [...$1, $2];
|
|
14414
14477
|
if ($3)
|
|
14415
14478
|
children.push($3);
|
|
@@ -14442,7 +14505,7 @@ ${input.slice(result.pos)}
|
|
|
14442
14505
|
return result;
|
|
14443
14506
|
}
|
|
14444
14507
|
}
|
|
14445
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
14508
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L75, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
14446
14509
|
if (!$2)
|
|
14447
14510
|
return $1;
|
|
14448
14511
|
return $0;
|
|
@@ -14568,10 +14631,10 @@ ${input.slice(result.pos)}
|
|
|
14568
14631
|
return result;
|
|
14569
14632
|
}
|
|
14570
14633
|
}
|
|
14571
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
14572
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
14573
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
14574
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
14634
|
+
var TypeUnaryOp$0 = $S($EXPECT($L165, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
14635
|
+
var TypeUnaryOp$1 = $S($EXPECT($L146, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
14636
|
+
var TypeUnaryOp$2 = $S($EXPECT($L166, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
14637
|
+
var TypeUnaryOp$3 = $S($EXPECT($L130, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
14575
14638
|
function TypeUnaryOp(state) {
|
|
14576
14639
|
let eventData;
|
|
14577
14640
|
if (state.events) {
|
|
@@ -14620,9 +14683,10 @@ ${input.slice(result.pos)}
|
|
|
14620
14683
|
var TypePrimary$0 = InterfaceBlock;
|
|
14621
14684
|
var TypePrimary$1 = $S(__, OpenParen, Type, __, CloseParen);
|
|
14622
14685
|
var TypePrimary$2 = $S(__, TypeTuple);
|
|
14623
|
-
var TypePrimary$3 = $S($Q(_),
|
|
14624
|
-
var TypePrimary$4 = $S($Q(_),
|
|
14625
|
-
var TypePrimary$5 = $S($Q(_),
|
|
14686
|
+
var TypePrimary$3 = $S($Q(_), ImportType);
|
|
14687
|
+
var TypePrimary$4 = $S($Q(_), FunctionType);
|
|
14688
|
+
var TypePrimary$5 = $S($Q(_), TypeLiteral);
|
|
14689
|
+
var TypePrimary$6 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
14626
14690
|
function TypePrimary(state) {
|
|
14627
14691
|
let eventData;
|
|
14628
14692
|
if (state.events) {
|
|
@@ -14634,17 +14698,41 @@ ${input.slice(result.pos)}
|
|
|
14634
14698
|
}
|
|
14635
14699
|
}
|
|
14636
14700
|
if (state.tokenize) {
|
|
14637
|
-
const result = $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state));
|
|
14701
|
+
const result = $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state) || TypePrimary$6(state));
|
|
14638
14702
|
if (state.events)
|
|
14639
14703
|
state.events.exit?.("TypePrimary", state, result, eventData);
|
|
14640
14704
|
return result;
|
|
14641
14705
|
} else {
|
|
14642
|
-
const result = TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state);
|
|
14706
|
+
const result = TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state) || TypePrimary$6(state);
|
|
14643
14707
|
if (state.events)
|
|
14644
14708
|
state.events.exit?.("TypePrimary", state, result, eventData);
|
|
14645
14709
|
return result;
|
|
14646
14710
|
}
|
|
14647
14711
|
}
|
|
14712
|
+
var ImportType$0 = $S($EXPECT($L10, fail, 'ImportType "import"'), OpenParen, __, BasicStringLiteral, __, CloseParen, $E($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
14713
|
+
var ImportType$1 = $S($EXPECT($L10, fail, 'ImportType "import"'), InsertOpenParen, Trimmed_, BasicStringLiteral, InsertCloseParen);
|
|
14714
|
+
function ImportType(state) {
|
|
14715
|
+
let eventData;
|
|
14716
|
+
if (state.events) {
|
|
14717
|
+
const result = state.events.enter?.("ImportType", state);
|
|
14718
|
+
if (result) {
|
|
14719
|
+
if (result.cache)
|
|
14720
|
+
return result.cache;
|
|
14721
|
+
eventData = result.data;
|
|
14722
|
+
}
|
|
14723
|
+
}
|
|
14724
|
+
if (state.tokenize) {
|
|
14725
|
+
const result = $TOKEN("ImportType", state, ImportType$0(state) || ImportType$1(state));
|
|
14726
|
+
if (state.events)
|
|
14727
|
+
state.events.exit?.("ImportType", state, result, eventData);
|
|
14728
|
+
return result;
|
|
14729
|
+
} else {
|
|
14730
|
+
const result = ImportType$0(state) || ImportType$1(state);
|
|
14731
|
+
if (state.events)
|
|
14732
|
+
state.events.exit?.("ImportType", state, result, eventData);
|
|
14733
|
+
return result;
|
|
14734
|
+
}
|
|
14735
|
+
}
|
|
14648
14736
|
var TypeTuple$0 = $S(OpenBracket, NestedTypeList, __, CloseBracket);
|
|
14649
14737
|
var TypeTuple$1 = $S(OpenBracket, $E(TypeList), __, CloseBracket);
|
|
14650
14738
|
function TypeTuple(state) {
|
|
@@ -14743,7 +14831,7 @@ ${input.slice(result.pos)}
|
|
|
14743
14831
|
return result;
|
|
14744
14832
|
}
|
|
14745
14833
|
}
|
|
14746
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
14834
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L111, fail, 'TypeConditional "extends"'), NonIdContinue, Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
14747
14835
|
if ($2)
|
|
14748
14836
|
return $0;
|
|
14749
14837
|
return $1;
|
|
@@ -14772,10 +14860,10 @@ ${input.slice(result.pos)}
|
|
|
14772
14860
|
}
|
|
14773
14861
|
var TypeLiteral$0 = Literal;
|
|
14774
14862
|
var TypeLiteral$1 = TemplateLiteral;
|
|
14775
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
14863
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L150, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14776
14864
|
return { $loc, token: "void" };
|
|
14777
14865
|
});
|
|
14778
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
14866
|
+
var TypeLiteral$3 = $TV($EXPECT($L167, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
14779
14867
|
return { $loc, token: "[]" };
|
|
14780
14868
|
});
|
|
14781
14869
|
function TypeLiteral(state) {
|
|
@@ -14800,10 +14888,10 @@ ${input.slice(result.pos)}
|
|
|
14800
14888
|
return result;
|
|
14801
14889
|
}
|
|
14802
14890
|
}
|
|
14803
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
14891
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L78, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
14804
14892
|
return { $loc, token: "|" };
|
|
14805
14893
|
});
|
|
14806
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
14894
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L76, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
14807
14895
|
return { $loc, token: "&" };
|
|
14808
14896
|
});
|
|
14809
14897
|
function TypeBinaryOp(state) {
|
|
@@ -14828,7 +14916,13 @@ ${input.slice(result.pos)}
|
|
|
14828
14916
|
return result;
|
|
14829
14917
|
}
|
|
14830
14918
|
}
|
|
14831
|
-
var FunctionType$0 = $S(Parameters, __, $EXPECT($
|
|
14919
|
+
var FunctionType$0 = $TS($S(Parameters, __, $EXPECT($L5, fail, 'FunctionType "=>"'), $E(Type)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
14920
|
+
var type = $4;
|
|
14921
|
+
if (type) {
|
|
14922
|
+
return $0;
|
|
14923
|
+
}
|
|
14924
|
+
return [...$0, "void"];
|
|
14925
|
+
});
|
|
14832
14926
|
function FunctionType(state) {
|
|
14833
14927
|
let eventData;
|
|
14834
14928
|
if (state.events) {
|
|
@@ -14851,7 +14945,7 @@ ${input.slice(result.pos)}
|
|
|
14851
14945
|
return result;
|
|
14852
14946
|
}
|
|
14853
14947
|
}
|
|
14854
|
-
var TypeArguments$0 = $TS($S(
|
|
14948
|
+
var TypeArguments$0 = $TS($S($EXPECT($L122, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L26, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
14855
14949
|
return { ts: true, children: $0 };
|
|
14856
14950
|
});
|
|
14857
14951
|
function TypeArguments(state) {
|
|
@@ -14876,103 +14970,6 @@ ${input.slice(result.pos)}
|
|
|
14876
14970
|
return result;
|
|
14877
14971
|
}
|
|
14878
14972
|
}
|
|
14879
|
-
var InlineTypeArguments$0 = $TS($S($Q(_), $EXPECT($L120, fail, 'InlineTypeArguments "<"'), $P(InlineTypeArgument), $Q(_), $EXPECT($L25, fail, 'InlineTypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
14880
|
-
return { ts: true, children: $0 };
|
|
14881
|
-
});
|
|
14882
|
-
function InlineTypeArguments(state) {
|
|
14883
|
-
let eventData;
|
|
14884
|
-
if (state.events) {
|
|
14885
|
-
const result = state.events.enter?.("InlineTypeArguments", state);
|
|
14886
|
-
if (result) {
|
|
14887
|
-
if (result.cache)
|
|
14888
|
-
return result.cache;
|
|
14889
|
-
eventData = result.data;
|
|
14890
|
-
}
|
|
14891
|
-
}
|
|
14892
|
-
if (state.tokenize) {
|
|
14893
|
-
const result = $TOKEN("InlineTypeArguments", state, InlineTypeArguments$0(state));
|
|
14894
|
-
if (state.events)
|
|
14895
|
-
state.events.exit?.("InlineTypeArguments", state, result, eventData);
|
|
14896
|
-
return result;
|
|
14897
|
-
} else {
|
|
14898
|
-
const result = InlineTypeArguments$0(state);
|
|
14899
|
-
if (state.events)
|
|
14900
|
-
state.events.exit?.("InlineTypeArguments", state, result, eventData);
|
|
14901
|
-
return result;
|
|
14902
|
-
}
|
|
14903
|
-
}
|
|
14904
|
-
var InlineTypeArgument$0 = $S($Q(_), Type, InlineTypeArgumentDelimiter);
|
|
14905
|
-
function InlineTypeArgument(state) {
|
|
14906
|
-
let eventData;
|
|
14907
|
-
if (state.events) {
|
|
14908
|
-
const result = state.events.enter?.("InlineTypeArgument", state);
|
|
14909
|
-
if (result) {
|
|
14910
|
-
if (result.cache)
|
|
14911
|
-
return result.cache;
|
|
14912
|
-
eventData = result.data;
|
|
14913
|
-
}
|
|
14914
|
-
}
|
|
14915
|
-
if (state.tokenize) {
|
|
14916
|
-
const result = $TOKEN("InlineTypeArgument", state, InlineTypeArgument$0(state));
|
|
14917
|
-
if (state.events)
|
|
14918
|
-
state.events.exit?.("InlineTypeArgument", state, result, eventData);
|
|
14919
|
-
return result;
|
|
14920
|
-
} else {
|
|
14921
|
-
const result = InlineTypeArgument$0(state);
|
|
14922
|
-
if (state.events)
|
|
14923
|
-
state.events.exit?.("InlineTypeArgument", state, result, eventData);
|
|
14924
|
-
return result;
|
|
14925
|
-
}
|
|
14926
|
-
}
|
|
14927
|
-
var InlineTypeArgumentDelimiter$0 = $S($Q(_), Comma);
|
|
14928
|
-
var InlineTypeArgumentDelimiter$1 = $Y($S($Q(_), $EXPECT($L25, fail, 'InlineTypeArgumentDelimiter ">"')));
|
|
14929
|
-
function InlineTypeArgumentDelimiter(state) {
|
|
14930
|
-
let eventData;
|
|
14931
|
-
if (state.events) {
|
|
14932
|
-
const result = state.events.enter?.("InlineTypeArgumentDelimiter", state);
|
|
14933
|
-
if (result) {
|
|
14934
|
-
if (result.cache)
|
|
14935
|
-
return result.cache;
|
|
14936
|
-
eventData = result.data;
|
|
14937
|
-
}
|
|
14938
|
-
}
|
|
14939
|
-
if (state.tokenize) {
|
|
14940
|
-
const result = $TOKEN("InlineTypeArgumentDelimiter", state, InlineTypeArgumentDelimiter$0(state) || InlineTypeArgumentDelimiter$1(state));
|
|
14941
|
-
if (state.events)
|
|
14942
|
-
state.events.exit?.("InlineTypeArgumentDelimiter", state, result, eventData);
|
|
14943
|
-
return result;
|
|
14944
|
-
} else {
|
|
14945
|
-
const result = InlineTypeArgumentDelimiter$0(state) || InlineTypeArgumentDelimiter$1(state);
|
|
14946
|
-
if (state.events)
|
|
14947
|
-
state.events.exit?.("InlineTypeArgumentDelimiter", state, result, eventData);
|
|
14948
|
-
return result;
|
|
14949
|
-
}
|
|
14950
|
-
}
|
|
14951
|
-
var CompactTypeArguments$0 = $TS($S($EXPECT($L120, fail, 'CompactTypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L25, fail, 'CompactTypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
14952
|
-
return { ts: true, children: $0 };
|
|
14953
|
-
});
|
|
14954
|
-
function CompactTypeArguments(state) {
|
|
14955
|
-
let eventData;
|
|
14956
|
-
if (state.events) {
|
|
14957
|
-
const result = state.events.enter?.("CompactTypeArguments", state);
|
|
14958
|
-
if (result) {
|
|
14959
|
-
if (result.cache)
|
|
14960
|
-
return result.cache;
|
|
14961
|
-
eventData = result.data;
|
|
14962
|
-
}
|
|
14963
|
-
}
|
|
14964
|
-
if (state.tokenize) {
|
|
14965
|
-
const result = $TOKEN("CompactTypeArguments", state, CompactTypeArguments$0(state));
|
|
14966
|
-
if (state.events)
|
|
14967
|
-
state.events.exit?.("CompactTypeArguments", state, result, eventData);
|
|
14968
|
-
return result;
|
|
14969
|
-
} else {
|
|
14970
|
-
const result = CompactTypeArguments$0(state);
|
|
14971
|
-
if (state.events)
|
|
14972
|
-
state.events.exit?.("CompactTypeArguments", state, result, eventData);
|
|
14973
|
-
return result;
|
|
14974
|
-
}
|
|
14975
|
-
}
|
|
14976
14973
|
var TypeArgument$0 = $S(__, Type, TypeArgumentDelimiter);
|
|
14977
14974
|
function TypeArgument(state) {
|
|
14978
14975
|
let eventData;
|
|
@@ -15019,7 +15016,7 @@ ${input.slice(result.pos)}
|
|
|
15019
15016
|
return result;
|
|
15020
15017
|
}
|
|
15021
15018
|
}
|
|
15022
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
15019
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L122, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L26, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
15023
15020
|
var parameters = $3;
|
|
15024
15021
|
return {
|
|
15025
15022
|
type: "TypeParameters",
|
|
@@ -15073,7 +15070,7 @@ ${input.slice(result.pos)}
|
|
|
15073
15070
|
return result;
|
|
15074
15071
|
}
|
|
15075
15072
|
}
|
|
15076
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
15073
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L111, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
15077
15074
|
function TypeConstraint(state) {
|
|
15078
15075
|
let eventData;
|
|
15079
15076
|
if (state.events) {
|
|
@@ -15096,7 +15093,7 @@ ${input.slice(result.pos)}
|
|
|
15096
15093
|
return result;
|
|
15097
15094
|
}
|
|
15098
15095
|
}
|
|
15099
|
-
var TypeInitializer$0 = $S(__, $EXPECT($
|
|
15096
|
+
var TypeInitializer$0 = $S(__, $EXPECT($L25, fail, 'TypeInitializer "="'), Type);
|
|
15100
15097
|
function TypeInitializer(state) {
|
|
15101
15098
|
let eventData;
|
|
15102
15099
|
if (state.events) {
|
|
@@ -15120,7 +15117,7 @@ ${input.slice(result.pos)}
|
|
|
15120
15117
|
}
|
|
15121
15118
|
}
|
|
15122
15119
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
15123
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
15120
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'TypeParameterDelimiter ">"')));
|
|
15124
15121
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
15125
15122
|
return value[1];
|
|
15126
15123
|
});
|
|
@@ -15199,7 +15196,7 @@ ${input.slice(result.pos)}
|
|
|
15199
15196
|
return result;
|
|
15200
15197
|
}
|
|
15201
15198
|
}
|
|
15202
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
15199
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L168, fail, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R54, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
15203
15200
|
var options = $3;
|
|
15204
15201
|
return {
|
|
15205
15202
|
type: "CivetPrologue",
|
|
@@ -15360,7 +15357,7 @@ ${input.slice(result.pos)}
|
|
|
15360
15357
|
return result;
|
|
15361
15358
|
}
|
|
15362
15359
|
}
|
|
15363
|
-
var Debugger$0 = $TV($EXPECT($
|
|
15360
|
+
var Debugger$0 = $TV($EXPECT($L1, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
15364
15361
|
debugger;
|
|
15365
15362
|
});
|
|
15366
15363
|
function Debugger(state) {
|
|
@@ -15385,7 +15382,7 @@ ${input.slice(result.pos)}
|
|
|
15385
15382
|
return result;
|
|
15386
15383
|
}
|
|
15387
15384
|
}
|
|
15388
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
15385
|
+
var InsertOpenParen$0 = $TV($EXPECT($L1, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
15389
15386
|
return { $loc, token: "(" };
|
|
15390
15387
|
});
|
|
15391
15388
|
function InsertOpenParen(state) {
|
|
@@ -15410,7 +15407,7 @@ ${input.slice(result.pos)}
|
|
|
15410
15407
|
return result;
|
|
15411
15408
|
}
|
|
15412
15409
|
}
|
|
15413
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
15410
|
+
var InsertCloseParen$0 = $TV($EXPECT($L1, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
15414
15411
|
return { $loc, token: ")" };
|
|
15415
15412
|
});
|
|
15416
15413
|
function InsertCloseParen(state) {
|
|
@@ -15435,7 +15432,7 @@ ${input.slice(result.pos)}
|
|
|
15435
15432
|
return result;
|
|
15436
15433
|
}
|
|
15437
15434
|
}
|
|
15438
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
15435
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L1, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
15439
15436
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
15440
15437
|
});
|
|
15441
15438
|
function InsertOpenBrace(state) {
|
|
@@ -15460,7 +15457,7 @@ ${input.slice(result.pos)}
|
|
|
15460
15457
|
return result;
|
|
15461
15458
|
}
|
|
15462
15459
|
}
|
|
15463
|
-
var InsertInlineOpenBrace$0 = $TV($EXPECT($
|
|
15460
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L1, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
15464
15461
|
return { $loc, token: "{" };
|
|
15465
15462
|
});
|
|
15466
15463
|
function InsertInlineOpenBrace(state) {
|
|
@@ -15485,7 +15482,7 @@ ${input.slice(result.pos)}
|
|
|
15485
15482
|
return result;
|
|
15486
15483
|
}
|
|
15487
15484
|
}
|
|
15488
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
15485
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L1, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
15489
15486
|
return { $loc, token: "}" };
|
|
15490
15487
|
});
|
|
15491
15488
|
function InsertCloseBrace(state) {
|
|
@@ -15510,7 +15507,7 @@ ${input.slice(result.pos)}
|
|
|
15510
15507
|
return result;
|
|
15511
15508
|
}
|
|
15512
15509
|
}
|
|
15513
|
-
var InsertComma$0 = $TV($EXPECT($
|
|
15510
|
+
var InsertComma$0 = $TV($EXPECT($L1, fail, 'InsertComma ""'), function($skip, $loc, $0, $1) {
|
|
15514
15511
|
return { $loc, token: "," };
|
|
15515
15512
|
});
|
|
15516
15513
|
function InsertComma(state) {
|
|
@@ -15535,7 +15532,7 @@ ${input.slice(result.pos)}
|
|
|
15535
15532
|
return result;
|
|
15536
15533
|
}
|
|
15537
15534
|
}
|
|
15538
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
15535
|
+
var InsertConst$0 = $TV($EXPECT($L1, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
15539
15536
|
return { $loc, token: "const " };
|
|
15540
15537
|
});
|
|
15541
15538
|
function InsertConst(state) {
|
|
@@ -15560,7 +15557,7 @@ ${input.slice(result.pos)}
|
|
|
15560
15557
|
return result;
|
|
15561
15558
|
}
|
|
15562
15559
|
}
|
|
15563
|
-
var InsertLet$0 = $TV($EXPECT($
|
|
15560
|
+
var InsertLet$0 = $TV($EXPECT($L1, fail, 'InsertLet ""'), function($skip, $loc, $0, $1) {
|
|
15564
15561
|
return { $loc, token: "let " };
|
|
15565
15562
|
});
|
|
15566
15563
|
function InsertLet(state) {
|
|
@@ -15585,7 +15582,7 @@ ${input.slice(result.pos)}
|
|
|
15585
15582
|
return result;
|
|
15586
15583
|
}
|
|
15587
15584
|
}
|
|
15588
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
15585
|
+
var InsertReadonly$0 = $TV($EXPECT($L1, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
15589
15586
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
15590
15587
|
});
|
|
15591
15588
|
function InsertReadonly(state) {
|
|
@@ -15610,7 +15607,7 @@ ${input.slice(result.pos)}
|
|
|
15610
15607
|
return result;
|
|
15611
15608
|
}
|
|
15612
15609
|
}
|
|
15613
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
15610
|
+
var InsertNewline$0 = $TV($EXPECT($L1, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
15614
15611
|
return "\n";
|
|
15615
15612
|
});
|
|
15616
15613
|
function InsertNewline(state) {
|
|
@@ -15635,7 +15632,7 @@ ${input.slice(result.pos)}
|
|
|
15635
15632
|
return result;
|
|
15636
15633
|
}
|
|
15637
15634
|
}
|
|
15638
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
15635
|
+
var InsertIndent$0 = $TV($EXPECT($L1, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
15639
15636
|
return module.currentIndent.token;
|
|
15640
15637
|
});
|
|
15641
15638
|
function InsertIndent(state) {
|
|
@@ -15660,7 +15657,7 @@ ${input.slice(result.pos)}
|
|
|
15660
15657
|
return result;
|
|
15661
15658
|
}
|
|
15662
15659
|
}
|
|
15663
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
15660
|
+
var InsertSpace$0 = $TV($EXPECT($L1, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
15664
15661
|
return { $loc, token: " " };
|
|
15665
15662
|
});
|
|
15666
15663
|
function InsertSpace(state) {
|
|
@@ -15685,7 +15682,7 @@ ${input.slice(result.pos)}
|
|
|
15685
15682
|
return result;
|
|
15686
15683
|
}
|
|
15687
15684
|
}
|
|
15688
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
15685
|
+
var InsertDot$0 = $TV($EXPECT($L1, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
15689
15686
|
return { $loc, token: "." };
|
|
15690
15687
|
});
|
|
15691
15688
|
function InsertDot(state) {
|
|
@@ -15710,7 +15707,7 @@ ${input.slice(result.pos)}
|
|
|
15710
15707
|
return result;
|
|
15711
15708
|
}
|
|
15712
15709
|
}
|
|
15713
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
15710
|
+
var InsertBreak$0 = $TV($EXPECT($L1, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
15714
15711
|
return { $loc, token: ";break;" };
|
|
15715
15712
|
});
|
|
15716
15713
|
function InsertBreak(state) {
|
|
@@ -15735,7 +15732,7 @@ ${input.slice(result.pos)}
|
|
|
15735
15732
|
return result;
|
|
15736
15733
|
}
|
|
15737
15734
|
}
|
|
15738
|
-
var InsertVar$0 = $TV($EXPECT($
|
|
15735
|
+
var InsertVar$0 = $TV($EXPECT($L1, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
15739
15736
|
return { $loc, token: "var " };
|
|
15740
15737
|
});
|
|
15741
15738
|
function InsertVar(state) {
|
|
@@ -15760,7 +15757,7 @@ ${input.slice(result.pos)}
|
|
|
15760
15757
|
return result;
|
|
15761
15758
|
}
|
|
15762
15759
|
}
|
|
15763
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
15760
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15764
15761
|
if (module.config.coffeeBinaryExistential)
|
|
15765
15762
|
return;
|
|
15766
15763
|
return $skip;
|
|
@@ -15787,7 +15784,7 @@ ${input.slice(result.pos)}
|
|
|
15787
15784
|
return result;
|
|
15788
15785
|
}
|
|
15789
15786
|
}
|
|
15790
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
15787
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15791
15788
|
if (module.config.coffeeBooleans)
|
|
15792
15789
|
return;
|
|
15793
15790
|
return $skip;
|
|
@@ -15814,7 +15811,7 @@ ${input.slice(result.pos)}
|
|
|
15814
15811
|
return result;
|
|
15815
15812
|
}
|
|
15816
15813
|
}
|
|
15817
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
15814
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15818
15815
|
if (module.config.coffeeClasses)
|
|
15819
15816
|
return;
|
|
15820
15817
|
return $skip;
|
|
@@ -15841,7 +15838,7 @@ ${input.slice(result.pos)}
|
|
|
15841
15838
|
return result;
|
|
15842
15839
|
}
|
|
15843
15840
|
}
|
|
15844
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
15841
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15845
15842
|
if (module.config.coffeeComment)
|
|
15846
15843
|
return;
|
|
15847
15844
|
return $skip;
|
|
@@ -15868,7 +15865,7 @@ ${input.slice(result.pos)}
|
|
|
15868
15865
|
return result;
|
|
15869
15866
|
}
|
|
15870
15867
|
}
|
|
15871
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
15868
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15872
15869
|
if (module.config.coffeeDo)
|
|
15873
15870
|
return;
|
|
15874
15871
|
return $skip;
|
|
@@ -15895,7 +15892,7 @@ ${input.slice(result.pos)}
|
|
|
15895
15892
|
return result;
|
|
15896
15893
|
}
|
|
15897
15894
|
}
|
|
15898
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
15895
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15899
15896
|
if (module.config.coffeeForLoops)
|
|
15900
15897
|
return;
|
|
15901
15898
|
return $skip;
|
|
@@ -15922,7 +15919,7 @@ ${input.slice(result.pos)}
|
|
|
15922
15919
|
return result;
|
|
15923
15920
|
}
|
|
15924
15921
|
}
|
|
15925
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
15922
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15926
15923
|
if (module.config.coffeeInterpolation)
|
|
15927
15924
|
return;
|
|
15928
15925
|
return $skip;
|
|
@@ -15949,7 +15946,7 @@ ${input.slice(result.pos)}
|
|
|
15949
15946
|
return result;
|
|
15950
15947
|
}
|
|
15951
15948
|
}
|
|
15952
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
15949
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15953
15950
|
if (module.config.coffeeIsnt)
|
|
15954
15951
|
return;
|
|
15955
15952
|
return $skip;
|
|
@@ -15976,7 +15973,7 @@ ${input.slice(result.pos)}
|
|
|
15976
15973
|
return result;
|
|
15977
15974
|
}
|
|
15978
15975
|
}
|
|
15979
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
15976
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15980
15977
|
if (module.config.coffeeLineContinuation)
|
|
15981
15978
|
return;
|
|
15982
15979
|
return $skip;
|
|
@@ -16003,7 +16000,7 @@ ${input.slice(result.pos)}
|
|
|
16003
16000
|
return result;
|
|
16004
16001
|
}
|
|
16005
16002
|
}
|
|
16006
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
16003
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
16007
16004
|
if (module.config.coffeeNot)
|
|
16008
16005
|
return;
|
|
16009
16006
|
return $skip;
|
|
@@ -16030,7 +16027,7 @@ ${input.slice(result.pos)}
|
|
|
16030
16027
|
return result;
|
|
16031
16028
|
}
|
|
16032
16029
|
}
|
|
16033
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
16030
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
16034
16031
|
if (module.config.coffeeOf)
|
|
16035
16032
|
return;
|
|
16036
16033
|
return $skip;
|
|
@@ -16057,7 +16054,7 @@ ${input.slice(result.pos)}
|
|
|
16057
16054
|
return result;
|
|
16058
16055
|
}
|
|
16059
16056
|
}
|
|
16060
|
-
var CoffeePrototypeEnabled$0 = $TV($EXPECT($
|
|
16057
|
+
var CoffeePrototypeEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
|
|
16061
16058
|
if (module.config.coffeePrototype)
|
|
16062
16059
|
return;
|
|
16063
16060
|
return $skip;
|
|
@@ -16084,7 +16081,7 @@ ${input.slice(result.pos)}
|
|
|
16084
16081
|
return result;
|
|
16085
16082
|
}
|
|
16086
16083
|
}
|
|
16087
|
-
var Reset$0 = $TV($EXPECT($
|
|
16084
|
+
var Reset$0 = $TV($EXPECT($L1, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
16088
16085
|
module.indentLevels = [{
|
|
16089
16086
|
level: 0,
|
|
16090
16087
|
token: ""
|
|
@@ -16150,6 +16147,16 @@ ${input.slice(result.pos)}
|
|
|
16150
16147
|
};
|
|
16151
16148
|
module.prelude.push(["", ["const ", moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b", "\n"]]);
|
|
16152
16149
|
},
|
|
16150
|
+
returnSymbol(ref) {
|
|
16151
|
+
module.prelude.push({
|
|
16152
|
+
children: [
|
|
16153
|
+
"const ",
|
|
16154
|
+
ref,
|
|
16155
|
+
` = Symbol("return")';
|
|
16156
|
+
`
|
|
16157
|
+
]
|
|
16158
|
+
});
|
|
16159
|
+
},
|
|
16153
16160
|
JSX(jsxRef) {
|
|
16154
16161
|
module.prelude.push({
|
|
16155
16162
|
ts: true,
|
|
@@ -16322,7 +16329,7 @@ ${input.slice(result.pos)}
|
|
|
16322
16329
|
return result;
|
|
16323
16330
|
}
|
|
16324
16331
|
}
|
|
16325
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
16332
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
16326
16333
|
var directives = $2;
|
|
16327
16334
|
directives.forEach((directive) => {
|
|
16328
16335
|
if (directive.type === "CivetPrologue") {
|
|
@@ -16446,35 +16453,19 @@ ${input.slice(result.pos)}
|
|
|
16446
16453
|
if (!node)
|
|
16447
16454
|
return;
|
|
16448
16455
|
switch (node.type) {
|
|
16449
|
-
case "AssignmentExpression":
|
|
16450
|
-
node.children.unshift(ref, ".push(");
|
|
16451
|
-
node.children.push(")");
|
|
16452
|
-
return;
|
|
16453
|
-
case "Identifier":
|
|
16454
|
-
node.children.unshift(ref, ".push(");
|
|
16455
|
-
node.children.push(")");
|
|
16456
|
-
return;
|
|
16457
16456
|
case "BlockStatement":
|
|
16458
16457
|
insertPush(node.expressions[node.expressions.length - 1], ref);
|
|
16459
16458
|
return;
|
|
16460
|
-
case "ObjectBindingPattern":
|
|
16461
|
-
case "ObjectExpression":
|
|
16462
|
-
module.insertTrimmingSpace(node.children[0], "");
|
|
16463
|
-
node.children.unshift(ref, ".push(");
|
|
16464
|
-
node.children.push(")");
|
|
16465
|
-
return;
|
|
16466
16459
|
case "CaseBlock":
|
|
16467
16460
|
node.clauses.forEach((clause) => {
|
|
16468
16461
|
insertPush(clause, ref);
|
|
16469
16462
|
});
|
|
16470
16463
|
return;
|
|
16471
|
-
case "CaseClause":
|
|
16472
|
-
return;
|
|
16473
16464
|
case "WhenClause":
|
|
16474
|
-
insertPush(node.
|
|
16465
|
+
insertPush(node.block, ref);
|
|
16475
16466
|
return;
|
|
16476
16467
|
case "DefaultClause":
|
|
16477
|
-
insertPush(node.
|
|
16468
|
+
insertPush(node.block, ref);
|
|
16478
16469
|
return;
|
|
16479
16470
|
}
|
|
16480
16471
|
if (!Array.isArray(node))
|
|
@@ -16520,41 +16511,42 @@ ${input.slice(result.pos)}
|
|
|
16520
16511
|
node.splice(1, 0, ref, ".push(");
|
|
16521
16512
|
node.push(")");
|
|
16522
16513
|
}
|
|
16514
|
+
function wrapWithReturn(expression) {
|
|
16515
|
+
const children = expression ? ["return ", expression] : ["return"];
|
|
16516
|
+
return {
|
|
16517
|
+
type: "ReturnStatement",
|
|
16518
|
+
children
|
|
16519
|
+
};
|
|
16520
|
+
}
|
|
16521
|
+
function insertSwitchReturns(exp) {
|
|
16522
|
+
switch (exp.type) {
|
|
16523
|
+
case "SwitchStatement":
|
|
16524
|
+
exp.caseBlock.clauses.forEach((clause) => {
|
|
16525
|
+
insertReturn(clause);
|
|
16526
|
+
});
|
|
16527
|
+
return;
|
|
16528
|
+
case "SwitchExpression":
|
|
16529
|
+
exp.caseBlock.clauses.forEach(insertReturn);
|
|
16530
|
+
return;
|
|
16531
|
+
}
|
|
16532
|
+
}
|
|
16523
16533
|
function insertReturn(node) {
|
|
16524
16534
|
if (!node)
|
|
16525
16535
|
return;
|
|
16526
16536
|
switch (node.type) {
|
|
16527
|
-
case "AssignmentExpression":
|
|
16528
|
-
node.children.unshift("return ");
|
|
16529
|
-
return;
|
|
16530
|
-
case "Identifier":
|
|
16531
|
-
node.children.unshift("return ");
|
|
16532
|
-
return;
|
|
16533
16537
|
case "BlockStatement":
|
|
16534
16538
|
insertReturn(node.expressions[node.expressions.length - 1]);
|
|
16535
16539
|
return;
|
|
16536
|
-
case "ObjectBindingPattern":
|
|
16537
|
-
case "ObjectExpression":
|
|
16538
|
-
module.insertTrimmingSpace(node.children[0], "");
|
|
16539
|
-
node.children.unshift("return ");
|
|
16540
|
-
return;
|
|
16541
|
-
case "CaseBlock":
|
|
16542
|
-
node.clauses.forEach((clause) => {
|
|
16543
|
-
insertReturn(clause);
|
|
16544
|
-
});
|
|
16545
|
-
return;
|
|
16546
|
-
case "CaseClause":
|
|
16547
|
-
return;
|
|
16548
16540
|
case "WhenClause":
|
|
16549
16541
|
node.children.splice(node.children.indexOf(node.break), 1);
|
|
16550
|
-
if (node.
|
|
16551
|
-
node.
|
|
16542
|
+
if (node.block.length === 0) {
|
|
16543
|
+
node.block.push(wrapWithReturn());
|
|
16552
16544
|
return;
|
|
16553
16545
|
}
|
|
16554
|
-
insertReturn(node.
|
|
16546
|
+
insertReturn(node.block);
|
|
16555
16547
|
return;
|
|
16556
16548
|
case "DefaultClause":
|
|
16557
|
-
insertReturn(node.
|
|
16549
|
+
insertReturn(node.block);
|
|
16558
16550
|
return;
|
|
16559
16551
|
}
|
|
16560
16552
|
if (!Array.isArray(node))
|
|
@@ -16586,10 +16578,10 @@ ${input.slice(result.pos)}
|
|
|
16586
16578
|
if (exp.children[3])
|
|
16587
16579
|
insertReturn(exp.children[3][2]);
|
|
16588
16580
|
else
|
|
16589
|
-
exp.children.push(["\n", indent,
|
|
16581
|
+
exp.children.push(["\n", indent, wrapWithReturn()]);
|
|
16590
16582
|
return;
|
|
16591
16583
|
case "SwitchStatement":
|
|
16592
|
-
|
|
16584
|
+
insertSwitchReturns(exp);
|
|
16593
16585
|
return;
|
|
16594
16586
|
case "TryStatement":
|
|
16595
16587
|
insertReturn(exp.children[1]);
|
|
@@ -16599,7 +16591,8 @@ ${input.slice(result.pos)}
|
|
|
16599
16591
|
}
|
|
16600
16592
|
if (node[node.length - 1]?.type === "SemicolonDelimiter")
|
|
16601
16593
|
return;
|
|
16602
|
-
|
|
16594
|
+
const returnStatement = wrapWithReturn(node[1]);
|
|
16595
|
+
node.splice(1, 1, returnStatement);
|
|
16603
16596
|
}
|
|
16604
16597
|
module.makeLeftHandSideExpression = function(exp) {
|
|
16605
16598
|
switch (exp.type) {
|
|
@@ -16952,9 +16945,7 @@ ${input.slice(result.pos)}
|
|
|
16952
16945
|
}
|
|
16953
16946
|
function processSwitchExpressions(statements) {
|
|
16954
16947
|
if (module.config.implicitReturns) {
|
|
16955
|
-
gatherRecursiveAll(statements, (n) => n.type === "SwitchExpression").forEach(
|
|
16956
|
-
insertReturn(block);
|
|
16957
|
-
});
|
|
16948
|
+
gatherRecursiveAll(statements, (n) => n.type === "SwitchExpression").forEach(insertSwitchReturns);
|
|
16958
16949
|
}
|
|
16959
16950
|
}
|
|
16960
16951
|
function processTryExpressions(statements) {
|
|
@@ -17189,6 +17180,7 @@ ${input.slice(result.pos)}
|
|
|
17189
17180
|
indent = indent[indent.length - 1];
|
|
17190
17181
|
statements.unshift([indent, "var ", varIds.join(", "), "\n"]);
|
|
17191
17182
|
}
|
|
17183
|
+
scopes.pop();
|
|
17192
17184
|
}
|
|
17193
17185
|
function createLetDecs(statements, scopes) {
|
|
17194
17186
|
function hasDec(name) {
|
|
@@ -17471,7 +17463,7 @@ ${input.slice(result.pos)}
|
|
|
17471
17463
|
return result;
|
|
17472
17464
|
}
|
|
17473
17465
|
}
|
|
17474
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
17466
|
+
var PopIndent$0 = $TV($EXPECT($L1, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
17475
17467
|
if (module.config.verbose) {
|
|
17476
17468
|
console.log("popping indent", module.indentLevels[module.indentLevels.length - 1], "->", module.indentLevels[module.indentLevels.length - 2]);
|
|
17477
17469
|
}
|