@danielx/civet 0.5.10 → 0.5.12
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/README.md +3 -0
- package/dist/browser.js +736 -435
- package/dist/main.js +736 -435
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -479,6 +479,8 @@ ${input.slice(result.pos)}
|
|
|
479
479
|
Program,
|
|
480
480
|
TopLevelStatement,
|
|
481
481
|
ExtendedExpression,
|
|
482
|
+
NonPipelineExtendedExpression,
|
|
483
|
+
NonAssignmentExtendedExpression,
|
|
482
484
|
ExpressionizedStatement,
|
|
483
485
|
Expression,
|
|
484
486
|
Arguments,
|
|
@@ -500,6 +502,8 @@ ${input.slice(result.pos)}
|
|
|
500
502
|
UpdateExpression,
|
|
501
503
|
UpdateExpressionSymbol,
|
|
502
504
|
AssignmentExpression,
|
|
505
|
+
NonPipelineAssignmentExpression,
|
|
506
|
+
SingleLineAssignmentExpression,
|
|
503
507
|
AssignmentExpressionTail,
|
|
504
508
|
ActualAssignment,
|
|
505
509
|
YieldExpression,
|
|
@@ -512,6 +516,9 @@ ${input.slice(result.pos)}
|
|
|
512
516
|
TernaryRest,
|
|
513
517
|
NestedTernaryRest,
|
|
514
518
|
ShortCircuitExpression,
|
|
519
|
+
PipelineExpression,
|
|
520
|
+
PipelineHeadItem,
|
|
521
|
+
PipelineTailItem,
|
|
515
522
|
PrimaryExpression,
|
|
516
523
|
ParenthesizedExpression,
|
|
517
524
|
ClassDeclaration,
|
|
@@ -529,9 +536,6 @@ ${input.slice(result.pos)}
|
|
|
529
536
|
ClassElement,
|
|
530
537
|
ClassElementDefinition,
|
|
531
538
|
AccessModifier,
|
|
532
|
-
Public,
|
|
533
|
-
Private,
|
|
534
|
-
Protected,
|
|
535
539
|
FieldDefinition,
|
|
536
540
|
ThisLiteral,
|
|
537
541
|
LeftHandSideExpression,
|
|
@@ -772,6 +776,7 @@ ${input.slice(result.pos)}
|
|
|
772
776
|
StatementDelimiter,
|
|
773
777
|
NonIdContinue,
|
|
774
778
|
Loc,
|
|
779
|
+
Abstract,
|
|
775
780
|
Ampersand,
|
|
776
781
|
As,
|
|
777
782
|
At,
|
|
@@ -815,7 +820,12 @@ ${input.slice(result.pos)}
|
|
|
815
820
|
OpenBrace,
|
|
816
821
|
OpenBracket,
|
|
817
822
|
OpenParen,
|
|
823
|
+
Public,
|
|
824
|
+
Private,
|
|
825
|
+
Protected,
|
|
826
|
+
Pipe,
|
|
818
827
|
QuestionMark,
|
|
828
|
+
Readonly,
|
|
819
829
|
Return,
|
|
820
830
|
Satisfies,
|
|
821
831
|
Semicolon,
|
|
@@ -967,162 +977,164 @@ ${input.slice(result.pos)}
|
|
|
967
977
|
var $L5 = $L("<");
|
|
968
978
|
var $L6 = $L("extends");
|
|
969
979
|
var $L7 = $L("implements");
|
|
970
|
-
var $L8 = $L("
|
|
971
|
-
var $L9 = $L("
|
|
972
|
-
var $L10 = $L("
|
|
973
|
-
var $L11 = $L("
|
|
974
|
-
var $L12 = $L("
|
|
975
|
-
var $L13 = $L("super");
|
|
976
|
-
var $L14 = $L("import");
|
|
977
|
-
var $L15 = $L("
|
|
978
|
-
var $L16 = $L("
|
|
979
|
-
var $L17 = $L("
|
|
980
|
-
var $L18 = $L("
|
|
981
|
-
var $L19 = $L("
|
|
982
|
-
var $L20 = $L("
|
|
983
|
-
var $L21 = $L("
|
|
984
|
-
var $L22 = $L("
|
|
985
|
-
var $L23 = $L("
|
|
986
|
-
var $L24 = $L("
|
|
987
|
-
var $L25 = $L("
|
|
988
|
-
var $L26 = $L("
|
|
989
|
-
var $L27 = $L("
|
|
990
|
-
var $L28 = $L("
|
|
991
|
-
var $L29 = $L("
|
|
992
|
-
var $L30 = $L("
|
|
993
|
-
var $L31 = $L("
|
|
994
|
-
var $L32 = $L("
|
|
995
|
-
var $L33 = $L("
|
|
996
|
-
var $L34 = $L("
|
|
997
|
-
var $L35 = $L("
|
|
998
|
-
var $L36 = $L("
|
|
999
|
-
var $L37 = $L("
|
|
1000
|
-
var $L38 = $L("
|
|
1001
|
-
var $L39 = $L("
|
|
1002
|
-
var $L40 = $L("
|
|
1003
|
-
var $L41 = $L("
|
|
1004
|
-
var $L42 = $L("
|
|
1005
|
-
var $L43 = $L("
|
|
1006
|
-
var $L44 = $L("
|
|
1007
|
-
var $L45 = $L("
|
|
1008
|
-
var $L46 = $L("
|
|
1009
|
-
var $L47 = $L("
|
|
1010
|
-
var $L48 = $L("
|
|
1011
|
-
var $L49 = $L("
|
|
1012
|
-
var $L50 = $L("
|
|
1013
|
-
var $L51 = $L("
|
|
1014
|
-
var $L52 = $L("
|
|
1015
|
-
var $L53 = $L("
|
|
1016
|
-
var $L54 = $L("
|
|
1017
|
-
var $L55 = $L("
|
|
1018
|
-
var $L56 = $L("
|
|
1019
|
-
var $L57 = $L("
|
|
1020
|
-
var $L58 = $L("
|
|
1021
|
-
var $L59 = $L("
|
|
1022
|
-
var $L60 = $L("
|
|
1023
|
-
var $L61 = $L("
|
|
1024
|
-
var $L62 = $L("
|
|
1025
|
-
var $L63 = $L("
|
|
1026
|
-
var $L64 = $L("
|
|
1027
|
-
var $L65 = $L("
|
|
1028
|
-
var $L66 = $L("
|
|
1029
|
-
var $L67 = $L("
|
|
1030
|
-
var $L68 = $L("
|
|
1031
|
-
var $L69 = $L("
|
|
1032
|
-
var $L70 = $L("
|
|
1033
|
-
var $L71 = $L("
|
|
1034
|
-
var $L72 = $L("
|
|
1035
|
-
var $L73 = $L("
|
|
1036
|
-
var $L74 = $L("
|
|
1037
|
-
var $L75 = $L("
|
|
1038
|
-
var $L76 = $L("
|
|
1039
|
-
var $L77 = $L("
|
|
1040
|
-
var $L78 = $L("
|
|
1041
|
-
var $L79 = $L("
|
|
1042
|
-
var $L80 = $L("
|
|
1043
|
-
var $L81 = $L("
|
|
1044
|
-
var $L82 = $L("
|
|
1045
|
-
var $L83 = $L("
|
|
1046
|
-
var $L84 = $L("
|
|
1047
|
-
var $L85 = $L("
|
|
1048
|
-
var $L86 = $L("
|
|
1049
|
-
var $L87 = $L("
|
|
1050
|
-
var $L88 = $L("
|
|
1051
|
-
var $L89 = $L("
|
|
1052
|
-
var $L90 = $L("
|
|
1053
|
-
var $L91 = $L("
|
|
1054
|
-
var $L92 = $L("
|
|
1055
|
-
var $L93 = $L("
|
|
1056
|
-
var $L94 = $L("
|
|
1057
|
-
var $L95 = $L("
|
|
1058
|
-
var $L96 = $L("
|
|
1059
|
-
var $L97 = $L("
|
|
1060
|
-
var $L98 = $L("
|
|
1061
|
-
var $L99 = $L("
|
|
1062
|
-
var $L100 = $L("
|
|
1063
|
-
var $L101 = $L("
|
|
1064
|
-
var $L102 = $L("
|
|
1065
|
-
var $L103 = $L("
|
|
1066
|
-
var $L104 = $L("
|
|
1067
|
-
var $L105 = $L("
|
|
1068
|
-
var $L106 = $L("
|
|
1069
|
-
var $L107 = $L("
|
|
1070
|
-
var $L108 = $L("
|
|
1071
|
-
var $L109 = $L("
|
|
1072
|
-
var $L110 = $L("
|
|
1073
|
-
var $L111 = $L(
|
|
1074
|
-
var $L112 = $L("
|
|
1075
|
-
var $L113 = $L("
|
|
1076
|
-
var $L114 = $L("
|
|
1077
|
-
var $L115 = $L("
|
|
1078
|
-
var $L116 = $L("
|
|
1079
|
-
var $L117 = $L("
|
|
1080
|
-
var $L118 = $L("
|
|
1081
|
-
var $L119 = $L("
|
|
1082
|
-
var $L120 = $L("
|
|
1083
|
-
var $L121 = $L("
|
|
1084
|
-
var $L122 = $L("
|
|
1085
|
-
var $L123 = $L("
|
|
1086
|
-
var $L124 = $L("
|
|
1087
|
-
var $L125 = $L("
|
|
1088
|
-
var $L126 = $L("
|
|
1089
|
-
var $L127 = $L("
|
|
1090
|
-
var $L128 = $L("
|
|
1091
|
-
var $L129 = $L("
|
|
1092
|
-
var $L130 = $L("
|
|
1093
|
-
var $L131 = $L("
|
|
1094
|
-
var $L132 = $L("
|
|
1095
|
-
var $L133 = $L("
|
|
1096
|
-
var $L134 = $L("
|
|
1097
|
-
var $L135 = $L("
|
|
1098
|
-
var $L136 = $L("
|
|
1099
|
-
var $L137 = $L(
|
|
1100
|
-
var $L138 = $L("
|
|
1101
|
-
var $L139 = $L("
|
|
1102
|
-
var $L140 = $L("
|
|
1103
|
-
var $L141 = $L("
|
|
1104
|
-
var $L142 = $L("
|
|
1105
|
-
var $L143 = $L("
|
|
1106
|
-
var $L144 = $L("
|
|
1107
|
-
var $L145 = $L("
|
|
1108
|
-
var $L146 = $L("
|
|
1109
|
-
var $L147 = $L("
|
|
1110
|
-
var $L148 = $L("
|
|
1111
|
-
var $L149 = $L("
|
|
1112
|
-
var $L150 = $L("
|
|
1113
|
-
var $L151 = $L("
|
|
1114
|
-
var $L152 = $L("
|
|
1115
|
-
var $L153 = $L("
|
|
1116
|
-
var $L154 = $L("
|
|
1117
|
-
var $L155 = $L("
|
|
1118
|
-
var $L156 = $L("
|
|
1119
|
-
var $L157 = $L("
|
|
1120
|
-
var $L158 = $L("
|
|
1121
|
-
var $L159 = $L("
|
|
1122
|
-
var $L160 = $L("
|
|
1123
|
-
var $L161 = $L("
|
|
1124
|
-
var $L162 = $L("
|
|
1125
|
-
var $L163 = $L("
|
|
980
|
+
var $L8 = $L("#");
|
|
981
|
+
var $L9 = $L(".");
|
|
982
|
+
var $L10 = $L("super");
|
|
983
|
+
var $L11 = $L("import");
|
|
984
|
+
var $L12 = $L("!");
|
|
985
|
+
var $L13 = $L("super[");
|
|
986
|
+
var $L14 = $L("import.meta");
|
|
987
|
+
var $L15 = $L(")");
|
|
988
|
+
var $L16 = $L("->");
|
|
989
|
+
var $L17 = $L("}");
|
|
990
|
+
var $L18 = $L("null");
|
|
991
|
+
var $L19 = $L("true");
|
|
992
|
+
var $L20 = $L("false");
|
|
993
|
+
var $L21 = $L("yes");
|
|
994
|
+
var $L22 = $L("on");
|
|
995
|
+
var $L23 = $L("no");
|
|
996
|
+
var $L24 = $L("off");
|
|
997
|
+
var $L25 = $L(",");
|
|
998
|
+
var $L26 = $L("=");
|
|
999
|
+
var $L27 = $L(">");
|
|
1000
|
+
var $L28 = $L("]");
|
|
1001
|
+
var $L29 = $L(":");
|
|
1002
|
+
var $L30 = $L("**=");
|
|
1003
|
+
var $L31 = $L("*=");
|
|
1004
|
+
var $L32 = $L("/=");
|
|
1005
|
+
var $L33 = $L("%=");
|
|
1006
|
+
var $L34 = $L("+=");
|
|
1007
|
+
var $L35 = $L("-=");
|
|
1008
|
+
var $L36 = $L("<<=");
|
|
1009
|
+
var $L37 = $L(">>>=");
|
|
1010
|
+
var $L38 = $L(">>=");
|
|
1011
|
+
var $L39 = $L("&&=");
|
|
1012
|
+
var $L40 = $L("&=");
|
|
1013
|
+
var $L41 = $L("^=");
|
|
1014
|
+
var $L42 = $L("||=");
|
|
1015
|
+
var $L43 = $L("|=");
|
|
1016
|
+
var $L44 = $L("??=");
|
|
1017
|
+
var $L45 = $L("?=");
|
|
1018
|
+
var $L46 = $L("and=");
|
|
1019
|
+
var $L47 = $L("or=");
|
|
1020
|
+
var $L48 = $L("**");
|
|
1021
|
+
var $L49 = $L("*");
|
|
1022
|
+
var $L50 = $L("/");
|
|
1023
|
+
var $L51 = $L("%");
|
|
1024
|
+
var $L52 = $L("+");
|
|
1025
|
+
var $L53 = $L("-");
|
|
1026
|
+
var $L54 = $L("<=");
|
|
1027
|
+
var $L55 = $L(">=");
|
|
1028
|
+
var $L56 = $L("<<");
|
|
1029
|
+
var $L57 = $L(">>>");
|
|
1030
|
+
var $L58 = $L(">>");
|
|
1031
|
+
var $L59 = $L("!==");
|
|
1032
|
+
var $L60 = $L("!=");
|
|
1033
|
+
var $L61 = $L("isnt");
|
|
1034
|
+
var $L62 = $L("is");
|
|
1035
|
+
var $L63 = $L("===");
|
|
1036
|
+
var $L64 = $L("==");
|
|
1037
|
+
var $L65 = $L("and");
|
|
1038
|
+
var $L66 = $L("&&");
|
|
1039
|
+
var $L67 = $L("of");
|
|
1040
|
+
var $L68 = $L("or");
|
|
1041
|
+
var $L69 = $L("||");
|
|
1042
|
+
var $L70 = $L("??");
|
|
1043
|
+
var $L71 = $L("?");
|
|
1044
|
+
var $L72 = $L("instanceof");
|
|
1045
|
+
var $L73 = $L("not");
|
|
1046
|
+
var $L74 = $L("in");
|
|
1047
|
+
var $L75 = $L("&");
|
|
1048
|
+
var $L76 = $L("^");
|
|
1049
|
+
var $L77 = $L("|");
|
|
1050
|
+
var $L78 = $L(";");
|
|
1051
|
+
var $L79 = $L("own");
|
|
1052
|
+
var $L80 = $L("finally");
|
|
1053
|
+
var $L81 = $L("break");
|
|
1054
|
+
var $L82 = $L("continue");
|
|
1055
|
+
var $L83 = $L("debugger");
|
|
1056
|
+
var $L84 = $L("import type");
|
|
1057
|
+
var $L85 = $L("default");
|
|
1058
|
+
var $L86 = $L(":=");
|
|
1059
|
+
var $L87 = $L("::=");
|
|
1060
|
+
var $L88 = $L(".=");
|
|
1061
|
+
var $L89 = $L("/*");
|
|
1062
|
+
var $L90 = $L("*/");
|
|
1063
|
+
var $L91 = $L("\\");
|
|
1064
|
+
var $L92 = $L("abstract");
|
|
1065
|
+
var $L93 = $L("as");
|
|
1066
|
+
var $L94 = $L("@");
|
|
1067
|
+
var $L95 = $L("@@");
|
|
1068
|
+
var $L96 = $L("async");
|
|
1069
|
+
var $L97 = $L("await");
|
|
1070
|
+
var $L98 = $L("`");
|
|
1071
|
+
var $L99 = $L("by");
|
|
1072
|
+
var $L100 = $L("case");
|
|
1073
|
+
var $L101 = $L("catch");
|
|
1074
|
+
var $L102 = $L("class");
|
|
1075
|
+
var $L103 = $L("#{");
|
|
1076
|
+
var $L104 = $L("delete");
|
|
1077
|
+
var $L105 = $L("do");
|
|
1078
|
+
var $L106 = $L("..");
|
|
1079
|
+
var $L107 = $L("...");
|
|
1080
|
+
var $L108 = $L("::");
|
|
1081
|
+
var $L109 = $L('"');
|
|
1082
|
+
var $L110 = $L("else");
|
|
1083
|
+
var $L111 = $L("export");
|
|
1084
|
+
var $L112 = $L("for");
|
|
1085
|
+
var $L113 = $L("from");
|
|
1086
|
+
var $L114 = $L("function");
|
|
1087
|
+
var $L115 = $L("get");
|
|
1088
|
+
var $L116 = $L("set");
|
|
1089
|
+
var $L117 = $L("if");
|
|
1090
|
+
var $L118 = $L("let");
|
|
1091
|
+
var $L119 = $L("const");
|
|
1092
|
+
var $L120 = $L("loop");
|
|
1093
|
+
var $L121 = $L("new");
|
|
1094
|
+
var $L122 = $L("{");
|
|
1095
|
+
var $L123 = $L("[");
|
|
1096
|
+
var $L124 = $L("(");
|
|
1097
|
+
var $L125 = $L("public");
|
|
1098
|
+
var $L126 = $L("private");
|
|
1099
|
+
var $L127 = $L("protected");
|
|
1100
|
+
var $L128 = $L("|>");
|
|
1101
|
+
var $L129 = $L("readonly");
|
|
1102
|
+
var $L130 = $L("return");
|
|
1103
|
+
var $L131 = $L("satisfies");
|
|
1104
|
+
var $L132 = $L("'");
|
|
1105
|
+
var $L133 = $L("static");
|
|
1106
|
+
var $L134 = $L("${");
|
|
1107
|
+
var $L135 = $L("switch");
|
|
1108
|
+
var $L136 = $L("target");
|
|
1109
|
+
var $L137 = $L("then");
|
|
1110
|
+
var $L138 = $L("this");
|
|
1111
|
+
var $L139 = $L("throw");
|
|
1112
|
+
var $L140 = $L('"""');
|
|
1113
|
+
var $L141 = $L("'''");
|
|
1114
|
+
var $L142 = $L("///");
|
|
1115
|
+
var $L143 = $L("```");
|
|
1116
|
+
var $L144 = $L("try");
|
|
1117
|
+
var $L145 = $L("typeof");
|
|
1118
|
+
var $L146 = $L("unless");
|
|
1119
|
+
var $L147 = $L("until");
|
|
1120
|
+
var $L148 = $L("var");
|
|
1121
|
+
var $L149 = $L("void");
|
|
1122
|
+
var $L150 = $L("when");
|
|
1123
|
+
var $L151 = $L("while");
|
|
1124
|
+
var $L152 = $L("yield");
|
|
1125
|
+
var $L153 = $L("/>");
|
|
1126
|
+
var $L154 = $L("</");
|
|
1127
|
+
var $L155 = $L("<>");
|
|
1128
|
+
var $L156 = $L("</>");
|
|
1129
|
+
var $L157 = $L("declare");
|
|
1130
|
+
var $L158 = $L("type");
|
|
1131
|
+
var $L159 = $L("interface");
|
|
1132
|
+
var $L160 = $L("namespace");
|
|
1133
|
+
var $L161 = $L("asserts");
|
|
1134
|
+
var $L162 = $L("keyof");
|
|
1135
|
+
var $L163 = $L("infer");
|
|
1136
|
+
var $L164 = $L("[]");
|
|
1137
|
+
var $L165 = $L("civet");
|
|
1126
1138
|
var $R0 = $R(new RegExp("(for|of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
1127
1139
|
var $R1 = $R(new RegExp("[&]", "suy"));
|
|
1128
1140
|
var $R2 = $R(new RegExp("[!~+-]+", "suy"));
|
|
@@ -1219,34 +1231,73 @@ ${input.slice(result.pos)}
|
|
|
1219
1231
|
return result;
|
|
1220
1232
|
}
|
|
1221
1233
|
}
|
|
1222
|
-
var ExtendedExpression$0 =
|
|
1234
|
+
var ExtendedExpression$0 = NonAssignmentExtendedExpression;
|
|
1235
|
+
var ExtendedExpression$1 = AssignmentExpression;
|
|
1236
|
+
function ExtendedExpression(state) {
|
|
1237
|
+
if (state.events) {
|
|
1238
|
+
const result = state.events.enter?.("ExtendedExpression", state);
|
|
1239
|
+
if (result)
|
|
1240
|
+
return result.cache;
|
|
1241
|
+
}
|
|
1242
|
+
if (state.tokenize) {
|
|
1243
|
+
const result = $TOKEN("ExtendedExpression", state, ExtendedExpression$0(state) || ExtendedExpression$1(state));
|
|
1244
|
+
if (state.events)
|
|
1245
|
+
state.events.exit?.("ExtendedExpression", state, result);
|
|
1246
|
+
return result;
|
|
1247
|
+
} else {
|
|
1248
|
+
const result = ExtendedExpression$0(state) || ExtendedExpression$1(state);
|
|
1249
|
+
if (state.events)
|
|
1250
|
+
state.events.exit?.("ExtendedExpression", state, result);
|
|
1251
|
+
return result;
|
|
1252
|
+
}
|
|
1253
|
+
}
|
|
1254
|
+
var NonPipelineExtendedExpression$0 = NonAssignmentExtendedExpression;
|
|
1255
|
+
var NonPipelineExtendedExpression$1 = NonPipelineAssignmentExpression;
|
|
1256
|
+
function NonPipelineExtendedExpression(state) {
|
|
1257
|
+
if (state.events) {
|
|
1258
|
+
const result = state.events.enter?.("NonPipelineExtendedExpression", state);
|
|
1259
|
+
if (result)
|
|
1260
|
+
return result.cache;
|
|
1261
|
+
}
|
|
1262
|
+
if (state.tokenize) {
|
|
1263
|
+
const result = $TOKEN("NonPipelineExtendedExpression", state, NonPipelineExtendedExpression$0(state) || NonPipelineExtendedExpression$1(state));
|
|
1264
|
+
if (state.events)
|
|
1265
|
+
state.events.exit?.("NonPipelineExtendedExpression", state, result);
|
|
1266
|
+
return result;
|
|
1267
|
+
} else {
|
|
1268
|
+
const result = NonPipelineExtendedExpression$0(state) || NonPipelineExtendedExpression$1(state);
|
|
1269
|
+
if (state.events)
|
|
1270
|
+
state.events.exit?.("NonPipelineExtendedExpression", state, result);
|
|
1271
|
+
return result;
|
|
1272
|
+
}
|
|
1273
|
+
}
|
|
1274
|
+
var NonAssignmentExtendedExpression$0 = $TS($S($Y(EOS), PushIndent, $E($S(Nested, ExpressionizedStatement)), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1223
1275
|
var expression = $3;
|
|
1224
1276
|
if (expression)
|
|
1225
1277
|
return expression;
|
|
1226
1278
|
return $skip;
|
|
1227
1279
|
});
|
|
1228
|
-
var
|
|
1280
|
+
var NonAssignmentExtendedExpression$1 = $TS($S(__, ExpressionizedStatement), function($skip, $loc, $0, $1, $2) {
|
|
1229
1281
|
return {
|
|
1230
1282
|
...$2,
|
|
1231
1283
|
children: [...$1, ...$2.children]
|
|
1232
1284
|
};
|
|
1233
1285
|
});
|
|
1234
|
-
|
|
1235
|
-
function ExtendedExpression(state) {
|
|
1286
|
+
function NonAssignmentExtendedExpression(state) {
|
|
1236
1287
|
if (state.events) {
|
|
1237
|
-
const result = state.events.enter?.("
|
|
1288
|
+
const result = state.events.enter?.("NonAssignmentExtendedExpression", state);
|
|
1238
1289
|
if (result)
|
|
1239
1290
|
return result.cache;
|
|
1240
1291
|
}
|
|
1241
1292
|
if (state.tokenize) {
|
|
1242
|
-
const result = $TOKEN("
|
|
1293
|
+
const result = $TOKEN("NonAssignmentExtendedExpression", state, NonAssignmentExtendedExpression$0(state) || NonAssignmentExtendedExpression$1(state));
|
|
1243
1294
|
if (state.events)
|
|
1244
|
-
state.events.exit?.("
|
|
1295
|
+
state.events.exit?.("NonAssignmentExtendedExpression", state, result);
|
|
1245
1296
|
return result;
|
|
1246
1297
|
} else {
|
|
1247
|
-
const result =
|
|
1298
|
+
const result = NonAssignmentExtendedExpression$0(state) || NonAssignmentExtendedExpression$1(state);
|
|
1248
1299
|
if (state.events)
|
|
1249
|
-
state.events.exit?.("
|
|
1300
|
+
state.events.exit?.("NonAssignmentExtendedExpression", state, result);
|
|
1250
1301
|
return result;
|
|
1251
1302
|
}
|
|
1252
1303
|
}
|
|
@@ -1405,8 +1456,11 @@ ${input.slice(result.pos)}
|
|
|
1405
1456
|
}
|
|
1406
1457
|
}
|
|
1407
1458
|
var ArgumentList$0 = $S(ArgumentPart, $P($S(__, Comma, $C(NestedImplicitObjectLiteral, NestedArgumentList))));
|
|
1408
|
-
var ArgumentList$1 =
|
|
1409
|
-
|
|
1459
|
+
var ArgumentList$1 = $TS($S(NestedImplicitObjectLiteral), function($skip, $loc, $0, $1) {
|
|
1460
|
+
return module.insertTrimmingSpace($1, "");
|
|
1461
|
+
});
|
|
1462
|
+
var ArgumentList$2 = NestedArgumentList;
|
|
1463
|
+
var ArgumentList$3 = InlineArgumentExpressions;
|
|
1410
1464
|
function ArgumentList(state) {
|
|
1411
1465
|
if (state.events) {
|
|
1412
1466
|
const result = state.events.enter?.("ArgumentList", state);
|
|
@@ -1414,12 +1468,12 @@ ${input.slice(result.pos)}
|
|
|
1414
1468
|
return result.cache;
|
|
1415
1469
|
}
|
|
1416
1470
|
if (state.tokenize) {
|
|
1417
|
-
const result = $TOKEN("ArgumentList", state, ArgumentList$0(state) || ArgumentList$1(state) || ArgumentList$2(state));
|
|
1471
|
+
const result = $TOKEN("ArgumentList", state, ArgumentList$0(state) || ArgumentList$1(state) || ArgumentList$2(state) || ArgumentList$3(state));
|
|
1418
1472
|
if (state.events)
|
|
1419
1473
|
state.events.exit?.("ArgumentList", state, result);
|
|
1420
1474
|
return result;
|
|
1421
1475
|
} else {
|
|
1422
|
-
const result = ArgumentList$0(state) || ArgumentList$1(state) || ArgumentList$2(state);
|
|
1476
|
+
const result = ArgumentList$0(state) || ArgumentList$1(state) || ArgumentList$2(state) || ArgumentList$3(state);
|
|
1423
1477
|
if (state.events)
|
|
1424
1478
|
state.events.exit?.("ArgumentList", state, result);
|
|
1425
1479
|
return result;
|
|
@@ -1694,7 +1748,8 @@ ${input.slice(result.pos)}
|
|
|
1694
1748
|
return result;
|
|
1695
1749
|
}
|
|
1696
1750
|
}
|
|
1697
|
-
var AssignmentExpression$0 =
|
|
1751
|
+
var AssignmentExpression$0 = PipelineExpression;
|
|
1752
|
+
var AssignmentExpression$1 = $TS($S($Q(TrailingComment), AssignmentExpressionTail), function($skip, $loc, $0, $1, $2) {
|
|
1698
1753
|
var ws = $1;
|
|
1699
1754
|
var tail = $2;
|
|
1700
1755
|
if (ws.length) {
|
|
@@ -1708,7 +1763,7 @@ ${input.slice(result.pos)}
|
|
|
1708
1763
|
}
|
|
1709
1764
|
return tail;
|
|
1710
1765
|
});
|
|
1711
|
-
var AssignmentExpression$
|
|
1766
|
+
var AssignmentExpression$2 = $S(__, AssignmentExpressionTail);
|
|
1712
1767
|
function AssignmentExpression(state) {
|
|
1713
1768
|
if (state.events) {
|
|
1714
1769
|
const result = state.events.enter?.("AssignmentExpression", state);
|
|
@@ -1716,17 +1771,69 @@ ${input.slice(result.pos)}
|
|
|
1716
1771
|
return result.cache;
|
|
1717
1772
|
}
|
|
1718
1773
|
if (state.tokenize) {
|
|
1719
|
-
const result = $TOKEN("AssignmentExpression", state, AssignmentExpression$0(state) || AssignmentExpression$1(state));
|
|
1774
|
+
const result = $TOKEN("AssignmentExpression", state, AssignmentExpression$0(state) || AssignmentExpression$1(state) || AssignmentExpression$2(state));
|
|
1720
1775
|
if (state.events)
|
|
1721
1776
|
state.events.exit?.("AssignmentExpression", state, result);
|
|
1722
1777
|
return result;
|
|
1723
1778
|
} else {
|
|
1724
|
-
const result = AssignmentExpression$0(state) || AssignmentExpression$1(state);
|
|
1779
|
+
const result = AssignmentExpression$0(state) || AssignmentExpression$1(state) || AssignmentExpression$2(state);
|
|
1725
1780
|
if (state.events)
|
|
1726
1781
|
state.events.exit?.("AssignmentExpression", state, result);
|
|
1727
1782
|
return result;
|
|
1728
1783
|
}
|
|
1729
1784
|
}
|
|
1785
|
+
var NonPipelineAssignmentExpression$0 = SingleLineAssignmentExpression;
|
|
1786
|
+
var NonPipelineAssignmentExpression$1 = $S(__, AssignmentExpressionTail);
|
|
1787
|
+
function NonPipelineAssignmentExpression(state) {
|
|
1788
|
+
if (state.events) {
|
|
1789
|
+
const result = state.events.enter?.("NonPipelineAssignmentExpression", state);
|
|
1790
|
+
if (result)
|
|
1791
|
+
return result.cache;
|
|
1792
|
+
}
|
|
1793
|
+
if (state.tokenize) {
|
|
1794
|
+
const result = $TOKEN("NonPipelineAssignmentExpression", state, NonPipelineAssignmentExpression$0(state) || NonPipelineAssignmentExpression$1(state));
|
|
1795
|
+
if (state.events)
|
|
1796
|
+
state.events.exit?.("NonPipelineAssignmentExpression", state, result);
|
|
1797
|
+
return result;
|
|
1798
|
+
} else {
|
|
1799
|
+
const result = NonPipelineAssignmentExpression$0(state) || NonPipelineAssignmentExpression$1(state);
|
|
1800
|
+
if (state.events)
|
|
1801
|
+
state.events.exit?.("NonPipelineAssignmentExpression", state, result);
|
|
1802
|
+
return result;
|
|
1803
|
+
}
|
|
1804
|
+
}
|
|
1805
|
+
var SingleLineAssignmentExpression$0 = $TS($S($Q(TrailingComment), AssignmentExpressionTail), function($skip, $loc, $0, $1, $2) {
|
|
1806
|
+
var ws = $1;
|
|
1807
|
+
var tail = $2;
|
|
1808
|
+
if (ws.length) {
|
|
1809
|
+
if (tail.children && tail.type !== "IterationExpression") {
|
|
1810
|
+
return {
|
|
1811
|
+
...tail,
|
|
1812
|
+
children: [...ws, ...tail.children]
|
|
1813
|
+
};
|
|
1814
|
+
}
|
|
1815
|
+
return $0;
|
|
1816
|
+
}
|
|
1817
|
+
return tail;
|
|
1818
|
+
});
|
|
1819
|
+
function SingleLineAssignmentExpression(state) {
|
|
1820
|
+
if (state.events) {
|
|
1821
|
+
const result = state.events.enter?.("SingleLineAssignmentExpression", state);
|
|
1822
|
+
if (result)
|
|
1823
|
+
return result.cache;
|
|
1824
|
+
}
|
|
1825
|
+
if (state.tokenize) {
|
|
1826
|
+
const result = $TOKEN("SingleLineAssignmentExpression", state, SingleLineAssignmentExpression$0(state));
|
|
1827
|
+
if (state.events)
|
|
1828
|
+
state.events.exit?.("SingleLineAssignmentExpression", state, result);
|
|
1829
|
+
return result;
|
|
1830
|
+
} else {
|
|
1831
|
+
const result = SingleLineAssignmentExpression$0(state);
|
|
1832
|
+
if (state.events)
|
|
1833
|
+
state.events.exit?.("SingleLineAssignmentExpression", state, result);
|
|
1834
|
+
return result;
|
|
1835
|
+
}
|
|
1836
|
+
}
|
|
1730
1837
|
var AssignmentExpressionTail$0 = YieldExpression;
|
|
1731
1838
|
var AssignmentExpressionTail$1 = ArrowFunction;
|
|
1732
1839
|
var AssignmentExpressionTail$2 = ActualAssignment;
|
|
@@ -2006,6 +2113,91 @@ ${input.slice(result.pos)}
|
|
|
2006
2113
|
return result;
|
|
2007
2114
|
}
|
|
2008
2115
|
}
|
|
2116
|
+
var PipelineExpression$0 = $TS($S($S(__, PipelineHeadItem, __, Pipe), $Q($S(__, PipelineTailItem, __, Pipe)), __, PipelineTailItem), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2117
|
+
var head = $1;
|
|
2118
|
+
var body = $2;
|
|
2119
|
+
var preTailWS = $3;
|
|
2120
|
+
var tail = $4;
|
|
2121
|
+
let children = head.slice(0, -1).map(module.skipIfOnlyWS);
|
|
2122
|
+
for (const [leadingComment, expr, trailingComment] of body) {
|
|
2123
|
+
children = module.constructPipeStep(
|
|
2124
|
+
{
|
|
2125
|
+
leadingComment: module.skipIfOnlyWS(leadingComment),
|
|
2126
|
+
trailingComment: module.skipIfOnlyWS(trailingComment),
|
|
2127
|
+
expr
|
|
2128
|
+
},
|
|
2129
|
+
{ expr: children }
|
|
2130
|
+
);
|
|
2131
|
+
}
|
|
2132
|
+
return {
|
|
2133
|
+
children: module.constructPipeStep(
|
|
2134
|
+
{
|
|
2135
|
+
leadingComment: module.skipIfOnlyWS(preTailWS),
|
|
2136
|
+
expr: tail
|
|
2137
|
+
},
|
|
2138
|
+
{ expr: children }
|
|
2139
|
+
)
|
|
2140
|
+
};
|
|
2141
|
+
});
|
|
2142
|
+
function PipelineExpression(state) {
|
|
2143
|
+
if (state.events) {
|
|
2144
|
+
const result = state.events.enter?.("PipelineExpression", state);
|
|
2145
|
+
if (result)
|
|
2146
|
+
return result.cache;
|
|
2147
|
+
}
|
|
2148
|
+
if (state.tokenize) {
|
|
2149
|
+
const result = $TOKEN("PipelineExpression", state, PipelineExpression$0(state));
|
|
2150
|
+
if (state.events)
|
|
2151
|
+
state.events.exit?.("PipelineExpression", state, result);
|
|
2152
|
+
return result;
|
|
2153
|
+
} else {
|
|
2154
|
+
const result = PipelineExpression$0(state);
|
|
2155
|
+
if (state.events)
|
|
2156
|
+
state.events.exit?.("PipelineExpression", state, result);
|
|
2157
|
+
return result;
|
|
2158
|
+
}
|
|
2159
|
+
}
|
|
2160
|
+
var PipelineHeadItem$0 = NonPipelineExtendedExpression;
|
|
2161
|
+
var PipelineHeadItem$1 = ParenthesizedExpression;
|
|
2162
|
+
function PipelineHeadItem(state) {
|
|
2163
|
+
if (state.events) {
|
|
2164
|
+
const result = state.events.enter?.("PipelineHeadItem", state);
|
|
2165
|
+
if (result)
|
|
2166
|
+
return result.cache;
|
|
2167
|
+
}
|
|
2168
|
+
if (state.tokenize) {
|
|
2169
|
+
const result = $TOKEN("PipelineHeadItem", state, PipelineHeadItem$0(state) || PipelineHeadItem$1(state));
|
|
2170
|
+
if (state.events)
|
|
2171
|
+
state.events.exit?.("PipelineHeadItem", state, result);
|
|
2172
|
+
return result;
|
|
2173
|
+
} else {
|
|
2174
|
+
const result = PipelineHeadItem$0(state) || PipelineHeadItem$1(state);
|
|
2175
|
+
if (state.events)
|
|
2176
|
+
state.events.exit?.("PipelineHeadItem", state, result);
|
|
2177
|
+
return result;
|
|
2178
|
+
}
|
|
2179
|
+
}
|
|
2180
|
+
var PipelineTailItem$0 = Await;
|
|
2181
|
+
var PipelineTailItem$1 = Yield;
|
|
2182
|
+
var PipelineTailItem$2 = PipelineHeadItem;
|
|
2183
|
+
function PipelineTailItem(state) {
|
|
2184
|
+
if (state.events) {
|
|
2185
|
+
const result = state.events.enter?.("PipelineTailItem", state);
|
|
2186
|
+
if (result)
|
|
2187
|
+
return result.cache;
|
|
2188
|
+
}
|
|
2189
|
+
if (state.tokenize) {
|
|
2190
|
+
const result = $TOKEN("PipelineTailItem", state, PipelineTailItem$0(state) || PipelineTailItem$1(state) || PipelineTailItem$2(state));
|
|
2191
|
+
if (state.events)
|
|
2192
|
+
state.events.exit?.("PipelineTailItem", state, result);
|
|
2193
|
+
return result;
|
|
2194
|
+
} else {
|
|
2195
|
+
const result = PipelineTailItem$0(state) || PipelineTailItem$1(state) || PipelineTailItem$2(state);
|
|
2196
|
+
if (state.events)
|
|
2197
|
+
state.events.exit?.("PipelineTailItem", state, result);
|
|
2198
|
+
return result;
|
|
2199
|
+
}
|
|
2200
|
+
}
|
|
2009
2201
|
var PrimaryExpression$0 = ObjectLiteral;
|
|
2010
2202
|
var PrimaryExpression$1 = ThisLiteral;
|
|
2011
2203
|
var PrimaryExpression$2 = Literal;
|
|
@@ -2085,7 +2277,9 @@ ${input.slice(result.pos)}
|
|
|
2085
2277
|
return result;
|
|
2086
2278
|
}
|
|
2087
2279
|
}
|
|
2088
|
-
var ClassExpression$0 = $S($E(Decorators), Class, $E($S(BindingIdentifier, $E(TypeParameters))), $E(ClassHeritage), ClassBody)
|
|
2280
|
+
var ClassExpression$0 = $TS($S($E(Decorators), $E($S(Abstract, __)), Class, $E($S(BindingIdentifier, $E(TypeParameters))), $E(ClassHeritage), ClassBody), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
2281
|
+
return $0;
|
|
2282
|
+
});
|
|
2089
2283
|
function ClassExpression(state) {
|
|
2090
2284
|
if (state.events) {
|
|
2091
2285
|
const result = state.events.enter?.("ClassExpression", state);
|
|
@@ -2377,69 +2571,6 @@ ${input.slice(result.pos)}
|
|
|
2377
2571
|
return result;
|
|
2378
2572
|
}
|
|
2379
2573
|
}
|
|
2380
|
-
var Public$0 = $TV($EXPECT($L8, fail, 'Public "public"'), function($skip, $loc, $0, $1) {
|
|
2381
|
-
return { $loc, token: $1 };
|
|
2382
|
-
});
|
|
2383
|
-
function Public(state) {
|
|
2384
|
-
if (state.events) {
|
|
2385
|
-
const result = state.events.enter?.("Public", state);
|
|
2386
|
-
if (result)
|
|
2387
|
-
return result.cache;
|
|
2388
|
-
}
|
|
2389
|
-
if (state.tokenize) {
|
|
2390
|
-
const result = $TOKEN("Public", state, Public$0(state));
|
|
2391
|
-
if (state.events)
|
|
2392
|
-
state.events.exit?.("Public", state, result);
|
|
2393
|
-
return result;
|
|
2394
|
-
} else {
|
|
2395
|
-
const result = Public$0(state);
|
|
2396
|
-
if (state.events)
|
|
2397
|
-
state.events.exit?.("Public", state, result);
|
|
2398
|
-
return result;
|
|
2399
|
-
}
|
|
2400
|
-
}
|
|
2401
|
-
var Private$0 = $TV($EXPECT($L9, fail, 'Private "private"'), function($skip, $loc, $0, $1) {
|
|
2402
|
-
return { $loc, token: $1 };
|
|
2403
|
-
});
|
|
2404
|
-
function Private(state) {
|
|
2405
|
-
if (state.events) {
|
|
2406
|
-
const result = state.events.enter?.("Private", state);
|
|
2407
|
-
if (result)
|
|
2408
|
-
return result.cache;
|
|
2409
|
-
}
|
|
2410
|
-
if (state.tokenize) {
|
|
2411
|
-
const result = $TOKEN("Private", state, Private$0(state));
|
|
2412
|
-
if (state.events)
|
|
2413
|
-
state.events.exit?.("Private", state, result);
|
|
2414
|
-
return result;
|
|
2415
|
-
} else {
|
|
2416
|
-
const result = Private$0(state);
|
|
2417
|
-
if (state.events)
|
|
2418
|
-
state.events.exit?.("Private", state, result);
|
|
2419
|
-
return result;
|
|
2420
|
-
}
|
|
2421
|
-
}
|
|
2422
|
-
var Protected$0 = $TV($EXPECT($L10, fail, 'Protected "protected"'), function($skip, $loc, $0, $1) {
|
|
2423
|
-
return { $loc, token: $1 };
|
|
2424
|
-
});
|
|
2425
|
-
function Protected(state) {
|
|
2426
|
-
if (state.events) {
|
|
2427
|
-
const result = state.events.enter?.("Protected", state);
|
|
2428
|
-
if (result)
|
|
2429
|
-
return result.cache;
|
|
2430
|
-
}
|
|
2431
|
-
if (state.tokenize) {
|
|
2432
|
-
const result = $TOKEN("Protected", state, Protected$0(state));
|
|
2433
|
-
if (state.events)
|
|
2434
|
-
state.events.exit?.("Protected", state, result);
|
|
2435
|
-
return result;
|
|
2436
|
-
} else {
|
|
2437
|
-
const result = Protected$0(state);
|
|
2438
|
-
if (state.events)
|
|
2439
|
-
state.events.exit?.("Protected", state, result);
|
|
2440
|
-
return result;
|
|
2441
|
-
}
|
|
2442
|
-
}
|
|
2443
2574
|
var FieldDefinition$0 = $TS($S(CoffeeClassesEnabled, ClassElementName, __, Colon, __, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
2444
2575
|
var id = $2;
|
|
2445
2576
|
var exp = $6;
|
|
@@ -2462,7 +2593,11 @@ ${input.slice(result.pos)}
|
|
|
2462
2593
|
};
|
|
2463
2594
|
return $0;
|
|
2464
2595
|
});
|
|
2465
|
-
var FieldDefinition$2 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer))
|
|
2596
|
+
var FieldDefinition$2 = $TS($S($E($S(Abstract, $Q(TrailingComment))), $E($S(Readonly, $Q(TrailingComment))), ClassElementName, $E(TypeSuffix), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
2597
|
+
if ($1)
|
|
2598
|
+
return { children: $0, ts: true };
|
|
2599
|
+
return $0;
|
|
2600
|
+
});
|
|
2466
2601
|
function FieldDefinition(state) {
|
|
2467
2602
|
if (state.events) {
|
|
2468
2603
|
const result = state.events.enter?.("FieldDefinition", state);
|
|
@@ -2482,7 +2617,7 @@ ${input.slice(result.pos)}
|
|
|
2482
2617
|
}
|
|
2483
2618
|
}
|
|
2484
2619
|
var ThisLiteral$0 = This;
|
|
2485
|
-
var ThisLiteral$1 = $TS($S(At, $TEXT($S($E($EXPECT($
|
|
2620
|
+
var ThisLiteral$1 = $TS($S(At, $TEXT($S($E($EXPECT($L8, fail, 'ThisLiteral "#"')), IdentifierName))), function($skip, $loc, $0, $1, $2) {
|
|
2486
2621
|
var t = $1;
|
|
2487
2622
|
var id = $2;
|
|
2488
2623
|
return [{ ...t, token: "this." }, id];
|
|
@@ -2509,7 +2644,7 @@ ${input.slice(result.pos)}
|
|
|
2509
2644
|
return result;
|
|
2510
2645
|
}
|
|
2511
2646
|
}
|
|
2512
|
-
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($
|
|
2647
|
+
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($L9, fail, 'LeftHandSideExpression "."')), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
2513
2648
|
if ($1.length)
|
|
2514
2649
|
return $0;
|
|
2515
2650
|
return $2;
|
|
@@ -2532,8 +2667,8 @@ ${input.slice(result.pos)}
|
|
|
2532
2667
|
return result;
|
|
2533
2668
|
}
|
|
2534
2669
|
}
|
|
2535
|
-
var CallExpression$0 = $S($EXPECT($
|
|
2536
|
-
var CallExpression$1 = $S($EXPECT($
|
|
2670
|
+
var CallExpression$0 = $S($EXPECT($L10, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions, $Q(CallExpressionRest));
|
|
2671
|
+
var CallExpression$1 = $S($EXPECT($L11, fail, 'CallExpression "import"'), ArgumentsWithTrailingCallExpressions, $Q(CallExpressionRest));
|
|
2537
2672
|
var CallExpression$2 = $TS($S(MemberExpression, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
2538
2673
|
if ($2.length)
|
|
2539
2674
|
return $0;
|
|
@@ -2597,7 +2732,7 @@ ${input.slice(result.pos)}
|
|
|
2597
2732
|
return result;
|
|
2598
2733
|
}
|
|
2599
2734
|
}
|
|
2600
|
-
var NonNullAssertion$0 = $T($EXPECT($
|
|
2735
|
+
var NonNullAssertion$0 = $T($EXPECT($L12, fail, 'NonNullAssertion "!"'), function(value) {
|
|
2601
2736
|
return { "ts": true, "children": value };
|
|
2602
2737
|
});
|
|
2603
2738
|
function NonNullAssertion(state) {
|
|
@@ -2838,8 +2973,8 @@ ${input.slice(result.pos)}
|
|
|
2838
2973
|
return result;
|
|
2839
2974
|
}
|
|
2840
2975
|
}
|
|
2841
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
2842
|
-
var SuperProperty$1 = $S($EXPECT($
|
|
2976
|
+
var SuperProperty$0 = $S($EXPECT($L13, fail, 'SuperProperty "super["'), ExtendedExpression, __, CloseBracket);
|
|
2977
|
+
var SuperProperty$1 = $S($EXPECT($L10, fail, 'SuperProperty "super"'), $N($C(QuestionMark, NonNullAssertion)), PropertyAccess);
|
|
2843
2978
|
function SuperProperty(state) {
|
|
2844
2979
|
if (state.events) {
|
|
2845
2980
|
const result = state.events.enter?.("SuperProperty", state);
|
|
@@ -2859,7 +2994,7 @@ ${input.slice(result.pos)}
|
|
|
2859
2994
|
}
|
|
2860
2995
|
}
|
|
2861
2996
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
2862
|
-
var MetaProperty$1 = $TV($EXPECT($
|
|
2997
|
+
var MetaProperty$1 = $TV($EXPECT($L14, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
|
|
2863
2998
|
return { $loc, token: $1 };
|
|
2864
2999
|
});
|
|
2865
3000
|
function MetaProperty(state) {
|
|
@@ -3023,7 +3158,7 @@ ${input.slice(result.pos)}
|
|
|
3023
3158
|
}
|
|
3024
3159
|
}
|
|
3025
3160
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
3026
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
3161
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L15, fail, 'ParameterElementDelimiter ")"')));
|
|
3027
3162
|
var ParameterElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
3028
3163
|
return value[1];
|
|
3029
3164
|
});
|
|
@@ -3778,7 +3913,7 @@ ${input.slice(result.pos)}
|
|
|
3778
3913
|
return result;
|
|
3779
3914
|
}
|
|
3780
3915
|
}
|
|
3781
|
-
var Arrow$0 = $TV($EXPECT($
|
|
3916
|
+
var Arrow$0 = $TV($EXPECT($L16, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
3782
3917
|
return { $loc, token: $1 };
|
|
3783
3918
|
});
|
|
3784
3919
|
function Arrow(state) {
|
|
@@ -4040,7 +4175,7 @@ ${input.slice(result.pos)}
|
|
|
4040
4175
|
children: [$1, expressions]
|
|
4041
4176
|
};
|
|
4042
4177
|
});
|
|
4043
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
4178
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L17, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
4044
4179
|
const expressions = [];
|
|
4045
4180
|
return {
|
|
4046
4181
|
type: "BlockStatement",
|
|
@@ -4165,7 +4300,7 @@ ${input.slice(result.pos)}
|
|
|
4165
4300
|
return result;
|
|
4166
4301
|
}
|
|
4167
4302
|
}
|
|
4168
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
4303
|
+
var NullLiteral$0 = $TS($S($EXPECT($L18, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4169
4304
|
return { $loc, token: $1 };
|
|
4170
4305
|
});
|
|
4171
4306
|
function NullLiteral(state) {
|
|
@@ -4189,7 +4324,7 @@ ${input.slice(result.pos)}
|
|
|
4189
4324
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
4190
4325
|
return value[1];
|
|
4191
4326
|
});
|
|
4192
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
4327
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L19, fail, 'BooleanLiteral "true"'), $EXPECT($L20, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4193
4328
|
return { $loc, token: $1 };
|
|
4194
4329
|
});
|
|
4195
4330
|
function BooleanLiteral(state) {
|
|
@@ -4210,10 +4345,10 @@ ${input.slice(result.pos)}
|
|
|
4210
4345
|
return result;
|
|
4211
4346
|
}
|
|
4212
4347
|
}
|
|
4213
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
4348
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4214
4349
|
return { $loc, token: "true" };
|
|
4215
4350
|
});
|
|
4216
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
4351
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L24, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4217
4352
|
return { $loc, token: "false" };
|
|
4218
4353
|
});
|
|
4219
4354
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -4234,7 +4369,7 @@ ${input.slice(result.pos)}
|
|
|
4234
4369
|
return result;
|
|
4235
4370
|
}
|
|
4236
4371
|
}
|
|
4237
|
-
var Comma$0 = $TV($EXPECT($
|
|
4372
|
+
var Comma$0 = $TV($EXPECT($L25, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
4238
4373
|
return { $loc, token: $1 };
|
|
4239
4374
|
});
|
|
4240
4375
|
function Comma(state) {
|
|
@@ -4324,7 +4459,7 @@ ${input.slice(result.pos)}
|
|
|
4324
4459
|
return result;
|
|
4325
4460
|
}
|
|
4326
4461
|
}
|
|
4327
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($
|
|
4462
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L26, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L26, fail, 'UpcomingAssignment "="'), $EXPECT($L27, fail, 'UpcomingAssignment ">"')))));
|
|
4328
4463
|
function UpcomingAssignment(state) {
|
|
4329
4464
|
if (state.events) {
|
|
4330
4465
|
const result = state.events.enter?.("UpcomingAssignment", state);
|
|
@@ -4572,7 +4707,7 @@ ${input.slice(result.pos)}
|
|
|
4572
4707
|
}
|
|
4573
4708
|
}
|
|
4574
4709
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
4575
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
4710
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L28, fail, 'ArrayElementDelimiter "]"')));
|
|
4576
4711
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
4577
4712
|
return value[1];
|
|
4578
4713
|
});
|
|
@@ -4941,7 +5076,7 @@ ${input.slice(result.pos)}
|
|
|
4941
5076
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S(EOS, NamedProperty)), InsertComma), function(value) {
|
|
4942
5077
|
return value[1];
|
|
4943
5078
|
});
|
|
4944
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
5079
|
+
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($L29, fail, 'ImplicitInlineObjectPropertyDelimiter ":"'), $EXPECT($L15, fail, 'ImplicitInlineObjectPropertyDelimiter ")"'), $EXPECT($L28, fail, 'ImplicitInlineObjectPropertyDelimiter "]"'), $EXPECT($L17, fail, 'ImplicitInlineObjectPropertyDelimiter "}"'), ReservedWord))), function(value) {
|
|
4945
5080
|
return "";
|
|
4946
5081
|
});
|
|
4947
5082
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -4966,7 +5101,7 @@ ${input.slice(result.pos)}
|
|
|
4966
5101
|
}
|
|
4967
5102
|
}
|
|
4968
5103
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
4969
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
5104
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L17, fail, 'ObjectPropertyDelimiter "}"')));
|
|
4970
5105
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
4971
5106
|
return value[1];
|
|
4972
5107
|
});
|
|
@@ -5222,7 +5357,18 @@ ${input.slice(result.pos)}
|
|
|
5222
5357
|
return result;
|
|
5223
5358
|
}
|
|
5224
5359
|
}
|
|
5225
|
-
var MethodDefinition$0 = $TS($S(
|
|
5360
|
+
var MethodDefinition$0 = $TS($S(Abstract, __, MethodSignature), function($skip, $loc, $0, $1, $2, $3) {
|
|
5361
|
+
var signature = $3;
|
|
5362
|
+
return {
|
|
5363
|
+
type: "MethodDefinition",
|
|
5364
|
+
children: $0,
|
|
5365
|
+
name: signature.name,
|
|
5366
|
+
signature,
|
|
5367
|
+
parameters: signature.parameters,
|
|
5368
|
+
ts: true
|
|
5369
|
+
};
|
|
5370
|
+
});
|
|
5371
|
+
var MethodDefinition$1 = $TS($S(MethodSignature, BracedBlock), function($skip, $loc, $0, $1, $2) {
|
|
5226
5372
|
var signature = $1;
|
|
5227
5373
|
var block = $2;
|
|
5228
5374
|
return {
|
|
@@ -5241,12 +5387,12 @@ ${input.slice(result.pos)}
|
|
|
5241
5387
|
return result.cache;
|
|
5242
5388
|
}
|
|
5243
5389
|
if (state.tokenize) {
|
|
5244
|
-
const result = $TOKEN("MethodDefinition", state, MethodDefinition$0(state));
|
|
5390
|
+
const result = $TOKEN("MethodDefinition", state, MethodDefinition$0(state) || MethodDefinition$1(state));
|
|
5245
5391
|
if (state.events)
|
|
5246
5392
|
state.events.exit?.("MethodDefinition", state, result);
|
|
5247
5393
|
return result;
|
|
5248
5394
|
} else {
|
|
5249
|
-
const result = MethodDefinition$0(state);
|
|
5395
|
+
const result = MethodDefinition$0(state) || MethodDefinition$1(state);
|
|
5250
5396
|
if (state.events)
|
|
5251
5397
|
state.events.exit?.("MethodDefinition", state, result);
|
|
5252
5398
|
return result;
|
|
@@ -5339,7 +5485,7 @@ ${input.slice(result.pos)}
|
|
|
5339
5485
|
return result;
|
|
5340
5486
|
}
|
|
5341
5487
|
}
|
|
5342
|
-
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($
|
|
5488
|
+
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
|
|
5343
5489
|
return {
|
|
5344
5490
|
type: "Identifier",
|
|
5345
5491
|
name: $0,
|
|
@@ -5395,25 +5541,25 @@ ${input.slice(result.pos)}
|
|
|
5395
5541
|
return result;
|
|
5396
5542
|
}
|
|
5397
5543
|
}
|
|
5398
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
5399
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
5400
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
5401
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
5402
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
5403
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
5404
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
5405
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
5406
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
5407
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
5408
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
5409
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
5410
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
5411
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
5412
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
5413
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
5544
|
+
var AssignmentOpSymbol$0 = $EXPECT($L30, fail, 'AssignmentOpSymbol "**="');
|
|
5545
|
+
var AssignmentOpSymbol$1 = $EXPECT($L31, fail, 'AssignmentOpSymbol "*="');
|
|
5546
|
+
var AssignmentOpSymbol$2 = $EXPECT($L32, fail, 'AssignmentOpSymbol "/="');
|
|
5547
|
+
var AssignmentOpSymbol$3 = $EXPECT($L33, fail, 'AssignmentOpSymbol "%="');
|
|
5548
|
+
var AssignmentOpSymbol$4 = $EXPECT($L34, fail, 'AssignmentOpSymbol "+="');
|
|
5549
|
+
var AssignmentOpSymbol$5 = $EXPECT($L35, fail, 'AssignmentOpSymbol "-="');
|
|
5550
|
+
var AssignmentOpSymbol$6 = $EXPECT($L36, fail, 'AssignmentOpSymbol "<<="');
|
|
5551
|
+
var AssignmentOpSymbol$7 = $EXPECT($L37, fail, 'AssignmentOpSymbol ">>>="');
|
|
5552
|
+
var AssignmentOpSymbol$8 = $EXPECT($L38, fail, 'AssignmentOpSymbol ">>="');
|
|
5553
|
+
var AssignmentOpSymbol$9 = $EXPECT($L39, fail, 'AssignmentOpSymbol "&&="');
|
|
5554
|
+
var AssignmentOpSymbol$10 = $EXPECT($L40, fail, 'AssignmentOpSymbol "&="');
|
|
5555
|
+
var AssignmentOpSymbol$11 = $EXPECT($L41, fail, 'AssignmentOpSymbol "^="');
|
|
5556
|
+
var AssignmentOpSymbol$12 = $EXPECT($L42, fail, 'AssignmentOpSymbol "||="');
|
|
5557
|
+
var AssignmentOpSymbol$13 = $EXPECT($L43, fail, 'AssignmentOpSymbol "|="');
|
|
5558
|
+
var AssignmentOpSymbol$14 = $EXPECT($L44, fail, 'AssignmentOpSymbol "??="');
|
|
5559
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L45, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
5414
5560
|
return "??=";
|
|
5415
5561
|
});
|
|
5416
|
-
var AssignmentOpSymbol$16 = $EXPECT($
|
|
5562
|
+
var AssignmentOpSymbol$16 = $EXPECT($L26, fail, 'AssignmentOpSymbol "="');
|
|
5417
5563
|
var AssignmentOpSymbol$17 = $T($S(CoffeeWordAssignmentOp), function(value) {
|
|
5418
5564
|
return value[0];
|
|
5419
5565
|
});
|
|
@@ -5435,10 +5581,10 @@ ${input.slice(result.pos)}
|
|
|
5435
5581
|
return result;
|
|
5436
5582
|
}
|
|
5437
5583
|
}
|
|
5438
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
5584
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L46, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
5439
5585
|
return "&&=";
|
|
5440
5586
|
});
|
|
5441
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
5587
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L47, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
5442
5588
|
return "||=";
|
|
5443
5589
|
});
|
|
5444
5590
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -5482,93 +5628,93 @@ ${input.slice(result.pos)}
|
|
|
5482
5628
|
return result;
|
|
5483
5629
|
}
|
|
5484
5630
|
}
|
|
5485
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
5486
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
5487
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
5488
|
-
var BinaryOpSymbol$3 = $EXPECT($
|
|
5489
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
5490
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
5491
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
5492
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
5493
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
5631
|
+
var BinaryOpSymbol$0 = $EXPECT($L48, fail, 'BinaryOpSymbol "**"');
|
|
5632
|
+
var BinaryOpSymbol$1 = $EXPECT($L49, fail, 'BinaryOpSymbol "*"');
|
|
5633
|
+
var BinaryOpSymbol$2 = $EXPECT($L50, fail, 'BinaryOpSymbol "/"');
|
|
5634
|
+
var BinaryOpSymbol$3 = $EXPECT($L51, fail, 'BinaryOpSymbol "%"');
|
|
5635
|
+
var BinaryOpSymbol$4 = $EXPECT($L52, fail, 'BinaryOpSymbol "+"');
|
|
5636
|
+
var BinaryOpSymbol$5 = $EXPECT($L53, fail, 'BinaryOpSymbol "-"');
|
|
5637
|
+
var BinaryOpSymbol$6 = $EXPECT($L54, fail, 'BinaryOpSymbol "<="');
|
|
5638
|
+
var BinaryOpSymbol$7 = $EXPECT($L55, fail, 'BinaryOpSymbol ">="');
|
|
5639
|
+
var BinaryOpSymbol$8 = $EXPECT($L56, fail, 'BinaryOpSymbol "<<"');
|
|
5494
5640
|
var BinaryOpSymbol$9 = $TR($EXPECT($R5, fail, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
5495
5641
|
return "<";
|
|
5496
5642
|
});
|
|
5497
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
5498
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
5499
|
-
var BinaryOpSymbol$12 = $EXPECT($
|
|
5500
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
5501
|
-
var BinaryOpSymbol$14 = $TV($EXPECT($
|
|
5643
|
+
var BinaryOpSymbol$10 = $EXPECT($L57, fail, 'BinaryOpSymbol ">>>"');
|
|
5644
|
+
var BinaryOpSymbol$11 = $EXPECT($L58, fail, 'BinaryOpSymbol ">>"');
|
|
5645
|
+
var BinaryOpSymbol$12 = $EXPECT($L27, fail, 'BinaryOpSymbol ">"');
|
|
5646
|
+
var BinaryOpSymbol$13 = $EXPECT($L59, fail, 'BinaryOpSymbol "!=="');
|
|
5647
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L60, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
5502
5648
|
if (module.config.coffeeEq)
|
|
5503
5649
|
return "!==";
|
|
5504
5650
|
return $1;
|
|
5505
5651
|
});
|
|
5506
|
-
var BinaryOpSymbol$15 = $TS($S($EXPECT($
|
|
5652
|
+
var BinaryOpSymbol$15 = $TS($S($EXPECT($L61, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5507
5653
|
if (module.config.coffeeIsnt)
|
|
5508
5654
|
return "!==";
|
|
5509
5655
|
return $skip;
|
|
5510
5656
|
});
|
|
5511
|
-
var BinaryOpSymbol$16 = $T($S($EXPECT($
|
|
5657
|
+
var BinaryOpSymbol$16 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
5512
5658
|
return "===";
|
|
5513
5659
|
});
|
|
5514
|
-
var BinaryOpSymbol$17 = $EXPECT($
|
|
5515
|
-
var BinaryOpSymbol$18 = $TV($EXPECT($
|
|
5660
|
+
var BinaryOpSymbol$17 = $EXPECT($L63, fail, 'BinaryOpSymbol "==="');
|
|
5661
|
+
var BinaryOpSymbol$18 = $TV($EXPECT($L64, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
5516
5662
|
if (module.config.coffeeEq)
|
|
5517
5663
|
return "===";
|
|
5518
5664
|
return $1;
|
|
5519
5665
|
});
|
|
5520
|
-
var BinaryOpSymbol$19 = $T($S($EXPECT($
|
|
5666
|
+
var BinaryOpSymbol$19 = $T($S($EXPECT($L65, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
5521
5667
|
return "&&";
|
|
5522
5668
|
});
|
|
5523
|
-
var BinaryOpSymbol$20 = $EXPECT($
|
|
5524
|
-
var BinaryOpSymbol$21 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
5669
|
+
var BinaryOpSymbol$20 = $EXPECT($L66, fail, 'BinaryOpSymbol "&&"');
|
|
5670
|
+
var BinaryOpSymbol$21 = $T($S(CoffeeOfEnabled, $EXPECT($L67, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
5525
5671
|
return "in";
|
|
5526
5672
|
});
|
|
5527
|
-
var BinaryOpSymbol$22 = $T($S($EXPECT($
|
|
5673
|
+
var BinaryOpSymbol$22 = $T($S($EXPECT($L68, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
5528
5674
|
return "||";
|
|
5529
5675
|
});
|
|
5530
|
-
var BinaryOpSymbol$23 = $EXPECT($
|
|
5531
|
-
var BinaryOpSymbol$24 = $EXPECT($
|
|
5532
|
-
var BinaryOpSymbol$25 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($
|
|
5676
|
+
var BinaryOpSymbol$23 = $EXPECT($L69, fail, 'BinaryOpSymbol "||"');
|
|
5677
|
+
var BinaryOpSymbol$24 = $EXPECT($L70, fail, 'BinaryOpSymbol "??"');
|
|
5678
|
+
var BinaryOpSymbol$25 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L71, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
5533
5679
|
return "??";
|
|
5534
5680
|
});
|
|
5535
|
-
var BinaryOpSymbol$26 = $TS($S($EXPECT($
|
|
5681
|
+
var BinaryOpSymbol$26 = $TS($S($EXPECT($L72, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5536
5682
|
return $1;
|
|
5537
5683
|
});
|
|
5538
|
-
var BinaryOpSymbol$27 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
5684
|
+
var BinaryOpSymbol$27 = $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) {
|
|
5539
5685
|
return {
|
|
5540
5686
|
$loc,
|
|
5541
5687
|
token: "instanceof",
|
|
5542
5688
|
special: true
|
|
5543
5689
|
};
|
|
5544
5690
|
});
|
|
5545
|
-
var BinaryOpSymbol$28 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
5691
|
+
var BinaryOpSymbol$28 = $TS($S(CoffeeNotEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L67, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
5546
5692
|
return {
|
|
5547
5693
|
$loc,
|
|
5548
5694
|
token: "in",
|
|
5549
5695
|
special: true
|
|
5550
5696
|
};
|
|
5551
5697
|
});
|
|
5552
|
-
var BinaryOpSymbol$29 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
5698
|
+
var BinaryOpSymbol$29 = $TS($S(CoffeeOfEnabled, $EXPECT($L74, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
5553
5699
|
return {
|
|
5554
5700
|
ref: module.getRef("indexOf"),
|
|
5555
5701
|
suffix: " >= 0",
|
|
5556
5702
|
special: true
|
|
5557
5703
|
};
|
|
5558
5704
|
});
|
|
5559
|
-
var BinaryOpSymbol$30 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
5705
|
+
var BinaryOpSymbol$30 = $TS($S(CoffeeOfEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L74, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
5560
5706
|
return {
|
|
5561
5707
|
ref: module.getRef("indexOf"),
|
|
5562
5708
|
suffix: " < 0",
|
|
5563
5709
|
special: true
|
|
5564
5710
|
};
|
|
5565
5711
|
});
|
|
5566
|
-
var BinaryOpSymbol$31 = $TS($S($EXPECT($
|
|
5712
|
+
var BinaryOpSymbol$31 = $TS($S($EXPECT($L74, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5567
5713
|
return $1;
|
|
5568
5714
|
});
|
|
5569
|
-
var BinaryOpSymbol$32 = $EXPECT($
|
|
5570
|
-
var BinaryOpSymbol$33 = $EXPECT($
|
|
5571
|
-
var BinaryOpSymbol$34 = $EXPECT($
|
|
5715
|
+
var BinaryOpSymbol$32 = $EXPECT($L75, fail, 'BinaryOpSymbol "&"');
|
|
5716
|
+
var BinaryOpSymbol$33 = $EXPECT($L76, fail, 'BinaryOpSymbol "^"');
|
|
5717
|
+
var BinaryOpSymbol$34 = $EXPECT($L77, fail, 'BinaryOpSymbol "|"');
|
|
5572
5718
|
function BinaryOpSymbol(state) {
|
|
5573
5719
|
if (state.events) {
|
|
5574
5720
|
const result = state.events.enter?.("BinaryOpSymbol", state);
|
|
@@ -5707,7 +5853,7 @@ ${input.slice(result.pos)}
|
|
|
5707
5853
|
return result;
|
|
5708
5854
|
}
|
|
5709
5855
|
}
|
|
5710
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
5856
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L78, fail, 'EmptyStatement ";"'))), function(value) {
|
|
5711
5857
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
5712
5858
|
});
|
|
5713
5859
|
function EmptyStatement(state) {
|
|
@@ -5728,7 +5874,7 @@ ${input.slice(result.pos)}
|
|
|
5728
5874
|
return result;
|
|
5729
5875
|
}
|
|
5730
5876
|
}
|
|
5731
|
-
var BlockStatement$0 = $T($S(ExplicitBlock, $N($S(__, $EXPECT($
|
|
5877
|
+
var BlockStatement$0 = $T($S(ExplicitBlock, $N($S(__, $EXPECT($L26, fail, 'BlockStatement "="')))), function(value) {
|
|
5732
5878
|
return value[0];
|
|
5733
5879
|
});
|
|
5734
5880
|
function BlockStatement(state) {
|
|
@@ -6555,7 +6701,7 @@ ${input.slice(result.pos)}
|
|
|
6555
6701
|
return result;
|
|
6556
6702
|
}
|
|
6557
6703
|
}
|
|
6558
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
6704
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L79, fail, 'CoffeeForDeclaration "own"'))), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
6559
6705
|
var own = $1;
|
|
6560
6706
|
var binding = $2;
|
|
6561
6707
|
if (own) {
|
|
@@ -7099,7 +7245,7 @@ ${input.slice(result.pos)}
|
|
|
7099
7245
|
return result;
|
|
7100
7246
|
}
|
|
7101
7247
|
}
|
|
7102
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
7248
|
+
var Finally$0 = $S(__, $EXPECT($L80, fail, 'Finally "finally"'), BracedBlock);
|
|
7103
7249
|
function Finally(state) {
|
|
7104
7250
|
if (state.events) {
|
|
7105
7251
|
const result = state.events.enter?.("Finally", state);
|
|
@@ -7235,13 +7381,13 @@ ${input.slice(result.pos)}
|
|
|
7235
7381
|
return result;
|
|
7236
7382
|
}
|
|
7237
7383
|
}
|
|
7238
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
7384
|
+
var KeywordStatement$0 = $T($S($EXPECT($L81, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
7239
7385
|
return { "type": "BreakStatement", "children": value };
|
|
7240
7386
|
});
|
|
7241
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
7387
|
+
var KeywordStatement$1 = $T($S($EXPECT($L82, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
7242
7388
|
return { "type": "ContinueStatement", "children": value };
|
|
7243
7389
|
});
|
|
7244
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
7390
|
+
var KeywordStatement$2 = $T($S($EXPECT($L83, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
7245
7391
|
return { "type": "DebuggerStatement", "children": value };
|
|
7246
7392
|
});
|
|
7247
7393
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -7268,7 +7414,7 @@ ${input.slice(result.pos)}
|
|
|
7268
7414
|
return result;
|
|
7269
7415
|
}
|
|
7270
7416
|
}
|
|
7271
|
-
var DebuggerExpression$0 = $TS($S($EXPECT($
|
|
7417
|
+
var DebuggerExpression$0 = $TS($S($EXPECT($L83, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7272
7418
|
return {
|
|
7273
7419
|
type: "DebuggerExpression",
|
|
7274
7420
|
children: ["(()=>{", $1, "})()"]
|
|
@@ -7341,7 +7487,7 @@ ${input.slice(result.pos)}
|
|
|
7341
7487
|
return result;
|
|
7342
7488
|
}
|
|
7343
7489
|
}
|
|
7344
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
7490
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L84, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
7345
7491
|
return { "ts": true, "children": value };
|
|
7346
7492
|
});
|
|
7347
7493
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
@@ -7641,7 +7787,7 @@ ${input.slice(result.pos)}
|
|
|
7641
7787
|
return result;
|
|
7642
7788
|
}
|
|
7643
7789
|
}
|
|
7644
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
7790
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L85, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression));
|
|
7645
7791
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
7646
7792
|
var ExportDeclaration$2 = $S(Export, __, $C(Declaration, NamedExports, VariableStatement, ExportVarDec));
|
|
7647
7793
|
function ExportDeclaration(state) {
|
|
@@ -7744,7 +7890,7 @@ ${input.slice(result.pos)}
|
|
|
7744
7890
|
return result;
|
|
7745
7891
|
}
|
|
7746
7892
|
}
|
|
7747
|
-
var ImplicitExportSpecifier$0 = $S($N($EXPECT($
|
|
7893
|
+
var ImplicitExportSpecifier$0 = $S($N($EXPECT($L85, fail, 'ImplicitExportSpecifier "default"')), ModuleExportName, $E($S(__, As, __, ModuleExportName)), $C($Y($S(__, From)), ImplicitInlineObjectPropertyDelimiter));
|
|
7748
7894
|
function ImplicitExportSpecifier(state) {
|
|
7749
7895
|
if (state.events) {
|
|
7750
7896
|
const result = state.events.enter?.("ImplicitExportSpecifier", state);
|
|
@@ -7899,7 +8045,7 @@ ${input.slice(result.pos)}
|
|
|
7899
8045
|
return result;
|
|
7900
8046
|
}
|
|
7901
8047
|
}
|
|
7902
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
8048
|
+
var ConstAssignment$0 = $TV($EXPECT($L86, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
7903
8049
|
return { $loc, token: "=" };
|
|
7904
8050
|
});
|
|
7905
8051
|
function ConstAssignment(state) {
|
|
@@ -7920,10 +8066,10 @@ ${input.slice(result.pos)}
|
|
|
7920
8066
|
return result;
|
|
7921
8067
|
}
|
|
7922
8068
|
}
|
|
7923
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
8069
|
+
var LetAssignment$0 = $TV($EXPECT($L87, fail, 'LetAssignment "::="'), function($skip, $loc, $0, $1) {
|
|
7924
8070
|
return { $loc, token: "=" };
|
|
7925
8071
|
});
|
|
7926
|
-
var LetAssignment$1 = $TV($EXPECT($
|
|
8072
|
+
var LetAssignment$1 = $TV($EXPECT($L88, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
7927
8073
|
return { $loc, token: "=" };
|
|
7928
8074
|
});
|
|
7929
8075
|
function LetAssignment(state) {
|
|
@@ -8481,7 +8627,7 @@ ${input.slice(result.pos)}
|
|
|
8481
8627
|
}
|
|
8482
8628
|
}
|
|
8483
8629
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
8484
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
8630
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L50, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L50, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
8485
8631
|
return { $loc, token: $1 };
|
|
8486
8632
|
});
|
|
8487
8633
|
function RegularExpressionLiteral(state) {
|
|
@@ -8927,7 +9073,7 @@ ${input.slice(result.pos)}
|
|
|
8927
9073
|
return result;
|
|
8928
9074
|
}
|
|
8929
9075
|
}
|
|
8930
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
9076
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L89, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L90, fail, 'JSMultiLineComment "*/"')), $EXPECT($R38, fail, "JSMultiLineComment /./"))), $EXPECT($L90, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
8931
9077
|
return { $loc, token: $1 };
|
|
8932
9078
|
});
|
|
8933
9079
|
function JSMultiLineComment(state) {
|
|
@@ -8969,7 +9115,7 @@ ${input.slice(result.pos)}
|
|
|
8969
9115
|
return result;
|
|
8970
9116
|
}
|
|
8971
9117
|
}
|
|
8972
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($Q($S($N($C(CoffeeHereCommentStart, $EXPECT($
|
|
9118
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($Q($S($N($C(CoffeeHereCommentStart, $EXPECT($L90, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R38, fail, "CoffeeMultiLineComment /./")))), CoffeeHereCommentStart), function($skip, $loc, $0, $1, $2, $3) {
|
|
8973
9119
|
return { $loc, token: `/*${$2}*/` };
|
|
8974
9120
|
});
|
|
8975
9121
|
function CoffeeMultiLineComment(state) {
|
|
@@ -9009,7 +9155,7 @@ ${input.slice(result.pos)}
|
|
|
9009
9155
|
return result;
|
|
9010
9156
|
}
|
|
9011
9157
|
}
|
|
9012
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
9158
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L89, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L90, fail, 'InlineComment "*/"')), $EXPECT($R41, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L90, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
9013
9159
|
return { $loc, token: $1 };
|
|
9014
9160
|
});
|
|
9015
9161
|
function InlineComment(state) {
|
|
@@ -9070,7 +9216,7 @@ ${input.slice(result.pos)}
|
|
|
9070
9216
|
return result;
|
|
9071
9217
|
}
|
|
9072
9218
|
}
|
|
9073
|
-
var _$0 = $P($C(NonNewlineWhitespace,
|
|
9219
|
+
var _$0 = $P($C(NonNewlineWhitespace, InlineComment));
|
|
9074
9220
|
function _(state) {
|
|
9075
9221
|
if (state.events) {
|
|
9076
9222
|
const result = state.events.enter?.("_", state);
|
|
@@ -9092,7 +9238,7 @@ ${input.slice(result.pos)}
|
|
|
9092
9238
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R42, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9093
9239
|
return { $loc, token: $0 };
|
|
9094
9240
|
});
|
|
9095
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
9241
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L91, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
9096
9242
|
return "";
|
|
9097
9243
|
});
|
|
9098
9244
|
function NonNewlineWhitespace(state) {
|
|
@@ -9237,7 +9383,28 @@ ${input.slice(result.pos)}
|
|
|
9237
9383
|
return result;
|
|
9238
9384
|
}
|
|
9239
9385
|
}
|
|
9240
|
-
var
|
|
9386
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L92, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L4, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
9387
|
+
return { $loc, token: $1, ts: true };
|
|
9388
|
+
});
|
|
9389
|
+
function Abstract(state) {
|
|
9390
|
+
if (state.events) {
|
|
9391
|
+
const result = state.events.enter?.("Abstract", state);
|
|
9392
|
+
if (result)
|
|
9393
|
+
return result.cache;
|
|
9394
|
+
}
|
|
9395
|
+
if (state.tokenize) {
|
|
9396
|
+
const result = $TOKEN("Abstract", state, Abstract$0(state));
|
|
9397
|
+
if (state.events)
|
|
9398
|
+
state.events.exit?.("Abstract", state, result);
|
|
9399
|
+
return result;
|
|
9400
|
+
} else {
|
|
9401
|
+
const result = Abstract$0(state);
|
|
9402
|
+
if (state.events)
|
|
9403
|
+
state.events.exit?.("Abstract", state, result);
|
|
9404
|
+
return result;
|
|
9405
|
+
}
|
|
9406
|
+
}
|
|
9407
|
+
var Ampersand$0 = $TV($EXPECT($L75, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
9241
9408
|
return { $loc, token: $1 };
|
|
9242
9409
|
});
|
|
9243
9410
|
function Ampersand(state) {
|
|
@@ -9258,7 +9425,7 @@ ${input.slice(result.pos)}
|
|
|
9258
9425
|
return result;
|
|
9259
9426
|
}
|
|
9260
9427
|
}
|
|
9261
|
-
var As$0 = $TS($S($EXPECT($
|
|
9428
|
+
var As$0 = $TS($S($EXPECT($L93, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9262
9429
|
return { $loc, token: $1 };
|
|
9263
9430
|
});
|
|
9264
9431
|
function As(state) {
|
|
@@ -9279,7 +9446,7 @@ ${input.slice(result.pos)}
|
|
|
9279
9446
|
return result;
|
|
9280
9447
|
}
|
|
9281
9448
|
}
|
|
9282
|
-
var At$0 = $TV($EXPECT($
|
|
9449
|
+
var At$0 = $TV($EXPECT($L94, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
9283
9450
|
return { $loc, token: $1 };
|
|
9284
9451
|
});
|
|
9285
9452
|
function At(state) {
|
|
@@ -9300,7 +9467,7 @@ ${input.slice(result.pos)}
|
|
|
9300
9467
|
return result;
|
|
9301
9468
|
}
|
|
9302
9469
|
}
|
|
9303
|
-
var AtAt$0 = $TV($EXPECT($
|
|
9470
|
+
var AtAt$0 = $TV($EXPECT($L95, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
9304
9471
|
return { $loc, token: "@" };
|
|
9305
9472
|
});
|
|
9306
9473
|
function AtAt(state) {
|
|
@@ -9321,7 +9488,7 @@ ${input.slice(result.pos)}
|
|
|
9321
9488
|
return result;
|
|
9322
9489
|
}
|
|
9323
9490
|
}
|
|
9324
|
-
var Async$0 = $TV($EXPECT($
|
|
9491
|
+
var Async$0 = $TV($EXPECT($L96, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
|
|
9325
9492
|
return { $loc, token: $1, type: "Async" };
|
|
9326
9493
|
});
|
|
9327
9494
|
function Async(state) {
|
|
@@ -9342,7 +9509,7 @@ ${input.slice(result.pos)}
|
|
|
9342
9509
|
return result;
|
|
9343
9510
|
}
|
|
9344
9511
|
}
|
|
9345
|
-
var Await$0 = $TS($S($EXPECT($
|
|
9512
|
+
var Await$0 = $TS($S($EXPECT($L97, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9346
9513
|
return { $loc, token: $1 };
|
|
9347
9514
|
});
|
|
9348
9515
|
function Await(state) {
|
|
@@ -9363,7 +9530,7 @@ ${input.slice(result.pos)}
|
|
|
9363
9530
|
return result;
|
|
9364
9531
|
}
|
|
9365
9532
|
}
|
|
9366
|
-
var Backtick$0 = $TV($EXPECT($
|
|
9533
|
+
var Backtick$0 = $TV($EXPECT($L98, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
9367
9534
|
return { $loc, token: $1 };
|
|
9368
9535
|
});
|
|
9369
9536
|
function Backtick(state) {
|
|
@@ -9384,7 +9551,7 @@ ${input.slice(result.pos)}
|
|
|
9384
9551
|
return result;
|
|
9385
9552
|
}
|
|
9386
9553
|
}
|
|
9387
|
-
var By$0 = $TS($S($EXPECT($
|
|
9554
|
+
var By$0 = $TS($S($EXPECT($L99, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9388
9555
|
return { $loc, token: $1 };
|
|
9389
9556
|
});
|
|
9390
9557
|
function By(state) {
|
|
@@ -9405,7 +9572,7 @@ ${input.slice(result.pos)}
|
|
|
9405
9572
|
return result;
|
|
9406
9573
|
}
|
|
9407
9574
|
}
|
|
9408
|
-
var Case$0 = $TS($S($EXPECT($
|
|
9575
|
+
var Case$0 = $TS($S($EXPECT($L100, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9409
9576
|
return { $loc, token: $1 };
|
|
9410
9577
|
});
|
|
9411
9578
|
function Case(state) {
|
|
@@ -9426,7 +9593,7 @@ ${input.slice(result.pos)}
|
|
|
9426
9593
|
return result;
|
|
9427
9594
|
}
|
|
9428
9595
|
}
|
|
9429
|
-
var Catch$0 = $TV($EXPECT($
|
|
9596
|
+
var Catch$0 = $TV($EXPECT($L101, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
9430
9597
|
return { $loc, token: $1 };
|
|
9431
9598
|
});
|
|
9432
9599
|
function Catch(state) {
|
|
@@ -9447,7 +9614,7 @@ ${input.slice(result.pos)}
|
|
|
9447
9614
|
return result;
|
|
9448
9615
|
}
|
|
9449
9616
|
}
|
|
9450
|
-
var Class$0 = $TV($EXPECT($
|
|
9617
|
+
var Class$0 = $TV($EXPECT($L102, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
9451
9618
|
return { $loc, token: $1 };
|
|
9452
9619
|
});
|
|
9453
9620
|
function Class(state) {
|
|
@@ -9468,7 +9635,7 @@ ${input.slice(result.pos)}
|
|
|
9468
9635
|
return result;
|
|
9469
9636
|
}
|
|
9470
9637
|
}
|
|
9471
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
9638
|
+
var CloseBrace$0 = $TV($EXPECT($L17, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
9472
9639
|
return { $loc, token: $1 };
|
|
9473
9640
|
});
|
|
9474
9641
|
function CloseBrace(state) {
|
|
@@ -9489,7 +9656,7 @@ ${input.slice(result.pos)}
|
|
|
9489
9656
|
return result;
|
|
9490
9657
|
}
|
|
9491
9658
|
}
|
|
9492
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
9659
|
+
var CloseBracket$0 = $TV($EXPECT($L28, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
9493
9660
|
return { $loc, token: $1 };
|
|
9494
9661
|
});
|
|
9495
9662
|
function CloseBracket(state) {
|
|
@@ -9510,7 +9677,7 @@ ${input.slice(result.pos)}
|
|
|
9510
9677
|
return result;
|
|
9511
9678
|
}
|
|
9512
9679
|
}
|
|
9513
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
9680
|
+
var CloseParen$0 = $TV($EXPECT($L15, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
9514
9681
|
return { $loc, token: $1 };
|
|
9515
9682
|
});
|
|
9516
9683
|
function CloseParen(state) {
|
|
@@ -9531,7 +9698,7 @@ ${input.slice(result.pos)}
|
|
|
9531
9698
|
return result;
|
|
9532
9699
|
}
|
|
9533
9700
|
}
|
|
9534
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
9701
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L103, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
9535
9702
|
return { $loc, token: "${" };
|
|
9536
9703
|
});
|
|
9537
9704
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -9552,7 +9719,7 @@ ${input.slice(result.pos)}
|
|
|
9552
9719
|
return result;
|
|
9553
9720
|
}
|
|
9554
9721
|
}
|
|
9555
|
-
var Colon$0 = $TV($EXPECT($
|
|
9722
|
+
var Colon$0 = $TV($EXPECT($L29, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
9556
9723
|
return { $loc, token: $1 };
|
|
9557
9724
|
});
|
|
9558
9725
|
function Colon(state) {
|
|
@@ -9573,7 +9740,7 @@ ${input.slice(result.pos)}
|
|
|
9573
9740
|
return result;
|
|
9574
9741
|
}
|
|
9575
9742
|
}
|
|
9576
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
9743
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L94, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
9577
9744
|
return { $loc, token: "constructor" };
|
|
9578
9745
|
});
|
|
9579
9746
|
function ConstructorShorthand(state) {
|
|
@@ -9594,7 +9761,7 @@ ${input.slice(result.pos)}
|
|
|
9594
9761
|
return result;
|
|
9595
9762
|
}
|
|
9596
9763
|
}
|
|
9597
|
-
var Default$0 = $TS($S($EXPECT($
|
|
9764
|
+
var Default$0 = $TS($S($EXPECT($L85, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9598
9765
|
return { $loc, token: $1 };
|
|
9599
9766
|
});
|
|
9600
9767
|
function Default(state) {
|
|
@@ -9615,7 +9782,7 @@ ${input.slice(result.pos)}
|
|
|
9615
9782
|
return result;
|
|
9616
9783
|
}
|
|
9617
9784
|
}
|
|
9618
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
9785
|
+
var Delete$0 = $TS($S($EXPECT($L104, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9619
9786
|
return { $loc, token: $1 };
|
|
9620
9787
|
});
|
|
9621
9788
|
function Delete(state) {
|
|
@@ -9636,7 +9803,7 @@ ${input.slice(result.pos)}
|
|
|
9636
9803
|
return result;
|
|
9637
9804
|
}
|
|
9638
9805
|
}
|
|
9639
|
-
var Do$0 = $TS($S($EXPECT($
|
|
9806
|
+
var Do$0 = $TS($S($EXPECT($L105, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9640
9807
|
return { $loc, token: $1 };
|
|
9641
9808
|
});
|
|
9642
9809
|
function Do(state) {
|
|
@@ -9657,7 +9824,7 @@ ${input.slice(result.pos)}
|
|
|
9657
9824
|
return result;
|
|
9658
9825
|
}
|
|
9659
9826
|
}
|
|
9660
|
-
var Dot$0 = $TV($EXPECT($
|
|
9827
|
+
var Dot$0 = $TV($EXPECT($L9, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
9661
9828
|
return { $loc, token: $1 };
|
|
9662
9829
|
});
|
|
9663
9830
|
function Dot(state) {
|
|
@@ -9678,7 +9845,7 @@ ${input.slice(result.pos)}
|
|
|
9678
9845
|
return result;
|
|
9679
9846
|
}
|
|
9680
9847
|
}
|
|
9681
|
-
var DotDot$0 = $TV($EXPECT($
|
|
9848
|
+
var DotDot$0 = $TV($EXPECT($L106, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
9682
9849
|
return { $loc, token: $1 };
|
|
9683
9850
|
});
|
|
9684
9851
|
function DotDot(state) {
|
|
@@ -9699,7 +9866,7 @@ ${input.slice(result.pos)}
|
|
|
9699
9866
|
return result;
|
|
9700
9867
|
}
|
|
9701
9868
|
}
|
|
9702
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
9869
|
+
var DotDotDot$0 = $TV($EXPECT($L107, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
9703
9870
|
return { $loc, token: $1 };
|
|
9704
9871
|
});
|
|
9705
9872
|
function DotDotDot(state) {
|
|
@@ -9720,7 +9887,7 @@ ${input.slice(result.pos)}
|
|
|
9720
9887
|
return result;
|
|
9721
9888
|
}
|
|
9722
9889
|
}
|
|
9723
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
9890
|
+
var DoubleColon$0 = $TV($EXPECT($L108, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
9724
9891
|
return { $loc, token: $1 };
|
|
9725
9892
|
});
|
|
9726
9893
|
function DoubleColon(state) {
|
|
@@ -9741,7 +9908,7 @@ ${input.slice(result.pos)}
|
|
|
9741
9908
|
return result;
|
|
9742
9909
|
}
|
|
9743
9910
|
}
|
|
9744
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
9911
|
+
var DoubleQuote$0 = $TV($EXPECT($L109, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
9745
9912
|
return { $loc, token: $1 };
|
|
9746
9913
|
});
|
|
9747
9914
|
function DoubleQuote(state) {
|
|
@@ -9762,7 +9929,7 @@ ${input.slice(result.pos)}
|
|
|
9762
9929
|
return result;
|
|
9763
9930
|
}
|
|
9764
9931
|
}
|
|
9765
|
-
var Else$0 = $TV($EXPECT($
|
|
9932
|
+
var Else$0 = $TV($EXPECT($L110, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
9766
9933
|
return { $loc, token: $1 };
|
|
9767
9934
|
});
|
|
9768
9935
|
function Else(state) {
|
|
@@ -9783,7 +9950,7 @@ ${input.slice(result.pos)}
|
|
|
9783
9950
|
return result;
|
|
9784
9951
|
}
|
|
9785
9952
|
}
|
|
9786
|
-
var Equals$0 = $TV($EXPECT($
|
|
9953
|
+
var Equals$0 = $TV($EXPECT($L26, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
9787
9954
|
return { $loc, token: $1 };
|
|
9788
9955
|
});
|
|
9789
9956
|
function Equals(state) {
|
|
@@ -9804,7 +9971,7 @@ ${input.slice(result.pos)}
|
|
|
9804
9971
|
return result;
|
|
9805
9972
|
}
|
|
9806
9973
|
}
|
|
9807
|
-
var Export$0 = $TS($S($EXPECT($
|
|
9974
|
+
var Export$0 = $TS($S($EXPECT($L111, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9808
9975
|
return { $loc, token: $1 };
|
|
9809
9976
|
});
|
|
9810
9977
|
function Export(state) {
|
|
@@ -9825,7 +9992,7 @@ ${input.slice(result.pos)}
|
|
|
9825
9992
|
return result;
|
|
9826
9993
|
}
|
|
9827
9994
|
}
|
|
9828
|
-
var For$0 = $TS($S($EXPECT($
|
|
9995
|
+
var For$0 = $TS($S($EXPECT($L112, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9829
9996
|
return { $loc, token: $1 };
|
|
9830
9997
|
});
|
|
9831
9998
|
function For(state) {
|
|
@@ -9846,7 +10013,7 @@ ${input.slice(result.pos)}
|
|
|
9846
10013
|
return result;
|
|
9847
10014
|
}
|
|
9848
10015
|
}
|
|
9849
|
-
var From$0 = $TS($S($EXPECT($
|
|
10016
|
+
var From$0 = $TS($S($EXPECT($L113, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9850
10017
|
return { $loc, token: $1 };
|
|
9851
10018
|
});
|
|
9852
10019
|
function From(state) {
|
|
@@ -9867,7 +10034,7 @@ ${input.slice(result.pos)}
|
|
|
9867
10034
|
return result;
|
|
9868
10035
|
}
|
|
9869
10036
|
}
|
|
9870
|
-
var Function$0 = $TV($EXPECT($
|
|
10037
|
+
var Function$0 = $TV($EXPECT($L114, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
9871
10038
|
return { $loc, token: $1 };
|
|
9872
10039
|
});
|
|
9873
10040
|
function Function(state) {
|
|
@@ -9888,7 +10055,7 @@ ${input.slice(result.pos)}
|
|
|
9888
10055
|
return result;
|
|
9889
10056
|
}
|
|
9890
10057
|
}
|
|
9891
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
10058
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L115, fail, 'GetOrSet "get"'), $EXPECT($L116, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9892
10059
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
9893
10060
|
});
|
|
9894
10061
|
function GetOrSet(state) {
|
|
@@ -9909,7 +10076,7 @@ ${input.slice(result.pos)}
|
|
|
9909
10076
|
return result;
|
|
9910
10077
|
}
|
|
9911
10078
|
}
|
|
9912
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
10079
|
+
var If$0 = $TV($TEXT($S($EXPECT($L117, fail, 'If "if"'), $E($EXPECT($L4, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
9913
10080
|
return { $loc, token: $1 };
|
|
9914
10081
|
});
|
|
9915
10082
|
function If(state) {
|
|
@@ -9930,7 +10097,7 @@ ${input.slice(result.pos)}
|
|
|
9930
10097
|
return result;
|
|
9931
10098
|
}
|
|
9932
10099
|
}
|
|
9933
|
-
var Import$0 = $TS($S($EXPECT($
|
|
10100
|
+
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R44, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
9934
10101
|
return { $loc, token: $1 };
|
|
9935
10102
|
});
|
|
9936
10103
|
function Import(state) {
|
|
@@ -9951,7 +10118,7 @@ ${input.slice(result.pos)}
|
|
|
9951
10118
|
return result;
|
|
9952
10119
|
}
|
|
9953
10120
|
}
|
|
9954
|
-
var In$0 = $TV($EXPECT($
|
|
10121
|
+
var In$0 = $TV($EXPECT($L74, fail, 'In "in"'), function($skip, $loc, $0, $1) {
|
|
9955
10122
|
return { $loc, token: $1 };
|
|
9956
10123
|
});
|
|
9957
10124
|
function In(state) {
|
|
@@ -9972,7 +10139,7 @@ ${input.slice(result.pos)}
|
|
|
9972
10139
|
return result;
|
|
9973
10140
|
}
|
|
9974
10141
|
}
|
|
9975
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
10142
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L118, fail, 'LetOrConst "let"'), $EXPECT($L119, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9976
10143
|
return { $loc, token: $1 };
|
|
9977
10144
|
});
|
|
9978
10145
|
function LetOrConst(state) {
|
|
@@ -9993,7 +10160,7 @@ ${input.slice(result.pos)}
|
|
|
9993
10160
|
return result;
|
|
9994
10161
|
}
|
|
9995
10162
|
}
|
|
9996
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
10163
|
+
var Loop$0 = $TS($S($EXPECT($L120, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9997
10164
|
return { $loc, token: "while(true)" };
|
|
9998
10165
|
});
|
|
9999
10166
|
function Loop(state) {
|
|
@@ -10014,7 +10181,7 @@ ${input.slice(result.pos)}
|
|
|
10014
10181
|
return result;
|
|
10015
10182
|
}
|
|
10016
10183
|
}
|
|
10017
|
-
var New$0 = $TS($S($EXPECT($
|
|
10184
|
+
var New$0 = $TS($S($EXPECT($L121, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10018
10185
|
return { $loc, token: $1 };
|
|
10019
10186
|
});
|
|
10020
10187
|
function New(state) {
|
|
@@ -10035,7 +10202,7 @@ ${input.slice(result.pos)}
|
|
|
10035
10202
|
return result;
|
|
10036
10203
|
}
|
|
10037
10204
|
}
|
|
10038
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
10205
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L73, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L4, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
10039
10206
|
return { $loc, token: "!" };
|
|
10040
10207
|
});
|
|
10041
10208
|
function Not(state) {
|
|
@@ -10056,7 +10223,7 @@ ${input.slice(result.pos)}
|
|
|
10056
10223
|
return result;
|
|
10057
10224
|
}
|
|
10058
10225
|
}
|
|
10059
|
-
var Of$0 = $TV($EXPECT($
|
|
10226
|
+
var Of$0 = $TV($EXPECT($L67, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
10060
10227
|
return { $loc, token: $1 };
|
|
10061
10228
|
});
|
|
10062
10229
|
function Of(state) {
|
|
@@ -10077,7 +10244,7 @@ ${input.slice(result.pos)}
|
|
|
10077
10244
|
return result;
|
|
10078
10245
|
}
|
|
10079
10246
|
}
|
|
10080
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
10247
|
+
var OpenBrace$0 = $TV($EXPECT($L122, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
10081
10248
|
return { $loc, token: $1 };
|
|
10082
10249
|
});
|
|
10083
10250
|
function OpenBrace(state) {
|
|
@@ -10098,7 +10265,7 @@ ${input.slice(result.pos)}
|
|
|
10098
10265
|
return result;
|
|
10099
10266
|
}
|
|
10100
10267
|
}
|
|
10101
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
10268
|
+
var OpenBracket$0 = $TV($EXPECT($L123, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
10102
10269
|
return { $loc, token: $1 };
|
|
10103
10270
|
});
|
|
10104
10271
|
function OpenBracket(state) {
|
|
@@ -10119,7 +10286,7 @@ ${input.slice(result.pos)}
|
|
|
10119
10286
|
return result;
|
|
10120
10287
|
}
|
|
10121
10288
|
}
|
|
10122
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
10289
|
+
var OpenParen$0 = $TV($EXPECT($L124, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
10123
10290
|
return { $loc, token: $1 };
|
|
10124
10291
|
});
|
|
10125
10292
|
function OpenParen(state) {
|
|
@@ -10140,7 +10307,91 @@ ${input.slice(result.pos)}
|
|
|
10140
10307
|
return result;
|
|
10141
10308
|
}
|
|
10142
10309
|
}
|
|
10143
|
-
var
|
|
10310
|
+
var Public$0 = $TS($S($EXPECT($L125, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10311
|
+
return { $loc, token: $1 };
|
|
10312
|
+
});
|
|
10313
|
+
function Public(state) {
|
|
10314
|
+
if (state.events) {
|
|
10315
|
+
const result = state.events.enter?.("Public", state);
|
|
10316
|
+
if (result)
|
|
10317
|
+
return result.cache;
|
|
10318
|
+
}
|
|
10319
|
+
if (state.tokenize) {
|
|
10320
|
+
const result = $TOKEN("Public", state, Public$0(state));
|
|
10321
|
+
if (state.events)
|
|
10322
|
+
state.events.exit?.("Public", state, result);
|
|
10323
|
+
return result;
|
|
10324
|
+
} else {
|
|
10325
|
+
const result = Public$0(state);
|
|
10326
|
+
if (state.events)
|
|
10327
|
+
state.events.exit?.("Public", state, result);
|
|
10328
|
+
return result;
|
|
10329
|
+
}
|
|
10330
|
+
}
|
|
10331
|
+
var Private$0 = $TS($S($EXPECT($L126, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10332
|
+
return { $loc, token: $1 };
|
|
10333
|
+
});
|
|
10334
|
+
function Private(state) {
|
|
10335
|
+
if (state.events) {
|
|
10336
|
+
const result = state.events.enter?.("Private", state);
|
|
10337
|
+
if (result)
|
|
10338
|
+
return result.cache;
|
|
10339
|
+
}
|
|
10340
|
+
if (state.tokenize) {
|
|
10341
|
+
const result = $TOKEN("Private", state, Private$0(state));
|
|
10342
|
+
if (state.events)
|
|
10343
|
+
state.events.exit?.("Private", state, result);
|
|
10344
|
+
return result;
|
|
10345
|
+
} else {
|
|
10346
|
+
const result = Private$0(state);
|
|
10347
|
+
if (state.events)
|
|
10348
|
+
state.events.exit?.("Private", state, result);
|
|
10349
|
+
return result;
|
|
10350
|
+
}
|
|
10351
|
+
}
|
|
10352
|
+
var Protected$0 = $TS($S($EXPECT($L127, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10353
|
+
return { $loc, token: $1 };
|
|
10354
|
+
});
|
|
10355
|
+
function Protected(state) {
|
|
10356
|
+
if (state.events) {
|
|
10357
|
+
const result = state.events.enter?.("Protected", state);
|
|
10358
|
+
if (result)
|
|
10359
|
+
return result.cache;
|
|
10360
|
+
}
|
|
10361
|
+
if (state.tokenize) {
|
|
10362
|
+
const result = $TOKEN("Protected", state, Protected$0(state));
|
|
10363
|
+
if (state.events)
|
|
10364
|
+
state.events.exit?.("Protected", state, result);
|
|
10365
|
+
return result;
|
|
10366
|
+
} else {
|
|
10367
|
+
const result = Protected$0(state);
|
|
10368
|
+
if (state.events)
|
|
10369
|
+
state.events.exit?.("Protected", state, result);
|
|
10370
|
+
return result;
|
|
10371
|
+
}
|
|
10372
|
+
}
|
|
10373
|
+
var Pipe$0 = $TV($EXPECT($L128, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
10374
|
+
return { $loc, token: $1 };
|
|
10375
|
+
});
|
|
10376
|
+
function Pipe(state) {
|
|
10377
|
+
if (state.events) {
|
|
10378
|
+
const result = state.events.enter?.("Pipe", state);
|
|
10379
|
+
if (result)
|
|
10380
|
+
return result.cache;
|
|
10381
|
+
}
|
|
10382
|
+
if (state.tokenize) {
|
|
10383
|
+
const result = $TOKEN("Pipe", state, Pipe$0(state));
|
|
10384
|
+
if (state.events)
|
|
10385
|
+
state.events.exit?.("Pipe", state, result);
|
|
10386
|
+
return result;
|
|
10387
|
+
} else {
|
|
10388
|
+
const result = Pipe$0(state);
|
|
10389
|
+
if (state.events)
|
|
10390
|
+
state.events.exit?.("Pipe", state, result);
|
|
10391
|
+
return result;
|
|
10392
|
+
}
|
|
10393
|
+
}
|
|
10394
|
+
var QuestionMark$0 = $TV($EXPECT($L71, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
10144
10395
|
return { $loc, token: $1 };
|
|
10145
10396
|
});
|
|
10146
10397
|
function QuestionMark(state) {
|
|
@@ -10161,7 +10412,28 @@ ${input.slice(result.pos)}
|
|
|
10161
10412
|
return result;
|
|
10162
10413
|
}
|
|
10163
10414
|
}
|
|
10164
|
-
var
|
|
10415
|
+
var Readonly$0 = $TS($S($EXPECT($L129, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10416
|
+
return { $loc, token: $1, ts: true };
|
|
10417
|
+
});
|
|
10418
|
+
function Readonly(state) {
|
|
10419
|
+
if (state.events) {
|
|
10420
|
+
const result = state.events.enter?.("Readonly", state);
|
|
10421
|
+
if (result)
|
|
10422
|
+
return result.cache;
|
|
10423
|
+
}
|
|
10424
|
+
if (state.tokenize) {
|
|
10425
|
+
const result = $TOKEN("Readonly", state, Readonly$0(state));
|
|
10426
|
+
if (state.events)
|
|
10427
|
+
state.events.exit?.("Readonly", state, result);
|
|
10428
|
+
return result;
|
|
10429
|
+
} else {
|
|
10430
|
+
const result = Readonly$0(state);
|
|
10431
|
+
if (state.events)
|
|
10432
|
+
state.events.exit?.("Readonly", state, result);
|
|
10433
|
+
return result;
|
|
10434
|
+
}
|
|
10435
|
+
}
|
|
10436
|
+
var Return$0 = $TS($S($EXPECT($L130, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10165
10437
|
return { $loc, token: $1 };
|
|
10166
10438
|
});
|
|
10167
10439
|
function Return(state) {
|
|
@@ -10182,7 +10454,7 @@ ${input.slice(result.pos)}
|
|
|
10182
10454
|
return result;
|
|
10183
10455
|
}
|
|
10184
10456
|
}
|
|
10185
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
10457
|
+
var Satisfies$0 = $TS($S($EXPECT($L131, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10186
10458
|
return { $loc, token: $1 };
|
|
10187
10459
|
});
|
|
10188
10460
|
function Satisfies(state) {
|
|
@@ -10203,7 +10475,7 @@ ${input.slice(result.pos)}
|
|
|
10203
10475
|
return result;
|
|
10204
10476
|
}
|
|
10205
10477
|
}
|
|
10206
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
10478
|
+
var Semicolon$0 = $TV($EXPECT($L78, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
10207
10479
|
return { $loc, token: $1 };
|
|
10208
10480
|
});
|
|
10209
10481
|
function Semicolon(state) {
|
|
@@ -10224,7 +10496,7 @@ ${input.slice(result.pos)}
|
|
|
10224
10496
|
return result;
|
|
10225
10497
|
}
|
|
10226
10498
|
}
|
|
10227
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
10499
|
+
var SingleQuote$0 = $TV($EXPECT($L132, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
10228
10500
|
return { $loc, token: $1 };
|
|
10229
10501
|
});
|
|
10230
10502
|
function SingleQuote(state) {
|
|
@@ -10245,7 +10517,7 @@ ${input.slice(result.pos)}
|
|
|
10245
10517
|
return result;
|
|
10246
10518
|
}
|
|
10247
10519
|
}
|
|
10248
|
-
var Star$0 = $TV($EXPECT($
|
|
10520
|
+
var Star$0 = $TV($EXPECT($L49, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
10249
10521
|
return { $loc, token: $1 };
|
|
10250
10522
|
});
|
|
10251
10523
|
function Star(state) {
|
|
@@ -10266,10 +10538,10 @@ ${input.slice(result.pos)}
|
|
|
10266
10538
|
return result;
|
|
10267
10539
|
}
|
|
10268
10540
|
}
|
|
10269
|
-
var Static$0 = $TV($EXPECT($
|
|
10541
|
+
var Static$0 = $TV($EXPECT($L133, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
10270
10542
|
return { $loc, token: $1 };
|
|
10271
10543
|
});
|
|
10272
|
-
var Static$1 = $TS($S($EXPECT($
|
|
10544
|
+
var Static$1 = $TS($S($EXPECT($L94, fail, 'Static "@"'), $N($C($EXPECT($L124, fail, 'Static "("'), $EXPECT($L94, fail, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
10273
10545
|
return { $loc, token: "static " };
|
|
10274
10546
|
});
|
|
10275
10547
|
function Static(state) {
|
|
@@ -10290,7 +10562,7 @@ ${input.slice(result.pos)}
|
|
|
10290
10562
|
return result;
|
|
10291
10563
|
}
|
|
10292
10564
|
}
|
|
10293
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
10565
|
+
var SubstitutionStart$0 = $TV($EXPECT($L134, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
10294
10566
|
return { $loc, token: $1 };
|
|
10295
10567
|
});
|
|
10296
10568
|
function SubstitutionStart(state) {
|
|
@@ -10311,7 +10583,7 @@ ${input.slice(result.pos)}
|
|
|
10311
10583
|
return result;
|
|
10312
10584
|
}
|
|
10313
10585
|
}
|
|
10314
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
10586
|
+
var Switch$0 = $TS($S($EXPECT($L135, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10315
10587
|
return { $loc, token: $1 };
|
|
10316
10588
|
});
|
|
10317
10589
|
function Switch(state) {
|
|
@@ -10332,7 +10604,7 @@ ${input.slice(result.pos)}
|
|
|
10332
10604
|
return result;
|
|
10333
10605
|
}
|
|
10334
10606
|
}
|
|
10335
|
-
var Target$0 = $TS($S($EXPECT($
|
|
10607
|
+
var Target$0 = $TS($S($EXPECT($L136, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10336
10608
|
return { $loc, token: $1 };
|
|
10337
10609
|
});
|
|
10338
10610
|
function Target(state) {
|
|
@@ -10353,7 +10625,7 @@ ${input.slice(result.pos)}
|
|
|
10353
10625
|
return result;
|
|
10354
10626
|
}
|
|
10355
10627
|
}
|
|
10356
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
10628
|
+
var Then$0 = $TS($S(__, $EXPECT($L137, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
10357
10629
|
return { $loc, token: "" };
|
|
10358
10630
|
});
|
|
10359
10631
|
function Then(state) {
|
|
@@ -10374,7 +10646,7 @@ ${input.slice(result.pos)}
|
|
|
10374
10646
|
return result;
|
|
10375
10647
|
}
|
|
10376
10648
|
}
|
|
10377
|
-
var This$0 = $TS($S($EXPECT($
|
|
10649
|
+
var This$0 = $TS($S($EXPECT($L138, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10378
10650
|
return { $loc, token: $1 };
|
|
10379
10651
|
});
|
|
10380
10652
|
function This(state) {
|
|
@@ -10395,7 +10667,7 @@ ${input.slice(result.pos)}
|
|
|
10395
10667
|
return result;
|
|
10396
10668
|
}
|
|
10397
10669
|
}
|
|
10398
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
10670
|
+
var Throw$0 = $TS($S($EXPECT($L139, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10399
10671
|
return { $loc, token: $1 };
|
|
10400
10672
|
});
|
|
10401
10673
|
function Throw(state) {
|
|
@@ -10416,7 +10688,7 @@ ${input.slice(result.pos)}
|
|
|
10416
10688
|
return result;
|
|
10417
10689
|
}
|
|
10418
10690
|
}
|
|
10419
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
10691
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L140, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
10420
10692
|
return { $loc, token: "`" };
|
|
10421
10693
|
});
|
|
10422
10694
|
function TripleDoubleQuote(state) {
|
|
@@ -10437,7 +10709,7 @@ ${input.slice(result.pos)}
|
|
|
10437
10709
|
return result;
|
|
10438
10710
|
}
|
|
10439
10711
|
}
|
|
10440
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
10712
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L141, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
10441
10713
|
return { $loc, token: "`" };
|
|
10442
10714
|
});
|
|
10443
10715
|
function TripleSingleQuote(state) {
|
|
@@ -10458,7 +10730,7 @@ ${input.slice(result.pos)}
|
|
|
10458
10730
|
return result;
|
|
10459
10731
|
}
|
|
10460
10732
|
}
|
|
10461
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
10733
|
+
var TripleSlash$0 = $TV($EXPECT($L142, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
10462
10734
|
return { $loc, token: "/" };
|
|
10463
10735
|
});
|
|
10464
10736
|
function TripleSlash(state) {
|
|
@@ -10479,7 +10751,7 @@ ${input.slice(result.pos)}
|
|
|
10479
10751
|
return result;
|
|
10480
10752
|
}
|
|
10481
10753
|
}
|
|
10482
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
10754
|
+
var TripleTick$0 = $TV($EXPECT($L143, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
10483
10755
|
return { $loc, token: "`" };
|
|
10484
10756
|
});
|
|
10485
10757
|
function TripleTick(state) {
|
|
@@ -10500,7 +10772,7 @@ ${input.slice(result.pos)}
|
|
|
10500
10772
|
return result;
|
|
10501
10773
|
}
|
|
10502
10774
|
}
|
|
10503
|
-
var Try$0 = $TS($S($EXPECT($
|
|
10775
|
+
var Try$0 = $TS($S($EXPECT($L144, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10504
10776
|
return { $loc, token: $1 };
|
|
10505
10777
|
});
|
|
10506
10778
|
function Try(state) {
|
|
@@ -10521,7 +10793,7 @@ ${input.slice(result.pos)}
|
|
|
10521
10793
|
return result;
|
|
10522
10794
|
}
|
|
10523
10795
|
}
|
|
10524
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
10796
|
+
var Typeof$0 = $TS($S($EXPECT($L145, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10525
10797
|
return { $loc, token: $1 };
|
|
10526
10798
|
});
|
|
10527
10799
|
function Typeof(state) {
|
|
@@ -10542,7 +10814,7 @@ ${input.slice(result.pos)}
|
|
|
10542
10814
|
return result;
|
|
10543
10815
|
}
|
|
10544
10816
|
}
|
|
10545
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
10817
|
+
var Unless$0 = $TS($S($EXPECT($L146, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10546
10818
|
return { $loc, token: $1 };
|
|
10547
10819
|
});
|
|
10548
10820
|
function Unless(state) {
|
|
@@ -10563,7 +10835,7 @@ ${input.slice(result.pos)}
|
|
|
10563
10835
|
return result;
|
|
10564
10836
|
}
|
|
10565
10837
|
}
|
|
10566
|
-
var Until$0 = $TS($S($EXPECT($
|
|
10838
|
+
var Until$0 = $TS($S($EXPECT($L147, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10567
10839
|
return { $loc, token: $1 };
|
|
10568
10840
|
});
|
|
10569
10841
|
function Until(state) {
|
|
@@ -10584,7 +10856,7 @@ ${input.slice(result.pos)}
|
|
|
10584
10856
|
return result;
|
|
10585
10857
|
}
|
|
10586
10858
|
}
|
|
10587
|
-
var Var$0 = $TS($S($EXPECT($
|
|
10859
|
+
var Var$0 = $TS($S($EXPECT($L148, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10588
10860
|
return { $loc, token: $1 };
|
|
10589
10861
|
});
|
|
10590
10862
|
function Var(state) {
|
|
@@ -10605,7 +10877,7 @@ ${input.slice(result.pos)}
|
|
|
10605
10877
|
return result;
|
|
10606
10878
|
}
|
|
10607
10879
|
}
|
|
10608
|
-
var Void$0 = $TS($S($EXPECT($
|
|
10880
|
+
var Void$0 = $TS($S($EXPECT($L149, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10609
10881
|
return { $loc, token: $1 };
|
|
10610
10882
|
});
|
|
10611
10883
|
function Void(state) {
|
|
@@ -10626,7 +10898,7 @@ ${input.slice(result.pos)}
|
|
|
10626
10898
|
return result;
|
|
10627
10899
|
}
|
|
10628
10900
|
}
|
|
10629
|
-
var When$0 = $TS($S($EXPECT($
|
|
10901
|
+
var When$0 = $TS($S($EXPECT($L150, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10630
10902
|
return { $loc, token: "case" };
|
|
10631
10903
|
});
|
|
10632
10904
|
function When(state) {
|
|
@@ -10647,7 +10919,7 @@ ${input.slice(result.pos)}
|
|
|
10647
10919
|
return result;
|
|
10648
10920
|
}
|
|
10649
10921
|
}
|
|
10650
|
-
var While$0 = $TS($S($EXPECT($
|
|
10922
|
+
var While$0 = $TS($S($EXPECT($L151, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10651
10923
|
return { $loc, token: $1 };
|
|
10652
10924
|
});
|
|
10653
10925
|
function While(state) {
|
|
@@ -10668,7 +10940,7 @@ ${input.slice(result.pos)}
|
|
|
10668
10940
|
return result;
|
|
10669
10941
|
}
|
|
10670
10942
|
}
|
|
10671
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
10943
|
+
var Yield$0 = $TS($S($EXPECT($L152, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10672
10944
|
return { $loc, token: $1 };
|
|
10673
10945
|
});
|
|
10674
10946
|
function Yield(state) {
|
|
@@ -10750,7 +11022,7 @@ ${input.slice(result.pos)}
|
|
|
10750
11022
|
return result;
|
|
10751
11023
|
}
|
|
10752
11024
|
}
|
|
10753
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(CompactTypeArguments), $E(JSXAttributes), __, $EXPECT($
|
|
11025
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(CompactTypeArguments), $E(JSXAttributes), __, $EXPECT($L153, fail, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
10754
11026
|
return { type: "JSXElement", children: $0 };
|
|
10755
11027
|
});
|
|
10756
11028
|
function JSXSelfClosingElement(state) {
|
|
@@ -10771,7 +11043,7 @@ ${input.slice(result.pos)}
|
|
|
10771
11043
|
return result;
|
|
10772
11044
|
}
|
|
10773
11045
|
}
|
|
10774
|
-
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(CompactTypeArguments), $E(JSXAttributes), __, $EXPECT($
|
|
11046
|
+
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(CompactTypeArguments), $E(JSXAttributes), __, $EXPECT($L27, fail, 'JSXOpeningElement ">"'));
|
|
10775
11047
|
function JSXOpeningElement(state) {
|
|
10776
11048
|
if (state.events) {
|
|
10777
11049
|
const result = state.events.enter?.("JSXOpeningElement", state);
|
|
@@ -10790,7 +11062,7 @@ ${input.slice(result.pos)}
|
|
|
10790
11062
|
return result;
|
|
10791
11063
|
}
|
|
10792
11064
|
}
|
|
10793
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
11065
|
+
var JSXClosingElement$0 = $S($EXPECT($L154, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L27, fail, 'JSXClosingElement ">"'));
|
|
10794
11066
|
function JSXClosingElement(state) {
|
|
10795
11067
|
if (state.events) {
|
|
10796
11068
|
const result = state.events.enter?.("JSXClosingElement", state);
|
|
@@ -10835,14 +11107,14 @@ ${input.slice(result.pos)}
|
|
|
10835
11107
|
return result;
|
|
10836
11108
|
}
|
|
10837
11109
|
}
|
|
10838
|
-
var JSXFragment$0 = $TS($S($EXPECT($
|
|
11110
|
+
var JSXFragment$0 = $TS($S($EXPECT($L155, fail, 'JSXFragment "<>"'), $E(JSXChildren), __, $EXPECT($L156, fail, 'JSXFragment "</>"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
10839
11111
|
if ($2) {
|
|
10840
11112
|
return { type: "JSXFragment", children: $0, jsxChildren: $2.jsxChildren };
|
|
10841
11113
|
} else {
|
|
10842
11114
|
return { type: "JSXFragment", children: $0, jsxChildren: [] };
|
|
10843
11115
|
}
|
|
10844
11116
|
});
|
|
10845
|
-
var JSXFragment$1 = $TS($S($EXPECT($
|
|
11117
|
+
var JSXFragment$1 = $TS($S($EXPECT($L155, fail, 'JSXFragment "<>"'), JSXMixedChildren, InsertNewline, InsertIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
10846
11118
|
return { type: "JSXFragment", children: [...$0, "</>"], jsxChildren: $2.jsxChildren };
|
|
10847
11119
|
});
|
|
10848
11120
|
function JSXFragment(state) {
|
|
@@ -11192,8 +11464,8 @@ ${input.slice(result.pos)}
|
|
|
11192
11464
|
return result;
|
|
11193
11465
|
}
|
|
11194
11466
|
}
|
|
11195
|
-
var InlineJSXCallExpression$0 = $S($EXPECT($
|
|
11196
|
-
var InlineJSXCallExpression$1 = $S($EXPECT($
|
|
11467
|
+
var InlineJSXCallExpression$0 = $S($EXPECT($L10, fail, 'InlineJSXCallExpression "super"'), ExplicitArguments);
|
|
11468
|
+
var InlineJSXCallExpression$1 = $S($EXPECT($L11, fail, 'InlineJSXCallExpression "import"'), OpenParen, ExtendedExpression, __, CloseParen);
|
|
11197
11469
|
var InlineJSXCallExpression$2 = $TS($S(InlineJSXMemberExpression, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
11198
11470
|
if ($2.length)
|
|
11199
11471
|
return $0;
|
|
@@ -11495,7 +11767,7 @@ ${input.slice(result.pos)}
|
|
|
11495
11767
|
return result;
|
|
11496
11768
|
}
|
|
11497
11769
|
}
|
|
11498
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
11770
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L157, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
11499
11771
|
var TypeDeclarationModifier$1 = Export;
|
|
11500
11772
|
function TypeDeclarationModifier(state) {
|
|
11501
11773
|
if (state.events) {
|
|
@@ -11537,7 +11809,7 @@ ${input.slice(result.pos)}
|
|
|
11537
11809
|
return result;
|
|
11538
11810
|
}
|
|
11539
11811
|
}
|
|
11540
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
11812
|
+
var TypeKeyword$0 = $S($EXPECT($L158, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
11541
11813
|
function TypeKeyword(state) {
|
|
11542
11814
|
if (state.events) {
|
|
11543
11815
|
const result = state.events.enter?.("TypeKeyword", state);
|
|
@@ -11556,7 +11828,7 @@ ${input.slice(result.pos)}
|
|
|
11556
11828
|
return result;
|
|
11557
11829
|
}
|
|
11558
11830
|
}
|
|
11559
|
-
var Interface$0 = $S($EXPECT($
|
|
11831
|
+
var Interface$0 = $S($EXPECT($L159, fail, 'Interface "interface"'), NonIdContinue);
|
|
11560
11832
|
function Interface(state) {
|
|
11561
11833
|
if (state.events) {
|
|
11562
11834
|
const result = state.events.enter?.("Interface", state);
|
|
@@ -11575,7 +11847,7 @@ ${input.slice(result.pos)}
|
|
|
11575
11847
|
return result;
|
|
11576
11848
|
}
|
|
11577
11849
|
}
|
|
11578
|
-
var Namespace$0 = $S($EXPECT($
|
|
11850
|
+
var Namespace$0 = $S($EXPECT($L160, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
11579
11851
|
function Namespace(state) {
|
|
11580
11852
|
if (state.events) {
|
|
11581
11853
|
const result = state.events.enter?.("Namespace", state);
|
|
@@ -11764,7 +12036,7 @@ ${input.slice(result.pos)}
|
|
|
11764
12036
|
return result;
|
|
11765
12037
|
}
|
|
11766
12038
|
}
|
|
11767
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R47, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($
|
|
12039
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R47, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L129, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R4, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
11768
12040
|
function TypeIndexSignature(state) {
|
|
11769
12041
|
if (state.events) {
|
|
11770
12042
|
const result = state.events.enter?.("TypeIndexSignature", state);
|
|
@@ -11824,7 +12096,7 @@ ${input.slice(result.pos)}
|
|
|
11824
12096
|
return result;
|
|
11825
12097
|
}
|
|
11826
12098
|
}
|
|
11827
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
12099
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L161, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
11828
12100
|
const children = [...$1, $2];
|
|
11829
12101
|
if ($3)
|
|
11830
12102
|
children.push($3);
|
|
@@ -11853,7 +12125,7 @@ ${input.slice(result.pos)}
|
|
|
11853
12125
|
return result;
|
|
11854
12126
|
}
|
|
11855
12127
|
}
|
|
11856
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
12128
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L62, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
11857
12129
|
if (!$2)
|
|
11858
12130
|
return $1;
|
|
11859
12131
|
return $0;
|
|
@@ -11959,10 +12231,10 @@ ${input.slice(result.pos)}
|
|
|
11959
12231
|
return result;
|
|
11960
12232
|
}
|
|
11961
12233
|
}
|
|
11962
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
11963
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
11964
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
11965
|
-
var TypeUnaryOp$3 = $EXPECT($
|
|
12234
|
+
var TypeUnaryOp$0 = $EXPECT($L162, fail, 'TypeUnaryOp "keyof"');
|
|
12235
|
+
var TypeUnaryOp$1 = $EXPECT($L145, fail, 'TypeUnaryOp "typeof"');
|
|
12236
|
+
var TypeUnaryOp$2 = $EXPECT($L163, fail, 'TypeUnaryOp "infer"');
|
|
12237
|
+
var TypeUnaryOp$3 = $EXPECT($L129, fail, 'TypeUnaryOp "readonly"');
|
|
11966
12238
|
function TypeUnaryOp(state) {
|
|
11967
12239
|
if (state.events) {
|
|
11968
12240
|
const result = state.events.enter?.("TypeUnaryOp", state);
|
|
@@ -12131,10 +12403,10 @@ ${input.slice(result.pos)}
|
|
|
12131
12403
|
}
|
|
12132
12404
|
var TypeLiteral$0 = Literal;
|
|
12133
12405
|
var TypeLiteral$1 = TemplateLiteral;
|
|
12134
|
-
var TypeLiteral$2 = $TV($EXPECT($
|
|
12406
|
+
var TypeLiteral$2 = $TV($EXPECT($L149, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
|
|
12135
12407
|
return { $loc, token: "void" };
|
|
12136
12408
|
});
|
|
12137
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
12409
|
+
var TypeLiteral$3 = $TV($EXPECT($L164, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
12138
12410
|
return { $loc, token: "[]" };
|
|
12139
12411
|
});
|
|
12140
12412
|
function TypeLiteral(state) {
|
|
@@ -12155,10 +12427,10 @@ ${input.slice(result.pos)}
|
|
|
12155
12427
|
return result;
|
|
12156
12428
|
}
|
|
12157
12429
|
}
|
|
12158
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
12430
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L77, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
12159
12431
|
return { $loc, token: "|" };
|
|
12160
12432
|
});
|
|
12161
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
12433
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L75, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
12162
12434
|
return { $loc, token: "&" };
|
|
12163
12435
|
});
|
|
12164
12436
|
function TypeBinaryOp(state) {
|
|
@@ -12198,7 +12470,7 @@ ${input.slice(result.pos)}
|
|
|
12198
12470
|
return result;
|
|
12199
12471
|
}
|
|
12200
12472
|
}
|
|
12201
|
-
var TypeArguments$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($
|
|
12473
|
+
var TypeArguments$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L27, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
12202
12474
|
return { ts: true, children: $0 };
|
|
12203
12475
|
});
|
|
12204
12476
|
function TypeArguments(state) {
|
|
@@ -12219,7 +12491,7 @@ ${input.slice(result.pos)}
|
|
|
12219
12491
|
return result;
|
|
12220
12492
|
}
|
|
12221
12493
|
}
|
|
12222
|
-
var CompactTypeArguments$0 = $TS($S($EXPECT($L5, fail, 'CompactTypeArguments "<"'), $P(TypeArgument), __, $EXPECT($
|
|
12494
|
+
var CompactTypeArguments$0 = $TS($S($EXPECT($L5, fail, 'CompactTypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L27, fail, 'CompactTypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
12223
12495
|
return { ts: true, children: $0 };
|
|
12224
12496
|
});
|
|
12225
12497
|
function CompactTypeArguments(state) {
|
|
@@ -12278,7 +12550,7 @@ ${input.slice(result.pos)}
|
|
|
12278
12550
|
return result;
|
|
12279
12551
|
}
|
|
12280
12552
|
}
|
|
12281
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($
|
|
12553
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L27, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
12282
12554
|
var parameters = $3;
|
|
12283
12555
|
return {
|
|
12284
12556
|
type: "TypeParameters",
|
|
@@ -12344,7 +12616,7 @@ ${input.slice(result.pos)}
|
|
|
12344
12616
|
}
|
|
12345
12617
|
}
|
|
12346
12618
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
12347
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
12619
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L27, fail, 'TypeParameterDelimiter ">"')));
|
|
12348
12620
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
12349
12621
|
return value[1];
|
|
12350
12622
|
});
|
|
@@ -12411,7 +12683,7 @@ ${input.slice(result.pos)}
|
|
|
12411
12683
|
return result;
|
|
12412
12684
|
}
|
|
12413
12685
|
}
|
|
12414
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
12686
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L165, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R50, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
12415
12687
|
var options = $2;
|
|
12416
12688
|
return {
|
|
12417
12689
|
type: "CivetPrologue",
|
|
@@ -13735,6 +14007,20 @@ ${input.slice(result.pos)}
|
|
|
13735
14007
|
}
|
|
13736
14008
|
return node;
|
|
13737
14009
|
};
|
|
14010
|
+
module.skipIfOnlyWS = function(target) {
|
|
14011
|
+
if (!target)
|
|
14012
|
+
return target;
|
|
14013
|
+
if (Array.isArray(target)) {
|
|
14014
|
+
if (target.length === 1) {
|
|
14015
|
+
return module.skipIfOnlyWS(target[0]);
|
|
14016
|
+
}
|
|
14017
|
+
return target;
|
|
14018
|
+
}
|
|
14019
|
+
if (target.token && target.token.trim() === "") {
|
|
14020
|
+
return void 0;
|
|
14021
|
+
}
|
|
14022
|
+
return target;
|
|
14023
|
+
};
|
|
13738
14024
|
module.insertTrimmingSpace = function(target, c) {
|
|
13739
14025
|
if (!target)
|
|
13740
14026
|
return target;
|
|
@@ -14254,6 +14540,21 @@ ${input.slice(result.pos)}
|
|
|
14254
14540
|
return [splices, thisAssignments];
|
|
14255
14541
|
}
|
|
14256
14542
|
module.gatherBindingCode = gatherBindingCode;
|
|
14543
|
+
module.constructInvocation = function(caller, callee) {
|
|
14544
|
+
const callerArr = [caller.leadingComment, caller.expr, caller.trailingComment];
|
|
14545
|
+
const calleeArr = [callee.leadingComment, callee.expr, callee.trailingComment];
|
|
14546
|
+
if (caller.expr.type === "Identifier") {
|
|
14547
|
+
return [callerArr, "(", calleeArr, ")"];
|
|
14548
|
+
} else {
|
|
14549
|
+
return ["(", callerArr, ")", "(", calleeArr, ")"];
|
|
14550
|
+
}
|
|
14551
|
+
};
|
|
14552
|
+
module.constructPipeStep = function(caller, callee) {
|
|
14553
|
+
if (caller.expr.token === "yield" || caller.expr.token === "await") {
|
|
14554
|
+
return [caller.leadingComment, caller.expr, caller.trailingComment, " ", callee.leadingComment, callee.expr, callee.trailingComment];
|
|
14555
|
+
}
|
|
14556
|
+
return module.constructInvocation(caller, callee);
|
|
14557
|
+
};
|
|
14257
14558
|
return $0;
|
|
14258
14559
|
});
|
|
14259
14560
|
function Init(state) {
|