@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.js
CHANGED
|
@@ -435,6 +435,7 @@ ${input.slice(result.pos)}
|
|
|
435
435
|
Arguments,
|
|
436
436
|
ExplicitArguments,
|
|
437
437
|
ApplicationStart,
|
|
438
|
+
ForbiddenImplicitCalls,
|
|
438
439
|
IndentedApplicationAllowed,
|
|
439
440
|
ArgumentsWithTrailingMemberExpressions,
|
|
440
441
|
ArgumentList,
|
|
@@ -493,7 +494,6 @@ ${input.slice(result.pos)}
|
|
|
493
494
|
CallExpressionRest,
|
|
494
495
|
OptionalShorthand,
|
|
495
496
|
NonNullAssertion,
|
|
496
|
-
AdditionalReservedWords,
|
|
497
497
|
MemberExpression,
|
|
498
498
|
MemberExpressionRest,
|
|
499
499
|
MemberBracketContent,
|
|
@@ -727,6 +727,7 @@ ${input.slice(result.pos)}
|
|
|
727
727
|
TrailingComment,
|
|
728
728
|
_,
|
|
729
729
|
NonNewlineWhitespace,
|
|
730
|
+
Trimmed_,
|
|
730
731
|
__,
|
|
731
732
|
Whitespace,
|
|
732
733
|
ExpressionDelimiter,
|
|
@@ -850,6 +851,8 @@ ${input.slice(result.pos)}
|
|
|
850
851
|
TypeDeclaration,
|
|
851
852
|
TypeDeclarationModifier,
|
|
852
853
|
TypeDeclarationRest,
|
|
854
|
+
InterfaceExtendsClause,
|
|
855
|
+
InterfaceExtendsTarget,
|
|
853
856
|
TypeKeyword,
|
|
854
857
|
Interface,
|
|
855
858
|
Namespace,
|
|
@@ -873,6 +876,7 @@ ${input.slice(result.pos)}
|
|
|
873
876
|
TypeUnaryOp,
|
|
874
877
|
TypeIndexedAccess,
|
|
875
878
|
TypePrimary,
|
|
879
|
+
ImportType,
|
|
876
880
|
TypeTuple,
|
|
877
881
|
TypeList,
|
|
878
882
|
NestedTypeList,
|
|
@@ -882,10 +886,6 @@ ${input.slice(result.pos)}
|
|
|
882
886
|
TypeBinaryOp,
|
|
883
887
|
FunctionType,
|
|
884
888
|
TypeArguments,
|
|
885
|
-
InlineTypeArguments,
|
|
886
|
-
InlineTypeArgument,
|
|
887
|
-
InlineTypeArgumentDelimiter,
|
|
888
|
-
CompactTypeArguments,
|
|
889
889
|
TypeArgument,
|
|
890
890
|
TypeArgumentDelimiter,
|
|
891
891
|
TypeParameters,
|
|
@@ -939,174 +939,176 @@ ${input.slice(result.pos)}
|
|
|
939
939
|
PopIndent,
|
|
940
940
|
Nested
|
|
941
941
|
});
|
|
942
|
-
var $L0 = $L("");
|
|
943
|
-
var $L1 = $L("
|
|
944
|
-
var $L2 = $L("
|
|
945
|
-
var $L3 = $L("
|
|
946
|
-
var $L4 = $L("
|
|
947
|
-
var $L5 = $L("
|
|
948
|
-
var $L6 = $L("
|
|
949
|
-
var $L7 = $L("
|
|
950
|
-
var $L8 = $L("
|
|
951
|
-
var $L9 = $L("
|
|
952
|
-
var $L10 = $L("
|
|
953
|
-
var $L11 = $L("
|
|
954
|
-
var $L12 = $L("
|
|
955
|
-
var $L13 = $L("
|
|
956
|
-
var $L14 = $L("
|
|
957
|
-
var $L15 = $L("
|
|
958
|
-
var $L16 = $L("
|
|
959
|
-
var $L17 = $L("
|
|
960
|
-
var $L18 = $L("
|
|
961
|
-
var $L19 = $L("
|
|
962
|
-
var $L20 = $L("
|
|
963
|
-
var $L21 = $L("
|
|
964
|
-
var $L22 = $L("
|
|
965
|
-
var $L23 = $L("
|
|
966
|
-
var $L24 = $L("
|
|
967
|
-
var $L25 = $L("
|
|
968
|
-
var $L26 = $L("
|
|
969
|
-
var $L27 = $L("
|
|
970
|
-
var $L28 = $L("
|
|
971
|
-
var $L29 = $L("
|
|
972
|
-
var $L30 = $L("
|
|
973
|
-
var $L31 = $L("
|
|
974
|
-
var $L32 = $L("
|
|
975
|
-
var $L33 = $L("
|
|
976
|
-
var $L34 = $L("
|
|
977
|
-
var $L35 = $L("
|
|
978
|
-
var $L36 = $L("
|
|
979
|
-
var $L37 = $L("
|
|
980
|
-
var $L38 = $L("
|
|
981
|
-
var $L39 = $L("
|
|
982
|
-
var $L40 = $L("
|
|
983
|
-
var $L41 = $L("
|
|
984
|
-
var $L42 = $L("
|
|
985
|
-
var $L43 = $L("
|
|
986
|
-
var $L44 = $L("
|
|
987
|
-
var $L45 = $L("
|
|
988
|
-
var $L46 = $L("
|
|
989
|
-
var $L47 = $L("
|
|
990
|
-
var $L48 = $L("
|
|
991
|
-
var $L49 = $L("
|
|
992
|
-
var $L50 = $L("
|
|
993
|
-
var $L51 = $L("
|
|
994
|
-
var $L52 = $L("
|
|
995
|
-
var $L53 = $L("
|
|
996
|
-
var $L54 = $L("
|
|
997
|
-
var $L55 = $L("
|
|
998
|
-
var $L56 = $L("
|
|
999
|
-
var $L57 = $L("
|
|
1000
|
-
var $L58 = $L("
|
|
1001
|
-
var $L59 = $L("
|
|
1002
|
-
var $L60 = $L("
|
|
1003
|
-
var $L61 = $L("
|
|
1004
|
-
var $L62 = $L("
|
|
1005
|
-
var $L63 = $L("
|
|
1006
|
-
var $L64 = $L("
|
|
1007
|
-
var $L65 = $L("
|
|
1008
|
-
var $L66 = $L("
|
|
1009
|
-
var $L67 = $L("
|
|
1010
|
-
var $L68 = $L("
|
|
1011
|
-
var $L69 = $L("
|
|
1012
|
-
var $L70 = $L("
|
|
1013
|
-
var $L71 = $L("
|
|
1014
|
-
var $L72 = $L("
|
|
1015
|
-
var $L73 = $L("
|
|
1016
|
-
var $L74 = $L("
|
|
1017
|
-
var $L75 = $L("
|
|
1018
|
-
var $L76 = $L("
|
|
1019
|
-
var $L77 = $L("
|
|
1020
|
-
var $L78 = $L("
|
|
1021
|
-
var $L79 = $L("
|
|
1022
|
-
var $L80 = $L("
|
|
1023
|
-
var $L81 = $L("
|
|
1024
|
-
var $L82 = $L("
|
|
1025
|
-
var $L83 = $L("
|
|
1026
|
-
var $L84 = $L("
|
|
1027
|
-
var $L85 = $L("
|
|
1028
|
-
var $L86 = $L("
|
|
1029
|
-
var $L87 = $L("
|
|
1030
|
-
var $L88 = $L("
|
|
1031
|
-
var $L89 = $L("
|
|
1032
|
-
var $L90 = $L("
|
|
1033
|
-
var $L91 = $L("
|
|
1034
|
-
var $L92 = $L("
|
|
1035
|
-
var $L93 = $L("
|
|
1036
|
-
var $L94 = $L("
|
|
1037
|
-
var $L95 = $L("
|
|
1038
|
-
var $L96 = $L("
|
|
1039
|
-
var $L97 = $L("
|
|
1040
|
-
var $L98 = $L("
|
|
1041
|
-
var $L99 = $L("
|
|
1042
|
-
var $L100 = $L("
|
|
1043
|
-
var $L101 = $L("
|
|
1044
|
-
var $L102 = $L("
|
|
1045
|
-
var $L103 = $L("
|
|
1046
|
-
var $L104 = $L("
|
|
1047
|
-
var $L105 = $L("
|
|
1048
|
-
var $L106 = $L(
|
|
1049
|
-
var $L107 = $L("
|
|
1050
|
-
var $L108 = $L("
|
|
1051
|
-
var $L109 = $L("
|
|
1052
|
-
var $L110 = $L("
|
|
1053
|
-
var $L111 = $L("
|
|
1054
|
-
var $L112 = $L("
|
|
1055
|
-
var $L113 = $L("
|
|
1056
|
-
var $L114 = $L("
|
|
1057
|
-
var $L115 = $L("
|
|
1058
|
-
var $L116 = $L("
|
|
1059
|
-
var $L117 = $L("
|
|
1060
|
-
var $L118 = $L("
|
|
1061
|
-
var $L119 = $L("
|
|
1062
|
-
var $L120 = $L("
|
|
1063
|
-
var $L121 = $L("
|
|
1064
|
-
var $L122 = $L("
|
|
1065
|
-
var $L123 = $L("
|
|
1066
|
-
var $L124 = $L("
|
|
1067
|
-
var $L125 = $L("
|
|
1068
|
-
var $L126 = $L("
|
|
1069
|
-
var $L127 = $L("
|
|
1070
|
-
var $L128 = $L("
|
|
1071
|
-
var $L129 = $L("
|
|
1072
|
-
var $L130 = $L("
|
|
1073
|
-
var $L131 = $L("
|
|
1074
|
-
var $L132 = $L("
|
|
1075
|
-
var $L133 = $L("
|
|
1076
|
-
var $L134 = $L("
|
|
1077
|
-
var $L135 = $L("
|
|
1078
|
-
var $L136 = $L("
|
|
1079
|
-
var $L137 = $L("
|
|
1080
|
-
var $L138 = $L("
|
|
1081
|
-
var $L139 = $L(
|
|
1082
|
-
var $L140 = $L("
|
|
1083
|
-
var $L141 = $L("
|
|
1084
|
-
var $L142 = $L("
|
|
1085
|
-
var $L143 = $L("
|
|
1086
|
-
var $L144 = $L("
|
|
1087
|
-
var $L145 = $L("
|
|
1088
|
-
var $L146 = $L("
|
|
1089
|
-
var $L147 = $L("
|
|
1090
|
-
var $L148 = $L("
|
|
1091
|
-
var $L149 = $L("
|
|
1092
|
-
var $L150 = $L("
|
|
1093
|
-
var $L151 = $L("
|
|
1094
|
-
var $L152 = $L("
|
|
1095
|
-
var $L153 = $L("
|
|
1096
|
-
var $L154 = $L("
|
|
1097
|
-
var $L155 = $L("
|
|
1098
|
-
var $L156 = $L("
|
|
1099
|
-
var $L157 = $L("
|
|
1100
|
-
var $L158 = $L("
|
|
1101
|
-
var $L159 = $L("
|
|
1102
|
-
var $L160 = $L("
|
|
1103
|
-
var $L161 = $L("
|
|
1104
|
-
var $L162 = $L("
|
|
1105
|
-
var $L163 = $L("
|
|
1106
|
-
var $L164 = $L("
|
|
1107
|
-
var $L165 = $L("
|
|
1108
|
-
var $L166 = $L("
|
|
1109
|
-
var $
|
|
942
|
+
var $L0 = $L("/ ");
|
|
943
|
+
var $L1 = $L("");
|
|
944
|
+
var $L2 = $L(".");
|
|
945
|
+
var $L3 = $L("++");
|
|
946
|
+
var $L4 = $L("--");
|
|
947
|
+
var $L5 = $L("=>");
|
|
948
|
+
var $L6 = $L(" ");
|
|
949
|
+
var $L7 = $L("implements");
|
|
950
|
+
var $L8 = $L("#");
|
|
951
|
+
var $L9 = $L("super");
|
|
952
|
+
var $L10 = $L("import");
|
|
953
|
+
var $L11 = $L("!");
|
|
954
|
+
var $L12 = $L("super[");
|
|
955
|
+
var $L13 = $L("import.meta");
|
|
956
|
+
var $L14 = $L(")");
|
|
957
|
+
var $L15 = $L("->");
|
|
958
|
+
var $L16 = $L("}");
|
|
959
|
+
var $L17 = $L("null");
|
|
960
|
+
var $L18 = $L("true");
|
|
961
|
+
var $L19 = $L("false");
|
|
962
|
+
var $L20 = $L("yes");
|
|
963
|
+
var $L21 = $L("on");
|
|
964
|
+
var $L22 = $L("no");
|
|
965
|
+
var $L23 = $L("off");
|
|
966
|
+
var $L24 = $L(",");
|
|
967
|
+
var $L25 = $L("=");
|
|
968
|
+
var $L26 = $L(">");
|
|
969
|
+
var $L27 = $L("]");
|
|
970
|
+
var $L28 = $L(":");
|
|
971
|
+
var $L29 = $L("**=");
|
|
972
|
+
var $L30 = $L("*=");
|
|
973
|
+
var $L31 = $L("/=");
|
|
974
|
+
var $L32 = $L("%=");
|
|
975
|
+
var $L33 = $L("+=");
|
|
976
|
+
var $L34 = $L("-=");
|
|
977
|
+
var $L35 = $L("<<=");
|
|
978
|
+
var $L36 = $L(">>>=");
|
|
979
|
+
var $L37 = $L(">>=");
|
|
980
|
+
var $L38 = $L("&&=");
|
|
981
|
+
var $L39 = $L("&=");
|
|
982
|
+
var $L40 = $L("^=");
|
|
983
|
+
var $L41 = $L("||=");
|
|
984
|
+
var $L42 = $L("|=");
|
|
985
|
+
var $L43 = $L("??=");
|
|
986
|
+
var $L44 = $L("?=");
|
|
987
|
+
var $L45 = $L("and=");
|
|
988
|
+
var $L46 = $L("or=");
|
|
989
|
+
var $L47 = $L("**");
|
|
990
|
+
var $L48 = $L("*");
|
|
991
|
+
var $L49 = $L("/");
|
|
992
|
+
var $L50 = $L("%%");
|
|
993
|
+
var $L51 = $L("%");
|
|
994
|
+
var $L52 = $L("+");
|
|
995
|
+
var $L53 = $L("-");
|
|
996
|
+
var $L54 = $L("<=");
|
|
997
|
+
var $L55 = $L(">=");
|
|
998
|
+
var $L56 = $L("<?");
|
|
999
|
+
var $L57 = $L("<<");
|
|
1000
|
+
var $L58 = $L(">>>");
|
|
1001
|
+
var $L59 = $L(">>");
|
|
1002
|
+
var $L60 = $L("!==");
|
|
1003
|
+
var $L61 = $L("!=");
|
|
1004
|
+
var $L62 = $L("isnt");
|
|
1005
|
+
var $L63 = $L("===");
|
|
1006
|
+
var $L64 = $L("==");
|
|
1007
|
+
var $L65 = $L("and");
|
|
1008
|
+
var $L66 = $L("&&");
|
|
1009
|
+
var $L67 = $L("of");
|
|
1010
|
+
var $L68 = $L("or");
|
|
1011
|
+
var $L69 = $L("||");
|
|
1012
|
+
var $L70 = $L("??");
|
|
1013
|
+
var $L71 = $L("?");
|
|
1014
|
+
var $L72 = $L("instanceof");
|
|
1015
|
+
var $L73 = $L("not");
|
|
1016
|
+
var $L74 = $L("in");
|
|
1017
|
+
var $L75 = $L("is");
|
|
1018
|
+
var $L76 = $L("&");
|
|
1019
|
+
var $L77 = $L("^");
|
|
1020
|
+
var $L78 = $L("|");
|
|
1021
|
+
var $L79 = $L(";");
|
|
1022
|
+
var $L80 = $L("own");
|
|
1023
|
+
var $L81 = $L("finally");
|
|
1024
|
+
var $L82 = $L("break");
|
|
1025
|
+
var $L83 = $L("continue");
|
|
1026
|
+
var $L84 = $L("debugger");
|
|
1027
|
+
var $L85 = $L("default");
|
|
1028
|
+
var $L86 = $L(":=");
|
|
1029
|
+
var $L87 = $L(".=");
|
|
1030
|
+
var $L88 = $L("/*");
|
|
1031
|
+
var $L89 = $L("*/");
|
|
1032
|
+
var $L90 = $L("\\");
|
|
1033
|
+
var $L91 = $L("abstract");
|
|
1034
|
+
var $L92 = $L("as");
|
|
1035
|
+
var $L93 = $L("@");
|
|
1036
|
+
var $L94 = $L("@@");
|
|
1037
|
+
var $L95 = $L("async");
|
|
1038
|
+
var $L96 = $L("await");
|
|
1039
|
+
var $L97 = $L("`");
|
|
1040
|
+
var $L98 = $L("by");
|
|
1041
|
+
var $L99 = $L("case");
|
|
1042
|
+
var $L100 = $L("catch");
|
|
1043
|
+
var $L101 = $L("class");
|
|
1044
|
+
var $L102 = $L("#{");
|
|
1045
|
+
var $L103 = $L("delete");
|
|
1046
|
+
var $L104 = $L("do");
|
|
1047
|
+
var $L105 = $L("..");
|
|
1048
|
+
var $L106 = $L("...");
|
|
1049
|
+
var $L107 = $L("::");
|
|
1050
|
+
var $L108 = $L('"');
|
|
1051
|
+
var $L109 = $L("else");
|
|
1052
|
+
var $L110 = $L("export");
|
|
1053
|
+
var $L111 = $L("extends");
|
|
1054
|
+
var $L112 = $L("for");
|
|
1055
|
+
var $L113 = $L("from");
|
|
1056
|
+
var $L114 = $L("function");
|
|
1057
|
+
var $L115 = $L("get");
|
|
1058
|
+
var $L116 = $L("set");
|
|
1059
|
+
var $L117 = $L("if");
|
|
1060
|
+
var $L118 = $L("let");
|
|
1061
|
+
var $L119 = $L("const");
|
|
1062
|
+
var $L120 = $L("loop");
|
|
1063
|
+
var $L121 = $L("new");
|
|
1064
|
+
var $L122 = $L("<");
|
|
1065
|
+
var $L123 = $L("{");
|
|
1066
|
+
var $L124 = $L("[");
|
|
1067
|
+
var $L125 = $L("(");
|
|
1068
|
+
var $L126 = $L("public");
|
|
1069
|
+
var $L127 = $L("private");
|
|
1070
|
+
var $L128 = $L("protected");
|
|
1071
|
+
var $L129 = $L("|>");
|
|
1072
|
+
var $L130 = $L("readonly");
|
|
1073
|
+
var $L131 = $L("return");
|
|
1074
|
+
var $L132 = $L("satisfies");
|
|
1075
|
+
var $L133 = $L("'");
|
|
1076
|
+
var $L134 = $L("static");
|
|
1077
|
+
var $L135 = $L("${");
|
|
1078
|
+
var $L136 = $L("switch");
|
|
1079
|
+
var $L137 = $L("target");
|
|
1080
|
+
var $L138 = $L("then");
|
|
1081
|
+
var $L139 = $L("this");
|
|
1082
|
+
var $L140 = $L("throw");
|
|
1083
|
+
var $L141 = $L('"""');
|
|
1084
|
+
var $L142 = $L("'''");
|
|
1085
|
+
var $L143 = $L("///");
|
|
1086
|
+
var $L144 = $L("```");
|
|
1087
|
+
var $L145 = $L("try");
|
|
1088
|
+
var $L146 = $L("typeof");
|
|
1089
|
+
var $L147 = $L("unless");
|
|
1090
|
+
var $L148 = $L("until");
|
|
1091
|
+
var $L149 = $L("var");
|
|
1092
|
+
var $L150 = $L("void");
|
|
1093
|
+
var $L151 = $L("when");
|
|
1094
|
+
var $L152 = $L("while");
|
|
1095
|
+
var $L153 = $L("yield");
|
|
1096
|
+
var $L154 = $L("/>");
|
|
1097
|
+
var $L155 = $L("</");
|
|
1098
|
+
var $L156 = $L("<>");
|
|
1099
|
+
var $L157 = $L("</>");
|
|
1100
|
+
var $L158 = $L("<!--");
|
|
1101
|
+
var $L159 = $L("-->");
|
|
1102
|
+
var $L160 = $L("declare");
|
|
1103
|
+
var $L161 = $L("type");
|
|
1104
|
+
var $L162 = $L("interface");
|
|
1105
|
+
var $L163 = $L("namespace");
|
|
1106
|
+
var $L164 = $L("asserts");
|
|
1107
|
+
var $L165 = $L("keyof");
|
|
1108
|
+
var $L166 = $L("infer");
|
|
1109
|
+
var $L167 = $L("[]");
|
|
1110
|
+
var $L168 = $L("civet");
|
|
1111
|
+
var $R0 = $R(new RegExp("(as|for|of|satisfies|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1110
1112
|
var $R1 = $R(new RegExp("[&]", "suy"));
|
|
1111
1113
|
var $R2 = $R(new RegExp("[!~+-]+", "suy"));
|
|
1112
1114
|
var $R3 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
@@ -1143,7 +1145,7 @@ ${input.slice(result.pos)}
|
|
|
1143
1145
|
var $R34 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
1144
1146
|
var $R35 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
1145
1147
|
var $R36 = $R(new RegExp("(?:not)(?!\\p{ID_Continue})", "suy"));
|
|
1146
|
-
var $R37 = $R(new RegExp("(?:and|
|
|
1148
|
+
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"));
|
|
1147
1149
|
var $R38 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
1148
1150
|
var $R39 = $R(new RegExp(".", "suy"));
|
|
1149
1151
|
var $R40 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
@@ -1353,7 +1355,7 @@ ${input.slice(result.pos)}
|
|
|
1353
1355
|
}
|
|
1354
1356
|
}
|
|
1355
1357
|
var Arguments$0 = ExplicitArguments;
|
|
1356
|
-
var Arguments$1 = $TS($S($E($S(
|
|
1358
|
+
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) {
|
|
1357
1359
|
var ta = $1;
|
|
1358
1360
|
var open = $3;
|
|
1359
1361
|
var ws = $4;
|
|
@@ -1407,7 +1409,7 @@ ${input.slice(result.pos)}
|
|
|
1407
1409
|
}
|
|
1408
1410
|
}
|
|
1409
1411
|
var ApplicationStart$0 = $S(IndentedApplicationAllowed, $Y(NestedImplicitObjectLiteral));
|
|
1410
|
-
var ApplicationStart$1 = $S($N(EOS), $Y($S($P(_), $N(
|
|
1412
|
+
var ApplicationStart$1 = $S($N(EOS), $Y($S($P(_), $N(ForbiddenImplicitCalls))));
|
|
1411
1413
|
function ApplicationStart(state) {
|
|
1412
1414
|
let eventData;
|
|
1413
1415
|
if (state.events) {
|
|
@@ -1430,7 +1432,32 @@ ${input.slice(result.pos)}
|
|
|
1430
1432
|
return result;
|
|
1431
1433
|
}
|
|
1432
1434
|
}
|
|
1433
|
-
var
|
|
1435
|
+
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|for|of|satisfies|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
1436
|
+
var ForbiddenImplicitCalls$1 = $EXPECT($L0, fail, 'ForbiddenImplicitCalls "/ "');
|
|
1437
|
+
var ForbiddenImplicitCalls$2 = AtAt;
|
|
1438
|
+
function ForbiddenImplicitCalls(state) {
|
|
1439
|
+
let eventData;
|
|
1440
|
+
if (state.events) {
|
|
1441
|
+
const result = state.events.enter?.("ForbiddenImplicitCalls", state);
|
|
1442
|
+
if (result) {
|
|
1443
|
+
if (result.cache)
|
|
1444
|
+
return result.cache;
|
|
1445
|
+
eventData = result.data;
|
|
1446
|
+
}
|
|
1447
|
+
}
|
|
1448
|
+
if (state.tokenize) {
|
|
1449
|
+
const result = $TOKEN("ForbiddenImplicitCalls", state, ForbiddenImplicitCalls$0(state) || ForbiddenImplicitCalls$1(state) || ForbiddenImplicitCalls$2(state));
|
|
1450
|
+
if (state.events)
|
|
1451
|
+
state.events.exit?.("ForbiddenImplicitCalls", state, result, eventData);
|
|
1452
|
+
return result;
|
|
1453
|
+
} else {
|
|
1454
|
+
const result = ForbiddenImplicitCalls$0(state) || ForbiddenImplicitCalls$1(state) || ForbiddenImplicitCalls$2(state);
|
|
1455
|
+
if (state.events)
|
|
1456
|
+
state.events.exit?.("ForbiddenImplicitCalls", state, result, eventData);
|
|
1457
|
+
return result;
|
|
1458
|
+
}
|
|
1459
|
+
}
|
|
1460
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L1, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
1434
1461
|
if (module2.suppressIndentedApplication)
|
|
1435
1462
|
return $skip;
|
|
1436
1463
|
return;
|
|
@@ -1457,7 +1484,7 @@ ${input.slice(result.pos)}
|
|
|
1457
1484
|
return result;
|
|
1458
1485
|
}
|
|
1459
1486
|
}
|
|
1460
|
-
var ArgumentsWithTrailingMemberExpressions$0 = $S(Arguments, $Q($S(Samedent, $Y($EXPECT($
|
|
1487
|
+
var ArgumentsWithTrailingMemberExpressions$0 = $S(Arguments, $Q($S(Samedent, $Y($EXPECT($L2, fail, 'ArgumentsWithTrailingMemberExpressions "."')), MemberExpressionRest)));
|
|
1461
1488
|
function ArgumentsWithTrailingMemberExpressions(state) {
|
|
1462
1489
|
let eventData;
|
|
1463
1490
|
if (state.events) {
|
|
@@ -1800,7 +1827,7 @@ ${input.slice(result.pos)}
|
|
|
1800
1827
|
return result;
|
|
1801
1828
|
}
|
|
1802
1829
|
}
|
|
1803
|
-
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($
|
|
1830
|
+
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L3, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L4, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
|
|
1804
1831
|
return { $loc, token: $1 };
|
|
1805
1832
|
});
|
|
1806
1833
|
function UpdateExpressionSymbol(state) {
|
|
@@ -2092,7 +2119,7 @@ ${input.slice(result.pos)}
|
|
|
2092
2119
|
return result;
|
|
2093
2120
|
}
|
|
2094
2121
|
}
|
|
2095
|
-
var FatArrow$0 = $TS($S(__, $EXPECT($
|
|
2122
|
+
var FatArrow$0 = $TS($S(__, $EXPECT($L5, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
|
|
2096
2123
|
var ws = $1;
|
|
2097
2124
|
if (!ws.length)
|
|
2098
2125
|
return " =>";
|
|
@@ -2175,7 +2202,7 @@ ${input.slice(result.pos)}
|
|
|
2175
2202
|
}
|
|
2176
2203
|
}
|
|
2177
2204
|
var TernaryRest$0 = NestedTernaryRest;
|
|
2178
|
-
var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($
|
|
2205
|
+
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) {
|
|
2179
2206
|
return $0.slice(2);
|
|
2180
2207
|
});
|
|
2181
2208
|
function TernaryRest(state) {
|
|
@@ -2535,7 +2562,7 @@ ${input.slice(result.pos)}
|
|
|
2535
2562
|
return result;
|
|
2536
2563
|
}
|
|
2537
2564
|
}
|
|
2538
|
-
var ExtendsToken$0 = $TS($S(Loc, __, OpenAngleBracket, $E($EXPECT($
|
|
2565
|
+
var ExtendsToken$0 = $TS($S(Loc, __, OpenAngleBracket, $E($EXPECT($L6, fail, 'ExtendsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2539
2566
|
var l = $1;
|
|
2540
2567
|
var ws = $2;
|
|
2541
2568
|
var lt = $3;
|
|
@@ -2631,7 +2658,7 @@ ${input.slice(result.pos)}
|
|
|
2631
2658
|
return result;
|
|
2632
2659
|
}
|
|
2633
2660
|
}
|
|
2634
|
-
var ImplementsToken$0 = $TS($S($EXPECT($
|
|
2661
|
+
var ImplementsToken$0 = $TS($S($EXPECT($L7, fail, 'ImplementsToken "implements"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2635
2662
|
return { $loc, token: $1 };
|
|
2636
2663
|
});
|
|
2637
2664
|
function ImplementsToken(state) {
|
|
@@ -2880,7 +2907,7 @@ ${input.slice(result.pos)}
|
|
|
2880
2907
|
}
|
|
2881
2908
|
}
|
|
2882
2909
|
var ThisLiteral$0 = This;
|
|
2883
|
-
var ThisLiteral$1 = $TS($S(At, $TEXT($S($E($EXPECT($
|
|
2910
|
+
var ThisLiteral$1 = $TS($S(At, $TEXT($S($E($EXPECT($L8, fail, 'ThisLiteral "#"')), IdentifierName))), function($skip, $loc, $0, $1, $2) {
|
|
2884
2911
|
var t = $1;
|
|
2885
2912
|
var id = $2;
|
|
2886
2913
|
return [{ ...t, token: "this." }, id];
|
|
@@ -2911,7 +2938,7 @@ ${input.slice(result.pos)}
|
|
|
2911
2938
|
return result;
|
|
2912
2939
|
}
|
|
2913
2940
|
}
|
|
2914
|
-
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($
|
|
2941
|
+
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($L2, fail, 'LeftHandSideExpression "."')), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
2915
2942
|
if ($1.length)
|
|
2916
2943
|
return $0;
|
|
2917
2944
|
return $2;
|
|
@@ -2938,8 +2965,8 @@ ${input.slice(result.pos)}
|
|
|
2938
2965
|
return result;
|
|
2939
2966
|
}
|
|
2940
2967
|
}
|
|
2941
|
-
var CallExpression$0 = $S($EXPECT($
|
|
2942
|
-
var CallExpression$1 = $TS($S($EXPECT($
|
|
2968
|
+
var CallExpression$0 = $S($EXPECT($L9, fail, 'CallExpression "super"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest));
|
|
2969
|
+
var CallExpression$1 = $TS($S($EXPECT($L10, fail, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
2943
2970
|
return {
|
|
2944
2971
|
type: "CallExpression",
|
|
2945
2972
|
children: $0
|
|
@@ -3024,7 +3051,7 @@ ${input.slice(result.pos)}
|
|
|
3024
3051
|
return result;
|
|
3025
3052
|
}
|
|
3026
3053
|
}
|
|
3027
|
-
var NonNullAssertion$0 = $T($EXPECT($
|
|
3054
|
+
var NonNullAssertion$0 = $T($EXPECT($L11, fail, 'NonNullAssertion "!"'), function(value) {
|
|
3028
3055
|
return { "ts": true, "children": value };
|
|
3029
3056
|
});
|
|
3030
3057
|
function NonNullAssertion(state) {
|
|
@@ -3049,30 +3076,6 @@ ${input.slice(result.pos)}
|
|
|
3049
3076
|
return result;
|
|
3050
3077
|
}
|
|
3051
3078
|
}
|
|
3052
|
-
var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(for|of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
3053
|
-
var AdditionalReservedWords$1 = AtAt;
|
|
3054
|
-
function AdditionalReservedWords(state) {
|
|
3055
|
-
let eventData;
|
|
3056
|
-
if (state.events) {
|
|
3057
|
-
const result = state.events.enter?.("AdditionalReservedWords", state);
|
|
3058
|
-
if (result) {
|
|
3059
|
-
if (result.cache)
|
|
3060
|
-
return result.cache;
|
|
3061
|
-
eventData = result.data;
|
|
3062
|
-
}
|
|
3063
|
-
}
|
|
3064
|
-
if (state.tokenize) {
|
|
3065
|
-
const result = $TOKEN("AdditionalReservedWords", state, AdditionalReservedWords$0(state) || AdditionalReservedWords$1(state));
|
|
3066
|
-
if (state.events)
|
|
3067
|
-
state.events.exit?.("AdditionalReservedWords", state, result, eventData);
|
|
3068
|
-
return result;
|
|
3069
|
-
} else {
|
|
3070
|
-
const result = AdditionalReservedWords$0(state) || AdditionalReservedWords$1(state);
|
|
3071
|
-
if (state.events)
|
|
3072
|
-
state.events.exit?.("AdditionalReservedWords", state, result, eventData);
|
|
3073
|
-
return result;
|
|
3074
|
-
}
|
|
3075
|
-
}
|
|
3076
3079
|
var MemberExpression$0 = $TS($S(PrimaryExpression, $Q(MemberExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
3077
3080
|
var rest = $2;
|
|
3078
3081
|
if (rest.length) {
|
|
@@ -3298,8 +3301,8 @@ ${input.slice(result.pos)}
|
|
|
3298
3301
|
return result;
|
|
3299
3302
|
}
|
|
3300
3303
|
}
|
|
3301
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
3302
|
-
var SuperProperty$1 = $S($EXPECT($
|
|
3304
|
+
var SuperProperty$0 = $S($EXPECT($L12, fail, 'SuperProperty "super["'), ExtendedExpression, __, CloseBracket);
|
|
3305
|
+
var SuperProperty$1 = $S($EXPECT($L9, fail, 'SuperProperty "super"'), $N($C(QuestionMark, NonNullAssertion)), PropertyAccess);
|
|
3303
3306
|
function SuperProperty(state) {
|
|
3304
3307
|
let eventData;
|
|
3305
3308
|
if (state.events) {
|
|
@@ -3323,7 +3326,7 @@ ${input.slice(result.pos)}
|
|
|
3323
3326
|
}
|
|
3324
3327
|
}
|
|
3325
3328
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
3326
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
3329
|
+
var MetaProperty$1 = $TS($S($EXPECT($L13, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3327
3330
|
return { $loc, token: $1 };
|
|
3328
3331
|
});
|
|
3329
3332
|
function MetaProperty(state) {
|
|
@@ -3349,7 +3352,7 @@ ${input.slice(result.pos)}
|
|
|
3349
3352
|
}
|
|
3350
3353
|
}
|
|
3351
3354
|
var Parameters$0 = NonEmptyParameters;
|
|
3352
|
-
var Parameters$1 = $TV($EXPECT($
|
|
3355
|
+
var Parameters$1 = $TV($EXPECT($L1, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
3353
3356
|
return {
|
|
3354
3357
|
type: "Parameters",
|
|
3355
3358
|
children: [{ $loc, token: "()" }],
|
|
@@ -3508,7 +3511,7 @@ ${input.slice(result.pos)}
|
|
|
3508
3511
|
}
|
|
3509
3512
|
}
|
|
3510
3513
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
3511
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
3514
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L14, fail, 'ParameterElementDelimiter ")"')));
|
|
3512
3515
|
var ParameterElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
3513
3516
|
return value[1];
|
|
3514
3517
|
});
|
|
@@ -4181,7 +4184,7 @@ ${input.slice(result.pos)}
|
|
|
4181
4184
|
return result;
|
|
4182
4185
|
}
|
|
4183
4186
|
}
|
|
4184
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
4187
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L1, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
4185
4188
|
const ref = {
|
|
4186
4189
|
type: "Ref",
|
|
4187
4190
|
base: "ref",
|
|
@@ -4457,7 +4460,7 @@ ${input.slice(result.pos)}
|
|
|
4457
4460
|
return result;
|
|
4458
4461
|
}
|
|
4459
4462
|
}
|
|
4460
|
-
var Arrow$0 = $TV($EXPECT($
|
|
4463
|
+
var Arrow$0 = $TV($EXPECT($L15, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
4461
4464
|
return { $loc, token: $1 };
|
|
4462
4465
|
});
|
|
4463
4466
|
function Arrow(state) {
|
|
@@ -4576,16 +4579,8 @@ ${input.slice(result.pos)}
|
|
|
4576
4579
|
return result;
|
|
4577
4580
|
}
|
|
4578
4581
|
}
|
|
4579
|
-
var ThenClause$0 = $
|
|
4580
|
-
|
|
4581
|
-
var s = $3;
|
|
4582
|
-
const expressions = [[ws, s]];
|
|
4583
|
-
return {
|
|
4584
|
-
type: "BlockStatement",
|
|
4585
|
-
expressions,
|
|
4586
|
-
children: [expressions],
|
|
4587
|
-
bare: true
|
|
4588
|
-
};
|
|
4582
|
+
var ThenClause$0 = $T($S(Then, SingleLineStatements), function(value) {
|
|
4583
|
+
return value[1];
|
|
4589
4584
|
});
|
|
4590
4585
|
function ThenClause(state) {
|
|
4591
4586
|
let eventData;
|
|
@@ -4690,8 +4685,8 @@ ${input.slice(result.pos)}
|
|
|
4690
4685
|
var c = $5;
|
|
4691
4686
|
return {
|
|
4692
4687
|
type: "BlockStatement",
|
|
4693
|
-
expressions: s,
|
|
4694
|
-
children: [o, s, ws, c]
|
|
4688
|
+
expressions: s.expressions,
|
|
4689
|
+
children: [o, s.children, ws, c]
|
|
4695
4690
|
};
|
|
4696
4691
|
});
|
|
4697
4692
|
function BracedBlock(state) {
|
|
@@ -4716,13 +4711,18 @@ ${input.slice(result.pos)}
|
|
|
4716
4711
|
return result;
|
|
4717
4712
|
}
|
|
4718
4713
|
}
|
|
4719
|
-
var SingleLineStatements$0 = $TS($S($S($Q(
|
|
4720
|
-
var
|
|
4721
|
-
var
|
|
4722
|
-
|
|
4723
|
-
|
|
4724
|
-
|
|
4725
|
-
return
|
|
4714
|
+
var SingleLineStatements$0 = $TS($S($Q($S($Q(_), Statement, SemicolonDelimiter)), $E($S($Q(_), Statement, $E(SemicolonDelimiter)))), function($skip, $loc, $0, $1, $2) {
|
|
4715
|
+
var stmts = $1;
|
|
4716
|
+
var last = $2;
|
|
4717
|
+
const children = [...stmts];
|
|
4718
|
+
if (last)
|
|
4719
|
+
children.push(last);
|
|
4720
|
+
return {
|
|
4721
|
+
type: "BlockStatement",
|
|
4722
|
+
expressions: children,
|
|
4723
|
+
children,
|
|
4724
|
+
bare: true
|
|
4725
|
+
};
|
|
4726
4726
|
});
|
|
4727
4727
|
function SingleLineStatements(state) {
|
|
4728
4728
|
let eventData;
|
|
@@ -4755,7 +4755,7 @@ ${input.slice(result.pos)}
|
|
|
4755
4755
|
children: [$1, expressions]
|
|
4756
4756
|
};
|
|
4757
4757
|
});
|
|
4758
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
4758
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L16, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
4759
4759
|
const expressions = [];
|
|
4760
4760
|
return {
|
|
4761
4761
|
type: "BlockStatement",
|
|
@@ -4900,7 +4900,7 @@ ${input.slice(result.pos)}
|
|
|
4900
4900
|
return result;
|
|
4901
4901
|
}
|
|
4902
4902
|
}
|
|
4903
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
4903
|
+
var NullLiteral$0 = $TS($S($EXPECT($L17, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4904
4904
|
return { $loc, token: $1 };
|
|
4905
4905
|
});
|
|
4906
4906
|
function NullLiteral(state) {
|
|
@@ -4928,7 +4928,7 @@ ${input.slice(result.pos)}
|
|
|
4928
4928
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
4929
4929
|
return value[1];
|
|
4930
4930
|
});
|
|
4931
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
4931
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L18, fail, 'BooleanLiteral "true"'), $EXPECT($L19, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4932
4932
|
return { $loc, token: $1 };
|
|
4933
4933
|
});
|
|
4934
4934
|
function BooleanLiteral(state) {
|
|
@@ -4953,10 +4953,10 @@ ${input.slice(result.pos)}
|
|
|
4953
4953
|
return result;
|
|
4954
4954
|
}
|
|
4955
4955
|
}
|
|
4956
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
4956
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L20, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4957
4957
|
return { $loc, token: "true" };
|
|
4958
4958
|
});
|
|
4959
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
4959
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4960
4960
|
return { $loc, token: "false" };
|
|
4961
4961
|
});
|
|
4962
4962
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -4981,7 +4981,7 @@ ${input.slice(result.pos)}
|
|
|
4981
4981
|
return result;
|
|
4982
4982
|
}
|
|
4983
4983
|
}
|
|
4984
|
-
var Comma$0 = $TV($EXPECT($
|
|
4984
|
+
var Comma$0 = $TV($EXPECT($L24, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
4985
4985
|
return { $loc, token: $1 };
|
|
4986
4986
|
});
|
|
4987
4987
|
function Comma(state) {
|
|
@@ -5087,7 +5087,7 @@ ${input.slice(result.pos)}
|
|
|
5087
5087
|
return result;
|
|
5088
5088
|
}
|
|
5089
5089
|
}
|
|
5090
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($
|
|
5090
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L25, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L25, fail, 'UpcomingAssignment "="'), $EXPECT($L26, fail, 'UpcomingAssignment ">"')))));
|
|
5091
5091
|
function UpcomingAssignment(state) {
|
|
5092
5092
|
let eventData;
|
|
5093
5093
|
if (state.events) {
|
|
@@ -5360,7 +5360,7 @@ ${input.slice(result.pos)}
|
|
|
5360
5360
|
}
|
|
5361
5361
|
}
|
|
5362
5362
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
5363
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
5363
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L27, fail, 'ArrayElementDelimiter "]"')));
|
|
5364
5364
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
5365
5365
|
return value[1];
|
|
5366
5366
|
});
|
|
@@ -5782,7 +5782,7 @@ ${input.slice(result.pos)}
|
|
|
5782
5782
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
|
|
5783
5783
|
return value[1];
|
|
5784
5784
|
});
|
|
5785
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
5785
|
+
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) {
|
|
5786
5786
|
return "";
|
|
5787
5787
|
});
|
|
5788
5788
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -5811,7 +5811,7 @@ ${input.slice(result.pos)}
|
|
|
5811
5811
|
}
|
|
5812
5812
|
}
|
|
5813
5813
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
5814
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
5814
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L16, fail, 'ObjectPropertyDelimiter "}"')));
|
|
5815
5815
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
5816
5816
|
return value[1];
|
|
5817
5817
|
});
|
|
@@ -6254,7 +6254,7 @@ ${input.slice(result.pos)}
|
|
|
6254
6254
|
return result;
|
|
6255
6255
|
}
|
|
6256
6256
|
}
|
|
6257
|
-
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($
|
|
6257
|
+
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
|
|
6258
6258
|
return {
|
|
6259
6259
|
type: "Identifier",
|
|
6260
6260
|
name: $0,
|
|
@@ -6318,25 +6318,25 @@ ${input.slice(result.pos)}
|
|
|
6318
6318
|
return result;
|
|
6319
6319
|
}
|
|
6320
6320
|
}
|
|
6321
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
6322
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
6323
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
6324
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
6325
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
6326
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
6327
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
6328
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
6329
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
6330
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
6331
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
6332
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
6333
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
6334
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
6335
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
6336
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
6321
|
+
var AssignmentOpSymbol$0 = $EXPECT($L29, fail, 'AssignmentOpSymbol "**="');
|
|
6322
|
+
var AssignmentOpSymbol$1 = $EXPECT($L30, fail, 'AssignmentOpSymbol "*="');
|
|
6323
|
+
var AssignmentOpSymbol$2 = $EXPECT($L31, fail, 'AssignmentOpSymbol "/="');
|
|
6324
|
+
var AssignmentOpSymbol$3 = $EXPECT($L32, fail, 'AssignmentOpSymbol "%="');
|
|
6325
|
+
var AssignmentOpSymbol$4 = $EXPECT($L33, fail, 'AssignmentOpSymbol "+="');
|
|
6326
|
+
var AssignmentOpSymbol$5 = $EXPECT($L34, fail, 'AssignmentOpSymbol "-="');
|
|
6327
|
+
var AssignmentOpSymbol$6 = $EXPECT($L35, fail, 'AssignmentOpSymbol "<<="');
|
|
6328
|
+
var AssignmentOpSymbol$7 = $EXPECT($L36, fail, 'AssignmentOpSymbol ">>>="');
|
|
6329
|
+
var AssignmentOpSymbol$8 = $EXPECT($L37, fail, 'AssignmentOpSymbol ">>="');
|
|
6330
|
+
var AssignmentOpSymbol$9 = $EXPECT($L38, fail, 'AssignmentOpSymbol "&&="');
|
|
6331
|
+
var AssignmentOpSymbol$10 = $EXPECT($L39, fail, 'AssignmentOpSymbol "&="');
|
|
6332
|
+
var AssignmentOpSymbol$11 = $EXPECT($L40, fail, 'AssignmentOpSymbol "^="');
|
|
6333
|
+
var AssignmentOpSymbol$12 = $EXPECT($L41, fail, 'AssignmentOpSymbol "||="');
|
|
6334
|
+
var AssignmentOpSymbol$13 = $EXPECT($L42, fail, 'AssignmentOpSymbol "|="');
|
|
6335
|
+
var AssignmentOpSymbol$14 = $EXPECT($L43, fail, 'AssignmentOpSymbol "??="');
|
|
6336
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L44, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
6337
6337
|
return "??=";
|
|
6338
6338
|
});
|
|
6339
|
-
var AssignmentOpSymbol$16 = $T($S($EXPECT($
|
|
6339
|
+
var AssignmentOpSymbol$16 = $T($S($EXPECT($L25, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L25, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
6340
6340
|
return value[0];
|
|
6341
6341
|
});
|
|
6342
6342
|
var AssignmentOpSymbol$17 = $T($S(CoffeeWordAssignmentOp), function(value) {
|
|
@@ -6364,10 +6364,10 @@ ${input.slice(result.pos)}
|
|
|
6364
6364
|
return result;
|
|
6365
6365
|
}
|
|
6366
6366
|
}
|
|
6367
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
6367
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L45, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
6368
6368
|
return "&&=";
|
|
6369
6369
|
});
|
|
6370
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
6370
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L46, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
6371
6371
|
return "||=";
|
|
6372
6372
|
});
|
|
6373
6373
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -6419,77 +6419,80 @@ ${input.slice(result.pos)}
|
|
|
6419
6419
|
return result;
|
|
6420
6420
|
}
|
|
6421
6421
|
}
|
|
6422
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
6423
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
6424
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
6425
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
6422
|
+
var BinaryOpSymbol$0 = $EXPECT($L47, fail, 'BinaryOpSymbol "**"');
|
|
6423
|
+
var BinaryOpSymbol$1 = $EXPECT($L48, fail, 'BinaryOpSymbol "*"');
|
|
6424
|
+
var BinaryOpSymbol$2 = $EXPECT($L49, fail, 'BinaryOpSymbol "/"');
|
|
6425
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L50, fail, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
6426
6426
|
return {
|
|
6427
6427
|
call: module2.getRef("modulo"),
|
|
6428
6428
|
special: true
|
|
6429
6429
|
};
|
|
6430
6430
|
});
|
|
6431
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
6432
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
6433
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
6434
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
6435
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
6436
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
6437
|
-
|
|
6431
|
+
var BinaryOpSymbol$4 = $EXPECT($L51, fail, 'BinaryOpSymbol "%"');
|
|
6432
|
+
var BinaryOpSymbol$5 = $EXPECT($L52, fail, 'BinaryOpSymbol "+"');
|
|
6433
|
+
var BinaryOpSymbol$6 = $EXPECT($L53, fail, 'BinaryOpSymbol "-"');
|
|
6434
|
+
var BinaryOpSymbol$7 = $EXPECT($L54, fail, 'BinaryOpSymbol "<="');
|
|
6435
|
+
var BinaryOpSymbol$8 = $EXPECT($L55, fail, 'BinaryOpSymbol ">="');
|
|
6436
|
+
var BinaryOpSymbol$9 = $TS($S($EXPECT($L56, fail, 'BinaryOpSymbol "<?"'), $E($EXPECT($L6, fail, 'BinaryOpSymbol " "'))), function($skip, $loc, $0, $1, $2) {
|
|
6437
|
+
return "instanceof ";
|
|
6438
|
+
});
|
|
6439
|
+
var BinaryOpSymbol$10 = $EXPECT($L57, fail, 'BinaryOpSymbol "<<"');
|
|
6440
|
+
var BinaryOpSymbol$11 = $TR($EXPECT($R5, fail, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
6438
6441
|
return "<";
|
|
6439
6442
|
});
|
|
6440
|
-
var BinaryOpSymbol$
|
|
6441
|
-
var BinaryOpSymbol$
|
|
6442
|
-
var BinaryOpSymbol$
|
|
6443
|
-
var BinaryOpSymbol$
|
|
6444
|
-
var BinaryOpSymbol$
|
|
6443
|
+
var BinaryOpSymbol$12 = $EXPECT($L58, fail, 'BinaryOpSymbol ">>>"');
|
|
6444
|
+
var BinaryOpSymbol$13 = $EXPECT($L59, fail, 'BinaryOpSymbol ">>"');
|
|
6445
|
+
var BinaryOpSymbol$14 = $EXPECT($L26, fail, 'BinaryOpSymbol ">"');
|
|
6446
|
+
var BinaryOpSymbol$15 = $EXPECT($L60, fail, 'BinaryOpSymbol "!=="');
|
|
6447
|
+
var BinaryOpSymbol$16 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
6445
6448
|
if (module2.config.coffeeEq)
|
|
6446
6449
|
return "!==";
|
|
6447
6450
|
return $1;
|
|
6448
6451
|
});
|
|
6449
|
-
var BinaryOpSymbol$
|
|
6452
|
+
var BinaryOpSymbol$17 = $TS($S($EXPECT($L62, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6450
6453
|
if (module2.config.coffeeIsnt)
|
|
6451
6454
|
return "!==";
|
|
6452
6455
|
return $skip;
|
|
6453
6456
|
});
|
|
6454
|
-
var BinaryOpSymbol$
|
|
6455
|
-
var BinaryOpSymbol$
|
|
6457
|
+
var BinaryOpSymbol$18 = $EXPECT($L63, fail, 'BinaryOpSymbol "==="');
|
|
6458
|
+
var BinaryOpSymbol$19 = $TV($EXPECT($L64, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
6456
6459
|
if (module2.config.coffeeEq)
|
|
6457
6460
|
return "===";
|
|
6458
6461
|
return $1;
|
|
6459
6462
|
});
|
|
6460
|
-
var BinaryOpSymbol$
|
|
6463
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L65, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
6461
6464
|
return "&&";
|
|
6462
6465
|
});
|
|
6463
|
-
var BinaryOpSymbol$
|
|
6464
|
-
var BinaryOpSymbol$
|
|
6466
|
+
var BinaryOpSymbol$21 = $EXPECT($L66, fail, 'BinaryOpSymbol "&&"');
|
|
6467
|
+
var BinaryOpSymbol$22 = $T($S(CoffeeOfEnabled, $EXPECT($L67, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
6465
6468
|
return "in";
|
|
6466
6469
|
});
|
|
6467
|
-
var BinaryOpSymbol$
|
|
6470
|
+
var BinaryOpSymbol$23 = $T($S($EXPECT($L68, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
6468
6471
|
return "||";
|
|
6469
6472
|
});
|
|
6470
|
-
var BinaryOpSymbol$
|
|
6471
|
-
var BinaryOpSymbol$
|
|
6472
|
-
var BinaryOpSymbol$
|
|
6473
|
+
var BinaryOpSymbol$24 = $EXPECT($L69, fail, 'BinaryOpSymbol "||"');
|
|
6474
|
+
var BinaryOpSymbol$25 = $EXPECT($L70, fail, 'BinaryOpSymbol "??"');
|
|
6475
|
+
var BinaryOpSymbol$26 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L71, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
6473
6476
|
return "??";
|
|
6474
6477
|
});
|
|
6475
|
-
var BinaryOpSymbol$
|
|
6478
|
+
var BinaryOpSymbol$27 = $TS($S($EXPECT($L72, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6476
6479
|
return $1;
|
|
6477
6480
|
});
|
|
6478
|
-
var BinaryOpSymbol$
|
|
6481
|
+
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) {
|
|
6479
6482
|
return {
|
|
6480
6483
|
$loc,
|
|
6481
6484
|
token: "instanceof",
|
|
6482
6485
|
special: true
|
|
6483
6486
|
};
|
|
6484
6487
|
});
|
|
6485
|
-
var BinaryOpSymbol$
|
|
6488
|
+
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) {
|
|
6486
6489
|
return {
|
|
6487
6490
|
$loc,
|
|
6488
6491
|
token: "in",
|
|
6489
6492
|
special: true
|
|
6490
6493
|
};
|
|
6491
6494
|
});
|
|
6492
|
-
var BinaryOpSymbol$
|
|
6495
|
+
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) {
|
|
6493
6496
|
return {
|
|
6494
6497
|
call: [module2.getRef("indexOf"), ".call"],
|
|
6495
6498
|
relational: true,
|
|
@@ -6498,7 +6501,7 @@ ${input.slice(result.pos)}
|
|
|
6498
6501
|
special: true
|
|
6499
6502
|
};
|
|
6500
6503
|
});
|
|
6501
|
-
var BinaryOpSymbol$
|
|
6504
|
+
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) {
|
|
6502
6505
|
return {
|
|
6503
6506
|
call: [module2.getRef("indexOf"), ".call"],
|
|
6504
6507
|
relational: true,
|
|
@@ -6507,18 +6510,18 @@ ${input.slice(result.pos)}
|
|
|
6507
6510
|
special: true
|
|
6508
6511
|
};
|
|
6509
6512
|
});
|
|
6510
|
-
var BinaryOpSymbol$
|
|
6513
|
+
var BinaryOpSymbol$32 = $T($S($N(CoffeeNotEnabled), $EXPECT($L75, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L73, fail, 'BinaryOpSymbol "not"'), NonIdContinue), function(value) {
|
|
6511
6514
|
return "!==";
|
|
6512
6515
|
});
|
|
6513
|
-
var BinaryOpSymbol$
|
|
6516
|
+
var BinaryOpSymbol$33 = $T($S($EXPECT($L75, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
6514
6517
|
return "===";
|
|
6515
6518
|
});
|
|
6516
|
-
var BinaryOpSymbol$
|
|
6519
|
+
var BinaryOpSymbol$34 = $TS($S($EXPECT($L74, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6517
6520
|
return $1;
|
|
6518
6521
|
});
|
|
6519
|
-
var BinaryOpSymbol$
|
|
6520
|
-
var BinaryOpSymbol$
|
|
6521
|
-
var BinaryOpSymbol$
|
|
6522
|
+
var BinaryOpSymbol$35 = $EXPECT($L76, fail, 'BinaryOpSymbol "&"');
|
|
6523
|
+
var BinaryOpSymbol$36 = $EXPECT($L77, fail, 'BinaryOpSymbol "^"');
|
|
6524
|
+
var BinaryOpSymbol$37 = $EXPECT($L78, fail, 'BinaryOpSymbol "|"');
|
|
6522
6525
|
function BinaryOpSymbol(state) {
|
|
6523
6526
|
let eventData;
|
|
6524
6527
|
if (state.events) {
|
|
@@ -6530,12 +6533,12 @@ ${input.slice(result.pos)}
|
|
|
6530
6533
|
}
|
|
6531
6534
|
}
|
|
6532
6535
|
if (state.tokenize) {
|
|
6533
|
-
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));
|
|
6536
|
+
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));
|
|
6534
6537
|
if (state.events)
|
|
6535
6538
|
state.events.exit?.("BinaryOpSymbol", state, result, eventData);
|
|
6536
6539
|
return result;
|
|
6537
6540
|
} else {
|
|
6538
|
-
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);
|
|
6541
|
+
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);
|
|
6539
6542
|
if (state.events)
|
|
6540
6543
|
state.events.exit?.("BinaryOpSymbol", state, result, eventData);
|
|
6541
6544
|
return result;
|
|
@@ -6681,7 +6684,7 @@ ${input.slice(result.pos)}
|
|
|
6681
6684
|
return result;
|
|
6682
6685
|
}
|
|
6683
6686
|
}
|
|
6684
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
6687
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L79, fail, 'EmptyStatement ";"'))), function(value) {
|
|
6685
6688
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
6686
6689
|
});
|
|
6687
6690
|
function EmptyStatement(state) {
|
|
@@ -6706,7 +6709,7 @@ ${input.slice(result.pos)}
|
|
|
6706
6709
|
return result;
|
|
6707
6710
|
}
|
|
6708
6711
|
}
|
|
6709
|
-
var BlockStatement$0 = $T($S(ExplicitBlock, $N($S(__, $EXPECT($
|
|
6712
|
+
var BlockStatement$0 = $T($S(ExplicitBlock, $N($S(__, $EXPECT($L25, fail, 'BlockStatement "="')))), function(value) {
|
|
6710
6713
|
return value[0];
|
|
6711
6714
|
});
|
|
6712
6715
|
function BlockStatement(state) {
|
|
@@ -7633,7 +7636,7 @@ ${input.slice(result.pos)}
|
|
|
7633
7636
|
return result;
|
|
7634
7637
|
}
|
|
7635
7638
|
}
|
|
7636
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
7639
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L80, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
7637
7640
|
var own = $1;
|
|
7638
7641
|
var binding = $2;
|
|
7639
7642
|
return {
|
|
@@ -7833,7 +7836,8 @@ ${input.slice(result.pos)}
|
|
|
7833
7836
|
}
|
|
7834
7837
|
return {
|
|
7835
7838
|
type: "SwitchStatement",
|
|
7836
|
-
children: $0
|
|
7839
|
+
children: $0,
|
|
7840
|
+
caseBlock
|
|
7837
7841
|
};
|
|
7838
7842
|
});
|
|
7839
7843
|
function SwitchStatement(state) {
|
|
@@ -7893,8 +7897,8 @@ ${input.slice(result.pos)}
|
|
|
7893
7897
|
var e = $0;
|
|
7894
7898
|
return {
|
|
7895
7899
|
type: "SwitchExpression",
|
|
7896
|
-
|
|
7897
|
-
|
|
7900
|
+
children: ["(()=>{", e.children, "})()"],
|
|
7901
|
+
caseBlock: e.children[2]
|
|
7898
7902
|
};
|
|
7899
7903
|
});
|
|
7900
7904
|
function SwitchExpression(state) {
|
|
@@ -7988,9 +7992,10 @@ ${input.slice(result.pos)}
|
|
|
7988
7992
|
var NestedCaseClause$0 = $TS($S(Nested, CaseClause), function($skip, $loc, $0, $1, $2) {
|
|
7989
7993
|
var indent = $1;
|
|
7990
7994
|
var clause = $2;
|
|
7991
|
-
return
|
|
7995
|
+
return {
|
|
7996
|
+
...clause,
|
|
7992
7997
|
children: [indent, ...clause.children]
|
|
7993
|
-
}
|
|
7998
|
+
};
|
|
7994
7999
|
});
|
|
7995
8000
|
function NestedCaseClause(state) {
|
|
7996
8001
|
let eventData;
|
|
@@ -8015,48 +8020,34 @@ ${input.slice(result.pos)}
|
|
|
8015
8020
|
}
|
|
8016
8021
|
}
|
|
8017
8022
|
var CaseClause$0 = $T($S(Case, CaseExpressionList, $C(NestedBlockStatements, NoExpressions)), function(value) {
|
|
8018
|
-
|
|
8019
|
-
var expressions = value[2];
|
|
8020
|
-
return { "type": "CaseClause", "cases": cases, "expressions": expressions, "children": value };
|
|
8023
|
+
return { "type": "CaseClause", "children": value };
|
|
8021
8024
|
});
|
|
8022
|
-
var CaseClause$1 = $TS($S(When, CaseExpressionList, InsertOpenBrace, $
|
|
8025
|
+
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) {
|
|
8023
8026
|
var cases = $2;
|
|
8024
|
-
var
|
|
8027
|
+
var block = $4;
|
|
8025
8028
|
var b = $5;
|
|
8026
|
-
let children = $0;
|
|
8027
|
-
if (!expressions) {
|
|
8028
|
-
expressions = [];
|
|
8029
|
-
children = children.map((c, i) => i === 3 ? expressions : c);
|
|
8030
|
-
}
|
|
8031
|
-
if (expressions.expressions) {
|
|
8032
|
-
expressions = expressions.expressions;
|
|
8033
|
-
}
|
|
8034
8029
|
return {
|
|
8035
8030
|
type: "WhenClause",
|
|
8036
8031
|
cases,
|
|
8037
|
-
|
|
8032
|
+
block,
|
|
8038
8033
|
break: b,
|
|
8039
|
-
children
|
|
8034
|
+
children: $0
|
|
8040
8035
|
};
|
|
8041
8036
|
});
|
|
8042
8037
|
var CaseClause$2 = $TS($S(Default, ImpliedColon, $C(NestedBlockStatements, NoExpressions)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8043
|
-
var
|
|
8044
|
-
if (expressions.expressions)
|
|
8045
|
-
expressions = expressions.expressions;
|
|
8038
|
+
var block = $3;
|
|
8046
8039
|
return {
|
|
8047
8040
|
type: "DefaultClause",
|
|
8048
|
-
|
|
8041
|
+
block,
|
|
8049
8042
|
children: $0
|
|
8050
8043
|
};
|
|
8051
8044
|
});
|
|
8052
|
-
var CaseClause$3 = $TS($S(Else, ImpliedColon, InsertOpenBrace, $C(NestedBlockStatements,
|
|
8053
|
-
var
|
|
8045
|
+
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) {
|
|
8046
|
+
var block = $4;
|
|
8054
8047
|
$1.token = "default";
|
|
8055
|
-
if (expressions.expressions)
|
|
8056
|
-
expressions = expressions.expressions;
|
|
8057
8048
|
return {
|
|
8058
8049
|
type: "DefaultClause",
|
|
8059
|
-
|
|
8050
|
+
block,
|
|
8060
8051
|
children: $0
|
|
8061
8052
|
};
|
|
8062
8053
|
});
|
|
@@ -8114,7 +8105,7 @@ ${input.slice(result.pos)}
|
|
|
8114
8105
|
return result;
|
|
8115
8106
|
}
|
|
8116
8107
|
}
|
|
8117
|
-
var NoExpressions$0 = $T($EXPECT($
|
|
8108
|
+
var NoExpressions$0 = $T($EXPECT($L1, fail, 'NoExpressions ""'), function(value) {
|
|
8118
8109
|
return [];
|
|
8119
8110
|
});
|
|
8120
8111
|
function NoExpressions(state) {
|
|
@@ -8140,7 +8131,7 @@ ${input.slice(result.pos)}
|
|
|
8140
8131
|
}
|
|
8141
8132
|
}
|
|
8142
8133
|
var ImpliedColon$0 = $S(__, Colon);
|
|
8143
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
8134
|
+
var ImpliedColon$1 = $TV($EXPECT($L1, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
8144
8135
|
return { $loc, token: ":" };
|
|
8145
8136
|
});
|
|
8146
8137
|
function ImpliedColon(state) {
|
|
@@ -8280,7 +8271,7 @@ ${input.slice(result.pos)}
|
|
|
8280
8271
|
return result;
|
|
8281
8272
|
}
|
|
8282
8273
|
}
|
|
8283
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
8274
|
+
var Finally$0 = $S(__, $EXPECT($L81, fail, 'Finally "finally"'), NonIdContinue, BracedBlock);
|
|
8284
8275
|
function Finally(state) {
|
|
8285
8276
|
let eventData;
|
|
8286
8277
|
if (state.events) {
|
|
@@ -8392,7 +8383,7 @@ ${input.slice(result.pos)}
|
|
|
8392
8383
|
return result;
|
|
8393
8384
|
}
|
|
8394
8385
|
}
|
|
8395
|
-
var SuppressIndentedApplication$0 = $TV($EXPECT($
|
|
8386
|
+
var SuppressIndentedApplication$0 = $TV($EXPECT($L1, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
8396
8387
|
module2.suppressIndentedApplication = true;
|
|
8397
8388
|
});
|
|
8398
8389
|
function SuppressIndentedApplication(state) {
|
|
@@ -8440,13 +8431,13 @@ ${input.slice(result.pos)}
|
|
|
8440
8431
|
return result;
|
|
8441
8432
|
}
|
|
8442
8433
|
}
|
|
8443
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
8434
|
+
var KeywordStatement$0 = $T($S($EXPECT($L82, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
8444
8435
|
return { "type": "BreakStatement", "children": value };
|
|
8445
8436
|
});
|
|
8446
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
8437
|
+
var KeywordStatement$1 = $T($S($EXPECT($L83, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
8447
8438
|
return { "type": "ContinueStatement", "children": value };
|
|
8448
8439
|
});
|
|
8449
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
8440
|
+
var KeywordStatement$2 = $T($S($EXPECT($L84, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
8450
8441
|
return { "type": "DebuggerStatement", "children": value };
|
|
8451
8442
|
});
|
|
8452
8443
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -8477,7 +8468,7 @@ ${input.slice(result.pos)}
|
|
|
8477
8468
|
return result;
|
|
8478
8469
|
}
|
|
8479
8470
|
}
|
|
8480
|
-
var DebuggerExpression$0 = $TS($S($EXPECT($
|
|
8471
|
+
var DebuggerExpression$0 = $TS($S($EXPECT($L84, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8481
8472
|
return {
|
|
8482
8473
|
type: "DebuggerExpression",
|
|
8483
8474
|
children: ["(()=>{", $1, "})()"]
|
|
@@ -8600,7 +8591,7 @@ ${input.slice(result.pos)}
|
|
|
8600
8591
|
return result;
|
|
8601
8592
|
}
|
|
8602
8593
|
}
|
|
8603
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
8594
|
+
var ImpliedImport$0 = $TV($EXPECT($L1, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
8604
8595
|
return { $loc, token: "import " };
|
|
8605
8596
|
});
|
|
8606
8597
|
function ImpliedImport(state) {
|
|
@@ -8813,7 +8804,7 @@ ${input.slice(result.pos)}
|
|
|
8813
8804
|
}
|
|
8814
8805
|
}
|
|
8815
8806
|
var ImportAsToken$0 = $S(__, As);
|
|
8816
|
-
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($
|
|
8807
|
+
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($L6, fail, 'ImportAsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8817
8808
|
var l = $1;
|
|
8818
8809
|
var ws = $2;
|
|
8819
8810
|
var c = $3;
|
|
@@ -8973,7 +8964,7 @@ ${input.slice(result.pos)}
|
|
|
8973
8964
|
return result;
|
|
8974
8965
|
}
|
|
8975
8966
|
}
|
|
8976
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
8967
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L85, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression));
|
|
8977
8968
|
var ExportDeclaration$1 = $TS($S(Export, __, ExportFromClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
8978
8969
|
if (!$3.ts)
|
|
8979
8970
|
return $0;
|
|
@@ -9135,7 +9126,7 @@ ${input.slice(result.pos)}
|
|
|
9135
9126
|
return result;
|
|
9136
9127
|
}
|
|
9137
9128
|
}
|
|
9138
|
-
var ImplicitExportSpecifier$0 = $S($N($EXPECT($
|
|
9129
|
+
var ImplicitExportSpecifier$0 = $S($N($EXPECT($L85, fail, 'ImplicitExportSpecifier "default"')), ModuleExportName, $E($S(__, As, __, ModuleExportName)), $C($Y($S(__, From)), ImplicitInlineObjectPropertyDelimiter));
|
|
9139
9130
|
function ImplicitExportSpecifier(state) {
|
|
9140
9131
|
let eventData;
|
|
9141
9132
|
if (state.events) {
|
|
@@ -9306,7 +9297,7 @@ ${input.slice(result.pos)}
|
|
|
9306
9297
|
return result;
|
|
9307
9298
|
}
|
|
9308
9299
|
}
|
|
9309
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
9300
|
+
var ConstAssignment$0 = $TV($EXPECT($L86, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
9310
9301
|
return { $loc, token: "=" };
|
|
9311
9302
|
});
|
|
9312
9303
|
function ConstAssignment(state) {
|
|
@@ -9331,7 +9322,7 @@ ${input.slice(result.pos)}
|
|
|
9331
9322
|
return result;
|
|
9332
9323
|
}
|
|
9333
9324
|
}
|
|
9334
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
9325
|
+
var LetAssignment$0 = $TV($EXPECT($L87, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
9335
9326
|
return { $loc, token: "=" };
|
|
9336
9327
|
});
|
|
9337
9328
|
function LetAssignment(state) {
|
|
@@ -9981,7 +9972,7 @@ ${input.slice(result.pos)}
|
|
|
9981
9972
|
}
|
|
9982
9973
|
}
|
|
9983
9974
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
9984
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
9975
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L49, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L49, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
9985
9976
|
return { $loc, token: $1 };
|
|
9986
9977
|
});
|
|
9987
9978
|
function RegularExpressionLiteral(state) {
|
|
@@ -10384,8 +10375,8 @@ ${input.slice(result.pos)}
|
|
|
10384
10375
|
var ReservedWord$2 = $S(CoffeeForLoopsEnabled, $R$0($EXPECT($R34, fail, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")));
|
|
10385
10376
|
var ReservedWord$3 = $S(CoffeeOfEnabled, $R$0($EXPECT($R35, fail, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")));
|
|
10386
10377
|
var ReservedWord$4 = $S(CoffeeNotEnabled, $R$0($EXPECT($R36, fail, "ReservedWord /(?:not)(?!\\p{ID_Continue})/")));
|
|
10387
|
-
var ReservedWord$5 = $S($EXPECT($
|
|
10388
|
-
var ReservedWord$6 = $R$0($EXPECT($R37, fail, "ReservedWord /(?:and|
|
|
10378
|
+
var ReservedWord$5 = $S($EXPECT($L73, fail, 'ReservedWord "not"'), NonIdContinue, __, $EXPECT($L74, fail, 'ReservedWord "in"'), NonIdContinue);
|
|
10379
|
+
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})/"));
|
|
10389
10380
|
function ReservedWord(state) {
|
|
10390
10381
|
let eventData;
|
|
10391
10382
|
if (state.events) {
|
|
@@ -10505,7 +10496,7 @@ ${input.slice(result.pos)}
|
|
|
10505
10496
|
return result;
|
|
10506
10497
|
}
|
|
10507
10498
|
}
|
|
10508
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
10499
|
+
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) {
|
|
10509
10500
|
return { $loc, token: $1 };
|
|
10510
10501
|
});
|
|
10511
10502
|
function JSMultiLineComment(state) {
|
|
@@ -10555,7 +10546,7 @@ ${input.slice(result.pos)}
|
|
|
10555
10546
|
return result;
|
|
10556
10547
|
}
|
|
10557
10548
|
}
|
|
10558
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($Q($S($N($C(CoffeeHereCommentStart, $EXPECT($
|
|
10549
|
+
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) {
|
|
10559
10550
|
return { $loc, token: `/*${$2}*/` };
|
|
10560
10551
|
});
|
|
10561
10552
|
function CoffeeMultiLineComment(state) {
|
|
@@ -10603,7 +10594,7 @@ ${input.slice(result.pos)}
|
|
|
10603
10594
|
return result;
|
|
10604
10595
|
}
|
|
10605
10596
|
}
|
|
10606
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
10597
|
+
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) {
|
|
10607
10598
|
return { $loc, token: $1 };
|
|
10608
10599
|
});
|
|
10609
10600
|
function InlineComment(state) {
|
|
@@ -10702,7 +10693,7 @@ ${input.slice(result.pos)}
|
|
|
10702
10693
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R43, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10703
10694
|
return { $loc, token: $0 };
|
|
10704
10695
|
});
|
|
10705
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
10696
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L90, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
10706
10697
|
return "";
|
|
10707
10698
|
});
|
|
10708
10699
|
function NonNewlineWhitespace(state) {
|
|
@@ -10727,6 +10718,32 @@ ${input.slice(result.pos)}
|
|
|
10727
10718
|
return result;
|
|
10728
10719
|
}
|
|
10729
10720
|
}
|
|
10721
|
+
var Trimmed_$0 = $TV($Q(_), function($skip, $loc, $0, $1) {
|
|
10722
|
+
var ws = $0;
|
|
10723
|
+
return module2.insertTrimmingSpace(ws, "");
|
|
10724
|
+
});
|
|
10725
|
+
function Trimmed_(state) {
|
|
10726
|
+
let eventData;
|
|
10727
|
+
if (state.events) {
|
|
10728
|
+
const result = state.events.enter?.("Trimmed_", state);
|
|
10729
|
+
if (result) {
|
|
10730
|
+
if (result.cache)
|
|
10731
|
+
return result.cache;
|
|
10732
|
+
eventData = result.data;
|
|
10733
|
+
}
|
|
10734
|
+
}
|
|
10735
|
+
if (state.tokenize) {
|
|
10736
|
+
const result = $TOKEN("Trimmed_", state, Trimmed_$0(state));
|
|
10737
|
+
if (state.events)
|
|
10738
|
+
state.events.exit?.("Trimmed_", state, result, eventData);
|
|
10739
|
+
return result;
|
|
10740
|
+
} else {
|
|
10741
|
+
const result = Trimmed_$0(state);
|
|
10742
|
+
if (state.events)
|
|
10743
|
+
state.events.exit?.("Trimmed_", state, result, eventData);
|
|
10744
|
+
return result;
|
|
10745
|
+
}
|
|
10746
|
+
}
|
|
10730
10747
|
var __$0 = $Q($C(Whitespace, Comment));
|
|
10731
10748
|
function __(state) {
|
|
10732
10749
|
let eventData;
|
|
@@ -10878,7 +10895,7 @@ ${input.slice(result.pos)}
|
|
|
10878
10895
|
return result;
|
|
10879
10896
|
}
|
|
10880
10897
|
}
|
|
10881
|
-
var Loc$0 = $TV($EXPECT($
|
|
10898
|
+
var Loc$0 = $TV($EXPECT($L1, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
10882
10899
|
return { $loc, token: "" };
|
|
10883
10900
|
});
|
|
10884
10901
|
function Loc(state) {
|
|
@@ -10903,7 +10920,7 @@ ${input.slice(result.pos)}
|
|
|
10903
10920
|
return result;
|
|
10904
10921
|
}
|
|
10905
10922
|
}
|
|
10906
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
10923
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L91, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L6, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
10907
10924
|
return { $loc, token: $1, ts: true };
|
|
10908
10925
|
});
|
|
10909
10926
|
function Abstract(state) {
|
|
@@ -10928,7 +10945,7 @@ ${input.slice(result.pos)}
|
|
|
10928
10945
|
return result;
|
|
10929
10946
|
}
|
|
10930
10947
|
}
|
|
10931
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
10948
|
+
var Ampersand$0 = $TV($EXPECT($L76, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
10932
10949
|
return { $loc, token: $1 };
|
|
10933
10950
|
});
|
|
10934
10951
|
function Ampersand(state) {
|
|
@@ -10953,7 +10970,7 @@ ${input.slice(result.pos)}
|
|
|
10953
10970
|
return result;
|
|
10954
10971
|
}
|
|
10955
10972
|
}
|
|
10956
|
-
var As$0 = $TS($S($EXPECT($
|
|
10973
|
+
var As$0 = $TS($S($EXPECT($L92, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10957
10974
|
return { $loc, token: $1 };
|
|
10958
10975
|
});
|
|
10959
10976
|
function As(state) {
|
|
@@ -10978,7 +10995,7 @@ ${input.slice(result.pos)}
|
|
|
10978
10995
|
return result;
|
|
10979
10996
|
}
|
|
10980
10997
|
}
|
|
10981
|
-
var At$0 = $TV($EXPECT($
|
|
10998
|
+
var At$0 = $TV($EXPECT($L93, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
10982
10999
|
return { $loc, token: $1 };
|
|
10983
11000
|
});
|
|
10984
11001
|
function At(state) {
|
|
@@ -11003,7 +11020,7 @@ ${input.slice(result.pos)}
|
|
|
11003
11020
|
return result;
|
|
11004
11021
|
}
|
|
11005
11022
|
}
|
|
11006
|
-
var AtAt$0 = $TV($EXPECT($
|
|
11023
|
+
var AtAt$0 = $TV($EXPECT($L94, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
11007
11024
|
return { $loc, token: "@" };
|
|
11008
11025
|
});
|
|
11009
11026
|
function AtAt(state) {
|
|
@@ -11028,7 +11045,7 @@ ${input.slice(result.pos)}
|
|
|
11028
11045
|
return result;
|
|
11029
11046
|
}
|
|
11030
11047
|
}
|
|
11031
|
-
var Async$0 = $TS($S($EXPECT($
|
|
11048
|
+
var Async$0 = $TS($S($EXPECT($L95, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11032
11049
|
return { $loc, token: $1, type: "Async" };
|
|
11033
11050
|
});
|
|
11034
11051
|
function Async(state) {
|
|
@@ -11053,7 +11070,7 @@ ${input.slice(result.pos)}
|
|
|
11053
11070
|
return result;
|
|
11054
11071
|
}
|
|
11055
11072
|
}
|
|
11056
|
-
var Await$0 = $TS($S($EXPECT($
|
|
11073
|
+
var Await$0 = $TS($S($EXPECT($L96, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11057
11074
|
return { $loc, token: $1 };
|
|
11058
11075
|
});
|
|
11059
11076
|
function Await(state) {
|
|
@@ -11078,7 +11095,7 @@ ${input.slice(result.pos)}
|
|
|
11078
11095
|
return result;
|
|
11079
11096
|
}
|
|
11080
11097
|
}
|
|
11081
|
-
var Backtick$0 = $TV($EXPECT($
|
|
11098
|
+
var Backtick$0 = $TV($EXPECT($L97, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
11082
11099
|
return { $loc, token: $1 };
|
|
11083
11100
|
});
|
|
11084
11101
|
function Backtick(state) {
|
|
@@ -11103,7 +11120,7 @@ ${input.slice(result.pos)}
|
|
|
11103
11120
|
return result;
|
|
11104
11121
|
}
|
|
11105
11122
|
}
|
|
11106
|
-
var By$0 = $TS($S($EXPECT($
|
|
11123
|
+
var By$0 = $TS($S($EXPECT($L98, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11107
11124
|
return { $loc, token: $1 };
|
|
11108
11125
|
});
|
|
11109
11126
|
function By(state) {
|
|
@@ -11128,7 +11145,7 @@ ${input.slice(result.pos)}
|
|
|
11128
11145
|
return result;
|
|
11129
11146
|
}
|
|
11130
11147
|
}
|
|
11131
|
-
var Case$0 = $TS($S($EXPECT($
|
|
11148
|
+
var Case$0 = $TS($S($EXPECT($L99, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11132
11149
|
return { $loc, token: $1 };
|
|
11133
11150
|
});
|
|
11134
11151
|
function Case(state) {
|
|
@@ -11153,7 +11170,7 @@ ${input.slice(result.pos)}
|
|
|
11153
11170
|
return result;
|
|
11154
11171
|
}
|
|
11155
11172
|
}
|
|
11156
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
11173
|
+
var Catch$0 = $TS($S($EXPECT($L100, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11157
11174
|
return { $loc, token: $1 };
|
|
11158
11175
|
});
|
|
11159
11176
|
function Catch(state) {
|
|
@@ -11178,7 +11195,7 @@ ${input.slice(result.pos)}
|
|
|
11178
11195
|
return result;
|
|
11179
11196
|
}
|
|
11180
11197
|
}
|
|
11181
|
-
var Class$0 = $TS($S($EXPECT($
|
|
11198
|
+
var Class$0 = $TS($S($EXPECT($L101, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11182
11199
|
return { $loc, token: $1 };
|
|
11183
11200
|
});
|
|
11184
11201
|
function Class(state) {
|
|
@@ -11203,7 +11220,7 @@ ${input.slice(result.pos)}
|
|
|
11203
11220
|
return result;
|
|
11204
11221
|
}
|
|
11205
11222
|
}
|
|
11206
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
11223
|
+
var CloseBrace$0 = $TV($EXPECT($L16, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
11207
11224
|
return { $loc, token: $1 };
|
|
11208
11225
|
});
|
|
11209
11226
|
function CloseBrace(state) {
|
|
@@ -11228,7 +11245,7 @@ ${input.slice(result.pos)}
|
|
|
11228
11245
|
return result;
|
|
11229
11246
|
}
|
|
11230
11247
|
}
|
|
11231
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
11248
|
+
var CloseBracket$0 = $TV($EXPECT($L27, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
11232
11249
|
return { $loc, token: $1 };
|
|
11233
11250
|
});
|
|
11234
11251
|
function CloseBracket(state) {
|
|
@@ -11253,7 +11270,7 @@ ${input.slice(result.pos)}
|
|
|
11253
11270
|
return result;
|
|
11254
11271
|
}
|
|
11255
11272
|
}
|
|
11256
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
11273
|
+
var CloseParen$0 = $TV($EXPECT($L14, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
11257
11274
|
return { $loc, token: $1 };
|
|
11258
11275
|
});
|
|
11259
11276
|
function CloseParen(state) {
|
|
@@ -11278,7 +11295,7 @@ ${input.slice(result.pos)}
|
|
|
11278
11295
|
return result;
|
|
11279
11296
|
}
|
|
11280
11297
|
}
|
|
11281
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
11298
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L102, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
11282
11299
|
return { $loc, token: "${" };
|
|
11283
11300
|
});
|
|
11284
11301
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -11303,7 +11320,7 @@ ${input.slice(result.pos)}
|
|
|
11303
11320
|
return result;
|
|
11304
11321
|
}
|
|
11305
11322
|
}
|
|
11306
|
-
var Colon$0 = $TV($EXPECT($
|
|
11323
|
+
var Colon$0 = $TV($EXPECT($L28, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
11307
11324
|
return { $loc, token: $1 };
|
|
11308
11325
|
});
|
|
11309
11326
|
function Colon(state) {
|
|
@@ -11328,7 +11345,7 @@ ${input.slice(result.pos)}
|
|
|
11328
11345
|
return result;
|
|
11329
11346
|
}
|
|
11330
11347
|
}
|
|
11331
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
11348
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L93, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
11332
11349
|
return { $loc, token: "constructor" };
|
|
11333
11350
|
});
|
|
11334
11351
|
function ConstructorShorthand(state) {
|
|
@@ -11353,7 +11370,7 @@ ${input.slice(result.pos)}
|
|
|
11353
11370
|
return result;
|
|
11354
11371
|
}
|
|
11355
11372
|
}
|
|
11356
|
-
var Default$0 = $TS($S($EXPECT($
|
|
11373
|
+
var Default$0 = $TS($S($EXPECT($L85, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11357
11374
|
return { $loc, token: $1 };
|
|
11358
11375
|
});
|
|
11359
11376
|
function Default(state) {
|
|
@@ -11378,7 +11395,7 @@ ${input.slice(result.pos)}
|
|
|
11378
11395
|
return result;
|
|
11379
11396
|
}
|
|
11380
11397
|
}
|
|
11381
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
11398
|
+
var Delete$0 = $TS($S($EXPECT($L103, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11382
11399
|
return { $loc, token: $1 };
|
|
11383
11400
|
});
|
|
11384
11401
|
function Delete(state) {
|
|
@@ -11403,7 +11420,7 @@ ${input.slice(result.pos)}
|
|
|
11403
11420
|
return result;
|
|
11404
11421
|
}
|
|
11405
11422
|
}
|
|
11406
|
-
var Do$0 = $TS($S($EXPECT($
|
|
11423
|
+
var Do$0 = $TS($S($EXPECT($L104, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11407
11424
|
return { $loc, token: $1 };
|
|
11408
11425
|
});
|
|
11409
11426
|
function Do(state) {
|
|
@@ -11428,7 +11445,7 @@ ${input.slice(result.pos)}
|
|
|
11428
11445
|
return result;
|
|
11429
11446
|
}
|
|
11430
11447
|
}
|
|
11431
|
-
var Dot$0 = $TV($EXPECT($
|
|
11448
|
+
var Dot$0 = $TV($EXPECT($L2, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
11432
11449
|
return { $loc, token: $1 };
|
|
11433
11450
|
});
|
|
11434
11451
|
function Dot(state) {
|
|
@@ -11453,7 +11470,7 @@ ${input.slice(result.pos)}
|
|
|
11453
11470
|
return result;
|
|
11454
11471
|
}
|
|
11455
11472
|
}
|
|
11456
|
-
var DotDot$0 = $TV($EXPECT($
|
|
11473
|
+
var DotDot$0 = $TV($EXPECT($L105, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
11457
11474
|
return { $loc, token: $1 };
|
|
11458
11475
|
});
|
|
11459
11476
|
function DotDot(state) {
|
|
@@ -11478,7 +11495,7 @@ ${input.slice(result.pos)}
|
|
|
11478
11495
|
return result;
|
|
11479
11496
|
}
|
|
11480
11497
|
}
|
|
11481
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
11498
|
+
var DotDotDot$0 = $TV($EXPECT($L106, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
11482
11499
|
return { $loc, token: $1 };
|
|
11483
11500
|
});
|
|
11484
11501
|
function DotDotDot(state) {
|
|
@@ -11503,7 +11520,7 @@ ${input.slice(result.pos)}
|
|
|
11503
11520
|
return result;
|
|
11504
11521
|
}
|
|
11505
11522
|
}
|
|
11506
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
11523
|
+
var DoubleColon$0 = $TV($EXPECT($L107, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
11507
11524
|
return { $loc, token: $1 };
|
|
11508
11525
|
});
|
|
11509
11526
|
function DoubleColon(state) {
|
|
@@ -11528,7 +11545,7 @@ ${input.slice(result.pos)}
|
|
|
11528
11545
|
return result;
|
|
11529
11546
|
}
|
|
11530
11547
|
}
|
|
11531
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
11548
|
+
var DoubleQuote$0 = $TV($EXPECT($L108, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
11532
11549
|
return { $loc, token: $1 };
|
|
11533
11550
|
});
|
|
11534
11551
|
function DoubleQuote(state) {
|
|
@@ -11553,7 +11570,7 @@ ${input.slice(result.pos)}
|
|
|
11553
11570
|
return result;
|
|
11554
11571
|
}
|
|
11555
11572
|
}
|
|
11556
|
-
var Else$0 = $TS($S($EXPECT($
|
|
11573
|
+
var Else$0 = $TS($S($EXPECT($L109, fail, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11557
11574
|
return { $loc, token: $1 };
|
|
11558
11575
|
});
|
|
11559
11576
|
function Else(state) {
|
|
@@ -11578,7 +11595,7 @@ ${input.slice(result.pos)}
|
|
|
11578
11595
|
return result;
|
|
11579
11596
|
}
|
|
11580
11597
|
}
|
|
11581
|
-
var Equals$0 = $TV($EXPECT($
|
|
11598
|
+
var Equals$0 = $TV($EXPECT($L25, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
11582
11599
|
return { $loc, token: $1 };
|
|
11583
11600
|
});
|
|
11584
11601
|
function Equals(state) {
|
|
@@ -11603,7 +11620,7 @@ ${input.slice(result.pos)}
|
|
|
11603
11620
|
return result;
|
|
11604
11621
|
}
|
|
11605
11622
|
}
|
|
11606
|
-
var Export$0 = $TS($S($EXPECT($
|
|
11623
|
+
var Export$0 = $TS($S($EXPECT($L110, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11607
11624
|
return { $loc, token: $1 };
|
|
11608
11625
|
});
|
|
11609
11626
|
function Export(state) {
|
|
@@ -11628,7 +11645,7 @@ ${input.slice(result.pos)}
|
|
|
11628
11645
|
return result;
|
|
11629
11646
|
}
|
|
11630
11647
|
}
|
|
11631
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
11648
|
+
var Extends$0 = $TS($S($EXPECT($L111, fail, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11632
11649
|
return { $loc, token: $1 };
|
|
11633
11650
|
});
|
|
11634
11651
|
function Extends(state) {
|
|
@@ -11653,7 +11670,7 @@ ${input.slice(result.pos)}
|
|
|
11653
11670
|
return result;
|
|
11654
11671
|
}
|
|
11655
11672
|
}
|
|
11656
|
-
var For$0 = $TS($S($EXPECT($
|
|
11673
|
+
var For$0 = $TS($S($EXPECT($L112, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11657
11674
|
return { $loc, token: $1 };
|
|
11658
11675
|
});
|
|
11659
11676
|
function For(state) {
|
|
@@ -11678,7 +11695,7 @@ ${input.slice(result.pos)}
|
|
|
11678
11695
|
return result;
|
|
11679
11696
|
}
|
|
11680
11697
|
}
|
|
11681
|
-
var From$0 = $TS($S($EXPECT($
|
|
11698
|
+
var From$0 = $TS($S($EXPECT($L113, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11682
11699
|
return { $loc, token: $1 };
|
|
11683
11700
|
});
|
|
11684
11701
|
function From(state) {
|
|
@@ -11703,7 +11720,7 @@ ${input.slice(result.pos)}
|
|
|
11703
11720
|
return result;
|
|
11704
11721
|
}
|
|
11705
11722
|
}
|
|
11706
|
-
var Function$0 = $TS($S($EXPECT($
|
|
11723
|
+
var Function$0 = $TS($S($EXPECT($L114, fail, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11707
11724
|
return { $loc, token: $1 };
|
|
11708
11725
|
});
|
|
11709
11726
|
function Function(state) {
|
|
@@ -11728,7 +11745,7 @@ ${input.slice(result.pos)}
|
|
|
11728
11745
|
return result;
|
|
11729
11746
|
}
|
|
11730
11747
|
}
|
|
11731
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
11748
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L115, fail, 'GetOrSet "get"'), $EXPECT($L116, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11732
11749
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
11733
11750
|
});
|
|
11734
11751
|
function GetOrSet(state) {
|
|
@@ -11753,7 +11770,7 @@ ${input.slice(result.pos)}
|
|
|
11753
11770
|
return result;
|
|
11754
11771
|
}
|
|
11755
11772
|
}
|
|
11756
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
11773
|
+
var If$0 = $TV($TEXT($S($EXPECT($L117, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L6, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
11757
11774
|
return { $loc, token: $1 };
|
|
11758
11775
|
});
|
|
11759
11776
|
function If(state) {
|
|
@@ -11778,7 +11795,7 @@ ${input.slice(result.pos)}
|
|
|
11778
11795
|
return result;
|
|
11779
11796
|
}
|
|
11780
11797
|
}
|
|
11781
|
-
var Import$0 = $TS($S($EXPECT($
|
|
11798
|
+
var Import$0 = $TS($S($EXPECT($L10, fail, 'Import "import"'), $Y($EXPECT($R45, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
11782
11799
|
return { $loc, token: $1 };
|
|
11783
11800
|
});
|
|
11784
11801
|
function Import(state) {
|
|
@@ -11803,7 +11820,7 @@ ${input.slice(result.pos)}
|
|
|
11803
11820
|
return result;
|
|
11804
11821
|
}
|
|
11805
11822
|
}
|
|
11806
|
-
var In$0 = $TS($S($EXPECT($
|
|
11823
|
+
var In$0 = $TS($S($EXPECT($L74, fail, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11807
11824
|
return { $loc, token: $1 };
|
|
11808
11825
|
});
|
|
11809
11826
|
function In(state) {
|
|
@@ -11828,7 +11845,7 @@ ${input.slice(result.pos)}
|
|
|
11828
11845
|
return result;
|
|
11829
11846
|
}
|
|
11830
11847
|
}
|
|
11831
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
11848
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L118, fail, 'LetOrConst "let"'), $EXPECT($L119, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11832
11849
|
return { $loc, token: $1 };
|
|
11833
11850
|
});
|
|
11834
11851
|
function LetOrConst(state) {
|
|
@@ -11853,7 +11870,7 @@ ${input.slice(result.pos)}
|
|
|
11853
11870
|
return result;
|
|
11854
11871
|
}
|
|
11855
11872
|
}
|
|
11856
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
11873
|
+
var Loop$0 = $TS($S($EXPECT($L120, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11857
11874
|
return { $loc, token: "while(true)" };
|
|
11858
11875
|
});
|
|
11859
11876
|
function Loop(state) {
|
|
@@ -11878,7 +11895,7 @@ ${input.slice(result.pos)}
|
|
|
11878
11895
|
return result;
|
|
11879
11896
|
}
|
|
11880
11897
|
}
|
|
11881
|
-
var New$0 = $TS($S($EXPECT($
|
|
11898
|
+
var New$0 = $TS($S($EXPECT($L121, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11882
11899
|
return { $loc, token: $1 };
|
|
11883
11900
|
});
|
|
11884
11901
|
function New(state) {
|
|
@@ -11903,7 +11920,7 @@ ${input.slice(result.pos)}
|
|
|
11903
11920
|
return result;
|
|
11904
11921
|
}
|
|
11905
11922
|
}
|
|
11906
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
11923
|
+
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) {
|
|
11907
11924
|
return { $loc, token: "!" };
|
|
11908
11925
|
});
|
|
11909
11926
|
function Not(state) {
|
|
@@ -11928,7 +11945,7 @@ ${input.slice(result.pos)}
|
|
|
11928
11945
|
return result;
|
|
11929
11946
|
}
|
|
11930
11947
|
}
|
|
11931
|
-
var Of$0 = $TS($S($EXPECT($
|
|
11948
|
+
var Of$0 = $TS($S($EXPECT($L67, fail, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11932
11949
|
return { $loc, token: $1 };
|
|
11933
11950
|
});
|
|
11934
11951
|
function Of(state) {
|
|
@@ -11953,7 +11970,7 @@ ${input.slice(result.pos)}
|
|
|
11953
11970
|
return result;
|
|
11954
11971
|
}
|
|
11955
11972
|
}
|
|
11956
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
11973
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L122, fail, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
11957
11974
|
return { $loc, token: $1 };
|
|
11958
11975
|
});
|
|
11959
11976
|
function OpenAngleBracket(state) {
|
|
@@ -11978,7 +11995,7 @@ ${input.slice(result.pos)}
|
|
|
11978
11995
|
return result;
|
|
11979
11996
|
}
|
|
11980
11997
|
}
|
|
11981
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
11998
|
+
var OpenBrace$0 = $TV($EXPECT($L123, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
11982
11999
|
return { $loc, token: $1 };
|
|
11983
12000
|
});
|
|
11984
12001
|
function OpenBrace(state) {
|
|
@@ -12003,7 +12020,7 @@ ${input.slice(result.pos)}
|
|
|
12003
12020
|
return result;
|
|
12004
12021
|
}
|
|
12005
12022
|
}
|
|
12006
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
12023
|
+
var OpenBracket$0 = $TV($EXPECT($L124, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
12007
12024
|
return { $loc, token: $1 };
|
|
12008
12025
|
});
|
|
12009
12026
|
function OpenBracket(state) {
|
|
@@ -12028,7 +12045,7 @@ ${input.slice(result.pos)}
|
|
|
12028
12045
|
return result;
|
|
12029
12046
|
}
|
|
12030
12047
|
}
|
|
12031
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
12048
|
+
var OpenParen$0 = $TV($EXPECT($L125, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
12032
12049
|
return { $loc, token: $1 };
|
|
12033
12050
|
});
|
|
12034
12051
|
function OpenParen(state) {
|
|
@@ -12053,7 +12070,7 @@ ${input.slice(result.pos)}
|
|
|
12053
12070
|
return result;
|
|
12054
12071
|
}
|
|
12055
12072
|
}
|
|
12056
|
-
var Public$0 = $TS($S($EXPECT($
|
|
12073
|
+
var Public$0 = $TS($S($EXPECT($L126, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12057
12074
|
return { $loc, token: $1 };
|
|
12058
12075
|
});
|
|
12059
12076
|
function Public(state) {
|
|
@@ -12078,7 +12095,7 @@ ${input.slice(result.pos)}
|
|
|
12078
12095
|
return result;
|
|
12079
12096
|
}
|
|
12080
12097
|
}
|
|
12081
|
-
var Private$0 = $TS($S($EXPECT($
|
|
12098
|
+
var Private$0 = $TS($S($EXPECT($L127, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12082
12099
|
return { $loc, token: $1 };
|
|
12083
12100
|
});
|
|
12084
12101
|
function Private(state) {
|
|
@@ -12103,7 +12120,7 @@ ${input.slice(result.pos)}
|
|
|
12103
12120
|
return result;
|
|
12104
12121
|
}
|
|
12105
12122
|
}
|
|
12106
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
12123
|
+
var Protected$0 = $TS($S($EXPECT($L128, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12107
12124
|
return { $loc, token: $1 };
|
|
12108
12125
|
});
|
|
12109
12126
|
function Protected(state) {
|
|
@@ -12128,7 +12145,7 @@ ${input.slice(result.pos)}
|
|
|
12128
12145
|
return result;
|
|
12129
12146
|
}
|
|
12130
12147
|
}
|
|
12131
|
-
var Pipe$0 = $TV($EXPECT($
|
|
12148
|
+
var Pipe$0 = $TV($EXPECT($L129, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
12132
12149
|
return { $loc, token: $1 };
|
|
12133
12150
|
});
|
|
12134
12151
|
function Pipe(state) {
|
|
@@ -12153,7 +12170,7 @@ ${input.slice(result.pos)}
|
|
|
12153
12170
|
return result;
|
|
12154
12171
|
}
|
|
12155
12172
|
}
|
|
12156
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
12173
|
+
var QuestionMark$0 = $TV($EXPECT($L71, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
12157
12174
|
return { $loc, token: $1 };
|
|
12158
12175
|
});
|
|
12159
12176
|
function QuestionMark(state) {
|
|
@@ -12178,7 +12195,7 @@ ${input.slice(result.pos)}
|
|
|
12178
12195
|
return result;
|
|
12179
12196
|
}
|
|
12180
12197
|
}
|
|
12181
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
12198
|
+
var Readonly$0 = $TS($S($EXPECT($L130, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12182
12199
|
return { $loc, token: $1, ts: true };
|
|
12183
12200
|
});
|
|
12184
12201
|
function Readonly(state) {
|
|
@@ -12203,7 +12220,7 @@ ${input.slice(result.pos)}
|
|
|
12203
12220
|
return result;
|
|
12204
12221
|
}
|
|
12205
12222
|
}
|
|
12206
|
-
var Return$0 = $TS($S($EXPECT($
|
|
12223
|
+
var Return$0 = $TS($S($EXPECT($L131, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12207
12224
|
return { $loc, token: $1 };
|
|
12208
12225
|
});
|
|
12209
12226
|
function Return(state) {
|
|
@@ -12228,7 +12245,7 @@ ${input.slice(result.pos)}
|
|
|
12228
12245
|
return result;
|
|
12229
12246
|
}
|
|
12230
12247
|
}
|
|
12231
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
12248
|
+
var Satisfies$0 = $TS($S($EXPECT($L132, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12232
12249
|
return { $loc, token: $1 };
|
|
12233
12250
|
});
|
|
12234
12251
|
function Satisfies(state) {
|
|
@@ -12253,7 +12270,7 @@ ${input.slice(result.pos)}
|
|
|
12253
12270
|
return result;
|
|
12254
12271
|
}
|
|
12255
12272
|
}
|
|
12256
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
12273
|
+
var Semicolon$0 = $TV($EXPECT($L79, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
12257
12274
|
return { $loc, token: $1 };
|
|
12258
12275
|
});
|
|
12259
12276
|
function Semicolon(state) {
|
|
@@ -12278,7 +12295,7 @@ ${input.slice(result.pos)}
|
|
|
12278
12295
|
return result;
|
|
12279
12296
|
}
|
|
12280
12297
|
}
|
|
12281
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
12298
|
+
var SingleQuote$0 = $TV($EXPECT($L133, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
12282
12299
|
return { $loc, token: $1 };
|
|
12283
12300
|
});
|
|
12284
12301
|
function SingleQuote(state) {
|
|
@@ -12303,7 +12320,7 @@ ${input.slice(result.pos)}
|
|
|
12303
12320
|
return result;
|
|
12304
12321
|
}
|
|
12305
12322
|
}
|
|
12306
|
-
var Star$0 = $TV($EXPECT($
|
|
12323
|
+
var Star$0 = $TV($EXPECT($L48, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
12307
12324
|
return { $loc, token: $1 };
|
|
12308
12325
|
});
|
|
12309
12326
|
function Star(state) {
|
|
@@ -12328,10 +12345,10 @@ ${input.slice(result.pos)}
|
|
|
12328
12345
|
return result;
|
|
12329
12346
|
}
|
|
12330
12347
|
}
|
|
12331
|
-
var Static$0 = $TS($S($EXPECT($
|
|
12348
|
+
var Static$0 = $TS($S($EXPECT($L134, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12332
12349
|
return { $loc, token: $1 };
|
|
12333
12350
|
});
|
|
12334
|
-
var Static$1 = $TS($S($EXPECT($
|
|
12351
|
+
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) {
|
|
12335
12352
|
return { $loc, token: "static " };
|
|
12336
12353
|
});
|
|
12337
12354
|
function Static(state) {
|
|
@@ -12356,7 +12373,7 @@ ${input.slice(result.pos)}
|
|
|
12356
12373
|
return result;
|
|
12357
12374
|
}
|
|
12358
12375
|
}
|
|
12359
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
12376
|
+
var SubstitutionStart$0 = $TV($EXPECT($L135, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
12360
12377
|
return { $loc, token: $1 };
|
|
12361
12378
|
});
|
|
12362
12379
|
function SubstitutionStart(state) {
|
|
@@ -12381,7 +12398,7 @@ ${input.slice(result.pos)}
|
|
|
12381
12398
|
return result;
|
|
12382
12399
|
}
|
|
12383
12400
|
}
|
|
12384
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
12401
|
+
var Switch$0 = $TS($S($EXPECT($L136, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12385
12402
|
return { $loc, token: $1 };
|
|
12386
12403
|
});
|
|
12387
12404
|
function Switch(state) {
|
|
@@ -12406,7 +12423,7 @@ ${input.slice(result.pos)}
|
|
|
12406
12423
|
return result;
|
|
12407
12424
|
}
|
|
12408
12425
|
}
|
|
12409
|
-
var Target$0 = $TS($S($EXPECT($
|
|
12426
|
+
var Target$0 = $TS($S($EXPECT($L137, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12410
12427
|
return { $loc, token: $1 };
|
|
12411
12428
|
});
|
|
12412
12429
|
function Target(state) {
|
|
@@ -12431,7 +12448,7 @@ ${input.slice(result.pos)}
|
|
|
12431
12448
|
return result;
|
|
12432
12449
|
}
|
|
12433
12450
|
}
|
|
12434
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
12451
|
+
var Then$0 = $TS($S(__, $EXPECT($L138, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
12435
12452
|
return { $loc, token: "" };
|
|
12436
12453
|
});
|
|
12437
12454
|
function Then(state) {
|
|
@@ -12456,7 +12473,7 @@ ${input.slice(result.pos)}
|
|
|
12456
12473
|
return result;
|
|
12457
12474
|
}
|
|
12458
12475
|
}
|
|
12459
|
-
var This$0 = $TS($S($EXPECT($
|
|
12476
|
+
var This$0 = $TS($S($EXPECT($L139, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12460
12477
|
return { $loc, token: $1 };
|
|
12461
12478
|
});
|
|
12462
12479
|
function This(state) {
|
|
@@ -12481,7 +12498,7 @@ ${input.slice(result.pos)}
|
|
|
12481
12498
|
return result;
|
|
12482
12499
|
}
|
|
12483
12500
|
}
|
|
12484
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
12501
|
+
var Throw$0 = $TS($S($EXPECT($L140, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12485
12502
|
return { $loc, token: $1 };
|
|
12486
12503
|
});
|
|
12487
12504
|
function Throw(state) {
|
|
@@ -12506,7 +12523,7 @@ ${input.slice(result.pos)}
|
|
|
12506
12523
|
return result;
|
|
12507
12524
|
}
|
|
12508
12525
|
}
|
|
12509
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
12526
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L141, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
12510
12527
|
return { $loc, token: "`" };
|
|
12511
12528
|
});
|
|
12512
12529
|
function TripleDoubleQuote(state) {
|
|
@@ -12531,7 +12548,7 @@ ${input.slice(result.pos)}
|
|
|
12531
12548
|
return result;
|
|
12532
12549
|
}
|
|
12533
12550
|
}
|
|
12534
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
12551
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L142, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
12535
12552
|
return { $loc, token: "`" };
|
|
12536
12553
|
});
|
|
12537
12554
|
function TripleSingleQuote(state) {
|
|
@@ -12556,7 +12573,7 @@ ${input.slice(result.pos)}
|
|
|
12556
12573
|
return result;
|
|
12557
12574
|
}
|
|
12558
12575
|
}
|
|
12559
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
12576
|
+
var TripleSlash$0 = $TV($EXPECT($L143, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
12560
12577
|
return { $loc, token: "/" };
|
|
12561
12578
|
});
|
|
12562
12579
|
function TripleSlash(state) {
|
|
@@ -12581,7 +12598,7 @@ ${input.slice(result.pos)}
|
|
|
12581
12598
|
return result;
|
|
12582
12599
|
}
|
|
12583
12600
|
}
|
|
12584
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
12601
|
+
var TripleTick$0 = $TV($EXPECT($L144, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
12585
12602
|
return { $loc, token: "`" };
|
|
12586
12603
|
});
|
|
12587
12604
|
function TripleTick(state) {
|
|
@@ -12606,7 +12623,7 @@ ${input.slice(result.pos)}
|
|
|
12606
12623
|
return result;
|
|
12607
12624
|
}
|
|
12608
12625
|
}
|
|
12609
|
-
var Try$0 = $TS($S($EXPECT($
|
|
12626
|
+
var Try$0 = $TS($S($EXPECT($L145, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12610
12627
|
return { $loc, token: $1 };
|
|
12611
12628
|
});
|
|
12612
12629
|
function Try(state) {
|
|
@@ -12631,7 +12648,7 @@ ${input.slice(result.pos)}
|
|
|
12631
12648
|
return result;
|
|
12632
12649
|
}
|
|
12633
12650
|
}
|
|
12634
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
12651
|
+
var Typeof$0 = $TS($S($EXPECT($L146, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12635
12652
|
return { $loc, token: $1 };
|
|
12636
12653
|
});
|
|
12637
12654
|
function Typeof(state) {
|
|
@@ -12656,7 +12673,7 @@ ${input.slice(result.pos)}
|
|
|
12656
12673
|
return result;
|
|
12657
12674
|
}
|
|
12658
12675
|
}
|
|
12659
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
12676
|
+
var Unless$0 = $TS($S($EXPECT($L147, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12660
12677
|
return { $loc, token: $1 };
|
|
12661
12678
|
});
|
|
12662
12679
|
function Unless(state) {
|
|
@@ -12681,7 +12698,7 @@ ${input.slice(result.pos)}
|
|
|
12681
12698
|
return result;
|
|
12682
12699
|
}
|
|
12683
12700
|
}
|
|
12684
|
-
var Until$0 = $TS($S($EXPECT($
|
|
12701
|
+
var Until$0 = $TS($S($EXPECT($L148, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12685
12702
|
return { $loc, token: $1 };
|
|
12686
12703
|
});
|
|
12687
12704
|
function Until(state) {
|
|
@@ -12706,7 +12723,7 @@ ${input.slice(result.pos)}
|
|
|
12706
12723
|
return result;
|
|
12707
12724
|
}
|
|
12708
12725
|
}
|
|
12709
|
-
var Var$0 = $TS($S($EXPECT($
|
|
12726
|
+
var Var$0 = $TS($S($EXPECT($L149, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12710
12727
|
return { $loc, token: $1 };
|
|
12711
12728
|
});
|
|
12712
12729
|
function Var(state) {
|
|
@@ -12731,7 +12748,7 @@ ${input.slice(result.pos)}
|
|
|
12731
12748
|
return result;
|
|
12732
12749
|
}
|
|
12733
12750
|
}
|
|
12734
|
-
var Void$0 = $TS($S($EXPECT($
|
|
12751
|
+
var Void$0 = $TS($S($EXPECT($L150, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12735
12752
|
return { $loc, token: $1 };
|
|
12736
12753
|
});
|
|
12737
12754
|
function Void(state) {
|
|
@@ -12756,7 +12773,7 @@ ${input.slice(result.pos)}
|
|
|
12756
12773
|
return result;
|
|
12757
12774
|
}
|
|
12758
12775
|
}
|
|
12759
|
-
var When$0 = $TS($S($EXPECT($
|
|
12776
|
+
var When$0 = $TS($S($EXPECT($L151, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12760
12777
|
return { $loc, token: "case" };
|
|
12761
12778
|
});
|
|
12762
12779
|
function When(state) {
|
|
@@ -12781,7 +12798,7 @@ ${input.slice(result.pos)}
|
|
|
12781
12798
|
return result;
|
|
12782
12799
|
}
|
|
12783
12800
|
}
|
|
12784
|
-
var While$0 = $TS($S($EXPECT($
|
|
12801
|
+
var While$0 = $TS($S($EXPECT($L152, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12785
12802
|
return { $loc, token: $1 };
|
|
12786
12803
|
});
|
|
12787
12804
|
function While(state) {
|
|
@@ -12806,7 +12823,7 @@ ${input.slice(result.pos)}
|
|
|
12806
12823
|
return result;
|
|
12807
12824
|
}
|
|
12808
12825
|
}
|
|
12809
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
12826
|
+
var Yield$0 = $TS($S($EXPECT($L153, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12810
12827
|
return { $loc, token: $1 };
|
|
12811
12828
|
});
|
|
12812
12829
|
function Yield(state) {
|
|
@@ -12938,7 +12955,7 @@ ${input.slice(result.pos)}
|
|
|
12938
12955
|
return result;
|
|
12939
12956
|
}
|
|
12940
12957
|
}
|
|
12941
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
12958
|
+
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) {
|
|
12942
12959
|
return { type: "JSXElement", children: $0 };
|
|
12943
12960
|
});
|
|
12944
12961
|
function JSXSelfClosingElement(state) {
|
|
@@ -12963,7 +12980,7 @@ ${input.slice(result.pos)}
|
|
|
12963
12980
|
return result;
|
|
12964
12981
|
}
|
|
12965
12982
|
}
|
|
12966
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
12983
|
+
var JSXOpeningElement$0 = $S($EXPECT($L122, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L26, fail, 'JSXOpeningElement ">"'));
|
|
12967
12984
|
function JSXOpeningElement(state) {
|
|
12968
12985
|
let eventData;
|
|
12969
12986
|
if (state.events) {
|
|
@@ -12986,7 +13003,7 @@ ${input.slice(result.pos)}
|
|
|
12986
13003
|
return result;
|
|
12987
13004
|
}
|
|
12988
13005
|
}
|
|
12989
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
13006
|
+
var JSXClosingElement$0 = $S($EXPECT($L155, fail, 'JSXClosingElement "</"'), $E(Whitespace), $TEXT(JSXElementName), $E(Whitespace), $EXPECT($L26, fail, 'JSXClosingElement ">"'));
|
|
12990
13007
|
function JSXClosingElement(state) {
|
|
12991
13008
|
let eventData;
|
|
12992
13009
|
if (state.events) {
|
|
@@ -13009,14 +13026,14 @@ ${input.slice(result.pos)}
|
|
|
13009
13026
|
return result;
|
|
13010
13027
|
}
|
|
13011
13028
|
}
|
|
13012
|
-
var JSXFragment$0 = $TS($S($EXPECT($
|
|
13029
|
+
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) {
|
|
13013
13030
|
if ($2) {
|
|
13014
13031
|
return { type: "JSXFragment", children: $0, jsxChildren: $2.jsxChildren };
|
|
13015
13032
|
} else {
|
|
13016
13033
|
return { type: "JSXFragment", children: $0, jsxChildren: [] };
|
|
13017
13034
|
}
|
|
13018
13035
|
});
|
|
13019
|
-
var JSXFragment$1 = $TS($S($EXPECT($
|
|
13036
|
+
var JSXFragment$1 = $TS($S($EXPECT($L156, fail, 'JSXFragment "<>"'), JSXMixedChildren, InsertNewline, InsertIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
13020
13037
|
return { type: "JSXFragment", children: [...$0, "</>"], jsxChildren: $2.jsxChildren };
|
|
13021
13038
|
});
|
|
13022
13039
|
function JSXFragment(state) {
|
|
@@ -13243,7 +13260,7 @@ ${input.slice(result.pos)}
|
|
|
13243
13260
|
}
|
|
13244
13261
|
});
|
|
13245
13262
|
var JSXAttribute$2 = $S(InsertInlineOpenBrace, DotDotDot, InlineJSXAttributeValue, InsertCloseBrace);
|
|
13246
|
-
var JSXAttribute$3 = $TS($S($EXPECT($
|
|
13263
|
+
var JSXAttribute$3 = $TS($S($EXPECT($L8, fail, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
13247
13264
|
return [" ", "id=", $2];
|
|
13248
13265
|
});
|
|
13249
13266
|
var JSXAttribute$4 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -13550,8 +13567,8 @@ ${input.slice(result.pos)}
|
|
|
13550
13567
|
return result;
|
|
13551
13568
|
}
|
|
13552
13569
|
}
|
|
13553
|
-
var InlineJSXCallExpression$0 = $S($EXPECT($
|
|
13554
|
-
var InlineJSXCallExpression$1 = $S($EXPECT($
|
|
13570
|
+
var InlineJSXCallExpression$0 = $S($EXPECT($L9, fail, 'InlineJSXCallExpression "super"'), ExplicitArguments);
|
|
13571
|
+
var InlineJSXCallExpression$1 = $S($EXPECT($L10, fail, 'InlineJSXCallExpression "import"'), OpenParen, ExtendedExpression, __, CloseParen);
|
|
13555
13572
|
var InlineJSXCallExpression$2 = $TS($S(InlineJSXMemberExpression, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
13556
13573
|
if ($2.length)
|
|
13557
13574
|
return $0;
|
|
@@ -13766,7 +13783,7 @@ ${input.slice(result.pos)}
|
|
|
13766
13783
|
}
|
|
13767
13784
|
return $skip;
|
|
13768
13785
|
});
|
|
13769
|
-
var JSXNestedChildren$1 = $TV($Y($C(EOS, $EXPECT($
|
|
13786
|
+
var JSXNestedChildren$1 = $TV($Y($C(EOS, $EXPECT($L16, fail, 'JSXNestedChildren "}"'))), function($skip, $loc, $0, $1) {
|
|
13770
13787
|
return { children: [], jsxChildren: [] };
|
|
13771
13788
|
});
|
|
13772
13789
|
function JSXNestedChildren(state) {
|
|
@@ -13841,7 +13858,7 @@ ${input.slice(result.pos)}
|
|
|
13841
13858
|
return result;
|
|
13842
13859
|
}
|
|
13843
13860
|
}
|
|
13844
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
13861
|
+
var JSXComment$0 = $TS($S($EXPECT($L158, fail, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L159, fail, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
13845
13862
|
return ["{/*", $2, "*/}"];
|
|
13846
13863
|
});
|
|
13847
13864
|
function JSXComment(state) {
|
|
@@ -14018,7 +14035,7 @@ ${input.slice(result.pos)}
|
|
|
14018
14035
|
return result;
|
|
14019
14036
|
}
|
|
14020
14037
|
}
|
|
14021
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
14038
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L160, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
14022
14039
|
var TypeDeclarationModifier$1 = Export;
|
|
14023
14040
|
function TypeDeclarationModifier(state) {
|
|
14024
14041
|
let eventData;
|
|
@@ -14043,7 +14060,7 @@ ${input.slice(result.pos)}
|
|
|
14043
14060
|
}
|
|
14044
14061
|
}
|
|
14045
14062
|
var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, Equals, __, Type);
|
|
14046
|
-
var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, $E(TypeParameters), InterfaceBlock);
|
|
14063
|
+
var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, $E(TypeParameters), $E(InterfaceExtendsClause), InterfaceBlock);
|
|
14047
14064
|
var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
|
|
14048
14065
|
var TypeDeclarationRest$3 = FunctionSignature;
|
|
14049
14066
|
function TypeDeclarationRest(state) {
|
|
@@ -14068,7 +14085,53 @@ ${input.slice(result.pos)}
|
|
|
14068
14085
|
return result;
|
|
14069
14086
|
}
|
|
14070
14087
|
}
|
|
14071
|
-
var
|
|
14088
|
+
var InterfaceExtendsClause$0 = $S(ExtendsToken, InterfaceExtendsTarget);
|
|
14089
|
+
function InterfaceExtendsClause(state) {
|
|
14090
|
+
let eventData;
|
|
14091
|
+
if (state.events) {
|
|
14092
|
+
const result = state.events.enter?.("InterfaceExtendsClause", state);
|
|
14093
|
+
if (result) {
|
|
14094
|
+
if (result.cache)
|
|
14095
|
+
return result.cache;
|
|
14096
|
+
eventData = result.data;
|
|
14097
|
+
}
|
|
14098
|
+
}
|
|
14099
|
+
if (state.tokenize) {
|
|
14100
|
+
const result = $TOKEN("InterfaceExtendsClause", state, InterfaceExtendsClause$0(state));
|
|
14101
|
+
if (state.events)
|
|
14102
|
+
state.events.exit?.("InterfaceExtendsClause", state, result, eventData);
|
|
14103
|
+
return result;
|
|
14104
|
+
} else {
|
|
14105
|
+
const result = InterfaceExtendsClause$0(state);
|
|
14106
|
+
if (state.events)
|
|
14107
|
+
state.events.exit?.("InterfaceExtendsClause", state, result, eventData);
|
|
14108
|
+
return result;
|
|
14109
|
+
}
|
|
14110
|
+
}
|
|
14111
|
+
var InterfaceExtendsTarget$0 = ImplementsTarget;
|
|
14112
|
+
function InterfaceExtendsTarget(state) {
|
|
14113
|
+
let eventData;
|
|
14114
|
+
if (state.events) {
|
|
14115
|
+
const result = state.events.enter?.("InterfaceExtendsTarget", state);
|
|
14116
|
+
if (result) {
|
|
14117
|
+
if (result.cache)
|
|
14118
|
+
return result.cache;
|
|
14119
|
+
eventData = result.data;
|
|
14120
|
+
}
|
|
14121
|
+
}
|
|
14122
|
+
if (state.tokenize) {
|
|
14123
|
+
const result = $TOKEN("InterfaceExtendsTarget", state, InterfaceExtendsTarget$0(state));
|
|
14124
|
+
if (state.events)
|
|
14125
|
+
state.events.exit?.("InterfaceExtendsTarget", state, result, eventData);
|
|
14126
|
+
return result;
|
|
14127
|
+
} else {
|
|
14128
|
+
const result = InterfaceExtendsTarget$0(state);
|
|
14129
|
+
if (state.events)
|
|
14130
|
+
state.events.exit?.("InterfaceExtendsTarget", state, result, eventData);
|
|
14131
|
+
return result;
|
|
14132
|
+
}
|
|
14133
|
+
}
|
|
14134
|
+
var TypeKeyword$0 = $S($EXPECT($L161, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
14072
14135
|
function TypeKeyword(state) {
|
|
14073
14136
|
let eventData;
|
|
14074
14137
|
if (state.events) {
|
|
@@ -14091,7 +14154,7 @@ ${input.slice(result.pos)}
|
|
|
14091
14154
|
return result;
|
|
14092
14155
|
}
|
|
14093
14156
|
}
|
|
14094
|
-
var Interface$0 = $S($EXPECT($
|
|
14157
|
+
var Interface$0 = $S($EXPECT($L162, fail, 'Interface "interface"'), NonIdContinue);
|
|
14095
14158
|
function Interface(state) {
|
|
14096
14159
|
let eventData;
|
|
14097
14160
|
if (state.events) {
|
|
@@ -14114,7 +14177,7 @@ ${input.slice(result.pos)}
|
|
|
14114
14177
|
return result;
|
|
14115
14178
|
}
|
|
14116
14179
|
}
|
|
14117
|
-
var Namespace$0 = $S($EXPECT($
|
|
14180
|
+
var Namespace$0 = $S($EXPECT($L163, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
14118
14181
|
function Namespace(state) {
|
|
14119
14182
|
let eventData;
|
|
14120
14183
|
if (state.events) {
|
|
@@ -14339,7 +14402,7 @@ ${input.slice(result.pos)}
|
|
|
14339
14402
|
return result;
|
|
14340
14403
|
}
|
|
14341
14404
|
}
|
|
14342
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R50, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($
|
|
14405
|
+
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)));
|
|
14343
14406
|
function TypeIndexSignature(state) {
|
|
14344
14407
|
let eventData;
|
|
14345
14408
|
if (state.events) {
|
|
@@ -14411,7 +14474,7 @@ ${input.slice(result.pos)}
|
|
|
14411
14474
|
return result;
|
|
14412
14475
|
}
|
|
14413
14476
|
}
|
|
14414
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
14477
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L164, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
14415
14478
|
const children = [...$1, $2];
|
|
14416
14479
|
if ($3)
|
|
14417
14480
|
children.push($3);
|
|
@@ -14444,7 +14507,7 @@ ${input.slice(result.pos)}
|
|
|
14444
14507
|
return result;
|
|
14445
14508
|
}
|
|
14446
14509
|
}
|
|
14447
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
14510
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L75, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
14448
14511
|
if (!$2)
|
|
14449
14512
|
return $1;
|
|
14450
14513
|
return $0;
|
|
@@ -14570,10 +14633,10 @@ ${input.slice(result.pos)}
|
|
|
14570
14633
|
return result;
|
|
14571
14634
|
}
|
|
14572
14635
|
}
|
|
14573
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
14574
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
14575
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
14576
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
14636
|
+
var TypeUnaryOp$0 = $S($EXPECT($L165, fail, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
14637
|
+
var TypeUnaryOp$1 = $S($EXPECT($L146, fail, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
14638
|
+
var TypeUnaryOp$2 = $S($EXPECT($L166, fail, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
14639
|
+
var TypeUnaryOp$3 = $S($EXPECT($L130, fail, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
14577
14640
|
function TypeUnaryOp(state) {
|
|
14578
14641
|
let eventData;
|
|
14579
14642
|
if (state.events) {
|
|
@@ -14622,9 +14685,10 @@ ${input.slice(result.pos)}
|
|
|
14622
14685
|
var TypePrimary$0 = InterfaceBlock;
|
|
14623
14686
|
var TypePrimary$1 = $S(__, OpenParen, Type, __, CloseParen);
|
|
14624
14687
|
var TypePrimary$2 = $S(__, TypeTuple);
|
|
14625
|
-
var TypePrimary$3 = $S($Q(_),
|
|
14626
|
-
var TypePrimary$4 = $S($Q(_),
|
|
14627
|
-
var TypePrimary$5 = $S($Q(_),
|
|
14688
|
+
var TypePrimary$3 = $S($Q(_), ImportType);
|
|
14689
|
+
var TypePrimary$4 = $S($Q(_), FunctionType);
|
|
14690
|
+
var TypePrimary$5 = $S($Q(_), TypeLiteral);
|
|
14691
|
+
var TypePrimary$6 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
14628
14692
|
function TypePrimary(state) {
|
|
14629
14693
|
let eventData;
|
|
14630
14694
|
if (state.events) {
|
|
@@ -14636,17 +14700,41 @@ ${input.slice(result.pos)}
|
|
|
14636
14700
|
}
|
|
14637
14701
|
}
|
|
14638
14702
|
if (state.tokenize) {
|
|
14639
|
-
const result = $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state));
|
|
14703
|
+
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));
|
|
14640
14704
|
if (state.events)
|
|
14641
14705
|
state.events.exit?.("TypePrimary", state, result, eventData);
|
|
14642
14706
|
return result;
|
|
14643
14707
|
} else {
|
|
14644
|
-
const result = TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state);
|
|
14708
|
+
const result = TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state) || TypePrimary$6(state);
|
|
14645
14709
|
if (state.events)
|
|
14646
14710
|
state.events.exit?.("TypePrimary", state, result, eventData);
|
|
14647
14711
|
return result;
|
|
14648
14712
|
}
|
|
14649
14713
|
}
|
|
14714
|
+
var ImportType$0 = $S($EXPECT($L10, fail, 'ImportType "import"'), OpenParen, __, BasicStringLiteral, __, CloseParen, $E($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
14715
|
+
var ImportType$1 = $S($EXPECT($L10, fail, 'ImportType "import"'), InsertOpenParen, Trimmed_, BasicStringLiteral, InsertCloseParen);
|
|
14716
|
+
function ImportType(state) {
|
|
14717
|
+
let eventData;
|
|
14718
|
+
if (state.events) {
|
|
14719
|
+
const result = state.events.enter?.("ImportType", state);
|
|
14720
|
+
if (result) {
|
|
14721
|
+
if (result.cache)
|
|
14722
|
+
return result.cache;
|
|
14723
|
+
eventData = result.data;
|
|
14724
|
+
}
|
|
14725
|
+
}
|
|
14726
|
+
if (state.tokenize) {
|
|
14727
|
+
const result = $TOKEN("ImportType", state, ImportType$0(state) || ImportType$1(state));
|
|
14728
|
+
if (state.events)
|
|
14729
|
+
state.events.exit?.("ImportType", state, result, eventData);
|
|
14730
|
+
return result;
|
|
14731
|
+
} else {
|
|
14732
|
+
const result = ImportType$0(state) || ImportType$1(state);
|
|
14733
|
+
if (state.events)
|
|
14734
|
+
state.events.exit?.("ImportType", state, result, eventData);
|
|
14735
|
+
return result;
|
|
14736
|
+
}
|
|
14737
|
+
}
|
|
14650
14738
|
var TypeTuple$0 = $S(OpenBracket, NestedTypeList, __, CloseBracket);
|
|
14651
14739
|
var TypeTuple$1 = $S(OpenBracket, $E(TypeList), __, CloseBracket);
|
|
14652
14740
|
function TypeTuple(state) {
|
|
@@ -14745,7 +14833,7 @@ ${input.slice(result.pos)}
|
|
|
14745
14833
|
return result;
|
|
14746
14834
|
}
|
|
14747
14835
|
}
|
|
14748
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
14836
|
+
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) {
|
|
14749
14837
|
if ($2)
|
|
14750
14838
|
return $0;
|
|
14751
14839
|
return $1;
|
|
@@ -14774,10 +14862,10 @@ ${input.slice(result.pos)}
|
|
|
14774
14862
|
}
|
|
14775
14863
|
var TypeLiteral$0 = Literal;
|
|
14776
14864
|
var TypeLiteral$1 = TemplateLiteral;
|
|
14777
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
14865
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L150, fail, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14778
14866
|
return { $loc, token: "void" };
|
|
14779
14867
|
});
|
|
14780
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
14868
|
+
var TypeLiteral$3 = $TV($EXPECT($L167, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
14781
14869
|
return { $loc, token: "[]" };
|
|
14782
14870
|
});
|
|
14783
14871
|
function TypeLiteral(state) {
|
|
@@ -14802,10 +14890,10 @@ ${input.slice(result.pos)}
|
|
|
14802
14890
|
return result;
|
|
14803
14891
|
}
|
|
14804
14892
|
}
|
|
14805
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
14893
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L78, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
14806
14894
|
return { $loc, token: "|" };
|
|
14807
14895
|
});
|
|
14808
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
14896
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L76, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
14809
14897
|
return { $loc, token: "&" };
|
|
14810
14898
|
});
|
|
14811
14899
|
function TypeBinaryOp(state) {
|
|
@@ -14830,7 +14918,13 @@ ${input.slice(result.pos)}
|
|
|
14830
14918
|
return result;
|
|
14831
14919
|
}
|
|
14832
14920
|
}
|
|
14833
|
-
var FunctionType$0 = $S(Parameters, __, $EXPECT($
|
|
14921
|
+
var FunctionType$0 = $TS($S(Parameters, __, $EXPECT($L5, fail, 'FunctionType "=>"'), $E(Type)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
14922
|
+
var type = $4;
|
|
14923
|
+
if (type) {
|
|
14924
|
+
return $0;
|
|
14925
|
+
}
|
|
14926
|
+
return [...$0, "void"];
|
|
14927
|
+
});
|
|
14834
14928
|
function FunctionType(state) {
|
|
14835
14929
|
let eventData;
|
|
14836
14930
|
if (state.events) {
|
|
@@ -14853,7 +14947,7 @@ ${input.slice(result.pos)}
|
|
|
14853
14947
|
return result;
|
|
14854
14948
|
}
|
|
14855
14949
|
}
|
|
14856
|
-
var TypeArguments$0 = $TS($S(
|
|
14950
|
+
var TypeArguments$0 = $TS($S($EXPECT($L122, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L26, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
14857
14951
|
return { ts: true, children: $0 };
|
|
14858
14952
|
});
|
|
14859
14953
|
function TypeArguments(state) {
|
|
@@ -14878,103 +14972,6 @@ ${input.slice(result.pos)}
|
|
|
14878
14972
|
return result;
|
|
14879
14973
|
}
|
|
14880
14974
|
}
|
|
14881
|
-
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) {
|
|
14882
|
-
return { ts: true, children: $0 };
|
|
14883
|
-
});
|
|
14884
|
-
function InlineTypeArguments(state) {
|
|
14885
|
-
let eventData;
|
|
14886
|
-
if (state.events) {
|
|
14887
|
-
const result = state.events.enter?.("InlineTypeArguments", state);
|
|
14888
|
-
if (result) {
|
|
14889
|
-
if (result.cache)
|
|
14890
|
-
return result.cache;
|
|
14891
|
-
eventData = result.data;
|
|
14892
|
-
}
|
|
14893
|
-
}
|
|
14894
|
-
if (state.tokenize) {
|
|
14895
|
-
const result = $TOKEN("InlineTypeArguments", state, InlineTypeArguments$0(state));
|
|
14896
|
-
if (state.events)
|
|
14897
|
-
state.events.exit?.("InlineTypeArguments", state, result, eventData);
|
|
14898
|
-
return result;
|
|
14899
|
-
} else {
|
|
14900
|
-
const result = InlineTypeArguments$0(state);
|
|
14901
|
-
if (state.events)
|
|
14902
|
-
state.events.exit?.("InlineTypeArguments", state, result, eventData);
|
|
14903
|
-
return result;
|
|
14904
|
-
}
|
|
14905
|
-
}
|
|
14906
|
-
var InlineTypeArgument$0 = $S($Q(_), Type, InlineTypeArgumentDelimiter);
|
|
14907
|
-
function InlineTypeArgument(state) {
|
|
14908
|
-
let eventData;
|
|
14909
|
-
if (state.events) {
|
|
14910
|
-
const result = state.events.enter?.("InlineTypeArgument", state);
|
|
14911
|
-
if (result) {
|
|
14912
|
-
if (result.cache)
|
|
14913
|
-
return result.cache;
|
|
14914
|
-
eventData = result.data;
|
|
14915
|
-
}
|
|
14916
|
-
}
|
|
14917
|
-
if (state.tokenize) {
|
|
14918
|
-
const result = $TOKEN("InlineTypeArgument", state, InlineTypeArgument$0(state));
|
|
14919
|
-
if (state.events)
|
|
14920
|
-
state.events.exit?.("InlineTypeArgument", state, result, eventData);
|
|
14921
|
-
return result;
|
|
14922
|
-
} else {
|
|
14923
|
-
const result = InlineTypeArgument$0(state);
|
|
14924
|
-
if (state.events)
|
|
14925
|
-
state.events.exit?.("InlineTypeArgument", state, result, eventData);
|
|
14926
|
-
return result;
|
|
14927
|
-
}
|
|
14928
|
-
}
|
|
14929
|
-
var InlineTypeArgumentDelimiter$0 = $S($Q(_), Comma);
|
|
14930
|
-
var InlineTypeArgumentDelimiter$1 = $Y($S($Q(_), $EXPECT($L25, fail, 'InlineTypeArgumentDelimiter ">"')));
|
|
14931
|
-
function InlineTypeArgumentDelimiter(state) {
|
|
14932
|
-
let eventData;
|
|
14933
|
-
if (state.events) {
|
|
14934
|
-
const result = state.events.enter?.("InlineTypeArgumentDelimiter", state);
|
|
14935
|
-
if (result) {
|
|
14936
|
-
if (result.cache)
|
|
14937
|
-
return result.cache;
|
|
14938
|
-
eventData = result.data;
|
|
14939
|
-
}
|
|
14940
|
-
}
|
|
14941
|
-
if (state.tokenize) {
|
|
14942
|
-
const result = $TOKEN("InlineTypeArgumentDelimiter", state, InlineTypeArgumentDelimiter$0(state) || InlineTypeArgumentDelimiter$1(state));
|
|
14943
|
-
if (state.events)
|
|
14944
|
-
state.events.exit?.("InlineTypeArgumentDelimiter", state, result, eventData);
|
|
14945
|
-
return result;
|
|
14946
|
-
} else {
|
|
14947
|
-
const result = InlineTypeArgumentDelimiter$0(state) || InlineTypeArgumentDelimiter$1(state);
|
|
14948
|
-
if (state.events)
|
|
14949
|
-
state.events.exit?.("InlineTypeArgumentDelimiter", state, result, eventData);
|
|
14950
|
-
return result;
|
|
14951
|
-
}
|
|
14952
|
-
}
|
|
14953
|
-
var CompactTypeArguments$0 = $TS($S($EXPECT($L120, fail, 'CompactTypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L25, fail, 'CompactTypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
14954
|
-
return { ts: true, children: $0 };
|
|
14955
|
-
});
|
|
14956
|
-
function CompactTypeArguments(state) {
|
|
14957
|
-
let eventData;
|
|
14958
|
-
if (state.events) {
|
|
14959
|
-
const result = state.events.enter?.("CompactTypeArguments", state);
|
|
14960
|
-
if (result) {
|
|
14961
|
-
if (result.cache)
|
|
14962
|
-
return result.cache;
|
|
14963
|
-
eventData = result.data;
|
|
14964
|
-
}
|
|
14965
|
-
}
|
|
14966
|
-
if (state.tokenize) {
|
|
14967
|
-
const result = $TOKEN("CompactTypeArguments", state, CompactTypeArguments$0(state));
|
|
14968
|
-
if (state.events)
|
|
14969
|
-
state.events.exit?.("CompactTypeArguments", state, result, eventData);
|
|
14970
|
-
return result;
|
|
14971
|
-
} else {
|
|
14972
|
-
const result = CompactTypeArguments$0(state);
|
|
14973
|
-
if (state.events)
|
|
14974
|
-
state.events.exit?.("CompactTypeArguments", state, result, eventData);
|
|
14975
|
-
return result;
|
|
14976
|
-
}
|
|
14977
|
-
}
|
|
14978
14975
|
var TypeArgument$0 = $S(__, Type, TypeArgumentDelimiter);
|
|
14979
14976
|
function TypeArgument(state) {
|
|
14980
14977
|
let eventData;
|
|
@@ -15021,7 +15018,7 @@ ${input.slice(result.pos)}
|
|
|
15021
15018
|
return result;
|
|
15022
15019
|
}
|
|
15023
15020
|
}
|
|
15024
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
15021
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L122, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L26, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
15025
15022
|
var parameters = $3;
|
|
15026
15023
|
return {
|
|
15027
15024
|
type: "TypeParameters",
|
|
@@ -15075,7 +15072,7 @@ ${input.slice(result.pos)}
|
|
|
15075
15072
|
return result;
|
|
15076
15073
|
}
|
|
15077
15074
|
}
|
|
15078
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
15075
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L111, fail, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
15079
15076
|
function TypeConstraint(state) {
|
|
15080
15077
|
let eventData;
|
|
15081
15078
|
if (state.events) {
|
|
@@ -15098,7 +15095,7 @@ ${input.slice(result.pos)}
|
|
|
15098
15095
|
return result;
|
|
15099
15096
|
}
|
|
15100
15097
|
}
|
|
15101
|
-
var TypeInitializer$0 = $S(__, $EXPECT($
|
|
15098
|
+
var TypeInitializer$0 = $S(__, $EXPECT($L25, fail, 'TypeInitializer "="'), Type);
|
|
15102
15099
|
function TypeInitializer(state) {
|
|
15103
15100
|
let eventData;
|
|
15104
15101
|
if (state.events) {
|
|
@@ -15122,7 +15119,7 @@ ${input.slice(result.pos)}
|
|
|
15122
15119
|
}
|
|
15123
15120
|
}
|
|
15124
15121
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
15125
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
15122
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'TypeParameterDelimiter ">"')));
|
|
15126
15123
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
15127
15124
|
return value[1];
|
|
15128
15125
|
});
|
|
@@ -15201,7 +15198,7 @@ ${input.slice(result.pos)}
|
|
|
15201
15198
|
return result;
|
|
15202
15199
|
}
|
|
15203
15200
|
}
|
|
15204
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
15201
|
+
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) {
|
|
15205
15202
|
var options = $3;
|
|
15206
15203
|
return {
|
|
15207
15204
|
type: "CivetPrologue",
|
|
@@ -15362,7 +15359,7 @@ ${input.slice(result.pos)}
|
|
|
15362
15359
|
return result;
|
|
15363
15360
|
}
|
|
15364
15361
|
}
|
|
15365
|
-
var Debugger$0 = $TV($EXPECT($
|
|
15362
|
+
var Debugger$0 = $TV($EXPECT($L1, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
15366
15363
|
debugger;
|
|
15367
15364
|
});
|
|
15368
15365
|
function Debugger(state) {
|
|
@@ -15387,7 +15384,7 @@ ${input.slice(result.pos)}
|
|
|
15387
15384
|
return result;
|
|
15388
15385
|
}
|
|
15389
15386
|
}
|
|
15390
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
15387
|
+
var InsertOpenParen$0 = $TV($EXPECT($L1, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
15391
15388
|
return { $loc, token: "(" };
|
|
15392
15389
|
});
|
|
15393
15390
|
function InsertOpenParen(state) {
|
|
@@ -15412,7 +15409,7 @@ ${input.slice(result.pos)}
|
|
|
15412
15409
|
return result;
|
|
15413
15410
|
}
|
|
15414
15411
|
}
|
|
15415
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
15412
|
+
var InsertCloseParen$0 = $TV($EXPECT($L1, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
15416
15413
|
return { $loc, token: ")" };
|
|
15417
15414
|
});
|
|
15418
15415
|
function InsertCloseParen(state) {
|
|
@@ -15437,7 +15434,7 @@ ${input.slice(result.pos)}
|
|
|
15437
15434
|
return result;
|
|
15438
15435
|
}
|
|
15439
15436
|
}
|
|
15440
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
15437
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L1, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
15441
15438
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
15442
15439
|
});
|
|
15443
15440
|
function InsertOpenBrace(state) {
|
|
@@ -15462,7 +15459,7 @@ ${input.slice(result.pos)}
|
|
|
15462
15459
|
return result;
|
|
15463
15460
|
}
|
|
15464
15461
|
}
|
|
15465
|
-
var InsertInlineOpenBrace$0 = $TV($EXPECT($
|
|
15462
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L1, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
15466
15463
|
return { $loc, token: "{" };
|
|
15467
15464
|
});
|
|
15468
15465
|
function InsertInlineOpenBrace(state) {
|
|
@@ -15487,7 +15484,7 @@ ${input.slice(result.pos)}
|
|
|
15487
15484
|
return result;
|
|
15488
15485
|
}
|
|
15489
15486
|
}
|
|
15490
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
15487
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L1, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
15491
15488
|
return { $loc, token: "}" };
|
|
15492
15489
|
});
|
|
15493
15490
|
function InsertCloseBrace(state) {
|
|
@@ -15512,7 +15509,7 @@ ${input.slice(result.pos)}
|
|
|
15512
15509
|
return result;
|
|
15513
15510
|
}
|
|
15514
15511
|
}
|
|
15515
|
-
var InsertComma$0 = $TV($EXPECT($
|
|
15512
|
+
var InsertComma$0 = $TV($EXPECT($L1, fail, 'InsertComma ""'), function($skip, $loc, $0, $1) {
|
|
15516
15513
|
return { $loc, token: "," };
|
|
15517
15514
|
});
|
|
15518
15515
|
function InsertComma(state) {
|
|
@@ -15537,7 +15534,7 @@ ${input.slice(result.pos)}
|
|
|
15537
15534
|
return result;
|
|
15538
15535
|
}
|
|
15539
15536
|
}
|
|
15540
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
15537
|
+
var InsertConst$0 = $TV($EXPECT($L1, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
15541
15538
|
return { $loc, token: "const " };
|
|
15542
15539
|
});
|
|
15543
15540
|
function InsertConst(state) {
|
|
@@ -15562,7 +15559,7 @@ ${input.slice(result.pos)}
|
|
|
15562
15559
|
return result;
|
|
15563
15560
|
}
|
|
15564
15561
|
}
|
|
15565
|
-
var InsertLet$0 = $TV($EXPECT($
|
|
15562
|
+
var InsertLet$0 = $TV($EXPECT($L1, fail, 'InsertLet ""'), function($skip, $loc, $0, $1) {
|
|
15566
15563
|
return { $loc, token: "let " };
|
|
15567
15564
|
});
|
|
15568
15565
|
function InsertLet(state) {
|
|
@@ -15587,7 +15584,7 @@ ${input.slice(result.pos)}
|
|
|
15587
15584
|
return result;
|
|
15588
15585
|
}
|
|
15589
15586
|
}
|
|
15590
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
15587
|
+
var InsertReadonly$0 = $TV($EXPECT($L1, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
15591
15588
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
15592
15589
|
});
|
|
15593
15590
|
function InsertReadonly(state) {
|
|
@@ -15612,7 +15609,7 @@ ${input.slice(result.pos)}
|
|
|
15612
15609
|
return result;
|
|
15613
15610
|
}
|
|
15614
15611
|
}
|
|
15615
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
15612
|
+
var InsertNewline$0 = $TV($EXPECT($L1, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
15616
15613
|
return "\n";
|
|
15617
15614
|
});
|
|
15618
15615
|
function InsertNewline(state) {
|
|
@@ -15637,7 +15634,7 @@ ${input.slice(result.pos)}
|
|
|
15637
15634
|
return result;
|
|
15638
15635
|
}
|
|
15639
15636
|
}
|
|
15640
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
15637
|
+
var InsertIndent$0 = $TV($EXPECT($L1, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
15641
15638
|
return module2.currentIndent.token;
|
|
15642
15639
|
});
|
|
15643
15640
|
function InsertIndent(state) {
|
|
@@ -15662,7 +15659,7 @@ ${input.slice(result.pos)}
|
|
|
15662
15659
|
return result;
|
|
15663
15660
|
}
|
|
15664
15661
|
}
|
|
15665
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
15662
|
+
var InsertSpace$0 = $TV($EXPECT($L1, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
15666
15663
|
return { $loc, token: " " };
|
|
15667
15664
|
});
|
|
15668
15665
|
function InsertSpace(state) {
|
|
@@ -15687,7 +15684,7 @@ ${input.slice(result.pos)}
|
|
|
15687
15684
|
return result;
|
|
15688
15685
|
}
|
|
15689
15686
|
}
|
|
15690
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
15687
|
+
var InsertDot$0 = $TV($EXPECT($L1, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
15691
15688
|
return { $loc, token: "." };
|
|
15692
15689
|
});
|
|
15693
15690
|
function InsertDot(state) {
|
|
@@ -15712,7 +15709,7 @@ ${input.slice(result.pos)}
|
|
|
15712
15709
|
return result;
|
|
15713
15710
|
}
|
|
15714
15711
|
}
|
|
15715
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
15712
|
+
var InsertBreak$0 = $TV($EXPECT($L1, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
15716
15713
|
return { $loc, token: ";break;" };
|
|
15717
15714
|
});
|
|
15718
15715
|
function InsertBreak(state) {
|
|
@@ -15737,7 +15734,7 @@ ${input.slice(result.pos)}
|
|
|
15737
15734
|
return result;
|
|
15738
15735
|
}
|
|
15739
15736
|
}
|
|
15740
|
-
var InsertVar$0 = $TV($EXPECT($
|
|
15737
|
+
var InsertVar$0 = $TV($EXPECT($L1, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
15741
15738
|
return { $loc, token: "var " };
|
|
15742
15739
|
});
|
|
15743
15740
|
function InsertVar(state) {
|
|
@@ -15762,7 +15759,7 @@ ${input.slice(result.pos)}
|
|
|
15762
15759
|
return result;
|
|
15763
15760
|
}
|
|
15764
15761
|
}
|
|
15765
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
15762
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15766
15763
|
if (module2.config.coffeeBinaryExistential)
|
|
15767
15764
|
return;
|
|
15768
15765
|
return $skip;
|
|
@@ -15789,7 +15786,7 @@ ${input.slice(result.pos)}
|
|
|
15789
15786
|
return result;
|
|
15790
15787
|
}
|
|
15791
15788
|
}
|
|
15792
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
15789
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15793
15790
|
if (module2.config.coffeeBooleans)
|
|
15794
15791
|
return;
|
|
15795
15792
|
return $skip;
|
|
@@ -15816,7 +15813,7 @@ ${input.slice(result.pos)}
|
|
|
15816
15813
|
return result;
|
|
15817
15814
|
}
|
|
15818
15815
|
}
|
|
15819
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
15816
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15820
15817
|
if (module2.config.coffeeClasses)
|
|
15821
15818
|
return;
|
|
15822
15819
|
return $skip;
|
|
@@ -15843,7 +15840,7 @@ ${input.slice(result.pos)}
|
|
|
15843
15840
|
return result;
|
|
15844
15841
|
}
|
|
15845
15842
|
}
|
|
15846
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
15843
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15847
15844
|
if (module2.config.coffeeComment)
|
|
15848
15845
|
return;
|
|
15849
15846
|
return $skip;
|
|
@@ -15870,7 +15867,7 @@ ${input.slice(result.pos)}
|
|
|
15870
15867
|
return result;
|
|
15871
15868
|
}
|
|
15872
15869
|
}
|
|
15873
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
15870
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15874
15871
|
if (module2.config.coffeeDo)
|
|
15875
15872
|
return;
|
|
15876
15873
|
return $skip;
|
|
@@ -15897,7 +15894,7 @@ ${input.slice(result.pos)}
|
|
|
15897
15894
|
return result;
|
|
15898
15895
|
}
|
|
15899
15896
|
}
|
|
15900
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
15897
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15901
15898
|
if (module2.config.coffeeForLoops)
|
|
15902
15899
|
return;
|
|
15903
15900
|
return $skip;
|
|
@@ -15924,7 +15921,7 @@ ${input.slice(result.pos)}
|
|
|
15924
15921
|
return result;
|
|
15925
15922
|
}
|
|
15926
15923
|
}
|
|
15927
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
15924
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15928
15925
|
if (module2.config.coffeeInterpolation)
|
|
15929
15926
|
return;
|
|
15930
15927
|
return $skip;
|
|
@@ -15951,7 +15948,7 @@ ${input.slice(result.pos)}
|
|
|
15951
15948
|
return result;
|
|
15952
15949
|
}
|
|
15953
15950
|
}
|
|
15954
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
15951
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15955
15952
|
if (module2.config.coffeeIsnt)
|
|
15956
15953
|
return;
|
|
15957
15954
|
return $skip;
|
|
@@ -15978,7 +15975,7 @@ ${input.slice(result.pos)}
|
|
|
15978
15975
|
return result;
|
|
15979
15976
|
}
|
|
15980
15977
|
}
|
|
15981
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
15978
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
15982
15979
|
if (module2.config.coffeeLineContinuation)
|
|
15983
15980
|
return;
|
|
15984
15981
|
return $skip;
|
|
@@ -16005,7 +16002,7 @@ ${input.slice(result.pos)}
|
|
|
16005
16002
|
return result;
|
|
16006
16003
|
}
|
|
16007
16004
|
}
|
|
16008
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
16005
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
16009
16006
|
if (module2.config.coffeeNot)
|
|
16010
16007
|
return;
|
|
16011
16008
|
return $skip;
|
|
@@ -16032,7 +16029,7 @@ ${input.slice(result.pos)}
|
|
|
16032
16029
|
return result;
|
|
16033
16030
|
}
|
|
16034
16031
|
}
|
|
16035
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
16032
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
16036
16033
|
if (module2.config.coffeeOf)
|
|
16037
16034
|
return;
|
|
16038
16035
|
return $skip;
|
|
@@ -16059,7 +16056,7 @@ ${input.slice(result.pos)}
|
|
|
16059
16056
|
return result;
|
|
16060
16057
|
}
|
|
16061
16058
|
}
|
|
16062
|
-
var CoffeePrototypeEnabled$0 = $TV($EXPECT($
|
|
16059
|
+
var CoffeePrototypeEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
|
|
16063
16060
|
if (module2.config.coffeePrototype)
|
|
16064
16061
|
return;
|
|
16065
16062
|
return $skip;
|
|
@@ -16086,7 +16083,7 @@ ${input.slice(result.pos)}
|
|
|
16086
16083
|
return result;
|
|
16087
16084
|
}
|
|
16088
16085
|
}
|
|
16089
|
-
var Reset$0 = $TV($EXPECT($
|
|
16086
|
+
var Reset$0 = $TV($EXPECT($L1, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
16090
16087
|
module2.indentLevels = [{
|
|
16091
16088
|
level: 0,
|
|
16092
16089
|
token: ""
|
|
@@ -16152,6 +16149,16 @@ ${input.slice(result.pos)}
|
|
|
16152
16149
|
};
|
|
16153
16150
|
module2.prelude.push(["", ["const ", moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b", "\n"]]);
|
|
16154
16151
|
},
|
|
16152
|
+
returnSymbol(ref) {
|
|
16153
|
+
module2.prelude.push({
|
|
16154
|
+
children: [
|
|
16155
|
+
"const ",
|
|
16156
|
+
ref,
|
|
16157
|
+
` = Symbol("return")';
|
|
16158
|
+
`
|
|
16159
|
+
]
|
|
16160
|
+
});
|
|
16161
|
+
},
|
|
16155
16162
|
JSX(jsxRef) {
|
|
16156
16163
|
module2.prelude.push({
|
|
16157
16164
|
ts: true,
|
|
@@ -16324,7 +16331,7 @@ ${input.slice(result.pos)}
|
|
|
16324
16331
|
return result;
|
|
16325
16332
|
}
|
|
16326
16333
|
}
|
|
16327
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
16334
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
16328
16335
|
var directives = $2;
|
|
16329
16336
|
directives.forEach((directive) => {
|
|
16330
16337
|
if (directive.type === "CivetPrologue") {
|
|
@@ -16448,35 +16455,19 @@ ${input.slice(result.pos)}
|
|
|
16448
16455
|
if (!node)
|
|
16449
16456
|
return;
|
|
16450
16457
|
switch (node.type) {
|
|
16451
|
-
case "AssignmentExpression":
|
|
16452
|
-
node.children.unshift(ref, ".push(");
|
|
16453
|
-
node.children.push(")");
|
|
16454
|
-
return;
|
|
16455
|
-
case "Identifier":
|
|
16456
|
-
node.children.unshift(ref, ".push(");
|
|
16457
|
-
node.children.push(")");
|
|
16458
|
-
return;
|
|
16459
16458
|
case "BlockStatement":
|
|
16460
16459
|
insertPush(node.expressions[node.expressions.length - 1], ref);
|
|
16461
16460
|
return;
|
|
16462
|
-
case "ObjectBindingPattern":
|
|
16463
|
-
case "ObjectExpression":
|
|
16464
|
-
module2.insertTrimmingSpace(node.children[0], "");
|
|
16465
|
-
node.children.unshift(ref, ".push(");
|
|
16466
|
-
node.children.push(")");
|
|
16467
|
-
return;
|
|
16468
16461
|
case "CaseBlock":
|
|
16469
16462
|
node.clauses.forEach((clause) => {
|
|
16470
16463
|
insertPush(clause, ref);
|
|
16471
16464
|
});
|
|
16472
16465
|
return;
|
|
16473
|
-
case "CaseClause":
|
|
16474
|
-
return;
|
|
16475
16466
|
case "WhenClause":
|
|
16476
|
-
insertPush(node.
|
|
16467
|
+
insertPush(node.block, ref);
|
|
16477
16468
|
return;
|
|
16478
16469
|
case "DefaultClause":
|
|
16479
|
-
insertPush(node.
|
|
16470
|
+
insertPush(node.block, ref);
|
|
16480
16471
|
return;
|
|
16481
16472
|
}
|
|
16482
16473
|
if (!Array.isArray(node))
|
|
@@ -16522,41 +16513,42 @@ ${input.slice(result.pos)}
|
|
|
16522
16513
|
node.splice(1, 0, ref, ".push(");
|
|
16523
16514
|
node.push(")");
|
|
16524
16515
|
}
|
|
16516
|
+
function wrapWithReturn(expression) {
|
|
16517
|
+
const children = expression ? ["return ", expression] : ["return"];
|
|
16518
|
+
return {
|
|
16519
|
+
type: "ReturnStatement",
|
|
16520
|
+
children
|
|
16521
|
+
};
|
|
16522
|
+
}
|
|
16523
|
+
function insertSwitchReturns(exp) {
|
|
16524
|
+
switch (exp.type) {
|
|
16525
|
+
case "SwitchStatement":
|
|
16526
|
+
exp.caseBlock.clauses.forEach((clause) => {
|
|
16527
|
+
insertReturn(clause);
|
|
16528
|
+
});
|
|
16529
|
+
return;
|
|
16530
|
+
case "SwitchExpression":
|
|
16531
|
+
exp.caseBlock.clauses.forEach(insertReturn);
|
|
16532
|
+
return;
|
|
16533
|
+
}
|
|
16534
|
+
}
|
|
16525
16535
|
function insertReturn(node) {
|
|
16526
16536
|
if (!node)
|
|
16527
16537
|
return;
|
|
16528
16538
|
switch (node.type) {
|
|
16529
|
-
case "AssignmentExpression":
|
|
16530
|
-
node.children.unshift("return ");
|
|
16531
|
-
return;
|
|
16532
|
-
case "Identifier":
|
|
16533
|
-
node.children.unshift("return ");
|
|
16534
|
-
return;
|
|
16535
16539
|
case "BlockStatement":
|
|
16536
16540
|
insertReturn(node.expressions[node.expressions.length - 1]);
|
|
16537
16541
|
return;
|
|
16538
|
-
case "ObjectBindingPattern":
|
|
16539
|
-
case "ObjectExpression":
|
|
16540
|
-
module2.insertTrimmingSpace(node.children[0], "");
|
|
16541
|
-
node.children.unshift("return ");
|
|
16542
|
-
return;
|
|
16543
|
-
case "CaseBlock":
|
|
16544
|
-
node.clauses.forEach((clause) => {
|
|
16545
|
-
insertReturn(clause);
|
|
16546
|
-
});
|
|
16547
|
-
return;
|
|
16548
|
-
case "CaseClause":
|
|
16549
|
-
return;
|
|
16550
16542
|
case "WhenClause":
|
|
16551
16543
|
node.children.splice(node.children.indexOf(node.break), 1);
|
|
16552
|
-
if (node.
|
|
16553
|
-
node.
|
|
16544
|
+
if (node.block.length === 0) {
|
|
16545
|
+
node.block.push(wrapWithReturn());
|
|
16554
16546
|
return;
|
|
16555
16547
|
}
|
|
16556
|
-
insertReturn(node.
|
|
16548
|
+
insertReturn(node.block);
|
|
16557
16549
|
return;
|
|
16558
16550
|
case "DefaultClause":
|
|
16559
|
-
insertReturn(node.
|
|
16551
|
+
insertReturn(node.block);
|
|
16560
16552
|
return;
|
|
16561
16553
|
}
|
|
16562
16554
|
if (!Array.isArray(node))
|
|
@@ -16588,10 +16580,10 @@ ${input.slice(result.pos)}
|
|
|
16588
16580
|
if (exp.children[3])
|
|
16589
16581
|
insertReturn(exp.children[3][2]);
|
|
16590
16582
|
else
|
|
16591
|
-
exp.children.push(["\n", indent,
|
|
16583
|
+
exp.children.push(["\n", indent, wrapWithReturn()]);
|
|
16592
16584
|
return;
|
|
16593
16585
|
case "SwitchStatement":
|
|
16594
|
-
|
|
16586
|
+
insertSwitchReturns(exp);
|
|
16595
16587
|
return;
|
|
16596
16588
|
case "TryStatement":
|
|
16597
16589
|
insertReturn(exp.children[1]);
|
|
@@ -16601,7 +16593,8 @@ ${input.slice(result.pos)}
|
|
|
16601
16593
|
}
|
|
16602
16594
|
if (node[node.length - 1]?.type === "SemicolonDelimiter")
|
|
16603
16595
|
return;
|
|
16604
|
-
|
|
16596
|
+
const returnStatement = wrapWithReturn(node[1]);
|
|
16597
|
+
node.splice(1, 1, returnStatement);
|
|
16605
16598
|
}
|
|
16606
16599
|
module2.makeLeftHandSideExpression = function(exp) {
|
|
16607
16600
|
switch (exp.type) {
|
|
@@ -16954,9 +16947,7 @@ ${input.slice(result.pos)}
|
|
|
16954
16947
|
}
|
|
16955
16948
|
function processSwitchExpressions(statements) {
|
|
16956
16949
|
if (module2.config.implicitReturns) {
|
|
16957
|
-
gatherRecursiveAll(statements, (n) => n.type === "SwitchExpression").forEach(
|
|
16958
|
-
insertReturn(block);
|
|
16959
|
-
});
|
|
16950
|
+
gatherRecursiveAll(statements, (n) => n.type === "SwitchExpression").forEach(insertSwitchReturns);
|
|
16960
16951
|
}
|
|
16961
16952
|
}
|
|
16962
16953
|
function processTryExpressions(statements) {
|
|
@@ -17191,6 +17182,7 @@ ${input.slice(result.pos)}
|
|
|
17191
17182
|
indent = indent[indent.length - 1];
|
|
17192
17183
|
statements.unshift([indent, "var ", varIds.join(", "), "\n"]);
|
|
17193
17184
|
}
|
|
17185
|
+
scopes.pop();
|
|
17194
17186
|
}
|
|
17195
17187
|
function createLetDecs(statements, scopes) {
|
|
17196
17188
|
function hasDec(name) {
|
|
@@ -17473,7 +17465,7 @@ ${input.slice(result.pos)}
|
|
|
17473
17465
|
return result;
|
|
17474
17466
|
}
|
|
17475
17467
|
}
|
|
17476
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
17468
|
+
var PopIndent$0 = $TV($EXPECT($L1, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
17477
17469
|
if (module2.config.verbose) {
|
|
17478
17470
|
console.log("popping indent", module2.indentLevels[module2.indentLevels.length - 1], "->", module2.indentLevels[module2.indentLevels.length - 2]);
|
|
17479
17471
|
}
|