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