@danielx/civet 0.5.9 → 0.5.11
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/browser.js +728 -430
- package/dist/main.js +728 -430
- package/dist/types.d.ts +7 -0
- 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
|
}
|
|
@@ -1694,7 +1745,8 @@ ${input.slice(result.pos)}
|
|
|
1694
1745
|
return result;
|
|
1695
1746
|
}
|
|
1696
1747
|
}
|
|
1697
|
-
var AssignmentExpression$0 =
|
|
1748
|
+
var AssignmentExpression$0 = PipelineExpression;
|
|
1749
|
+
var AssignmentExpression$1 = $TS($S($Q(TrailingComment), AssignmentExpressionTail), function($skip, $loc, $0, $1, $2) {
|
|
1698
1750
|
var ws = $1;
|
|
1699
1751
|
var tail = $2;
|
|
1700
1752
|
if (ws.length) {
|
|
@@ -1708,7 +1760,7 @@ ${input.slice(result.pos)}
|
|
|
1708
1760
|
}
|
|
1709
1761
|
return tail;
|
|
1710
1762
|
});
|
|
1711
|
-
var AssignmentExpression$
|
|
1763
|
+
var AssignmentExpression$2 = $S(__, AssignmentExpressionTail);
|
|
1712
1764
|
function AssignmentExpression(state) {
|
|
1713
1765
|
if (state.events) {
|
|
1714
1766
|
const result = state.events.enter?.("AssignmentExpression", state);
|
|
@@ -1716,17 +1768,69 @@ ${input.slice(result.pos)}
|
|
|
1716
1768
|
return result.cache;
|
|
1717
1769
|
}
|
|
1718
1770
|
if (state.tokenize) {
|
|
1719
|
-
const result = $TOKEN("AssignmentExpression", state, AssignmentExpression$0(state) || AssignmentExpression$1(state));
|
|
1771
|
+
const result = $TOKEN("AssignmentExpression", state, AssignmentExpression$0(state) || AssignmentExpression$1(state) || AssignmentExpression$2(state));
|
|
1720
1772
|
if (state.events)
|
|
1721
1773
|
state.events.exit?.("AssignmentExpression", state, result);
|
|
1722
1774
|
return result;
|
|
1723
1775
|
} else {
|
|
1724
|
-
const result = AssignmentExpression$0(state) || AssignmentExpression$1(state);
|
|
1776
|
+
const result = AssignmentExpression$0(state) || AssignmentExpression$1(state) || AssignmentExpression$2(state);
|
|
1725
1777
|
if (state.events)
|
|
1726
1778
|
state.events.exit?.("AssignmentExpression", state, result);
|
|
1727
1779
|
return result;
|
|
1728
1780
|
}
|
|
1729
1781
|
}
|
|
1782
|
+
var NonPipelineAssignmentExpression$0 = SingleLineAssignmentExpression;
|
|
1783
|
+
var NonPipelineAssignmentExpression$1 = $S(__, AssignmentExpressionTail);
|
|
1784
|
+
function NonPipelineAssignmentExpression(state) {
|
|
1785
|
+
if (state.events) {
|
|
1786
|
+
const result = state.events.enter?.("NonPipelineAssignmentExpression", state);
|
|
1787
|
+
if (result)
|
|
1788
|
+
return result.cache;
|
|
1789
|
+
}
|
|
1790
|
+
if (state.tokenize) {
|
|
1791
|
+
const result = $TOKEN("NonPipelineAssignmentExpression", state, NonPipelineAssignmentExpression$0(state) || NonPipelineAssignmentExpression$1(state));
|
|
1792
|
+
if (state.events)
|
|
1793
|
+
state.events.exit?.("NonPipelineAssignmentExpression", state, result);
|
|
1794
|
+
return result;
|
|
1795
|
+
} else {
|
|
1796
|
+
const result = NonPipelineAssignmentExpression$0(state) || NonPipelineAssignmentExpression$1(state);
|
|
1797
|
+
if (state.events)
|
|
1798
|
+
state.events.exit?.("NonPipelineAssignmentExpression", state, result);
|
|
1799
|
+
return result;
|
|
1800
|
+
}
|
|
1801
|
+
}
|
|
1802
|
+
var SingleLineAssignmentExpression$0 = $TS($S($Q(TrailingComment), AssignmentExpressionTail), function($skip, $loc, $0, $1, $2) {
|
|
1803
|
+
var ws = $1;
|
|
1804
|
+
var tail = $2;
|
|
1805
|
+
if (ws.length) {
|
|
1806
|
+
if (tail.children && tail.type !== "IterationExpression") {
|
|
1807
|
+
return {
|
|
1808
|
+
...tail,
|
|
1809
|
+
children: [...ws, ...tail.children]
|
|
1810
|
+
};
|
|
1811
|
+
}
|
|
1812
|
+
return $0;
|
|
1813
|
+
}
|
|
1814
|
+
return tail;
|
|
1815
|
+
});
|
|
1816
|
+
function SingleLineAssignmentExpression(state) {
|
|
1817
|
+
if (state.events) {
|
|
1818
|
+
const result = state.events.enter?.("SingleLineAssignmentExpression", state);
|
|
1819
|
+
if (result)
|
|
1820
|
+
return result.cache;
|
|
1821
|
+
}
|
|
1822
|
+
if (state.tokenize) {
|
|
1823
|
+
const result = $TOKEN("SingleLineAssignmentExpression", state, SingleLineAssignmentExpression$0(state));
|
|
1824
|
+
if (state.events)
|
|
1825
|
+
state.events.exit?.("SingleLineAssignmentExpression", state, result);
|
|
1826
|
+
return result;
|
|
1827
|
+
} else {
|
|
1828
|
+
const result = SingleLineAssignmentExpression$0(state);
|
|
1829
|
+
if (state.events)
|
|
1830
|
+
state.events.exit?.("SingleLineAssignmentExpression", state, result);
|
|
1831
|
+
return result;
|
|
1832
|
+
}
|
|
1833
|
+
}
|
|
1730
1834
|
var AssignmentExpressionTail$0 = YieldExpression;
|
|
1731
1835
|
var AssignmentExpressionTail$1 = ArrowFunction;
|
|
1732
1836
|
var AssignmentExpressionTail$2 = ActualAssignment;
|
|
@@ -2006,6 +2110,91 @@ ${input.slice(result.pos)}
|
|
|
2006
2110
|
return result;
|
|
2007
2111
|
}
|
|
2008
2112
|
}
|
|
2113
|
+
var PipelineExpression$0 = $TS($S($S(__, PipelineHeadItem, __, Pipe), $Q($S(__, PipelineTailItem, __, Pipe)), __, PipelineTailItem), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2114
|
+
var head = $1;
|
|
2115
|
+
var body = $2;
|
|
2116
|
+
var preTailWS = $3;
|
|
2117
|
+
var tail = $4;
|
|
2118
|
+
let children = head.slice(0, -1).map(module.skipIfOnlyWS);
|
|
2119
|
+
for (const [leadingComment, expr, trailingComment] of body) {
|
|
2120
|
+
children = module.constructPipeStep(
|
|
2121
|
+
{
|
|
2122
|
+
leadingComment: module.skipIfOnlyWS(leadingComment),
|
|
2123
|
+
trailingComment: module.skipIfOnlyWS(trailingComment),
|
|
2124
|
+
expr
|
|
2125
|
+
},
|
|
2126
|
+
{ expr: children }
|
|
2127
|
+
);
|
|
2128
|
+
}
|
|
2129
|
+
return {
|
|
2130
|
+
children: module.constructPipeStep(
|
|
2131
|
+
{
|
|
2132
|
+
leadingComment: module.skipIfOnlyWS(preTailWS),
|
|
2133
|
+
expr: tail
|
|
2134
|
+
},
|
|
2135
|
+
{ expr: children }
|
|
2136
|
+
)
|
|
2137
|
+
};
|
|
2138
|
+
});
|
|
2139
|
+
function PipelineExpression(state) {
|
|
2140
|
+
if (state.events) {
|
|
2141
|
+
const result = state.events.enter?.("PipelineExpression", state);
|
|
2142
|
+
if (result)
|
|
2143
|
+
return result.cache;
|
|
2144
|
+
}
|
|
2145
|
+
if (state.tokenize) {
|
|
2146
|
+
const result = $TOKEN("PipelineExpression", state, PipelineExpression$0(state));
|
|
2147
|
+
if (state.events)
|
|
2148
|
+
state.events.exit?.("PipelineExpression", state, result);
|
|
2149
|
+
return result;
|
|
2150
|
+
} else {
|
|
2151
|
+
const result = PipelineExpression$0(state);
|
|
2152
|
+
if (state.events)
|
|
2153
|
+
state.events.exit?.("PipelineExpression", state, result);
|
|
2154
|
+
return result;
|
|
2155
|
+
}
|
|
2156
|
+
}
|
|
2157
|
+
var PipelineHeadItem$0 = NonPipelineExtendedExpression;
|
|
2158
|
+
var PipelineHeadItem$1 = ParenthesizedExpression;
|
|
2159
|
+
function PipelineHeadItem(state) {
|
|
2160
|
+
if (state.events) {
|
|
2161
|
+
const result = state.events.enter?.("PipelineHeadItem", state);
|
|
2162
|
+
if (result)
|
|
2163
|
+
return result.cache;
|
|
2164
|
+
}
|
|
2165
|
+
if (state.tokenize) {
|
|
2166
|
+
const result = $TOKEN("PipelineHeadItem", state, PipelineHeadItem$0(state) || PipelineHeadItem$1(state));
|
|
2167
|
+
if (state.events)
|
|
2168
|
+
state.events.exit?.("PipelineHeadItem", state, result);
|
|
2169
|
+
return result;
|
|
2170
|
+
} else {
|
|
2171
|
+
const result = PipelineHeadItem$0(state) || PipelineHeadItem$1(state);
|
|
2172
|
+
if (state.events)
|
|
2173
|
+
state.events.exit?.("PipelineHeadItem", state, result);
|
|
2174
|
+
return result;
|
|
2175
|
+
}
|
|
2176
|
+
}
|
|
2177
|
+
var PipelineTailItem$0 = Await;
|
|
2178
|
+
var PipelineTailItem$1 = Yield;
|
|
2179
|
+
var PipelineTailItem$2 = PipelineHeadItem;
|
|
2180
|
+
function PipelineTailItem(state) {
|
|
2181
|
+
if (state.events) {
|
|
2182
|
+
const result = state.events.enter?.("PipelineTailItem", state);
|
|
2183
|
+
if (result)
|
|
2184
|
+
return result.cache;
|
|
2185
|
+
}
|
|
2186
|
+
if (state.tokenize) {
|
|
2187
|
+
const result = $TOKEN("PipelineTailItem", state, PipelineTailItem$0(state) || PipelineTailItem$1(state) || PipelineTailItem$2(state));
|
|
2188
|
+
if (state.events)
|
|
2189
|
+
state.events.exit?.("PipelineTailItem", state, result);
|
|
2190
|
+
return result;
|
|
2191
|
+
} else {
|
|
2192
|
+
const result = PipelineTailItem$0(state) || PipelineTailItem$1(state) || PipelineTailItem$2(state);
|
|
2193
|
+
if (state.events)
|
|
2194
|
+
state.events.exit?.("PipelineTailItem", state, result);
|
|
2195
|
+
return result;
|
|
2196
|
+
}
|
|
2197
|
+
}
|
|
2009
2198
|
var PrimaryExpression$0 = ObjectLiteral;
|
|
2010
2199
|
var PrimaryExpression$1 = ThisLiteral;
|
|
2011
2200
|
var PrimaryExpression$2 = Literal;
|
|
@@ -2085,7 +2274,9 @@ ${input.slice(result.pos)}
|
|
|
2085
2274
|
return result;
|
|
2086
2275
|
}
|
|
2087
2276
|
}
|
|
2088
|
-
var ClassExpression$0 = $S($E(Decorators), Class, $E($S(BindingIdentifier, $E(TypeParameters))), $E(ClassHeritage), ClassBody)
|
|
2277
|
+
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) {
|
|
2278
|
+
return $0;
|
|
2279
|
+
});
|
|
2089
2280
|
function ClassExpression(state) {
|
|
2090
2281
|
if (state.events) {
|
|
2091
2282
|
const result = state.events.enter?.("ClassExpression", state);
|
|
@@ -2377,69 +2568,6 @@ ${input.slice(result.pos)}
|
|
|
2377
2568
|
return result;
|
|
2378
2569
|
}
|
|
2379
2570
|
}
|
|
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
2571
|
var FieldDefinition$0 = $TS($S(CoffeeClassesEnabled, ClassElementName, __, Colon, __, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
2444
2572
|
var id = $2;
|
|
2445
2573
|
var exp = $6;
|
|
@@ -2462,7 +2590,11 @@ ${input.slice(result.pos)}
|
|
|
2462
2590
|
};
|
|
2463
2591
|
return $0;
|
|
2464
2592
|
});
|
|
2465
|
-
var FieldDefinition$2 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer))
|
|
2593
|
+
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) {
|
|
2594
|
+
if ($1)
|
|
2595
|
+
return { children: $0, ts: true };
|
|
2596
|
+
return $0;
|
|
2597
|
+
});
|
|
2466
2598
|
function FieldDefinition(state) {
|
|
2467
2599
|
if (state.events) {
|
|
2468
2600
|
const result = state.events.enter?.("FieldDefinition", state);
|
|
@@ -2482,7 +2614,7 @@ ${input.slice(result.pos)}
|
|
|
2482
2614
|
}
|
|
2483
2615
|
}
|
|
2484
2616
|
var ThisLiteral$0 = This;
|
|
2485
|
-
var ThisLiteral$1 = $TS($S(At, $TEXT($S($E($EXPECT($
|
|
2617
|
+
var ThisLiteral$1 = $TS($S(At, $TEXT($S($E($EXPECT($L8, fail, 'ThisLiteral "#"')), IdentifierName))), function($skip, $loc, $0, $1, $2) {
|
|
2486
2618
|
var t = $1;
|
|
2487
2619
|
var id = $2;
|
|
2488
2620
|
return [{ ...t, token: "this." }, id];
|
|
@@ -2509,7 +2641,7 @@ ${input.slice(result.pos)}
|
|
|
2509
2641
|
return result;
|
|
2510
2642
|
}
|
|
2511
2643
|
}
|
|
2512
|
-
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($
|
|
2644
|
+
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($L9, fail, 'LeftHandSideExpression "."')), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
2513
2645
|
if ($1.length)
|
|
2514
2646
|
return $0;
|
|
2515
2647
|
return $2;
|
|
@@ -2532,8 +2664,8 @@ ${input.slice(result.pos)}
|
|
|
2532
2664
|
return result;
|
|
2533
2665
|
}
|
|
2534
2666
|
}
|
|
2535
|
-
var CallExpression$0 = $S($EXPECT($
|
|
2536
|
-
var CallExpression$1 = $S($EXPECT($
|
|
2667
|
+
var CallExpression$0 = $S($EXPECT($L10, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
|
|
2668
|
+
var CallExpression$1 = $S($EXPECT($L11, fail, 'CallExpression "import"'), __, OpenParen, ExtendedExpression, __, CloseParen);
|
|
2537
2669
|
var CallExpression$2 = $TS($S(MemberExpression, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
2538
2670
|
if ($2.length)
|
|
2539
2671
|
return $0;
|
|
@@ -2597,7 +2729,7 @@ ${input.slice(result.pos)}
|
|
|
2597
2729
|
return result;
|
|
2598
2730
|
}
|
|
2599
2731
|
}
|
|
2600
|
-
var NonNullAssertion$0 = $T($EXPECT($
|
|
2732
|
+
var NonNullAssertion$0 = $T($EXPECT($L12, fail, 'NonNullAssertion "!"'), function(value) {
|
|
2601
2733
|
return { "ts": true, "children": value };
|
|
2602
2734
|
});
|
|
2603
2735
|
function NonNullAssertion(state) {
|
|
@@ -2838,8 +2970,8 @@ ${input.slice(result.pos)}
|
|
|
2838
2970
|
return result;
|
|
2839
2971
|
}
|
|
2840
2972
|
}
|
|
2841
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
2842
|
-
var SuperProperty$1 = $S($EXPECT($
|
|
2973
|
+
var SuperProperty$0 = $S($EXPECT($L13, fail, 'SuperProperty "super["'), ExtendedExpression, __, CloseBracket);
|
|
2974
|
+
var SuperProperty$1 = $S($EXPECT($L10, fail, 'SuperProperty "super"'), $N($C(QuestionMark, NonNullAssertion)), PropertyAccess);
|
|
2843
2975
|
function SuperProperty(state) {
|
|
2844
2976
|
if (state.events) {
|
|
2845
2977
|
const result = state.events.enter?.("SuperProperty", state);
|
|
@@ -2859,7 +2991,7 @@ ${input.slice(result.pos)}
|
|
|
2859
2991
|
}
|
|
2860
2992
|
}
|
|
2861
2993
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
2862
|
-
var MetaProperty$1 = $TV($EXPECT($
|
|
2994
|
+
var MetaProperty$1 = $TV($EXPECT($L14, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
|
|
2863
2995
|
return { $loc, token: $1 };
|
|
2864
2996
|
});
|
|
2865
2997
|
function MetaProperty(state) {
|
|
@@ -3023,7 +3155,7 @@ ${input.slice(result.pos)}
|
|
|
3023
3155
|
}
|
|
3024
3156
|
}
|
|
3025
3157
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
3026
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
3158
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L15, fail, 'ParameterElementDelimiter ")"')));
|
|
3027
3159
|
var ParameterElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
3028
3160
|
return value[1];
|
|
3029
3161
|
});
|
|
@@ -3778,7 +3910,7 @@ ${input.slice(result.pos)}
|
|
|
3778
3910
|
return result;
|
|
3779
3911
|
}
|
|
3780
3912
|
}
|
|
3781
|
-
var Arrow$0 = $TV($EXPECT($
|
|
3913
|
+
var Arrow$0 = $TV($EXPECT($L16, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
3782
3914
|
return { $loc, token: $1 };
|
|
3783
3915
|
});
|
|
3784
3916
|
function Arrow(state) {
|
|
@@ -4040,7 +4172,7 @@ ${input.slice(result.pos)}
|
|
|
4040
4172
|
children: [$1, expressions]
|
|
4041
4173
|
};
|
|
4042
4174
|
});
|
|
4043
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
4175
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L17, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
4044
4176
|
const expressions = [];
|
|
4045
4177
|
return {
|
|
4046
4178
|
type: "BlockStatement",
|
|
@@ -4165,7 +4297,7 @@ ${input.slice(result.pos)}
|
|
|
4165
4297
|
return result;
|
|
4166
4298
|
}
|
|
4167
4299
|
}
|
|
4168
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
4300
|
+
var NullLiteral$0 = $TS($S($EXPECT($L18, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4169
4301
|
return { $loc, token: $1 };
|
|
4170
4302
|
});
|
|
4171
4303
|
function NullLiteral(state) {
|
|
@@ -4189,7 +4321,7 @@ ${input.slice(result.pos)}
|
|
|
4189
4321
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
4190
4322
|
return value[1];
|
|
4191
4323
|
});
|
|
4192
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
4324
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L19, fail, 'BooleanLiteral "true"'), $EXPECT($L20, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4193
4325
|
return { $loc, token: $1 };
|
|
4194
4326
|
});
|
|
4195
4327
|
function BooleanLiteral(state) {
|
|
@@ -4210,10 +4342,10 @@ ${input.slice(result.pos)}
|
|
|
4210
4342
|
return result;
|
|
4211
4343
|
}
|
|
4212
4344
|
}
|
|
4213
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
4345
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4214
4346
|
return { $loc, token: "true" };
|
|
4215
4347
|
});
|
|
4216
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
4348
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L24, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4217
4349
|
return { $loc, token: "false" };
|
|
4218
4350
|
});
|
|
4219
4351
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -4234,7 +4366,7 @@ ${input.slice(result.pos)}
|
|
|
4234
4366
|
return result;
|
|
4235
4367
|
}
|
|
4236
4368
|
}
|
|
4237
|
-
var Comma$0 = $TV($EXPECT($
|
|
4369
|
+
var Comma$0 = $TV($EXPECT($L25, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
4238
4370
|
return { $loc, token: $1 };
|
|
4239
4371
|
});
|
|
4240
4372
|
function Comma(state) {
|
|
@@ -4324,7 +4456,7 @@ ${input.slice(result.pos)}
|
|
|
4324
4456
|
return result;
|
|
4325
4457
|
}
|
|
4326
4458
|
}
|
|
4327
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($
|
|
4459
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L26, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L26, fail, 'UpcomingAssignment "="'), $EXPECT($L27, fail, 'UpcomingAssignment ">"')))));
|
|
4328
4460
|
function UpcomingAssignment(state) {
|
|
4329
4461
|
if (state.events) {
|
|
4330
4462
|
const result = state.events.enter?.("UpcomingAssignment", state);
|
|
@@ -4572,7 +4704,7 @@ ${input.slice(result.pos)}
|
|
|
4572
4704
|
}
|
|
4573
4705
|
}
|
|
4574
4706
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
4575
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
4707
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L28, fail, 'ArrayElementDelimiter "]"')));
|
|
4576
4708
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
4577
4709
|
return value[1];
|
|
4578
4710
|
});
|
|
@@ -4941,7 +5073,7 @@ ${input.slice(result.pos)}
|
|
|
4941
5073
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S(EOS, NamedProperty)), InsertComma), function(value) {
|
|
4942
5074
|
return value[1];
|
|
4943
5075
|
});
|
|
4944
|
-
var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($
|
|
5076
|
+
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
5077
|
return "";
|
|
4946
5078
|
});
|
|
4947
5079
|
var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -4966,7 +5098,7 @@ ${input.slice(result.pos)}
|
|
|
4966
5098
|
}
|
|
4967
5099
|
}
|
|
4968
5100
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
4969
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
5101
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L17, fail, 'ObjectPropertyDelimiter "}"')));
|
|
4970
5102
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
4971
5103
|
return value[1];
|
|
4972
5104
|
});
|
|
@@ -5222,7 +5354,18 @@ ${input.slice(result.pos)}
|
|
|
5222
5354
|
return result;
|
|
5223
5355
|
}
|
|
5224
5356
|
}
|
|
5225
|
-
var MethodDefinition$0 = $TS($S(
|
|
5357
|
+
var MethodDefinition$0 = $TS($S(Abstract, __, MethodSignature), function($skip, $loc, $0, $1, $2, $3) {
|
|
5358
|
+
var signature = $3;
|
|
5359
|
+
return {
|
|
5360
|
+
type: "MethodDefinition",
|
|
5361
|
+
children: $0,
|
|
5362
|
+
name: signature.name,
|
|
5363
|
+
signature,
|
|
5364
|
+
parameters: signature.parameters,
|
|
5365
|
+
ts: true
|
|
5366
|
+
};
|
|
5367
|
+
});
|
|
5368
|
+
var MethodDefinition$1 = $TS($S(MethodSignature, BracedBlock), function($skip, $loc, $0, $1, $2) {
|
|
5226
5369
|
var signature = $1;
|
|
5227
5370
|
var block = $2;
|
|
5228
5371
|
return {
|
|
@@ -5241,12 +5384,12 @@ ${input.slice(result.pos)}
|
|
|
5241
5384
|
return result.cache;
|
|
5242
5385
|
}
|
|
5243
5386
|
if (state.tokenize) {
|
|
5244
|
-
const result = $TOKEN("MethodDefinition", state, MethodDefinition$0(state));
|
|
5387
|
+
const result = $TOKEN("MethodDefinition", state, MethodDefinition$0(state) || MethodDefinition$1(state));
|
|
5245
5388
|
if (state.events)
|
|
5246
5389
|
state.events.exit?.("MethodDefinition", state, result);
|
|
5247
5390
|
return result;
|
|
5248
5391
|
} else {
|
|
5249
|
-
const result = MethodDefinition$0(state);
|
|
5392
|
+
const result = MethodDefinition$0(state) || MethodDefinition$1(state);
|
|
5250
5393
|
if (state.events)
|
|
5251
5394
|
state.events.exit?.("MethodDefinition", state, result);
|
|
5252
5395
|
return result;
|
|
@@ -5339,7 +5482,7 @@ ${input.slice(result.pos)}
|
|
|
5339
5482
|
return result;
|
|
5340
5483
|
}
|
|
5341
5484
|
}
|
|
5342
|
-
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($
|
|
5485
|
+
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
|
|
5343
5486
|
return {
|
|
5344
5487
|
type: "Identifier",
|
|
5345
5488
|
name: $0,
|
|
@@ -5395,25 +5538,25 @@ ${input.slice(result.pos)}
|
|
|
5395
5538
|
return result;
|
|
5396
5539
|
}
|
|
5397
5540
|
}
|
|
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($
|
|
5541
|
+
var AssignmentOpSymbol$0 = $EXPECT($L30, fail, 'AssignmentOpSymbol "**="');
|
|
5542
|
+
var AssignmentOpSymbol$1 = $EXPECT($L31, fail, 'AssignmentOpSymbol "*="');
|
|
5543
|
+
var AssignmentOpSymbol$2 = $EXPECT($L32, fail, 'AssignmentOpSymbol "/="');
|
|
5544
|
+
var AssignmentOpSymbol$3 = $EXPECT($L33, fail, 'AssignmentOpSymbol "%="');
|
|
5545
|
+
var AssignmentOpSymbol$4 = $EXPECT($L34, fail, 'AssignmentOpSymbol "+="');
|
|
5546
|
+
var AssignmentOpSymbol$5 = $EXPECT($L35, fail, 'AssignmentOpSymbol "-="');
|
|
5547
|
+
var AssignmentOpSymbol$6 = $EXPECT($L36, fail, 'AssignmentOpSymbol "<<="');
|
|
5548
|
+
var AssignmentOpSymbol$7 = $EXPECT($L37, fail, 'AssignmentOpSymbol ">>>="');
|
|
5549
|
+
var AssignmentOpSymbol$8 = $EXPECT($L38, fail, 'AssignmentOpSymbol ">>="');
|
|
5550
|
+
var AssignmentOpSymbol$9 = $EXPECT($L39, fail, 'AssignmentOpSymbol "&&="');
|
|
5551
|
+
var AssignmentOpSymbol$10 = $EXPECT($L40, fail, 'AssignmentOpSymbol "&="');
|
|
5552
|
+
var AssignmentOpSymbol$11 = $EXPECT($L41, fail, 'AssignmentOpSymbol "^="');
|
|
5553
|
+
var AssignmentOpSymbol$12 = $EXPECT($L42, fail, 'AssignmentOpSymbol "||="');
|
|
5554
|
+
var AssignmentOpSymbol$13 = $EXPECT($L43, fail, 'AssignmentOpSymbol "|="');
|
|
5555
|
+
var AssignmentOpSymbol$14 = $EXPECT($L44, fail, 'AssignmentOpSymbol "??="');
|
|
5556
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L45, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
5414
5557
|
return "??=";
|
|
5415
5558
|
});
|
|
5416
|
-
var AssignmentOpSymbol$16 = $EXPECT($
|
|
5559
|
+
var AssignmentOpSymbol$16 = $EXPECT($L26, fail, 'AssignmentOpSymbol "="');
|
|
5417
5560
|
var AssignmentOpSymbol$17 = $T($S(CoffeeWordAssignmentOp), function(value) {
|
|
5418
5561
|
return value[0];
|
|
5419
5562
|
});
|
|
@@ -5435,10 +5578,10 @@ ${input.slice(result.pos)}
|
|
|
5435
5578
|
return result;
|
|
5436
5579
|
}
|
|
5437
5580
|
}
|
|
5438
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
5581
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L46, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
5439
5582
|
return "&&=";
|
|
5440
5583
|
});
|
|
5441
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
5584
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L47, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
5442
5585
|
return "||=";
|
|
5443
5586
|
});
|
|
5444
5587
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -5482,93 +5625,93 @@ ${input.slice(result.pos)}
|
|
|
5482
5625
|
return result;
|
|
5483
5626
|
}
|
|
5484
5627
|
}
|
|
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($
|
|
5628
|
+
var BinaryOpSymbol$0 = $EXPECT($L48, fail, 'BinaryOpSymbol "**"');
|
|
5629
|
+
var BinaryOpSymbol$1 = $EXPECT($L49, fail, 'BinaryOpSymbol "*"');
|
|
5630
|
+
var BinaryOpSymbol$2 = $EXPECT($L50, fail, 'BinaryOpSymbol "/"');
|
|
5631
|
+
var BinaryOpSymbol$3 = $EXPECT($L51, fail, 'BinaryOpSymbol "%"');
|
|
5632
|
+
var BinaryOpSymbol$4 = $EXPECT($L52, fail, 'BinaryOpSymbol "+"');
|
|
5633
|
+
var BinaryOpSymbol$5 = $EXPECT($L53, fail, 'BinaryOpSymbol "-"');
|
|
5634
|
+
var BinaryOpSymbol$6 = $EXPECT($L54, fail, 'BinaryOpSymbol "<="');
|
|
5635
|
+
var BinaryOpSymbol$7 = $EXPECT($L55, fail, 'BinaryOpSymbol ">="');
|
|
5636
|
+
var BinaryOpSymbol$8 = $EXPECT($L56, fail, 'BinaryOpSymbol "<<"');
|
|
5494
5637
|
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
5638
|
return "<";
|
|
5496
5639
|
});
|
|
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($
|
|
5640
|
+
var BinaryOpSymbol$10 = $EXPECT($L57, fail, 'BinaryOpSymbol ">>>"');
|
|
5641
|
+
var BinaryOpSymbol$11 = $EXPECT($L58, fail, 'BinaryOpSymbol ">>"');
|
|
5642
|
+
var BinaryOpSymbol$12 = $EXPECT($L27, fail, 'BinaryOpSymbol ">"');
|
|
5643
|
+
var BinaryOpSymbol$13 = $EXPECT($L59, fail, 'BinaryOpSymbol "!=="');
|
|
5644
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L60, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
5502
5645
|
if (module.config.coffeeEq)
|
|
5503
5646
|
return "!==";
|
|
5504
5647
|
return $1;
|
|
5505
5648
|
});
|
|
5506
|
-
var BinaryOpSymbol$15 = $TS($S($EXPECT($
|
|
5649
|
+
var BinaryOpSymbol$15 = $TS($S($EXPECT($L61, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5507
5650
|
if (module.config.coffeeIsnt)
|
|
5508
5651
|
return "!==";
|
|
5509
5652
|
return $skip;
|
|
5510
5653
|
});
|
|
5511
|
-
var BinaryOpSymbol$16 = $T($S($EXPECT($
|
|
5654
|
+
var BinaryOpSymbol$16 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
5512
5655
|
return "===";
|
|
5513
5656
|
});
|
|
5514
|
-
var BinaryOpSymbol$17 = $EXPECT($
|
|
5515
|
-
var BinaryOpSymbol$18 = $TV($EXPECT($
|
|
5657
|
+
var BinaryOpSymbol$17 = $EXPECT($L63, fail, 'BinaryOpSymbol "==="');
|
|
5658
|
+
var BinaryOpSymbol$18 = $TV($EXPECT($L64, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
5516
5659
|
if (module.config.coffeeEq)
|
|
5517
5660
|
return "===";
|
|
5518
5661
|
return $1;
|
|
5519
5662
|
});
|
|
5520
|
-
var BinaryOpSymbol$19 = $T($S($EXPECT($
|
|
5663
|
+
var BinaryOpSymbol$19 = $T($S($EXPECT($L65, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
5521
5664
|
return "&&";
|
|
5522
5665
|
});
|
|
5523
|
-
var BinaryOpSymbol$20 = $EXPECT($
|
|
5524
|
-
var BinaryOpSymbol$21 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
5666
|
+
var BinaryOpSymbol$20 = $EXPECT($L66, fail, 'BinaryOpSymbol "&&"');
|
|
5667
|
+
var BinaryOpSymbol$21 = $T($S(CoffeeOfEnabled, $EXPECT($L67, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
5525
5668
|
return "in";
|
|
5526
5669
|
});
|
|
5527
|
-
var BinaryOpSymbol$22 = $T($S($EXPECT($
|
|
5670
|
+
var BinaryOpSymbol$22 = $T($S($EXPECT($L68, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
5528
5671
|
return "||";
|
|
5529
5672
|
});
|
|
5530
|
-
var BinaryOpSymbol$23 = $EXPECT($
|
|
5531
|
-
var BinaryOpSymbol$24 = $EXPECT($
|
|
5532
|
-
var BinaryOpSymbol$25 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($
|
|
5673
|
+
var BinaryOpSymbol$23 = $EXPECT($L69, fail, 'BinaryOpSymbol "||"');
|
|
5674
|
+
var BinaryOpSymbol$24 = $EXPECT($L70, fail, 'BinaryOpSymbol "??"');
|
|
5675
|
+
var BinaryOpSymbol$25 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L71, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
5533
5676
|
return "??";
|
|
5534
5677
|
});
|
|
5535
|
-
var BinaryOpSymbol$26 = $TS($S($EXPECT($
|
|
5678
|
+
var BinaryOpSymbol$26 = $TS($S($EXPECT($L72, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5536
5679
|
return $1;
|
|
5537
5680
|
});
|
|
5538
|
-
var BinaryOpSymbol$27 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
5681
|
+
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
5682
|
return {
|
|
5540
5683
|
$loc,
|
|
5541
5684
|
token: "instanceof",
|
|
5542
5685
|
special: true
|
|
5543
5686
|
};
|
|
5544
5687
|
});
|
|
5545
|
-
var BinaryOpSymbol$28 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
5688
|
+
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
5689
|
return {
|
|
5547
5690
|
$loc,
|
|
5548
5691
|
token: "in",
|
|
5549
5692
|
special: true
|
|
5550
5693
|
};
|
|
5551
5694
|
});
|
|
5552
|
-
var BinaryOpSymbol$29 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
5695
|
+
var BinaryOpSymbol$29 = $TS($S(CoffeeOfEnabled, $EXPECT($L74, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
5553
5696
|
return {
|
|
5554
5697
|
ref: module.getRef("indexOf"),
|
|
5555
5698
|
suffix: " >= 0",
|
|
5556
5699
|
special: true
|
|
5557
5700
|
};
|
|
5558
5701
|
});
|
|
5559
|
-
var BinaryOpSymbol$30 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
5702
|
+
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
5703
|
return {
|
|
5561
5704
|
ref: module.getRef("indexOf"),
|
|
5562
5705
|
suffix: " < 0",
|
|
5563
5706
|
special: true
|
|
5564
5707
|
};
|
|
5565
5708
|
});
|
|
5566
|
-
var BinaryOpSymbol$31 = $TS($S($EXPECT($
|
|
5709
|
+
var BinaryOpSymbol$31 = $TS($S($EXPECT($L74, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5567
5710
|
return $1;
|
|
5568
5711
|
});
|
|
5569
|
-
var BinaryOpSymbol$32 = $EXPECT($
|
|
5570
|
-
var BinaryOpSymbol$33 = $EXPECT($
|
|
5571
|
-
var BinaryOpSymbol$34 = $EXPECT($
|
|
5712
|
+
var BinaryOpSymbol$32 = $EXPECT($L75, fail, 'BinaryOpSymbol "&"');
|
|
5713
|
+
var BinaryOpSymbol$33 = $EXPECT($L76, fail, 'BinaryOpSymbol "^"');
|
|
5714
|
+
var BinaryOpSymbol$34 = $EXPECT($L77, fail, 'BinaryOpSymbol "|"');
|
|
5572
5715
|
function BinaryOpSymbol(state) {
|
|
5573
5716
|
if (state.events) {
|
|
5574
5717
|
const result = state.events.enter?.("BinaryOpSymbol", state);
|
|
@@ -5707,7 +5850,7 @@ ${input.slice(result.pos)}
|
|
|
5707
5850
|
return result;
|
|
5708
5851
|
}
|
|
5709
5852
|
}
|
|
5710
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
5853
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L78, fail, 'EmptyStatement ";"'))), function(value) {
|
|
5711
5854
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
5712
5855
|
});
|
|
5713
5856
|
function EmptyStatement(state) {
|
|
@@ -5728,7 +5871,7 @@ ${input.slice(result.pos)}
|
|
|
5728
5871
|
return result;
|
|
5729
5872
|
}
|
|
5730
5873
|
}
|
|
5731
|
-
var BlockStatement$0 = $T($S(ExplicitBlock, $N($S(__, $EXPECT($
|
|
5874
|
+
var BlockStatement$0 = $T($S(ExplicitBlock, $N($S(__, $EXPECT($L26, fail, 'BlockStatement "="')))), function(value) {
|
|
5732
5875
|
return value[0];
|
|
5733
5876
|
});
|
|
5734
5877
|
function BlockStatement(state) {
|
|
@@ -6555,7 +6698,7 @@ ${input.slice(result.pos)}
|
|
|
6555
6698
|
return result;
|
|
6556
6699
|
}
|
|
6557
6700
|
}
|
|
6558
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
6701
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L79, fail, 'CoffeeForDeclaration "own"'))), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
6559
6702
|
var own = $1;
|
|
6560
6703
|
var binding = $2;
|
|
6561
6704
|
if (own) {
|
|
@@ -7099,7 +7242,7 @@ ${input.slice(result.pos)}
|
|
|
7099
7242
|
return result;
|
|
7100
7243
|
}
|
|
7101
7244
|
}
|
|
7102
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
7245
|
+
var Finally$0 = $S(__, $EXPECT($L80, fail, 'Finally "finally"'), BracedBlock);
|
|
7103
7246
|
function Finally(state) {
|
|
7104
7247
|
if (state.events) {
|
|
7105
7248
|
const result = state.events.enter?.("Finally", state);
|
|
@@ -7235,13 +7378,13 @@ ${input.slice(result.pos)}
|
|
|
7235
7378
|
return result;
|
|
7236
7379
|
}
|
|
7237
7380
|
}
|
|
7238
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
7381
|
+
var KeywordStatement$0 = $T($S($EXPECT($L81, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
7239
7382
|
return { "type": "BreakStatement", "children": value };
|
|
7240
7383
|
});
|
|
7241
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
7384
|
+
var KeywordStatement$1 = $T($S($EXPECT($L82, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
7242
7385
|
return { "type": "ContinueStatement", "children": value };
|
|
7243
7386
|
});
|
|
7244
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
7387
|
+
var KeywordStatement$2 = $T($S($EXPECT($L83, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
7245
7388
|
return { "type": "DebuggerStatement", "children": value };
|
|
7246
7389
|
});
|
|
7247
7390
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -7268,7 +7411,7 @@ ${input.slice(result.pos)}
|
|
|
7268
7411
|
return result;
|
|
7269
7412
|
}
|
|
7270
7413
|
}
|
|
7271
|
-
var DebuggerExpression$0 = $TS($S($EXPECT($
|
|
7414
|
+
var DebuggerExpression$0 = $TS($S($EXPECT($L83, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7272
7415
|
return {
|
|
7273
7416
|
type: "DebuggerExpression",
|
|
7274
7417
|
children: ["(()=>{", $1, "})()"]
|
|
@@ -7341,7 +7484,7 @@ ${input.slice(result.pos)}
|
|
|
7341
7484
|
return result;
|
|
7342
7485
|
}
|
|
7343
7486
|
}
|
|
7344
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
7487
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L84, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
7345
7488
|
return { "ts": true, "children": value };
|
|
7346
7489
|
});
|
|
7347
7490
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
@@ -7641,7 +7784,7 @@ ${input.slice(result.pos)}
|
|
|
7641
7784
|
return result;
|
|
7642
7785
|
}
|
|
7643
7786
|
}
|
|
7644
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
7787
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L85, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression));
|
|
7645
7788
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
7646
7789
|
var ExportDeclaration$2 = $S(Export, __, $C(Declaration, NamedExports, VariableStatement, ExportVarDec));
|
|
7647
7790
|
function ExportDeclaration(state) {
|
|
@@ -7744,7 +7887,7 @@ ${input.slice(result.pos)}
|
|
|
7744
7887
|
return result;
|
|
7745
7888
|
}
|
|
7746
7889
|
}
|
|
7747
|
-
var ImplicitExportSpecifier$0 = $S($N($EXPECT($
|
|
7890
|
+
var ImplicitExportSpecifier$0 = $S($N($EXPECT($L85, fail, 'ImplicitExportSpecifier "default"')), ModuleExportName, $E($S(__, As, __, ModuleExportName)), $C($Y($S(__, From)), ImplicitInlineObjectPropertyDelimiter));
|
|
7748
7891
|
function ImplicitExportSpecifier(state) {
|
|
7749
7892
|
if (state.events) {
|
|
7750
7893
|
const result = state.events.enter?.("ImplicitExportSpecifier", state);
|
|
@@ -7899,7 +8042,7 @@ ${input.slice(result.pos)}
|
|
|
7899
8042
|
return result;
|
|
7900
8043
|
}
|
|
7901
8044
|
}
|
|
7902
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
8045
|
+
var ConstAssignment$0 = $TV($EXPECT($L86, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
7903
8046
|
return { $loc, token: "=" };
|
|
7904
8047
|
});
|
|
7905
8048
|
function ConstAssignment(state) {
|
|
@@ -7920,10 +8063,10 @@ ${input.slice(result.pos)}
|
|
|
7920
8063
|
return result;
|
|
7921
8064
|
}
|
|
7922
8065
|
}
|
|
7923
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
8066
|
+
var LetAssignment$0 = $TV($EXPECT($L87, fail, 'LetAssignment "::="'), function($skip, $loc, $0, $1) {
|
|
7924
8067
|
return { $loc, token: "=" };
|
|
7925
8068
|
});
|
|
7926
|
-
var LetAssignment$1 = $TV($EXPECT($
|
|
8069
|
+
var LetAssignment$1 = $TV($EXPECT($L88, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
7927
8070
|
return { $loc, token: "=" };
|
|
7928
8071
|
});
|
|
7929
8072
|
function LetAssignment(state) {
|
|
@@ -8481,7 +8624,7 @@ ${input.slice(result.pos)}
|
|
|
8481
8624
|
}
|
|
8482
8625
|
}
|
|
8483
8626
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
8484
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
8627
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L50, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L50, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
8485
8628
|
return { $loc, token: $1 };
|
|
8486
8629
|
});
|
|
8487
8630
|
function RegularExpressionLiteral(state) {
|
|
@@ -8927,7 +9070,7 @@ ${input.slice(result.pos)}
|
|
|
8927
9070
|
return result;
|
|
8928
9071
|
}
|
|
8929
9072
|
}
|
|
8930
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
9073
|
+
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
9074
|
return { $loc, token: $1 };
|
|
8932
9075
|
});
|
|
8933
9076
|
function JSMultiLineComment(state) {
|
|
@@ -8969,7 +9112,7 @@ ${input.slice(result.pos)}
|
|
|
8969
9112
|
return result;
|
|
8970
9113
|
}
|
|
8971
9114
|
}
|
|
8972
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($Q($S($N($C(CoffeeHereCommentStart, $EXPECT($
|
|
9115
|
+
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
9116
|
return { $loc, token: `/*${$2}*/` };
|
|
8974
9117
|
});
|
|
8975
9118
|
function CoffeeMultiLineComment(state) {
|
|
@@ -9009,7 +9152,7 @@ ${input.slice(result.pos)}
|
|
|
9009
9152
|
return result;
|
|
9010
9153
|
}
|
|
9011
9154
|
}
|
|
9012
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
9155
|
+
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
9156
|
return { $loc, token: $1 };
|
|
9014
9157
|
});
|
|
9015
9158
|
function InlineComment(state) {
|
|
@@ -9092,7 +9235,7 @@ ${input.slice(result.pos)}
|
|
|
9092
9235
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R42, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9093
9236
|
return { $loc, token: $0 };
|
|
9094
9237
|
});
|
|
9095
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
9238
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L91, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
9096
9239
|
return "";
|
|
9097
9240
|
});
|
|
9098
9241
|
function NonNewlineWhitespace(state) {
|
|
@@ -9237,7 +9380,28 @@ ${input.slice(result.pos)}
|
|
|
9237
9380
|
return result;
|
|
9238
9381
|
}
|
|
9239
9382
|
}
|
|
9240
|
-
var
|
|
9383
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L92, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L4, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
9384
|
+
return { $loc, token: $1, ts: true };
|
|
9385
|
+
});
|
|
9386
|
+
function Abstract(state) {
|
|
9387
|
+
if (state.events) {
|
|
9388
|
+
const result = state.events.enter?.("Abstract", state);
|
|
9389
|
+
if (result)
|
|
9390
|
+
return result.cache;
|
|
9391
|
+
}
|
|
9392
|
+
if (state.tokenize) {
|
|
9393
|
+
const result = $TOKEN("Abstract", state, Abstract$0(state));
|
|
9394
|
+
if (state.events)
|
|
9395
|
+
state.events.exit?.("Abstract", state, result);
|
|
9396
|
+
return result;
|
|
9397
|
+
} else {
|
|
9398
|
+
const result = Abstract$0(state);
|
|
9399
|
+
if (state.events)
|
|
9400
|
+
state.events.exit?.("Abstract", state, result);
|
|
9401
|
+
return result;
|
|
9402
|
+
}
|
|
9403
|
+
}
|
|
9404
|
+
var Ampersand$0 = $TV($EXPECT($L75, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
9241
9405
|
return { $loc, token: $1 };
|
|
9242
9406
|
});
|
|
9243
9407
|
function Ampersand(state) {
|
|
@@ -9258,7 +9422,7 @@ ${input.slice(result.pos)}
|
|
|
9258
9422
|
return result;
|
|
9259
9423
|
}
|
|
9260
9424
|
}
|
|
9261
|
-
var As$0 = $TS($S($EXPECT($
|
|
9425
|
+
var As$0 = $TS($S($EXPECT($L93, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9262
9426
|
return { $loc, token: $1 };
|
|
9263
9427
|
});
|
|
9264
9428
|
function As(state) {
|
|
@@ -9279,7 +9443,7 @@ ${input.slice(result.pos)}
|
|
|
9279
9443
|
return result;
|
|
9280
9444
|
}
|
|
9281
9445
|
}
|
|
9282
|
-
var At$0 = $TV($EXPECT($
|
|
9446
|
+
var At$0 = $TV($EXPECT($L94, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
9283
9447
|
return { $loc, token: $1 };
|
|
9284
9448
|
});
|
|
9285
9449
|
function At(state) {
|
|
@@ -9300,7 +9464,7 @@ ${input.slice(result.pos)}
|
|
|
9300
9464
|
return result;
|
|
9301
9465
|
}
|
|
9302
9466
|
}
|
|
9303
|
-
var AtAt$0 = $TV($EXPECT($
|
|
9467
|
+
var AtAt$0 = $TV($EXPECT($L95, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
9304
9468
|
return { $loc, token: "@" };
|
|
9305
9469
|
});
|
|
9306
9470
|
function AtAt(state) {
|
|
@@ -9321,7 +9485,7 @@ ${input.slice(result.pos)}
|
|
|
9321
9485
|
return result;
|
|
9322
9486
|
}
|
|
9323
9487
|
}
|
|
9324
|
-
var Async$0 = $TV($EXPECT($
|
|
9488
|
+
var Async$0 = $TV($EXPECT($L96, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
|
|
9325
9489
|
return { $loc, token: $1, type: "Async" };
|
|
9326
9490
|
});
|
|
9327
9491
|
function Async(state) {
|
|
@@ -9342,7 +9506,7 @@ ${input.slice(result.pos)}
|
|
|
9342
9506
|
return result;
|
|
9343
9507
|
}
|
|
9344
9508
|
}
|
|
9345
|
-
var Await$0 = $TS($S($EXPECT($
|
|
9509
|
+
var Await$0 = $TS($S($EXPECT($L97, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9346
9510
|
return { $loc, token: $1 };
|
|
9347
9511
|
});
|
|
9348
9512
|
function Await(state) {
|
|
@@ -9363,7 +9527,7 @@ ${input.slice(result.pos)}
|
|
|
9363
9527
|
return result;
|
|
9364
9528
|
}
|
|
9365
9529
|
}
|
|
9366
|
-
var Backtick$0 = $TV($EXPECT($
|
|
9530
|
+
var Backtick$0 = $TV($EXPECT($L98, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
9367
9531
|
return { $loc, token: $1 };
|
|
9368
9532
|
});
|
|
9369
9533
|
function Backtick(state) {
|
|
@@ -9384,7 +9548,7 @@ ${input.slice(result.pos)}
|
|
|
9384
9548
|
return result;
|
|
9385
9549
|
}
|
|
9386
9550
|
}
|
|
9387
|
-
var By$0 = $TS($S($EXPECT($
|
|
9551
|
+
var By$0 = $TS($S($EXPECT($L99, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9388
9552
|
return { $loc, token: $1 };
|
|
9389
9553
|
});
|
|
9390
9554
|
function By(state) {
|
|
@@ -9405,7 +9569,7 @@ ${input.slice(result.pos)}
|
|
|
9405
9569
|
return result;
|
|
9406
9570
|
}
|
|
9407
9571
|
}
|
|
9408
|
-
var Case$0 = $TS($S($EXPECT($
|
|
9572
|
+
var Case$0 = $TS($S($EXPECT($L100, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9409
9573
|
return { $loc, token: $1 };
|
|
9410
9574
|
});
|
|
9411
9575
|
function Case(state) {
|
|
@@ -9426,7 +9590,7 @@ ${input.slice(result.pos)}
|
|
|
9426
9590
|
return result;
|
|
9427
9591
|
}
|
|
9428
9592
|
}
|
|
9429
|
-
var Catch$0 = $TV($EXPECT($
|
|
9593
|
+
var Catch$0 = $TV($EXPECT($L101, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
9430
9594
|
return { $loc, token: $1 };
|
|
9431
9595
|
});
|
|
9432
9596
|
function Catch(state) {
|
|
@@ -9447,7 +9611,7 @@ ${input.slice(result.pos)}
|
|
|
9447
9611
|
return result;
|
|
9448
9612
|
}
|
|
9449
9613
|
}
|
|
9450
|
-
var Class$0 = $TV($EXPECT($
|
|
9614
|
+
var Class$0 = $TV($EXPECT($L102, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
9451
9615
|
return { $loc, token: $1 };
|
|
9452
9616
|
});
|
|
9453
9617
|
function Class(state) {
|
|
@@ -9468,7 +9632,7 @@ ${input.slice(result.pos)}
|
|
|
9468
9632
|
return result;
|
|
9469
9633
|
}
|
|
9470
9634
|
}
|
|
9471
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
9635
|
+
var CloseBrace$0 = $TV($EXPECT($L17, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
9472
9636
|
return { $loc, token: $1 };
|
|
9473
9637
|
});
|
|
9474
9638
|
function CloseBrace(state) {
|
|
@@ -9489,7 +9653,7 @@ ${input.slice(result.pos)}
|
|
|
9489
9653
|
return result;
|
|
9490
9654
|
}
|
|
9491
9655
|
}
|
|
9492
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
9656
|
+
var CloseBracket$0 = $TV($EXPECT($L28, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
9493
9657
|
return { $loc, token: $1 };
|
|
9494
9658
|
});
|
|
9495
9659
|
function CloseBracket(state) {
|
|
@@ -9510,7 +9674,7 @@ ${input.slice(result.pos)}
|
|
|
9510
9674
|
return result;
|
|
9511
9675
|
}
|
|
9512
9676
|
}
|
|
9513
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
9677
|
+
var CloseParen$0 = $TV($EXPECT($L15, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
9514
9678
|
return { $loc, token: $1 };
|
|
9515
9679
|
});
|
|
9516
9680
|
function CloseParen(state) {
|
|
@@ -9531,7 +9695,7 @@ ${input.slice(result.pos)}
|
|
|
9531
9695
|
return result;
|
|
9532
9696
|
}
|
|
9533
9697
|
}
|
|
9534
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
9698
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L103, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
9535
9699
|
return { $loc, token: "${" };
|
|
9536
9700
|
});
|
|
9537
9701
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -9552,7 +9716,7 @@ ${input.slice(result.pos)}
|
|
|
9552
9716
|
return result;
|
|
9553
9717
|
}
|
|
9554
9718
|
}
|
|
9555
|
-
var Colon$0 = $TV($EXPECT($
|
|
9719
|
+
var Colon$0 = $TV($EXPECT($L29, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
9556
9720
|
return { $loc, token: $1 };
|
|
9557
9721
|
});
|
|
9558
9722
|
function Colon(state) {
|
|
@@ -9573,7 +9737,7 @@ ${input.slice(result.pos)}
|
|
|
9573
9737
|
return result;
|
|
9574
9738
|
}
|
|
9575
9739
|
}
|
|
9576
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
9740
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L94, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
9577
9741
|
return { $loc, token: "constructor" };
|
|
9578
9742
|
});
|
|
9579
9743
|
function ConstructorShorthand(state) {
|
|
@@ -9594,7 +9758,7 @@ ${input.slice(result.pos)}
|
|
|
9594
9758
|
return result;
|
|
9595
9759
|
}
|
|
9596
9760
|
}
|
|
9597
|
-
var Default$0 = $TS($S($EXPECT($
|
|
9761
|
+
var Default$0 = $TS($S($EXPECT($L85, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9598
9762
|
return { $loc, token: $1 };
|
|
9599
9763
|
});
|
|
9600
9764
|
function Default(state) {
|
|
@@ -9615,7 +9779,7 @@ ${input.slice(result.pos)}
|
|
|
9615
9779
|
return result;
|
|
9616
9780
|
}
|
|
9617
9781
|
}
|
|
9618
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
9782
|
+
var Delete$0 = $TS($S($EXPECT($L104, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9619
9783
|
return { $loc, token: $1 };
|
|
9620
9784
|
});
|
|
9621
9785
|
function Delete(state) {
|
|
@@ -9636,7 +9800,7 @@ ${input.slice(result.pos)}
|
|
|
9636
9800
|
return result;
|
|
9637
9801
|
}
|
|
9638
9802
|
}
|
|
9639
|
-
var Do$0 = $TS($S($EXPECT($
|
|
9803
|
+
var Do$0 = $TS($S($EXPECT($L105, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9640
9804
|
return { $loc, token: $1 };
|
|
9641
9805
|
});
|
|
9642
9806
|
function Do(state) {
|
|
@@ -9657,7 +9821,7 @@ ${input.slice(result.pos)}
|
|
|
9657
9821
|
return result;
|
|
9658
9822
|
}
|
|
9659
9823
|
}
|
|
9660
|
-
var Dot$0 = $TV($EXPECT($
|
|
9824
|
+
var Dot$0 = $TV($EXPECT($L9, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
9661
9825
|
return { $loc, token: $1 };
|
|
9662
9826
|
});
|
|
9663
9827
|
function Dot(state) {
|
|
@@ -9678,7 +9842,7 @@ ${input.slice(result.pos)}
|
|
|
9678
9842
|
return result;
|
|
9679
9843
|
}
|
|
9680
9844
|
}
|
|
9681
|
-
var DotDot$0 = $TV($EXPECT($
|
|
9845
|
+
var DotDot$0 = $TV($EXPECT($L106, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
9682
9846
|
return { $loc, token: $1 };
|
|
9683
9847
|
});
|
|
9684
9848
|
function DotDot(state) {
|
|
@@ -9699,7 +9863,7 @@ ${input.slice(result.pos)}
|
|
|
9699
9863
|
return result;
|
|
9700
9864
|
}
|
|
9701
9865
|
}
|
|
9702
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
9866
|
+
var DotDotDot$0 = $TV($EXPECT($L107, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
9703
9867
|
return { $loc, token: $1 };
|
|
9704
9868
|
});
|
|
9705
9869
|
function DotDotDot(state) {
|
|
@@ -9720,7 +9884,7 @@ ${input.slice(result.pos)}
|
|
|
9720
9884
|
return result;
|
|
9721
9885
|
}
|
|
9722
9886
|
}
|
|
9723
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
9887
|
+
var DoubleColon$0 = $TV($EXPECT($L108, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
9724
9888
|
return { $loc, token: $1 };
|
|
9725
9889
|
});
|
|
9726
9890
|
function DoubleColon(state) {
|
|
@@ -9741,7 +9905,7 @@ ${input.slice(result.pos)}
|
|
|
9741
9905
|
return result;
|
|
9742
9906
|
}
|
|
9743
9907
|
}
|
|
9744
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
9908
|
+
var DoubleQuote$0 = $TV($EXPECT($L109, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
9745
9909
|
return { $loc, token: $1 };
|
|
9746
9910
|
});
|
|
9747
9911
|
function DoubleQuote(state) {
|
|
@@ -9762,7 +9926,7 @@ ${input.slice(result.pos)}
|
|
|
9762
9926
|
return result;
|
|
9763
9927
|
}
|
|
9764
9928
|
}
|
|
9765
|
-
var Else$0 = $TV($EXPECT($
|
|
9929
|
+
var Else$0 = $TV($EXPECT($L110, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
9766
9930
|
return { $loc, token: $1 };
|
|
9767
9931
|
});
|
|
9768
9932
|
function Else(state) {
|
|
@@ -9783,7 +9947,7 @@ ${input.slice(result.pos)}
|
|
|
9783
9947
|
return result;
|
|
9784
9948
|
}
|
|
9785
9949
|
}
|
|
9786
|
-
var Equals$0 = $TV($EXPECT($
|
|
9950
|
+
var Equals$0 = $TV($EXPECT($L26, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
9787
9951
|
return { $loc, token: $1 };
|
|
9788
9952
|
});
|
|
9789
9953
|
function Equals(state) {
|
|
@@ -9804,7 +9968,7 @@ ${input.slice(result.pos)}
|
|
|
9804
9968
|
return result;
|
|
9805
9969
|
}
|
|
9806
9970
|
}
|
|
9807
|
-
var Export$0 = $TS($S($EXPECT($
|
|
9971
|
+
var Export$0 = $TS($S($EXPECT($L111, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9808
9972
|
return { $loc, token: $1 };
|
|
9809
9973
|
});
|
|
9810
9974
|
function Export(state) {
|
|
@@ -9825,7 +9989,7 @@ ${input.slice(result.pos)}
|
|
|
9825
9989
|
return result;
|
|
9826
9990
|
}
|
|
9827
9991
|
}
|
|
9828
|
-
var For$0 = $TS($S($EXPECT($
|
|
9992
|
+
var For$0 = $TS($S($EXPECT($L112, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9829
9993
|
return { $loc, token: $1 };
|
|
9830
9994
|
});
|
|
9831
9995
|
function For(state) {
|
|
@@ -9846,7 +10010,7 @@ ${input.slice(result.pos)}
|
|
|
9846
10010
|
return result;
|
|
9847
10011
|
}
|
|
9848
10012
|
}
|
|
9849
|
-
var From$0 = $TS($S($EXPECT($
|
|
10013
|
+
var From$0 = $TS($S($EXPECT($L113, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9850
10014
|
return { $loc, token: $1 };
|
|
9851
10015
|
});
|
|
9852
10016
|
function From(state) {
|
|
@@ -9867,7 +10031,7 @@ ${input.slice(result.pos)}
|
|
|
9867
10031
|
return result;
|
|
9868
10032
|
}
|
|
9869
10033
|
}
|
|
9870
|
-
var Function$0 = $TV($EXPECT($
|
|
10034
|
+
var Function$0 = $TV($EXPECT($L114, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
9871
10035
|
return { $loc, token: $1 };
|
|
9872
10036
|
});
|
|
9873
10037
|
function Function(state) {
|
|
@@ -9888,7 +10052,7 @@ ${input.slice(result.pos)}
|
|
|
9888
10052
|
return result;
|
|
9889
10053
|
}
|
|
9890
10054
|
}
|
|
9891
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
10055
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L115, fail, 'GetOrSet "get"'), $EXPECT($L116, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9892
10056
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
9893
10057
|
});
|
|
9894
10058
|
function GetOrSet(state) {
|
|
@@ -9909,7 +10073,7 @@ ${input.slice(result.pos)}
|
|
|
9909
10073
|
return result;
|
|
9910
10074
|
}
|
|
9911
10075
|
}
|
|
9912
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
10076
|
+
var If$0 = $TV($TEXT($S($EXPECT($L117, fail, 'If "if"'), $E($EXPECT($L4, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
9913
10077
|
return { $loc, token: $1 };
|
|
9914
10078
|
});
|
|
9915
10079
|
function If(state) {
|
|
@@ -9930,7 +10094,7 @@ ${input.slice(result.pos)}
|
|
|
9930
10094
|
return result;
|
|
9931
10095
|
}
|
|
9932
10096
|
}
|
|
9933
|
-
var Import$0 = $TS($S($EXPECT($
|
|
10097
|
+
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R44, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
9934
10098
|
return { $loc, token: $1 };
|
|
9935
10099
|
});
|
|
9936
10100
|
function Import(state) {
|
|
@@ -9951,7 +10115,7 @@ ${input.slice(result.pos)}
|
|
|
9951
10115
|
return result;
|
|
9952
10116
|
}
|
|
9953
10117
|
}
|
|
9954
|
-
var In$0 = $TV($EXPECT($
|
|
10118
|
+
var In$0 = $TV($EXPECT($L74, fail, 'In "in"'), function($skip, $loc, $0, $1) {
|
|
9955
10119
|
return { $loc, token: $1 };
|
|
9956
10120
|
});
|
|
9957
10121
|
function In(state) {
|
|
@@ -9972,7 +10136,7 @@ ${input.slice(result.pos)}
|
|
|
9972
10136
|
return result;
|
|
9973
10137
|
}
|
|
9974
10138
|
}
|
|
9975
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
10139
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L118, fail, 'LetOrConst "let"'), $EXPECT($L119, fail, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9976
10140
|
return { $loc, token: $1 };
|
|
9977
10141
|
});
|
|
9978
10142
|
function LetOrConst(state) {
|
|
@@ -9993,7 +10157,7 @@ ${input.slice(result.pos)}
|
|
|
9993
10157
|
return result;
|
|
9994
10158
|
}
|
|
9995
10159
|
}
|
|
9996
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
10160
|
+
var Loop$0 = $TS($S($EXPECT($L120, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9997
10161
|
return { $loc, token: "while(true)" };
|
|
9998
10162
|
});
|
|
9999
10163
|
function Loop(state) {
|
|
@@ -10014,7 +10178,7 @@ ${input.slice(result.pos)}
|
|
|
10014
10178
|
return result;
|
|
10015
10179
|
}
|
|
10016
10180
|
}
|
|
10017
|
-
var New$0 = $TS($S($EXPECT($
|
|
10181
|
+
var New$0 = $TS($S($EXPECT($L121, fail, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10018
10182
|
return { $loc, token: $1 };
|
|
10019
10183
|
});
|
|
10020
10184
|
function New(state) {
|
|
@@ -10035,7 +10199,7 @@ ${input.slice(result.pos)}
|
|
|
10035
10199
|
return result;
|
|
10036
10200
|
}
|
|
10037
10201
|
}
|
|
10038
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
10202
|
+
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
10203
|
return { $loc, token: "!" };
|
|
10040
10204
|
});
|
|
10041
10205
|
function Not(state) {
|
|
@@ -10056,7 +10220,7 @@ ${input.slice(result.pos)}
|
|
|
10056
10220
|
return result;
|
|
10057
10221
|
}
|
|
10058
10222
|
}
|
|
10059
|
-
var Of$0 = $TV($EXPECT($
|
|
10223
|
+
var Of$0 = $TV($EXPECT($L67, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
10060
10224
|
return { $loc, token: $1 };
|
|
10061
10225
|
});
|
|
10062
10226
|
function Of(state) {
|
|
@@ -10077,7 +10241,7 @@ ${input.slice(result.pos)}
|
|
|
10077
10241
|
return result;
|
|
10078
10242
|
}
|
|
10079
10243
|
}
|
|
10080
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
10244
|
+
var OpenBrace$0 = $TV($EXPECT($L122, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
10081
10245
|
return { $loc, token: $1 };
|
|
10082
10246
|
});
|
|
10083
10247
|
function OpenBrace(state) {
|
|
@@ -10098,7 +10262,7 @@ ${input.slice(result.pos)}
|
|
|
10098
10262
|
return result;
|
|
10099
10263
|
}
|
|
10100
10264
|
}
|
|
10101
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
10265
|
+
var OpenBracket$0 = $TV($EXPECT($L123, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
10102
10266
|
return { $loc, token: $1 };
|
|
10103
10267
|
});
|
|
10104
10268
|
function OpenBracket(state) {
|
|
@@ -10119,7 +10283,7 @@ ${input.slice(result.pos)}
|
|
|
10119
10283
|
return result;
|
|
10120
10284
|
}
|
|
10121
10285
|
}
|
|
10122
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
10286
|
+
var OpenParen$0 = $TV($EXPECT($L124, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
10123
10287
|
return { $loc, token: $1 };
|
|
10124
10288
|
});
|
|
10125
10289
|
function OpenParen(state) {
|
|
@@ -10140,7 +10304,91 @@ ${input.slice(result.pos)}
|
|
|
10140
10304
|
return result;
|
|
10141
10305
|
}
|
|
10142
10306
|
}
|
|
10143
|
-
var
|
|
10307
|
+
var Public$0 = $TS($S($EXPECT($L125, fail, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10308
|
+
return { $loc, token: $1 };
|
|
10309
|
+
});
|
|
10310
|
+
function Public(state) {
|
|
10311
|
+
if (state.events) {
|
|
10312
|
+
const result = state.events.enter?.("Public", state);
|
|
10313
|
+
if (result)
|
|
10314
|
+
return result.cache;
|
|
10315
|
+
}
|
|
10316
|
+
if (state.tokenize) {
|
|
10317
|
+
const result = $TOKEN("Public", state, Public$0(state));
|
|
10318
|
+
if (state.events)
|
|
10319
|
+
state.events.exit?.("Public", state, result);
|
|
10320
|
+
return result;
|
|
10321
|
+
} else {
|
|
10322
|
+
const result = Public$0(state);
|
|
10323
|
+
if (state.events)
|
|
10324
|
+
state.events.exit?.("Public", state, result);
|
|
10325
|
+
return result;
|
|
10326
|
+
}
|
|
10327
|
+
}
|
|
10328
|
+
var Private$0 = $TS($S($EXPECT($L126, fail, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10329
|
+
return { $loc, token: $1 };
|
|
10330
|
+
});
|
|
10331
|
+
function Private(state) {
|
|
10332
|
+
if (state.events) {
|
|
10333
|
+
const result = state.events.enter?.("Private", state);
|
|
10334
|
+
if (result)
|
|
10335
|
+
return result.cache;
|
|
10336
|
+
}
|
|
10337
|
+
if (state.tokenize) {
|
|
10338
|
+
const result = $TOKEN("Private", state, Private$0(state));
|
|
10339
|
+
if (state.events)
|
|
10340
|
+
state.events.exit?.("Private", state, result);
|
|
10341
|
+
return result;
|
|
10342
|
+
} else {
|
|
10343
|
+
const result = Private$0(state);
|
|
10344
|
+
if (state.events)
|
|
10345
|
+
state.events.exit?.("Private", state, result);
|
|
10346
|
+
return result;
|
|
10347
|
+
}
|
|
10348
|
+
}
|
|
10349
|
+
var Protected$0 = $TS($S($EXPECT($L127, fail, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10350
|
+
return { $loc, token: $1 };
|
|
10351
|
+
});
|
|
10352
|
+
function Protected(state) {
|
|
10353
|
+
if (state.events) {
|
|
10354
|
+
const result = state.events.enter?.("Protected", state);
|
|
10355
|
+
if (result)
|
|
10356
|
+
return result.cache;
|
|
10357
|
+
}
|
|
10358
|
+
if (state.tokenize) {
|
|
10359
|
+
const result = $TOKEN("Protected", state, Protected$0(state));
|
|
10360
|
+
if (state.events)
|
|
10361
|
+
state.events.exit?.("Protected", state, result);
|
|
10362
|
+
return result;
|
|
10363
|
+
} else {
|
|
10364
|
+
const result = Protected$0(state);
|
|
10365
|
+
if (state.events)
|
|
10366
|
+
state.events.exit?.("Protected", state, result);
|
|
10367
|
+
return result;
|
|
10368
|
+
}
|
|
10369
|
+
}
|
|
10370
|
+
var Pipe$0 = $TV($EXPECT($L128, fail, 'Pipe "|>"'), function($skip, $loc, $0, $1) {
|
|
10371
|
+
return { $loc, token: $1 };
|
|
10372
|
+
});
|
|
10373
|
+
function Pipe(state) {
|
|
10374
|
+
if (state.events) {
|
|
10375
|
+
const result = state.events.enter?.("Pipe", state);
|
|
10376
|
+
if (result)
|
|
10377
|
+
return result.cache;
|
|
10378
|
+
}
|
|
10379
|
+
if (state.tokenize) {
|
|
10380
|
+
const result = $TOKEN("Pipe", state, Pipe$0(state));
|
|
10381
|
+
if (state.events)
|
|
10382
|
+
state.events.exit?.("Pipe", state, result);
|
|
10383
|
+
return result;
|
|
10384
|
+
} else {
|
|
10385
|
+
const result = Pipe$0(state);
|
|
10386
|
+
if (state.events)
|
|
10387
|
+
state.events.exit?.("Pipe", state, result);
|
|
10388
|
+
return result;
|
|
10389
|
+
}
|
|
10390
|
+
}
|
|
10391
|
+
var QuestionMark$0 = $TV($EXPECT($L71, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
10144
10392
|
return { $loc, token: $1 };
|
|
10145
10393
|
});
|
|
10146
10394
|
function QuestionMark(state) {
|
|
@@ -10161,7 +10409,28 @@ ${input.slice(result.pos)}
|
|
|
10161
10409
|
return result;
|
|
10162
10410
|
}
|
|
10163
10411
|
}
|
|
10164
|
-
var
|
|
10412
|
+
var Readonly$0 = $TS($S($EXPECT($L129, fail, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10413
|
+
return { $loc, token: $1, ts: true };
|
|
10414
|
+
});
|
|
10415
|
+
function Readonly(state) {
|
|
10416
|
+
if (state.events) {
|
|
10417
|
+
const result = state.events.enter?.("Readonly", state);
|
|
10418
|
+
if (result)
|
|
10419
|
+
return result.cache;
|
|
10420
|
+
}
|
|
10421
|
+
if (state.tokenize) {
|
|
10422
|
+
const result = $TOKEN("Readonly", state, Readonly$0(state));
|
|
10423
|
+
if (state.events)
|
|
10424
|
+
state.events.exit?.("Readonly", state, result);
|
|
10425
|
+
return result;
|
|
10426
|
+
} else {
|
|
10427
|
+
const result = Readonly$0(state);
|
|
10428
|
+
if (state.events)
|
|
10429
|
+
state.events.exit?.("Readonly", state, result);
|
|
10430
|
+
return result;
|
|
10431
|
+
}
|
|
10432
|
+
}
|
|
10433
|
+
var Return$0 = $TS($S($EXPECT($L130, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10165
10434
|
return { $loc, token: $1 };
|
|
10166
10435
|
});
|
|
10167
10436
|
function Return(state) {
|
|
@@ -10182,7 +10451,7 @@ ${input.slice(result.pos)}
|
|
|
10182
10451
|
return result;
|
|
10183
10452
|
}
|
|
10184
10453
|
}
|
|
10185
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
10454
|
+
var Satisfies$0 = $TS($S($EXPECT($L131, fail, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10186
10455
|
return { $loc, token: $1 };
|
|
10187
10456
|
});
|
|
10188
10457
|
function Satisfies(state) {
|
|
@@ -10203,7 +10472,7 @@ ${input.slice(result.pos)}
|
|
|
10203
10472
|
return result;
|
|
10204
10473
|
}
|
|
10205
10474
|
}
|
|
10206
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
10475
|
+
var Semicolon$0 = $TV($EXPECT($L78, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
10207
10476
|
return { $loc, token: $1 };
|
|
10208
10477
|
});
|
|
10209
10478
|
function Semicolon(state) {
|
|
@@ -10224,7 +10493,7 @@ ${input.slice(result.pos)}
|
|
|
10224
10493
|
return result;
|
|
10225
10494
|
}
|
|
10226
10495
|
}
|
|
10227
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
10496
|
+
var SingleQuote$0 = $TV($EXPECT($L132, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
10228
10497
|
return { $loc, token: $1 };
|
|
10229
10498
|
});
|
|
10230
10499
|
function SingleQuote(state) {
|
|
@@ -10245,7 +10514,7 @@ ${input.slice(result.pos)}
|
|
|
10245
10514
|
return result;
|
|
10246
10515
|
}
|
|
10247
10516
|
}
|
|
10248
|
-
var Star$0 = $TV($EXPECT($
|
|
10517
|
+
var Star$0 = $TV($EXPECT($L49, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
10249
10518
|
return { $loc, token: $1 };
|
|
10250
10519
|
});
|
|
10251
10520
|
function Star(state) {
|
|
@@ -10266,10 +10535,10 @@ ${input.slice(result.pos)}
|
|
|
10266
10535
|
return result;
|
|
10267
10536
|
}
|
|
10268
10537
|
}
|
|
10269
|
-
var Static$0 = $TV($EXPECT($
|
|
10538
|
+
var Static$0 = $TV($EXPECT($L133, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
10270
10539
|
return { $loc, token: $1 };
|
|
10271
10540
|
});
|
|
10272
|
-
var Static$1 = $TS($S($EXPECT($
|
|
10541
|
+
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
10542
|
return { $loc, token: "static " };
|
|
10274
10543
|
});
|
|
10275
10544
|
function Static(state) {
|
|
@@ -10290,7 +10559,7 @@ ${input.slice(result.pos)}
|
|
|
10290
10559
|
return result;
|
|
10291
10560
|
}
|
|
10292
10561
|
}
|
|
10293
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
10562
|
+
var SubstitutionStart$0 = $TV($EXPECT($L134, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
10294
10563
|
return { $loc, token: $1 };
|
|
10295
10564
|
});
|
|
10296
10565
|
function SubstitutionStart(state) {
|
|
@@ -10311,7 +10580,7 @@ ${input.slice(result.pos)}
|
|
|
10311
10580
|
return result;
|
|
10312
10581
|
}
|
|
10313
10582
|
}
|
|
10314
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
10583
|
+
var Switch$0 = $TS($S($EXPECT($L135, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10315
10584
|
return { $loc, token: $1 };
|
|
10316
10585
|
});
|
|
10317
10586
|
function Switch(state) {
|
|
@@ -10332,7 +10601,7 @@ ${input.slice(result.pos)}
|
|
|
10332
10601
|
return result;
|
|
10333
10602
|
}
|
|
10334
10603
|
}
|
|
10335
|
-
var Target$0 = $TS($S($EXPECT($
|
|
10604
|
+
var Target$0 = $TS($S($EXPECT($L136, fail, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10336
10605
|
return { $loc, token: $1 };
|
|
10337
10606
|
});
|
|
10338
10607
|
function Target(state) {
|
|
@@ -10353,7 +10622,7 @@ ${input.slice(result.pos)}
|
|
|
10353
10622
|
return result;
|
|
10354
10623
|
}
|
|
10355
10624
|
}
|
|
10356
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
10625
|
+
var Then$0 = $TS($S(__, $EXPECT($L137, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
10357
10626
|
return { $loc, token: "" };
|
|
10358
10627
|
});
|
|
10359
10628
|
function Then(state) {
|
|
@@ -10374,7 +10643,7 @@ ${input.slice(result.pos)}
|
|
|
10374
10643
|
return result;
|
|
10375
10644
|
}
|
|
10376
10645
|
}
|
|
10377
|
-
var This$0 = $TS($S($EXPECT($
|
|
10646
|
+
var This$0 = $TS($S($EXPECT($L138, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10378
10647
|
return { $loc, token: $1 };
|
|
10379
10648
|
});
|
|
10380
10649
|
function This(state) {
|
|
@@ -10395,7 +10664,7 @@ ${input.slice(result.pos)}
|
|
|
10395
10664
|
return result;
|
|
10396
10665
|
}
|
|
10397
10666
|
}
|
|
10398
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
10667
|
+
var Throw$0 = $TS($S($EXPECT($L139, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10399
10668
|
return { $loc, token: $1 };
|
|
10400
10669
|
});
|
|
10401
10670
|
function Throw(state) {
|
|
@@ -10416,7 +10685,7 @@ ${input.slice(result.pos)}
|
|
|
10416
10685
|
return result;
|
|
10417
10686
|
}
|
|
10418
10687
|
}
|
|
10419
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
10688
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L140, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
10420
10689
|
return { $loc, token: "`" };
|
|
10421
10690
|
});
|
|
10422
10691
|
function TripleDoubleQuote(state) {
|
|
@@ -10437,7 +10706,7 @@ ${input.slice(result.pos)}
|
|
|
10437
10706
|
return result;
|
|
10438
10707
|
}
|
|
10439
10708
|
}
|
|
10440
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
10709
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L141, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
10441
10710
|
return { $loc, token: "`" };
|
|
10442
10711
|
});
|
|
10443
10712
|
function TripleSingleQuote(state) {
|
|
@@ -10458,7 +10727,7 @@ ${input.slice(result.pos)}
|
|
|
10458
10727
|
return result;
|
|
10459
10728
|
}
|
|
10460
10729
|
}
|
|
10461
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
10730
|
+
var TripleSlash$0 = $TV($EXPECT($L142, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
10462
10731
|
return { $loc, token: "/" };
|
|
10463
10732
|
});
|
|
10464
10733
|
function TripleSlash(state) {
|
|
@@ -10479,7 +10748,7 @@ ${input.slice(result.pos)}
|
|
|
10479
10748
|
return result;
|
|
10480
10749
|
}
|
|
10481
10750
|
}
|
|
10482
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
10751
|
+
var TripleTick$0 = $TV($EXPECT($L143, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
10483
10752
|
return { $loc, token: "`" };
|
|
10484
10753
|
});
|
|
10485
10754
|
function TripleTick(state) {
|
|
@@ -10500,7 +10769,7 @@ ${input.slice(result.pos)}
|
|
|
10500
10769
|
return result;
|
|
10501
10770
|
}
|
|
10502
10771
|
}
|
|
10503
|
-
var Try$0 = $TS($S($EXPECT($
|
|
10772
|
+
var Try$0 = $TS($S($EXPECT($L144, fail, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10504
10773
|
return { $loc, token: $1 };
|
|
10505
10774
|
});
|
|
10506
10775
|
function Try(state) {
|
|
@@ -10521,7 +10790,7 @@ ${input.slice(result.pos)}
|
|
|
10521
10790
|
return result;
|
|
10522
10791
|
}
|
|
10523
10792
|
}
|
|
10524
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
10793
|
+
var Typeof$0 = $TS($S($EXPECT($L145, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10525
10794
|
return { $loc, token: $1 };
|
|
10526
10795
|
});
|
|
10527
10796
|
function Typeof(state) {
|
|
@@ -10542,7 +10811,7 @@ ${input.slice(result.pos)}
|
|
|
10542
10811
|
return result;
|
|
10543
10812
|
}
|
|
10544
10813
|
}
|
|
10545
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
10814
|
+
var Unless$0 = $TS($S($EXPECT($L146, fail, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10546
10815
|
return { $loc, token: $1 };
|
|
10547
10816
|
});
|
|
10548
10817
|
function Unless(state) {
|
|
@@ -10563,7 +10832,7 @@ ${input.slice(result.pos)}
|
|
|
10563
10832
|
return result;
|
|
10564
10833
|
}
|
|
10565
10834
|
}
|
|
10566
|
-
var Until$0 = $TS($S($EXPECT($
|
|
10835
|
+
var Until$0 = $TS($S($EXPECT($L147, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10567
10836
|
return { $loc, token: $1 };
|
|
10568
10837
|
});
|
|
10569
10838
|
function Until(state) {
|
|
@@ -10584,7 +10853,7 @@ ${input.slice(result.pos)}
|
|
|
10584
10853
|
return result;
|
|
10585
10854
|
}
|
|
10586
10855
|
}
|
|
10587
|
-
var Var$0 = $TS($S($EXPECT($
|
|
10856
|
+
var Var$0 = $TS($S($EXPECT($L148, fail, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10588
10857
|
return { $loc, token: $1 };
|
|
10589
10858
|
});
|
|
10590
10859
|
function Var(state) {
|
|
@@ -10605,7 +10874,7 @@ ${input.slice(result.pos)}
|
|
|
10605
10874
|
return result;
|
|
10606
10875
|
}
|
|
10607
10876
|
}
|
|
10608
|
-
var Void$0 = $TS($S($EXPECT($
|
|
10877
|
+
var Void$0 = $TS($S($EXPECT($L149, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10609
10878
|
return { $loc, token: $1 };
|
|
10610
10879
|
});
|
|
10611
10880
|
function Void(state) {
|
|
@@ -10626,7 +10895,7 @@ ${input.slice(result.pos)}
|
|
|
10626
10895
|
return result;
|
|
10627
10896
|
}
|
|
10628
10897
|
}
|
|
10629
|
-
var When$0 = $TS($S($EXPECT($
|
|
10898
|
+
var When$0 = $TS($S($EXPECT($L150, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10630
10899
|
return { $loc, token: "case" };
|
|
10631
10900
|
});
|
|
10632
10901
|
function When(state) {
|
|
@@ -10647,7 +10916,7 @@ ${input.slice(result.pos)}
|
|
|
10647
10916
|
return result;
|
|
10648
10917
|
}
|
|
10649
10918
|
}
|
|
10650
|
-
var While$0 = $TS($S($EXPECT($
|
|
10919
|
+
var While$0 = $TS($S($EXPECT($L151, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10651
10920
|
return { $loc, token: $1 };
|
|
10652
10921
|
});
|
|
10653
10922
|
function While(state) {
|
|
@@ -10668,7 +10937,7 @@ ${input.slice(result.pos)}
|
|
|
10668
10937
|
return result;
|
|
10669
10938
|
}
|
|
10670
10939
|
}
|
|
10671
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
10940
|
+
var Yield$0 = $TS($S($EXPECT($L152, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10672
10941
|
return { $loc, token: $1 };
|
|
10673
10942
|
});
|
|
10674
10943
|
function Yield(state) {
|
|
@@ -10750,7 +11019,7 @@ ${input.slice(result.pos)}
|
|
|
10750
11019
|
return result;
|
|
10751
11020
|
}
|
|
10752
11021
|
}
|
|
10753
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(CompactTypeArguments), $E(JSXAttributes), __, $EXPECT($
|
|
11022
|
+
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
11023
|
return { type: "JSXElement", children: $0 };
|
|
10755
11024
|
});
|
|
10756
11025
|
function JSXSelfClosingElement(state) {
|
|
@@ -10771,7 +11040,7 @@ ${input.slice(result.pos)}
|
|
|
10771
11040
|
return result;
|
|
10772
11041
|
}
|
|
10773
11042
|
}
|
|
10774
|
-
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(CompactTypeArguments), $E(JSXAttributes), __, $EXPECT($
|
|
11043
|
+
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(CompactTypeArguments), $E(JSXAttributes), __, $EXPECT($L27, fail, 'JSXOpeningElement ">"'));
|
|
10775
11044
|
function JSXOpeningElement(state) {
|
|
10776
11045
|
if (state.events) {
|
|
10777
11046
|
const result = state.events.enter?.("JSXOpeningElement", state);
|
|
@@ -10790,7 +11059,7 @@ ${input.slice(result.pos)}
|
|
|
10790
11059
|
return result;
|
|
10791
11060
|
}
|
|
10792
11061
|
}
|
|
10793
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
11062
|
+
var JSXClosingElement$0 = $S($EXPECT($L154, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L27, fail, 'JSXClosingElement ">"'));
|
|
10794
11063
|
function JSXClosingElement(state) {
|
|
10795
11064
|
if (state.events) {
|
|
10796
11065
|
const result = state.events.enter?.("JSXClosingElement", state);
|
|
@@ -10835,14 +11104,14 @@ ${input.slice(result.pos)}
|
|
|
10835
11104
|
return result;
|
|
10836
11105
|
}
|
|
10837
11106
|
}
|
|
10838
|
-
var JSXFragment$0 = $TS($S($EXPECT($
|
|
11107
|
+
var JSXFragment$0 = $TS($S($EXPECT($L155, fail, 'JSXFragment "<>"'), $E(JSXChildren), __, $EXPECT($L156, fail, 'JSXFragment "</>"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
10839
11108
|
if ($2) {
|
|
10840
11109
|
return { type: "JSXFragment", children: $0, jsxChildren: $2.jsxChildren };
|
|
10841
11110
|
} else {
|
|
10842
11111
|
return { type: "JSXFragment", children: $0, jsxChildren: [] };
|
|
10843
11112
|
}
|
|
10844
11113
|
});
|
|
10845
|
-
var JSXFragment$1 = $TS($S($EXPECT($
|
|
11114
|
+
var JSXFragment$1 = $TS($S($EXPECT($L155, fail, 'JSXFragment "<>"'), JSXMixedChildren, InsertNewline, InsertIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
10846
11115
|
return { type: "JSXFragment", children: [...$0, "</>"], jsxChildren: $2.jsxChildren };
|
|
10847
11116
|
});
|
|
10848
11117
|
function JSXFragment(state) {
|
|
@@ -11192,8 +11461,8 @@ ${input.slice(result.pos)}
|
|
|
11192
11461
|
return result;
|
|
11193
11462
|
}
|
|
11194
11463
|
}
|
|
11195
|
-
var InlineJSXCallExpression$0 = $S($EXPECT($
|
|
11196
|
-
var InlineJSXCallExpression$1 = $S($EXPECT($
|
|
11464
|
+
var InlineJSXCallExpression$0 = $S($EXPECT($L10, fail, 'InlineJSXCallExpression "super"'), ExplicitArguments);
|
|
11465
|
+
var InlineJSXCallExpression$1 = $S($EXPECT($L11, fail, 'InlineJSXCallExpression "import"'), OpenParen, ExtendedExpression, __, CloseParen);
|
|
11197
11466
|
var InlineJSXCallExpression$2 = $TS($S(InlineJSXMemberExpression, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
11198
11467
|
if ($2.length)
|
|
11199
11468
|
return $0;
|
|
@@ -11495,7 +11764,7 @@ ${input.slice(result.pos)}
|
|
|
11495
11764
|
return result;
|
|
11496
11765
|
}
|
|
11497
11766
|
}
|
|
11498
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
11767
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L157, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
11499
11768
|
var TypeDeclarationModifier$1 = Export;
|
|
11500
11769
|
function TypeDeclarationModifier(state) {
|
|
11501
11770
|
if (state.events) {
|
|
@@ -11537,7 +11806,7 @@ ${input.slice(result.pos)}
|
|
|
11537
11806
|
return result;
|
|
11538
11807
|
}
|
|
11539
11808
|
}
|
|
11540
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
11809
|
+
var TypeKeyword$0 = $S($EXPECT($L158, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
11541
11810
|
function TypeKeyword(state) {
|
|
11542
11811
|
if (state.events) {
|
|
11543
11812
|
const result = state.events.enter?.("TypeKeyword", state);
|
|
@@ -11556,7 +11825,7 @@ ${input.slice(result.pos)}
|
|
|
11556
11825
|
return result;
|
|
11557
11826
|
}
|
|
11558
11827
|
}
|
|
11559
|
-
var Interface$0 = $S($EXPECT($
|
|
11828
|
+
var Interface$0 = $S($EXPECT($L159, fail, 'Interface "interface"'), NonIdContinue);
|
|
11560
11829
|
function Interface(state) {
|
|
11561
11830
|
if (state.events) {
|
|
11562
11831
|
const result = state.events.enter?.("Interface", state);
|
|
@@ -11575,7 +11844,7 @@ ${input.slice(result.pos)}
|
|
|
11575
11844
|
return result;
|
|
11576
11845
|
}
|
|
11577
11846
|
}
|
|
11578
|
-
var Namespace$0 = $S($EXPECT($
|
|
11847
|
+
var Namespace$0 = $S($EXPECT($L160, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
11579
11848
|
function Namespace(state) {
|
|
11580
11849
|
if (state.events) {
|
|
11581
11850
|
const result = state.events.enter?.("Namespace", state);
|
|
@@ -11764,7 +12033,7 @@ ${input.slice(result.pos)}
|
|
|
11764
12033
|
return result;
|
|
11765
12034
|
}
|
|
11766
12035
|
}
|
|
11767
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R47, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($
|
|
12036
|
+
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
12037
|
function TypeIndexSignature(state) {
|
|
11769
12038
|
if (state.events) {
|
|
11770
12039
|
const result = state.events.enter?.("TypeIndexSignature", state);
|
|
@@ -11824,7 +12093,7 @@ ${input.slice(result.pos)}
|
|
|
11824
12093
|
return result;
|
|
11825
12094
|
}
|
|
11826
12095
|
}
|
|
11827
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
12096
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L161, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
11828
12097
|
const children = [...$1, $2];
|
|
11829
12098
|
if ($3)
|
|
11830
12099
|
children.push($3);
|
|
@@ -11853,7 +12122,7 @@ ${input.slice(result.pos)}
|
|
|
11853
12122
|
return result;
|
|
11854
12123
|
}
|
|
11855
12124
|
}
|
|
11856
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
12125
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L62, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
11857
12126
|
if (!$2)
|
|
11858
12127
|
return $1;
|
|
11859
12128
|
return $0;
|
|
@@ -11959,10 +12228,10 @@ ${input.slice(result.pos)}
|
|
|
11959
12228
|
return result;
|
|
11960
12229
|
}
|
|
11961
12230
|
}
|
|
11962
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
11963
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
11964
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
11965
|
-
var TypeUnaryOp$3 = $EXPECT($
|
|
12231
|
+
var TypeUnaryOp$0 = $EXPECT($L162, fail, 'TypeUnaryOp "keyof"');
|
|
12232
|
+
var TypeUnaryOp$1 = $EXPECT($L145, fail, 'TypeUnaryOp "typeof"');
|
|
12233
|
+
var TypeUnaryOp$2 = $EXPECT($L163, fail, 'TypeUnaryOp "infer"');
|
|
12234
|
+
var TypeUnaryOp$3 = $EXPECT($L129, fail, 'TypeUnaryOp "readonly"');
|
|
11966
12235
|
function TypeUnaryOp(state) {
|
|
11967
12236
|
if (state.events) {
|
|
11968
12237
|
const result = state.events.enter?.("TypeUnaryOp", state);
|
|
@@ -12131,10 +12400,10 @@ ${input.slice(result.pos)}
|
|
|
12131
12400
|
}
|
|
12132
12401
|
var TypeLiteral$0 = Literal;
|
|
12133
12402
|
var TypeLiteral$1 = TemplateLiteral;
|
|
12134
|
-
var TypeLiteral$2 = $TV($EXPECT($
|
|
12403
|
+
var TypeLiteral$2 = $TV($EXPECT($L149, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
|
|
12135
12404
|
return { $loc, token: "void" };
|
|
12136
12405
|
});
|
|
12137
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
12406
|
+
var TypeLiteral$3 = $TV($EXPECT($L164, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
12138
12407
|
return { $loc, token: "[]" };
|
|
12139
12408
|
});
|
|
12140
12409
|
function TypeLiteral(state) {
|
|
@@ -12155,10 +12424,10 @@ ${input.slice(result.pos)}
|
|
|
12155
12424
|
return result;
|
|
12156
12425
|
}
|
|
12157
12426
|
}
|
|
12158
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
12427
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L77, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
12159
12428
|
return { $loc, token: "|" };
|
|
12160
12429
|
});
|
|
12161
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
12430
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L75, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
12162
12431
|
return { $loc, token: "&" };
|
|
12163
12432
|
});
|
|
12164
12433
|
function TypeBinaryOp(state) {
|
|
@@ -12198,7 +12467,7 @@ ${input.slice(result.pos)}
|
|
|
12198
12467
|
return result;
|
|
12199
12468
|
}
|
|
12200
12469
|
}
|
|
12201
|
-
var TypeArguments$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($
|
|
12470
|
+
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
12471
|
return { ts: true, children: $0 };
|
|
12203
12472
|
});
|
|
12204
12473
|
function TypeArguments(state) {
|
|
@@ -12219,7 +12488,7 @@ ${input.slice(result.pos)}
|
|
|
12219
12488
|
return result;
|
|
12220
12489
|
}
|
|
12221
12490
|
}
|
|
12222
|
-
var CompactTypeArguments$0 = $TS($S($EXPECT($L5, fail, 'CompactTypeArguments "<"'), $P(TypeArgument), __, $EXPECT($
|
|
12491
|
+
var CompactTypeArguments$0 = $TS($S($EXPECT($L5, fail, 'CompactTypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L27, fail, 'CompactTypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
12223
12492
|
return { ts: true, children: $0 };
|
|
12224
12493
|
});
|
|
12225
12494
|
function CompactTypeArguments(state) {
|
|
@@ -12278,7 +12547,7 @@ ${input.slice(result.pos)}
|
|
|
12278
12547
|
return result;
|
|
12279
12548
|
}
|
|
12280
12549
|
}
|
|
12281
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($
|
|
12550
|
+
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
12551
|
var parameters = $3;
|
|
12283
12552
|
return {
|
|
12284
12553
|
type: "TypeParameters",
|
|
@@ -12344,7 +12613,7 @@ ${input.slice(result.pos)}
|
|
|
12344
12613
|
}
|
|
12345
12614
|
}
|
|
12346
12615
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
12347
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
12616
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L27, fail, 'TypeParameterDelimiter ">"')));
|
|
12348
12617
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
12349
12618
|
return value[1];
|
|
12350
12619
|
});
|
|
@@ -12411,7 +12680,7 @@ ${input.slice(result.pos)}
|
|
|
12411
12680
|
return result;
|
|
12412
12681
|
}
|
|
12413
12682
|
}
|
|
12414
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
12683
|
+
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
12684
|
var options = $2;
|
|
12416
12685
|
return {
|
|
12417
12686
|
type: "CivetPrologue",
|
|
@@ -13735,6 +14004,20 @@ ${input.slice(result.pos)}
|
|
|
13735
14004
|
}
|
|
13736
14005
|
return node;
|
|
13737
14006
|
};
|
|
14007
|
+
module.skipIfOnlyWS = function(target) {
|
|
14008
|
+
if (!target)
|
|
14009
|
+
return target;
|
|
14010
|
+
if (Array.isArray(target)) {
|
|
14011
|
+
if (target.length === 1) {
|
|
14012
|
+
return module.skipIfOnlyWS(target[0]);
|
|
14013
|
+
}
|
|
14014
|
+
return target;
|
|
14015
|
+
}
|
|
14016
|
+
if (target.token && target.token.trim() === "") {
|
|
14017
|
+
return void 0;
|
|
14018
|
+
}
|
|
14019
|
+
return target;
|
|
14020
|
+
};
|
|
13738
14021
|
module.insertTrimmingSpace = function(target, c) {
|
|
13739
14022
|
if (!target)
|
|
13740
14023
|
return target;
|
|
@@ -14254,6 +14537,21 @@ ${input.slice(result.pos)}
|
|
|
14254
14537
|
return [splices, thisAssignments];
|
|
14255
14538
|
}
|
|
14256
14539
|
module.gatherBindingCode = gatherBindingCode;
|
|
14540
|
+
module.constructInvocation = function(caller, callee) {
|
|
14541
|
+
const callerArr = [caller.leadingComment, caller.expr, caller.trailingComment];
|
|
14542
|
+
const calleeArr = [callee.leadingComment, callee.expr, callee.trailingComment];
|
|
14543
|
+
if (caller.expr.type === "Identifier") {
|
|
14544
|
+
return [callerArr, "(", calleeArr, ")"];
|
|
14545
|
+
} else {
|
|
14546
|
+
return ["(", callerArr, ")", "(", calleeArr, ")"];
|
|
14547
|
+
}
|
|
14548
|
+
};
|
|
14549
|
+
module.constructPipeStep = function(caller, callee) {
|
|
14550
|
+
if (caller.expr.token === "yield" || caller.expr.token === "await") {
|
|
14551
|
+
return [caller.leadingComment, caller.expr, caller.trailingComment, " ", callee.leadingComment, callee.expr, callee.trailingComment];
|
|
14552
|
+
}
|
|
14553
|
+
return module.constructInvocation(caller, callee);
|
|
14554
|
+
};
|
|
14257
14555
|
return $0;
|
|
14258
14556
|
});
|
|
14259
14557
|
function Init(state) {
|