@danielx/civet 0.6.69 → 0.6.71
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 +450 -384
- package/dist/civet +112 -97
- package/dist/main.js +450 -384
- package/dist/main.mjs +451 -384
- package/dist/types.d.ts +1 -0
- package/package.json +1 -1
package/dist/main.js
CHANGED
|
@@ -75,6 +75,7 @@ __export(lib_exports, {
|
|
|
75
75
|
isWhitespaceOrEmpty: () => isWhitespaceOrEmpty,
|
|
76
76
|
lastAccessInCallExpression: () => lastAccessInCallExpression,
|
|
77
77
|
literalValue: () => literalValue,
|
|
78
|
+
makeAmpersandFunction: () => makeAmpersandFunction,
|
|
78
79
|
makeAsConst: () => makeAsConst,
|
|
79
80
|
makeEmptyBlock: () => makeEmptyBlock,
|
|
80
81
|
makeExpressionStatement: () => makeExpressionStatement,
|
|
@@ -146,6 +147,30 @@ function makeNode(node) {
|
|
|
146
147
|
updateParentPointers(node);
|
|
147
148
|
return node;
|
|
148
149
|
}
|
|
150
|
+
function makeAmpersandFunction(bodyAfterRef = []) {
|
|
151
|
+
const ref = makeRef("$");
|
|
152
|
+
const body = [ref, ...bodyAfterRef];
|
|
153
|
+
const parameters = {
|
|
154
|
+
type: "Parameters",
|
|
155
|
+
children: [ref],
|
|
156
|
+
names: []
|
|
157
|
+
};
|
|
158
|
+
const block = {
|
|
159
|
+
expressions: body
|
|
160
|
+
};
|
|
161
|
+
return {
|
|
162
|
+
type: "ArrowFunction",
|
|
163
|
+
signature: {
|
|
164
|
+
modifier: {}
|
|
165
|
+
},
|
|
166
|
+
children: [parameters, " => ", body],
|
|
167
|
+
ref,
|
|
168
|
+
body,
|
|
169
|
+
ampersandBlock: true,
|
|
170
|
+
block,
|
|
171
|
+
parameters
|
|
172
|
+
};
|
|
173
|
+
}
|
|
149
174
|
function addPostfixStatement(statement, ws, post) {
|
|
150
175
|
const expressions = [
|
|
151
176
|
...post.blockPrefix || [],
|
|
@@ -677,7 +702,7 @@ function processCallMemberExpression(node) {
|
|
|
677
702
|
commaCount ? {
|
|
678
703
|
type: "ParenthesizedExpression",
|
|
679
704
|
children: ["(", call, ")"]
|
|
680
|
-
} : call
|
|
705
|
+
} : { ...call, type: "ParenthesizedExpression" }
|
|
681
706
|
);
|
|
682
707
|
}
|
|
683
708
|
}
|
|
@@ -1950,7 +1975,7 @@ function duplicateBlock(block) {
|
|
|
1950
1975
|
children
|
|
1951
1976
|
};
|
|
1952
1977
|
}
|
|
1953
|
-
function makeGetterMethod(name, ws, value, block, kind = { token: "get" }, autoReturn = true) {
|
|
1978
|
+
function makeGetterMethod(name, ws, value, returnType, block, kind = { token: "get" }, autoReturn = true) {
|
|
1954
1979
|
const { token } = kind;
|
|
1955
1980
|
ws = insertTrimmingSpace(ws, "");
|
|
1956
1981
|
let setVal;
|
|
@@ -1981,7 +2006,7 @@ function makeGetterMethod(name, ws, value, block, kind = { token: "get" }, autoR
|
|
|
1981
2006
|
const finalStatement = token === "get" ? [[expressions[0]?.[0] || "", ws], wrapWithReturn(value)] : [[expressions[0]?.[0] || "", ws], [value, " = ", setVal]];
|
|
1982
2007
|
expressions.push(finalStatement);
|
|
1983
2008
|
}
|
|
1984
|
-
const children = [kind, " ", name, parameters, block];
|
|
2009
|
+
const children = [kind, " ", name, parameters, returnType, block];
|
|
1985
2010
|
return {
|
|
1986
2011
|
type: "MethodDefinition",
|
|
1987
2012
|
children,
|
|
@@ -1994,7 +2019,7 @@ function makeGetterMethod(name, ws, value, block, kind = { token: "get" }, autoR
|
|
|
1994
2019
|
async: false
|
|
1995
2020
|
},
|
|
1996
2021
|
name,
|
|
1997
|
-
returnType
|
|
2022
|
+
returnType
|
|
1998
2023
|
},
|
|
1999
2024
|
block,
|
|
2000
2025
|
parameters
|
|
@@ -3618,9 +3643,9 @@ var require_machine = __commonJS({
|
|
|
3618
3643
|
Validator: () => Validator
|
|
3619
3644
|
});
|
|
3620
3645
|
module2.exports = __toCommonJS2(machine_exports);
|
|
3621
|
-
function $EXPECT(
|
|
3646
|
+
function $EXPECT(parser, expectation) {
|
|
3622
3647
|
return function(ctx, state) {
|
|
3623
|
-
const result =
|
|
3648
|
+
const result = parser(ctx, state);
|
|
3624
3649
|
if (!result)
|
|
3625
3650
|
ctx.fail(state.pos, expectation);
|
|
3626
3651
|
return result;
|
|
@@ -3807,9 +3832,9 @@ var require_machine = __commonJS({
|
|
|
3807
3832
|
};
|
|
3808
3833
|
};
|
|
3809
3834
|
}
|
|
3810
|
-
function $T(
|
|
3835
|
+
function $T(parser, fn) {
|
|
3811
3836
|
return function(ctx, state) {
|
|
3812
|
-
const result =
|
|
3837
|
+
const result = parser(ctx, state);
|
|
3813
3838
|
if (!result)
|
|
3814
3839
|
return;
|
|
3815
3840
|
if (ctx.tokenize)
|
|
@@ -3820,9 +3845,9 @@ var require_machine = __commonJS({
|
|
|
3820
3845
|
return result;
|
|
3821
3846
|
};
|
|
3822
3847
|
}
|
|
3823
|
-
function $TR(
|
|
3848
|
+
function $TR(parser, fn) {
|
|
3824
3849
|
return function(ctx, state) {
|
|
3825
|
-
const result =
|
|
3850
|
+
const result = parser(ctx, state);
|
|
3826
3851
|
if (!result)
|
|
3827
3852
|
return;
|
|
3828
3853
|
if (ctx.tokenize)
|
|
@@ -3836,9 +3861,9 @@ var require_machine = __commonJS({
|
|
|
3836
3861
|
return result;
|
|
3837
3862
|
};
|
|
3838
3863
|
}
|
|
3839
|
-
function $TS(
|
|
3864
|
+
function $TS(parser, fn) {
|
|
3840
3865
|
return function(ctx, state) {
|
|
3841
|
-
const result =
|
|
3866
|
+
const result = parser(ctx, state);
|
|
3842
3867
|
if (!result)
|
|
3843
3868
|
return;
|
|
3844
3869
|
if (ctx.tokenize)
|
|
@@ -3852,9 +3877,9 @@ var require_machine = __commonJS({
|
|
|
3852
3877
|
return result;
|
|
3853
3878
|
};
|
|
3854
3879
|
}
|
|
3855
|
-
function $TV(
|
|
3880
|
+
function $TV(parser, fn) {
|
|
3856
3881
|
return function(ctx, state) {
|
|
3857
|
-
const result =
|
|
3882
|
+
const result = parser(ctx, state);
|
|
3858
3883
|
if (!result)
|
|
3859
3884
|
return;
|
|
3860
3885
|
if (ctx.tokenize)
|
|
@@ -3868,9 +3893,9 @@ var require_machine = __commonJS({
|
|
|
3868
3893
|
return result;
|
|
3869
3894
|
};
|
|
3870
3895
|
}
|
|
3871
|
-
function $R$0(
|
|
3896
|
+
function $R$0(parser) {
|
|
3872
3897
|
return function(ctx, state) {
|
|
3873
|
-
const result =
|
|
3898
|
+
const result = parser(ctx, state);
|
|
3874
3899
|
if (!result)
|
|
3875
3900
|
return;
|
|
3876
3901
|
const value = result.value[0];
|
|
@@ -4097,6 +4122,7 @@ var require_parser = __commonJS({
|
|
|
4097
4122
|
UnaryWithoutParenthesizedAssignmentBody,
|
|
4098
4123
|
UnaryPostfix,
|
|
4099
4124
|
TypePostfix,
|
|
4125
|
+
NWTypePostfix,
|
|
4100
4126
|
UpdateExpression,
|
|
4101
4127
|
UpdateExpressionSymbol,
|
|
4102
4128
|
AssignmentExpression,
|
|
@@ -4209,6 +4235,7 @@ var require_parser = __commonJS({
|
|
|
4209
4235
|
OperatorDeclaration,
|
|
4210
4236
|
OperatorSignature,
|
|
4211
4237
|
AmpersandBlockRHS,
|
|
4238
|
+
AmpersandTypeSuffix,
|
|
4212
4239
|
AmpersandBlockRHSBody,
|
|
4213
4240
|
ThinArrowFunction,
|
|
4214
4241
|
Arrow,
|
|
@@ -4265,8 +4292,10 @@ var require_parser = __commonJS({
|
|
|
4265
4292
|
NestedImplicitPropertyDefinition,
|
|
4266
4293
|
NestedPropertyDefinitions,
|
|
4267
4294
|
NestedPropertyDefinition,
|
|
4295
|
+
ImplicitObjectLiteral,
|
|
4296
|
+
ImplicitObjectPropertyDelimiter,
|
|
4268
4297
|
InlineObjectLiteral,
|
|
4269
|
-
|
|
4298
|
+
InlineObjectPropertyDelimiter,
|
|
4270
4299
|
ObjectPropertyDelimiter,
|
|
4271
4300
|
PropertyDefinition,
|
|
4272
4301
|
NamedProperty,
|
|
@@ -4873,118 +4902,119 @@ var require_parser = __commonJS({
|
|
|
4873
4902
|
var $L100 = $L("\u2209");
|
|
4874
4903
|
var $L101 = $L("&");
|
|
4875
4904
|
var $L102 = $L("|");
|
|
4876
|
-
var $L103 = $L("
|
|
4877
|
-
var $L104 = $L("
|
|
4905
|
+
var $L103 = $L("$:");
|
|
4906
|
+
var $L104 = $L(";");
|
|
4878
4907
|
var $L105 = $L("break");
|
|
4879
4908
|
var $L106 = $L("continue");
|
|
4880
4909
|
var $L107 = $L("debugger");
|
|
4881
|
-
var $L108 = $L("
|
|
4882
|
-
var $L109 = $L("
|
|
4883
|
-
var $L110 = $L("
|
|
4884
|
-
var $L111 = $L("
|
|
4885
|
-
var $L112 = $L("
|
|
4886
|
-
var $L113 = $L("
|
|
4887
|
-
var $L114 = $L("
|
|
4888
|
-
var $L115 = $L("
|
|
4889
|
-
var $L116 = $L("
|
|
4890
|
-
var $L117 = $L("
|
|
4891
|
-
var $L118 = $L("
|
|
4892
|
-
var $L119 = $L("
|
|
4893
|
-
var $L120 = $L("
|
|
4894
|
-
var $L121 = $L("
|
|
4895
|
-
var $L122 = $L("
|
|
4896
|
-
var $L123 = $L("
|
|
4897
|
-
var $L124 = $L("
|
|
4898
|
-
var $L125 = $L("
|
|
4899
|
-
var $L126 = $L("
|
|
4900
|
-
var $L127 = $L("
|
|
4901
|
-
var $L128 = $L("
|
|
4902
|
-
var $L129 = $L("
|
|
4903
|
-
var $L130 = $L("
|
|
4904
|
-
var $L131 = $L("
|
|
4905
|
-
var $L132 = $L("
|
|
4906
|
-
var $L133 = $L("
|
|
4907
|
-
var $L134 = $L("
|
|
4908
|
-
var $L135 = $L("
|
|
4909
|
-
var $L136 = $L("
|
|
4910
|
-
var $L137 = $L("
|
|
4911
|
-
var $L138 = $L(
|
|
4912
|
-
var $L139 = $L("
|
|
4913
|
-
var $L140 = $L("
|
|
4914
|
-
var $L141 = $L("
|
|
4915
|
-
var $L142 = $L("
|
|
4916
|
-
var $L143 = $L("
|
|
4917
|
-
var $L144 = $L("
|
|
4918
|
-
var $L145 = $L("
|
|
4919
|
-
var $L146 = $L("
|
|
4920
|
-
var $L147 = $L("
|
|
4921
|
-
var $L148 = $L("
|
|
4922
|
-
var $L149 = $L("
|
|
4923
|
-
var $L150 = $L("
|
|
4924
|
-
var $L151 = $L("
|
|
4925
|
-
var $L152 = $L("
|
|
4926
|
-
var $L153 = $L("
|
|
4927
|
-
var $L154 = $L("
|
|
4928
|
-
var $L155 = $L("
|
|
4929
|
-
var $L156 = $L("
|
|
4930
|
-
var $L157 = $L("
|
|
4931
|
-
var $L158 = $L("
|
|
4932
|
-
var $L159 = $L("
|
|
4933
|
-
var $L160 = $L("
|
|
4934
|
-
var $L161 = $L("
|
|
4935
|
-
var $L162 = $L("
|
|
4936
|
-
var $L163 = $L("
|
|
4937
|
-
var $L164 = $L("
|
|
4938
|
-
var $L165 = $L("
|
|
4939
|
-
var $L166 = $L("
|
|
4940
|
-
var $L167 = $L("
|
|
4941
|
-
var $L168 = $L("
|
|
4942
|
-
var $L169 = $L("
|
|
4943
|
-
var $L170 = $L("
|
|
4944
|
-
var $L171 = $L("
|
|
4945
|
-
var $L172 = $L("
|
|
4946
|
-
var $L173 = $L("
|
|
4947
|
-
var $L174 = $L("
|
|
4948
|
-
var $L175 = $L("
|
|
4949
|
-
var $L176 = $L("
|
|
4950
|
-
var $L177 = $L("
|
|
4951
|
-
var $L178 = $L("
|
|
4952
|
-
var $L179 = $L("
|
|
4953
|
-
var $L180 = $L("
|
|
4954
|
-
var $L181 = $L("
|
|
4955
|
-
var $L182 = $L("
|
|
4956
|
-
var $L183 = $L(
|
|
4957
|
-
var $L184 = $L("'
|
|
4958
|
-
var $L185 = $L("
|
|
4959
|
-
var $L186 = $L("
|
|
4960
|
-
var $L187 = $L("
|
|
4961
|
-
var $L188 = $L("
|
|
4962
|
-
var $L189 = $L("
|
|
4963
|
-
var $L190 = $L("
|
|
4964
|
-
var $L191 = $L("
|
|
4965
|
-
var $L192 = $L("
|
|
4966
|
-
var $L193 = $L("
|
|
4967
|
-
var $L194 = $L("
|
|
4968
|
-
var $L195 = $L("
|
|
4969
|
-
var $L196 = $L("
|
|
4970
|
-
var $L197 = $L("
|
|
4971
|
-
var $L198 = $L("
|
|
4972
|
-
var $L199 = $L("
|
|
4973
|
-
var $L200 = $L("
|
|
4974
|
-
var $L201 = $L("
|
|
4975
|
-
var $L202 = $L("
|
|
4976
|
-
var $L203 = $L("
|
|
4977
|
-
var $L204 = $L("
|
|
4978
|
-
var $L205 = $L("
|
|
4979
|
-
var $L206 = $L("
|
|
4980
|
-
var $L207 = $L("
|
|
4981
|
-
var $L208 = $L("
|
|
4982
|
-
var $L209 = $L("
|
|
4983
|
-
var $L210 = $L("
|
|
4984
|
-
var $L211 = $L("
|
|
4985
|
-
var $L212 = $L("
|
|
4986
|
-
var $L213 = $L("
|
|
4987
|
-
var $L214 = $L("
|
|
4910
|
+
var $L108 = $L("require");
|
|
4911
|
+
var $L109 = $L("with");
|
|
4912
|
+
var $L110 = $L("assert");
|
|
4913
|
+
var $L111 = $L(":=");
|
|
4914
|
+
var $L112 = $L("\u2254");
|
|
4915
|
+
var $L113 = $L(".=");
|
|
4916
|
+
var $L114 = $L("/*");
|
|
4917
|
+
var $L115 = $L("*/");
|
|
4918
|
+
var $L116 = $L("\\");
|
|
4919
|
+
var $L117 = $L(")");
|
|
4920
|
+
var $L118 = $L("abstract");
|
|
4921
|
+
var $L119 = $L("as");
|
|
4922
|
+
var $L120 = $L("@");
|
|
4923
|
+
var $L121 = $L("@@");
|
|
4924
|
+
var $L122 = $L("async");
|
|
4925
|
+
var $L123 = $L("await");
|
|
4926
|
+
var $L124 = $L("`");
|
|
4927
|
+
var $L125 = $L("by");
|
|
4928
|
+
var $L126 = $L("case");
|
|
4929
|
+
var $L127 = $L("catch");
|
|
4930
|
+
var $L128 = $L("class");
|
|
4931
|
+
var $L129 = $L("#{");
|
|
4932
|
+
var $L130 = $L("declare");
|
|
4933
|
+
var $L131 = $L("default");
|
|
4934
|
+
var $L132 = $L("delete");
|
|
4935
|
+
var $L133 = $L("do");
|
|
4936
|
+
var $L134 = $L("..");
|
|
4937
|
+
var $L135 = $L("\u2025");
|
|
4938
|
+
var $L136 = $L("...");
|
|
4939
|
+
var $L137 = $L("\u2026");
|
|
4940
|
+
var $L138 = $L("::");
|
|
4941
|
+
var $L139 = $L('"');
|
|
4942
|
+
var $L140 = $L("each");
|
|
4943
|
+
var $L141 = $L("else");
|
|
4944
|
+
var $L142 = $L("export");
|
|
4945
|
+
var $L143 = $L("extends");
|
|
4946
|
+
var $L144 = $L("finally");
|
|
4947
|
+
var $L145 = $L("for");
|
|
4948
|
+
var $L146 = $L("from");
|
|
4949
|
+
var $L147 = $L("function");
|
|
4950
|
+
var $L148 = $L("get");
|
|
4951
|
+
var $L149 = $L("set");
|
|
4952
|
+
var $L150 = $L("#");
|
|
4953
|
+
var $L151 = $L("if");
|
|
4954
|
+
var $L152 = $L("in");
|
|
4955
|
+
var $L153 = $L("let");
|
|
4956
|
+
var $L154 = $L("const");
|
|
4957
|
+
var $L155 = $L("is");
|
|
4958
|
+
var $L156 = $L("loop");
|
|
4959
|
+
var $L157 = $L("new");
|
|
4960
|
+
var $L158 = $L("not");
|
|
4961
|
+
var $L159 = $L("of");
|
|
4962
|
+
var $L160 = $L("[");
|
|
4963
|
+
var $L161 = $L("operator");
|
|
4964
|
+
var $L162 = $L("own");
|
|
4965
|
+
var $L163 = $L("public");
|
|
4966
|
+
var $L164 = $L("private");
|
|
4967
|
+
var $L165 = $L("protected");
|
|
4968
|
+
var $L166 = $L("||>");
|
|
4969
|
+
var $L167 = $L("|\u25B7");
|
|
4970
|
+
var $L168 = $L("|>=");
|
|
4971
|
+
var $L169 = $L("\u25B7=");
|
|
4972
|
+
var $L170 = $L("|>");
|
|
4973
|
+
var $L171 = $L("\u25B7");
|
|
4974
|
+
var $L172 = $L("readonly");
|
|
4975
|
+
var $L173 = $L("return");
|
|
4976
|
+
var $L174 = $L("satisfies");
|
|
4977
|
+
var $L175 = $L("'");
|
|
4978
|
+
var $L176 = $L("static");
|
|
4979
|
+
var $L177 = $L("${");
|
|
4980
|
+
var $L178 = $L("super");
|
|
4981
|
+
var $L179 = $L("switch");
|
|
4982
|
+
var $L180 = $L("target");
|
|
4983
|
+
var $L181 = $L("then");
|
|
4984
|
+
var $L182 = $L("this");
|
|
4985
|
+
var $L183 = $L("throw");
|
|
4986
|
+
var $L184 = $L('"""');
|
|
4987
|
+
var $L185 = $L("'''");
|
|
4988
|
+
var $L186 = $L("///");
|
|
4989
|
+
var $L187 = $L("```");
|
|
4990
|
+
var $L188 = $L("try");
|
|
4991
|
+
var $L189 = $L("typeof");
|
|
4992
|
+
var $L190 = $L("unless");
|
|
4993
|
+
var $L191 = $L("until");
|
|
4994
|
+
var $L192 = $L("using");
|
|
4995
|
+
var $L193 = $L("var");
|
|
4996
|
+
var $L194 = $L("void");
|
|
4997
|
+
var $L195 = $L("when");
|
|
4998
|
+
var $L196 = $L("while");
|
|
4999
|
+
var $L197 = $L("yield");
|
|
5000
|
+
var $L198 = $L("/>");
|
|
5001
|
+
var $L199 = $L("</");
|
|
5002
|
+
var $L200 = $L("<>");
|
|
5003
|
+
var $L201 = $L("</>");
|
|
5004
|
+
var $L202 = $L("<!--");
|
|
5005
|
+
var $L203 = $L("-->");
|
|
5006
|
+
var $L204 = $L("type");
|
|
5007
|
+
var $L205 = $L("enum");
|
|
5008
|
+
var $L206 = $L("interface");
|
|
5009
|
+
var $L207 = $L("global");
|
|
5010
|
+
var $L208 = $L("module");
|
|
5011
|
+
var $L209 = $L("namespace");
|
|
5012
|
+
var $L210 = $L("asserts");
|
|
5013
|
+
var $L211 = $L("keyof");
|
|
5014
|
+
var $L212 = $L("infer");
|
|
5015
|
+
var $L213 = $L("???");
|
|
5016
|
+
var $L214 = $L("[]");
|
|
5017
|
+
var $L215 = $L("civet");
|
|
4988
5018
|
var $R0 = $R(new RegExp("(?=debugger|if|unless|do|for|loop|until|while|switch|throw|try)", "suy"));
|
|
4989
5019
|
var $R1 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
4990
5020
|
var $R2 = $R(new RegExp("[0-9]", "suy"));
|
|
@@ -5549,20 +5579,27 @@ var require_parser = __commonJS({
|
|
|
5549
5579
|
function UnaryPostfix(ctx, state) {
|
|
5550
5580
|
return $EVENT_C(ctx, state, "UnaryPostfix", UnaryPostfix$$);
|
|
5551
5581
|
}
|
|
5552
|
-
var TypePostfix$0 = $TS($S(_,
|
|
5582
|
+
var TypePostfix$0 = $TS($S(_, NWTypePostfix), function($skip, $loc, $0, $1, $2) {
|
|
5553
5583
|
var ws = $1;
|
|
5554
|
-
var
|
|
5555
|
-
|
|
5556
|
-
|
|
5584
|
+
var postfix = $2;
|
|
5585
|
+
return [ws, ...postfix];
|
|
5586
|
+
});
|
|
5587
|
+
function TypePostfix(ctx, state) {
|
|
5588
|
+
return $EVENT(ctx, state, "TypePostfix", TypePostfix$0);
|
|
5589
|
+
}
|
|
5590
|
+
var NWTypePostfix$0 = $TS($S(As, $E(ExclamationPoint), Type), function($skip, $loc, $0, $1, $2, $3) {
|
|
5591
|
+
var as = $1;
|
|
5592
|
+
var ex = $2;
|
|
5593
|
+
var type = $3;
|
|
5557
5594
|
if (ex) {
|
|
5558
|
-
return [{ $loc: ex.$loc, token: "
|
|
5595
|
+
return [{ $loc: ex.$loc, token: "as unknown " }, as, type];
|
|
5559
5596
|
}
|
|
5560
|
-
return [
|
|
5597
|
+
return [as, type];
|
|
5561
5598
|
});
|
|
5562
|
-
var
|
|
5563
|
-
var
|
|
5564
|
-
function
|
|
5565
|
-
return $EVENT_C(ctx, state, "
|
|
5599
|
+
var NWTypePostfix$1 = $S(Satisfies, Type);
|
|
5600
|
+
var NWTypePostfix$$ = [NWTypePostfix$0, NWTypePostfix$1];
|
|
5601
|
+
function NWTypePostfix(ctx, state) {
|
|
5602
|
+
return $EVENT_C(ctx, state, "NWTypePostfix", NWTypePostfix$$);
|
|
5566
5603
|
}
|
|
5567
5604
|
var UpdateExpression$0 = $TS($S(UpdateExpressionSymbol, UnaryWithoutParenthesizedAssignment), function($skip, $loc, $0, $1, $2) {
|
|
5568
5605
|
return {
|
|
@@ -5757,36 +5794,19 @@ var require_parser = __commonJS({
|
|
|
5757
5794
|
var head = $2;
|
|
5758
5795
|
var body = $3;
|
|
5759
5796
|
if (head.token === "&") {
|
|
5760
|
-
|
|
5761
|
-
|
|
5797
|
+
head = makeAmpersandFunction();
|
|
5798
|
+
}
|
|
5799
|
+
if (head.type === "ArrowFunction" && head.ampersandBlock) {
|
|
5800
|
+
const expressions = [{
|
|
5762
5801
|
type: "PipelineExpression",
|
|
5763
|
-
children: [ws,
|
|
5764
|
-
};
|
|
5765
|
-
const
|
|
5766
|
-
type: "Parameters",
|
|
5767
|
-
children: [ref],
|
|
5768
|
-
names: []
|
|
5769
|
-
};
|
|
5770
|
-
const expressions = [arrowBody];
|
|
5771
|
-
const block = {
|
|
5772
|
-
bare: true,
|
|
5773
|
-
expressions,
|
|
5774
|
-
children: [expressions]
|
|
5775
|
-
};
|
|
5776
|
-
const children = [parameters, " => ", block];
|
|
5802
|
+
children: [ws, head.block.expressions[0], body]
|
|
5803
|
+
}];
|
|
5804
|
+
const block = { ...head.block, expressions, children: [expressions] };
|
|
5777
5805
|
return {
|
|
5778
|
-
|
|
5779
|
-
|
|
5780
|
-
|
|
5781
|
-
|
|
5782
|
-
}
|
|
5783
|
-
},
|
|
5784
|
-
children,
|
|
5785
|
-
ref,
|
|
5786
|
-
body: [arrowBody],
|
|
5787
|
-
ampersandBlock: true,
|
|
5788
|
-
parameters,
|
|
5789
|
-
block
|
|
5806
|
+
...head,
|
|
5807
|
+
block,
|
|
5808
|
+
body: expressions,
|
|
5809
|
+
children: [...head.children.slice(0, -1), block]
|
|
5790
5810
|
};
|
|
5791
5811
|
}
|
|
5792
5812
|
return {
|
|
@@ -5806,12 +5826,17 @@ var require_parser = __commonJS({
|
|
|
5806
5826
|
}
|
|
5807
5827
|
var PipelineTailItem$0 = Await;
|
|
5808
5828
|
var PipelineTailItem$1 = Yield;
|
|
5809
|
-
var PipelineTailItem$2 = Return
|
|
5810
|
-
|
|
5811
|
-
|
|
5829
|
+
var PipelineTailItem$2 = $T($S(Return, $N(AccessStart)), function(value) {
|
|
5830
|
+
return value[0];
|
|
5831
|
+
});
|
|
5832
|
+
var PipelineTailItem$3 = $TS($S(NWTypePostfix, $Q(TypePostfix)), function($skip, $loc, $0, $1, $2) {
|
|
5833
|
+
return makeAmpersandFunction([" ", $1, ...$2]);
|
|
5834
|
+
});
|
|
5835
|
+
var PipelineTailItem$4 = AmpersandFunctionExpression;
|
|
5836
|
+
var PipelineTailItem$5 = $T($S($N(Ampersand), PipelineHeadItem), function(value) {
|
|
5812
5837
|
return value[1];
|
|
5813
5838
|
});
|
|
5814
|
-
var PipelineTailItem$$ = [PipelineTailItem$0, PipelineTailItem$1, PipelineTailItem$2, PipelineTailItem$3, PipelineTailItem$4];
|
|
5839
|
+
var PipelineTailItem$$ = [PipelineTailItem$0, PipelineTailItem$1, PipelineTailItem$2, PipelineTailItem$3, PipelineTailItem$4, PipelineTailItem$5];
|
|
5815
5840
|
function PipelineTailItem(ctx, state) {
|
|
5816
5841
|
return $EVENT_C(ctx, state, "PipelineTailItem", PipelineTailItem$$);
|
|
5817
5842
|
}
|
|
@@ -6040,7 +6065,7 @@ var require_parser = __commonJS({
|
|
|
6040
6065
|
var ClassElement$0 = $TS($S($E(Decorators), $E(AccessModifier), $E($S(Static, $E(_))), ClassElementDefinition), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6041
6066
|
var decorators = $1;
|
|
6042
6067
|
var definition = $4;
|
|
6043
|
-
if (definition.type === "
|
|
6068
|
+
if (definition.type === "MultiMethodDefinition") {
|
|
6044
6069
|
return {
|
|
6045
6070
|
...definition,
|
|
6046
6071
|
children: definition.children.map((c) => {
|
|
@@ -7199,27 +7224,7 @@ var require_parser = __commonJS({
|
|
|
7199
7224
|
};
|
|
7200
7225
|
});
|
|
7201
7226
|
var FunctionExpression$1 = $TV($EXPECT($L26, 'FunctionExpression "(&)"'), function($skip, $loc, $0, $1) {
|
|
7202
|
-
|
|
7203
|
-
const parameters = {
|
|
7204
|
-
type: "Parameters",
|
|
7205
|
-
children: [ref],
|
|
7206
|
-
names: []
|
|
7207
|
-
};
|
|
7208
|
-
const block = {
|
|
7209
|
-
expressions: [ref]
|
|
7210
|
-
};
|
|
7211
|
-
return {
|
|
7212
|
-
type: "ArrowFunction",
|
|
7213
|
-
signature: {
|
|
7214
|
-
modifier: {}
|
|
7215
|
-
},
|
|
7216
|
-
children: [parameters, " => ", body],
|
|
7217
|
-
ref,
|
|
7218
|
-
body,
|
|
7219
|
-
ampersandBlock: true,
|
|
7220
|
-
block,
|
|
7221
|
-
parameters
|
|
7222
|
-
};
|
|
7227
|
+
return makeAmpersandFunction();
|
|
7223
7228
|
});
|
|
7224
7229
|
var FunctionExpression$2 = $TS($S(OpenParen, BinaryOp, CloseParen), function($skip, $loc, $0, $1, $2, $3) {
|
|
7225
7230
|
var open = $1;
|
|
@@ -7343,15 +7348,11 @@ var require_parser = __commonJS({
|
|
|
7343
7348
|
var rhs = $3;
|
|
7344
7349
|
if (!prefix.length && !rhs)
|
|
7345
7350
|
return $skip;
|
|
7346
|
-
let body, ref;
|
|
7351
|
+
let body, ref, typeSuffix;
|
|
7347
7352
|
if (!rhs) {
|
|
7348
7353
|
body = ref = makeRef("$");
|
|
7349
7354
|
} else {
|
|
7350
|
-
|
|
7351
|
-
while (!exp.ref && exp.expression) {
|
|
7352
|
-
exp = exp.expression;
|
|
7353
|
-
}
|
|
7354
|
-
({ ref } = exp);
|
|
7355
|
+
({ ref, typeSuffix } = rhs);
|
|
7355
7356
|
if (!ref) {
|
|
7356
7357
|
throw new Error("Could not find ref in ampersand shorthand block");
|
|
7357
7358
|
}
|
|
@@ -7365,7 +7366,7 @@ var require_parser = __commonJS({
|
|
|
7365
7366
|
}
|
|
7366
7367
|
const parameters = {
|
|
7367
7368
|
type: "Parameters",
|
|
7368
|
-
children: [ref],
|
|
7369
|
+
children: typeSuffix ? ["(", ref, typeSuffix, ")"] : [ref],
|
|
7369
7370
|
names: []
|
|
7370
7371
|
};
|
|
7371
7372
|
const expressions = [body];
|
|
@@ -7465,12 +7466,19 @@ var require_parser = __commonJS({
|
|
|
7465
7466
|
function AmpersandBlockRHS(ctx, state) {
|
|
7466
7467
|
return $EVENT(ctx, state, "AmpersandBlockRHS", AmpersandBlockRHS$0);
|
|
7467
7468
|
}
|
|
7468
|
-
var
|
|
7469
|
-
|
|
7470
|
-
|
|
7471
|
-
|
|
7472
|
-
|
|
7473
|
-
|
|
7469
|
+
var AmpersandTypeSuffix$0 = $T($S($Y($S($E(_), $E(QuestionMark), $E(_), Colon)), TypeSuffix), function(value) {
|
|
7470
|
+
return value[1];
|
|
7471
|
+
});
|
|
7472
|
+
function AmpersandTypeSuffix(ctx, state) {
|
|
7473
|
+
return $EVENT(ctx, state, "AmpersandTypeSuffix", AmpersandTypeSuffix$0);
|
|
7474
|
+
}
|
|
7475
|
+
var AmpersandBlockRHSBody$0 = $TS($S($E(AmpersandTypeSuffix), $E($S($N(_), $P(CallExpressionRest))), $E(UnaryPostfix), $E($S(WAssignmentOp, $Q($S(NotDedented, UpdateExpression, WAssignmentOp)), NonPipelineExtendedExpression)), $E($S($N($EXPECT($R10, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
7476
|
+
var typeSuffix = $1;
|
|
7477
|
+
var callExpRest = $2;
|
|
7478
|
+
var unaryPostfix = $3;
|
|
7479
|
+
var assign = $4;
|
|
7480
|
+
var binopRHS = $5;
|
|
7481
|
+
if (!typeSuffix && !callExpRest && !binopRHS && !unaryPostfix)
|
|
7474
7482
|
return $skip;
|
|
7475
7483
|
const ref = makeRef("$");
|
|
7476
7484
|
let exp = {
|
|
@@ -7497,16 +7505,16 @@ var require_parser = __commonJS({
|
|
|
7497
7505
|
names: null,
|
|
7498
7506
|
lhs,
|
|
7499
7507
|
assigned: exp,
|
|
7500
|
-
exp: rhs
|
|
7501
|
-
ref
|
|
7508
|
+
exp: rhs
|
|
7502
7509
|
};
|
|
7503
7510
|
}
|
|
7504
7511
|
if (binopRHS) {
|
|
7505
7512
|
exp = {
|
|
7506
|
-
children: processBinaryOpExpression([exp, binopRHS[1]])
|
|
7507
|
-
ref
|
|
7513
|
+
children: processBinaryOpExpression([exp, binopRHS[1]])
|
|
7508
7514
|
};
|
|
7509
7515
|
}
|
|
7516
|
+
exp.ref = ref;
|
|
7517
|
+
exp.typeSuffix = typeSuffix;
|
|
7510
7518
|
return exp;
|
|
7511
7519
|
});
|
|
7512
7520
|
function AmpersandBlockRHSBody(ctx, state) {
|
|
@@ -7778,13 +7786,12 @@ var require_parser = __commonJS({
|
|
|
7778
7786
|
return block;
|
|
7779
7787
|
});
|
|
7780
7788
|
var NonSingleBracedBlock$1 = ImplicitNestedBlock;
|
|
7781
|
-
var NonSingleBracedBlock$2 = $TS($S(InsertOpenBrace,
|
|
7782
|
-
var s = $
|
|
7789
|
+
var NonSingleBracedBlock$2 = $TS($S(InsertOpenBrace, NestedImplicitObjectLiteral, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3) {
|
|
7790
|
+
var s = $2;
|
|
7783
7791
|
return {
|
|
7784
7792
|
type: "BlockStatement",
|
|
7785
7793
|
expressions: [s],
|
|
7786
|
-
|
|
7787
|
-
children: [$1, s, $3]
|
|
7794
|
+
children: $0
|
|
7788
7795
|
};
|
|
7789
7796
|
});
|
|
7790
7797
|
var NonSingleBracedBlock$$ = [NonSingleBracedBlock$0, NonSingleBracedBlock$1, NonSingleBracedBlock$2];
|
|
@@ -8182,7 +8189,10 @@ var require_parser = __commonJS({
|
|
|
8182
8189
|
return $EVENT(ctx, state, "ElementListRest", ElementListRest$0);
|
|
8183
8190
|
}
|
|
8184
8191
|
var ArrayElementExpression$0 = JSXTag;
|
|
8185
|
-
var ArrayElementExpression$1 = $
|
|
8192
|
+
var ArrayElementExpression$1 = $T($S(ImplicitObjectLiteral, $Y(ArrayElementDelimiter)), function(value) {
|
|
8193
|
+
return value[0];
|
|
8194
|
+
});
|
|
8195
|
+
var ArrayElementExpression$2 = $TS($S($E(ExtendedExpression), __, DotDotDot, $Y(ArrayElementDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8186
8196
|
var exp = $1;
|
|
8187
8197
|
var ws = $2;
|
|
8188
8198
|
var dots = $3;
|
|
@@ -8195,7 +8205,7 @@ var require_parser = __commonJS({
|
|
|
8195
8205
|
names: exp.names
|
|
8196
8206
|
};
|
|
8197
8207
|
});
|
|
8198
|
-
var ArrayElementExpression$
|
|
8208
|
+
var ArrayElementExpression$3 = $TS($S($E($S($E($S(__, DotDotDot, __)), PostfixedExpression)), $Y(ArrayElementDelimiter)), function($skip, $loc, $0, $1, $2) {
|
|
8199
8209
|
var expMaybeSpread = $1;
|
|
8200
8210
|
if (expMaybeSpread) {
|
|
8201
8211
|
const [spread, exp] = expMaybeSpread;
|
|
@@ -8218,7 +8228,7 @@ var require_parser = __commonJS({
|
|
|
8218
8228
|
children: []
|
|
8219
8229
|
};
|
|
8220
8230
|
});
|
|
8221
|
-
var ArrayElementExpression$$ = [ArrayElementExpression$0, ArrayElementExpression$1, ArrayElementExpression$2];
|
|
8231
|
+
var ArrayElementExpression$$ = [ArrayElementExpression$0, ArrayElementExpression$1, ArrayElementExpression$2, ArrayElementExpression$3];
|
|
8222
8232
|
function ArrayElementExpression(ctx, state) {
|
|
8223
8233
|
return $EVENT_C(ctx, state, "ArrayElementExpression", ArrayElementExpression$$);
|
|
8224
8234
|
}
|
|
@@ -8282,8 +8292,10 @@ var require_parser = __commonJS({
|
|
|
8282
8292
|
function BracedObjectLiteralContent(ctx, state) {
|
|
8283
8293
|
return $EVENT_C(ctx, state, "BracedObjectLiteralContent", BracedObjectLiteralContent$$);
|
|
8284
8294
|
}
|
|
8285
|
-
var NestedImplicitObjectLiteral$0 = $TS($S(InsertOpenBrace, NestedImplicitPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
8286
|
-
var properties = $
|
|
8295
|
+
var NestedImplicitObjectLiteral$0 = $TS($S(InsertOpenBrace, PushIndent, $E(NestedImplicitPropertyDefinitions), PopIndent, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
8296
|
+
var properties = $3;
|
|
8297
|
+
if (!properties)
|
|
8298
|
+
return $skip;
|
|
8287
8299
|
return {
|
|
8288
8300
|
type: "ObjectExpression",
|
|
8289
8301
|
properties,
|
|
@@ -8293,10 +8305,8 @@ var require_parser = __commonJS({
|
|
|
8293
8305
|
function NestedImplicitObjectLiteral(ctx, state) {
|
|
8294
8306
|
return $EVENT(ctx, state, "NestedImplicitObjectLiteral", NestedImplicitObjectLiteral$0);
|
|
8295
8307
|
}
|
|
8296
|
-
var NestedImplicitPropertyDefinitions$0 = $
|
|
8297
|
-
var defs = $
|
|
8298
|
-
if (!defs.length)
|
|
8299
|
-
return $skip;
|
|
8308
|
+
var NestedImplicitPropertyDefinitions$0 = $TV($P(NestedImplicitPropertyDefinition), function($skip, $loc, $0, $1) {
|
|
8309
|
+
var defs = $0;
|
|
8300
8310
|
return defs.flat();
|
|
8301
8311
|
});
|
|
8302
8312
|
function NestedImplicitPropertyDefinitions(ctx, state) {
|
|
@@ -8348,7 +8358,7 @@ var require_parser = __commonJS({
|
|
|
8348
8358
|
function NestedPropertyDefinition(ctx, state) {
|
|
8349
8359
|
return $EVENT(ctx, state, "NestedPropertyDefinition", NestedPropertyDefinition$0);
|
|
8350
8360
|
}
|
|
8351
|
-
var
|
|
8361
|
+
var ImplicitObjectLiteral$0 = $TS($S(InsertInlineOpenBrace, SnugNamedProperty, $Q($S(ImplicitObjectPropertyDelimiter, NamedProperty)), $E($S($E(_), Comma)), InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
8352
8362
|
var open = $1;
|
|
8353
8363
|
var first = $2;
|
|
8354
8364
|
var rest = $3;
|
|
@@ -8359,16 +8369,34 @@ var require_parser = __commonJS({
|
|
|
8359
8369
|
children: [open, first, ...rest, trailing, close]
|
|
8360
8370
|
};
|
|
8361
8371
|
});
|
|
8362
|
-
function
|
|
8363
|
-
return $EVENT(ctx, state, "
|
|
8372
|
+
function ImplicitObjectLiteral(ctx, state) {
|
|
8373
|
+
return $EVENT(ctx, state, "ImplicitObjectLiteral", ImplicitObjectLiteral$0);
|
|
8364
8374
|
}
|
|
8365
|
-
var
|
|
8366
|
-
var
|
|
8375
|
+
var ImplicitObjectPropertyDelimiter$0 = $S($E(_), Comma, $C(NotDedented, $E(_)));
|
|
8376
|
+
var ImplicitObjectPropertyDelimiter$1 = $T($S($Y($S(Nested, NamedProperty)), InsertComma, Nested), function(value) {
|
|
8367
8377
|
return [value[1], value[2]];
|
|
8368
8378
|
});
|
|
8369
|
-
var
|
|
8370
|
-
function
|
|
8371
|
-
return $EVENT_C(ctx, state, "
|
|
8379
|
+
var ImplicitObjectPropertyDelimiter$$ = [ImplicitObjectPropertyDelimiter$0, ImplicitObjectPropertyDelimiter$1];
|
|
8380
|
+
function ImplicitObjectPropertyDelimiter(ctx, state) {
|
|
8381
|
+
return $EVENT_C(ctx, state, "ImplicitObjectPropertyDelimiter", ImplicitObjectPropertyDelimiter$$);
|
|
8382
|
+
}
|
|
8383
|
+
var InlineObjectLiteral$0 = $TS($S(InsertInlineOpenBrace, SnugNamedProperty, $Q($S(InlineObjectPropertyDelimiter, NamedProperty)), $E($S($E(_), Comma, $Y(Dedented))), InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
8384
|
+
var open = $1;
|
|
8385
|
+
var first = $2;
|
|
8386
|
+
var rest = $3;
|
|
8387
|
+
var trailing = $4;
|
|
8388
|
+
var close = $5;
|
|
8389
|
+
return {
|
|
8390
|
+
type: "ObjectExpression",
|
|
8391
|
+
children: [open, first, ...rest, trailing, close]
|
|
8392
|
+
};
|
|
8393
|
+
});
|
|
8394
|
+
function InlineObjectLiteral(ctx, state) {
|
|
8395
|
+
return $EVENT(ctx, state, "InlineObjectLiteral", InlineObjectLiteral$0);
|
|
8396
|
+
}
|
|
8397
|
+
var InlineObjectPropertyDelimiter$0 = $S($E(_), Comma, $C(NotDedented, $E(_)));
|
|
8398
|
+
function InlineObjectPropertyDelimiter(ctx, state) {
|
|
8399
|
+
return $EVENT(ctx, state, "InlineObjectPropertyDelimiter", InlineObjectPropertyDelimiter$0);
|
|
8372
8400
|
}
|
|
8373
8401
|
var ObjectPropertyDelimiter$0 = $S($E(_), Comma);
|
|
8374
8402
|
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L29, 'ObjectPropertyDelimiter "}"')));
|
|
@@ -8403,6 +8431,11 @@ var require_parser = __commonJS({
|
|
|
8403
8431
|
var PropertyDefinition$2 = $TS($S($E(_), MethodDefinition), function($skip, $loc, $0, $1, $2) {
|
|
8404
8432
|
var ws = $1;
|
|
8405
8433
|
var def = $2;
|
|
8434
|
+
if (def.type === "MultiMethodDefinition") {
|
|
8435
|
+
return {
|
|
8436
|
+
children: def.children.flatMap((c, i) => i ? [",", c] : [c])
|
|
8437
|
+
};
|
|
8438
|
+
}
|
|
8406
8439
|
if (!def.block || def.block.empty)
|
|
8407
8440
|
return $skip;
|
|
8408
8441
|
return {
|
|
@@ -8637,16 +8670,16 @@ var require_parser = __commonJS({
|
|
|
8637
8670
|
parameters: signature.parameters
|
|
8638
8671
|
};
|
|
8639
8672
|
});
|
|
8640
|
-
var MethodDefinition$2 = $TS($S(GetOrSet, $E(_), ForbidIndentedApplication, $E($S(MemberBase, $Q(CallExpressionRest))), RestoreIndentedApplication, $E(BracedBlock)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
8673
|
+
var MethodDefinition$2 = $TS($S(GetOrSet, $E(_), ForbidIndentedApplication, $E($S(MemberBase, $Q(CallExpressionRest), $E(ReturnTypeSuffix))), RestoreIndentedApplication, $E(BracedBlock)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
8641
8674
|
var kind = $1;
|
|
8642
8675
|
var ws = $2;
|
|
8643
|
-
var
|
|
8676
|
+
var content = $4;
|
|
8644
8677
|
var block = $6;
|
|
8645
|
-
if (!
|
|
8678
|
+
if (!content)
|
|
8646
8679
|
return $skip;
|
|
8647
|
-
const rest =
|
|
8680
|
+
const [base, rest, returnType] = content;
|
|
8681
|
+
const value = [base, rest];
|
|
8648
8682
|
if (!rest.length) {
|
|
8649
|
-
const base = value[0];
|
|
8650
8683
|
let name2;
|
|
8651
8684
|
if (base.type === "MemberExpression") {
|
|
8652
8685
|
const lastAccess2 = lastAccessInCallExpression(base);
|
|
@@ -8661,7 +8694,7 @@ var require_parser = __commonJS({
|
|
|
8661
8694
|
if (name2[0] === "#")
|
|
8662
8695
|
name2 = name2.slice(1);
|
|
8663
8696
|
const autoReturn = !block || base.type !== "Identifier";
|
|
8664
|
-
return makeGetterMethod(name2, ws, base, block, kind, autoReturn);
|
|
8697
|
+
return makeGetterMethod(name2, ws, base, returnType, block, kind, autoReturn);
|
|
8665
8698
|
}
|
|
8666
8699
|
let last = rest[rest.length - 1];
|
|
8667
8700
|
while (Array.isArray(last)) {
|
|
@@ -8672,10 +8705,10 @@ var require_parser = __commonJS({
|
|
|
8672
8705
|
return $skip;
|
|
8673
8706
|
case "PropertyAccess":
|
|
8674
8707
|
const { name: name2 } = last;
|
|
8675
|
-
return makeGetterMethod(name2, ws, value, block, kind);
|
|
8708
|
+
return makeGetterMethod(name2, ws, value, returnType, block, kind);
|
|
8676
8709
|
case "PropertyGlob":
|
|
8677
8710
|
return {
|
|
8678
|
-
type: "
|
|
8711
|
+
type: "MultiMethodDefinition",
|
|
8679
8712
|
children: last.object.properties.map((p) => {
|
|
8680
8713
|
const { name: name3, type } = p;
|
|
8681
8714
|
let v;
|
|
@@ -8689,7 +8722,7 @@ var require_parser = __commonJS({
|
|
|
8689
8722
|
}
|
|
8690
8723
|
const exp = processCallMemberExpression({
|
|
8691
8724
|
type: "CallExpression",
|
|
8692
|
-
children: [
|
|
8725
|
+
children: [base, ...rest.slice(0, -1), {
|
|
8693
8726
|
type: "PropertyAccess",
|
|
8694
8727
|
children: [last.dot, {
|
|
8695
8728
|
...v,
|
|
@@ -8698,13 +8731,13 @@ var require_parser = __commonJS({
|
|
|
8698
8731
|
}]
|
|
8699
8732
|
}]
|
|
8700
8733
|
});
|
|
8701
|
-
return makeGetterMethod(name3, ws, exp, block, kind);
|
|
8734
|
+
return makeGetterMethod(name3, ws, exp, returnType, block, kind);
|
|
8702
8735
|
})
|
|
8703
8736
|
};
|
|
8704
8737
|
}
|
|
8705
8738
|
const lastAccess = lastAccessInCallExpression({ children: rest });
|
|
8706
8739
|
const { name } = lastAccess;
|
|
8707
|
-
return makeGetterMethod(name, ws, value, block, kind);
|
|
8740
|
+
return makeGetterMethod(name, ws, value, returnType, block, kind);
|
|
8708
8741
|
});
|
|
8709
8742
|
var MethodDefinition$$ = [MethodDefinition$0, MethodDefinition$1, MethodDefinition$2];
|
|
8710
8743
|
function MethodDefinition(ctx, state) {
|
|
@@ -9254,8 +9287,11 @@ var require_parser = __commonJS({
|
|
|
9254
9287
|
return $EVENT_C(ctx, state, "ModuleItem", ModuleItem$$);
|
|
9255
9288
|
}
|
|
9256
9289
|
var StatementListItem$0 = Declaration;
|
|
9257
|
-
var StatementListItem$1 =
|
|
9258
|
-
|
|
9290
|
+
var StatementListItem$1 = $TS($S($N($EXPECT($L103, 'StatementListItem "$:"')), ImplicitObjectLiteral), function($skip, $loc, $0, $1, $2) {
|
|
9291
|
+
return makeLeftHandSideExpression($2);
|
|
9292
|
+
});
|
|
9293
|
+
var StatementListItem$2 = PostfixedStatement;
|
|
9294
|
+
var StatementListItem$$ = [StatementListItem$0, StatementListItem$1, StatementListItem$2];
|
|
9259
9295
|
function StatementListItem(ctx, state) {
|
|
9260
9296
|
return $EVENT_C(ctx, state, "StatementListItem", StatementListItem$$);
|
|
9261
9297
|
}
|
|
@@ -9361,7 +9397,7 @@ var require_parser = __commonJS({
|
|
|
9361
9397
|
function NoCommaStatement(ctx, state) {
|
|
9362
9398
|
return $EVENT_C(ctx, state, "NoCommaStatement", NoCommaStatement$$);
|
|
9363
9399
|
}
|
|
9364
|
-
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($
|
|
9400
|
+
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L104, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
|
|
9365
9401
|
return { type: "EmptyStatement", children: $1 || [] };
|
|
9366
9402
|
});
|
|
9367
9403
|
function EmptyStatement(ctx, state) {
|
|
@@ -9392,7 +9428,7 @@ var require_parser = __commonJS({
|
|
|
9392
9428
|
var w = $3;
|
|
9393
9429
|
return [id, colon, w];
|
|
9394
9430
|
});
|
|
9395
|
-
var Label$1 = $S($EXPECT($
|
|
9431
|
+
var Label$1 = $S($EXPECT($L103, 'Label "$:"'), Whitespace);
|
|
9396
9432
|
var Label$$ = [Label$0, Label$1];
|
|
9397
9433
|
function Label(ctx, state) {
|
|
9398
9434
|
return $EVENT_C(ctx, state, "Label", Label$$);
|
|
@@ -10550,16 +10586,26 @@ var require_parser = __commonJS({
|
|
|
10550
10586
|
function MaybeNestedExpression(ctx, state) {
|
|
10551
10587
|
return $EVENT_C(ctx, state, "MaybeNestedExpression", MaybeNestedExpression$$);
|
|
10552
10588
|
}
|
|
10553
|
-
var ImportDeclaration$0 = $
|
|
10589
|
+
var ImportDeclaration$0 = $TS($S(Import, _, Identifier, $E(_), Equals, __, $EXPECT($L108, 'ImportDeclaration "require"'), NonIdContinue, Arguments), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10590
|
+
const imp = [
|
|
10591
|
+
{ ...$1, ts: true },
|
|
10592
|
+
{ ...$1, token: "const", js: true }
|
|
10593
|
+
];
|
|
10594
|
+
return {
|
|
10595
|
+
type: "ImportDeclaration",
|
|
10596
|
+
children: [imp, $0.slice(1)]
|
|
10597
|
+
};
|
|
10598
|
+
});
|
|
10599
|
+
var ImportDeclaration$1 = $T($S(Import, __, TypeKeyword, __, ImportClause, __, FromClause, $E(ImportAssertion)), function(value) {
|
|
10554
10600
|
return { "type": "ImportDeclaration", "ts": true, "children": value };
|
|
10555
10601
|
});
|
|
10556
|
-
var ImportDeclaration$
|
|
10602
|
+
var ImportDeclaration$2 = $T($S(Import, __, ImportClause, __, FromClause, $E(ImportAssertion)), function(value) {
|
|
10557
10603
|
return { "type": "ImportDeclaration", "children": value };
|
|
10558
10604
|
});
|
|
10559
|
-
var ImportDeclaration$
|
|
10605
|
+
var ImportDeclaration$3 = $T($S(Import, __, ModuleSpecifier, $E(ImportAssertion)), function(value) {
|
|
10560
10606
|
return { "type": "ImportDeclaration", "children": value };
|
|
10561
10607
|
});
|
|
10562
|
-
var ImportDeclaration$
|
|
10608
|
+
var ImportDeclaration$4 = $TS($S(ImpliedImport, $E($S(TypeKeyword, __)), ImportClause, __, FromClause, $E(ImportAssertion)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
10563
10609
|
var i = $1;
|
|
10564
10610
|
var t = $2;
|
|
10565
10611
|
var c = $3;
|
|
@@ -10575,7 +10621,7 @@ var require_parser = __commonJS({
|
|
|
10575
10621
|
return children;
|
|
10576
10622
|
return { type: "ImportDeclaration", ts: true, children };
|
|
10577
10623
|
});
|
|
10578
|
-
var ImportDeclaration$$ = [ImportDeclaration$0, ImportDeclaration$1, ImportDeclaration$2, ImportDeclaration$3];
|
|
10624
|
+
var ImportDeclaration$$ = [ImportDeclaration$0, ImportDeclaration$1, ImportDeclaration$2, ImportDeclaration$3, ImportDeclaration$4];
|
|
10579
10625
|
function ImportDeclaration(ctx, state) {
|
|
10580
10626
|
return $EVENT_C(ctx, state, "ImportDeclaration", ImportDeclaration$$);
|
|
10581
10627
|
}
|
|
@@ -10634,7 +10680,7 @@ var require_parser = __commonJS({
|
|
|
10634
10680
|
function FromClause(ctx, state) {
|
|
10635
10681
|
return $EVENT(ctx, state, "FromClause", FromClause$0);
|
|
10636
10682
|
}
|
|
10637
|
-
var ImportAssertion$0 = $S($E(_), $C($EXPECT($
|
|
10683
|
+
var ImportAssertion$0 = $S($E(_), $C($EXPECT($L109, 'ImportAssertion "with"'), $EXPECT($L110, 'ImportAssertion "assert"')), NonIdContinue, $E(_), ObjectLiteral);
|
|
10638
10684
|
function ImportAssertion(ctx, state) {
|
|
10639
10685
|
return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
|
|
10640
10686
|
}
|
|
@@ -10708,10 +10754,17 @@ var require_parser = __commonJS({
|
|
|
10708
10754
|
return $EVENT_C(ctx, state, "ModuleExportName", ModuleExportName$$);
|
|
10709
10755
|
}
|
|
10710
10756
|
var ModuleSpecifier$0 = $TS($S(UnprocessedModuleSpecifier), function($skip, $loc, $0, $1) {
|
|
10711
|
-
|
|
10712
|
-
|
|
10713
|
-
|
|
10714
|
-
|
|
10757
|
+
let { token } = $1;
|
|
10758
|
+
if (module2.config.rewriteTsImports) {
|
|
10759
|
+
token = token.replace(/\.([mc])?ts(['"])$/, ".$1js$2");
|
|
10760
|
+
}
|
|
10761
|
+
if (module2.config.rewriteCivetImports) {
|
|
10762
|
+
token = token.replace(
|
|
10763
|
+
/\.civet(['"])$/,
|
|
10764
|
+
`${module2.config.rewriteCivetImports.replace(/\$/g, "$$")}$1`
|
|
10765
|
+
);
|
|
10766
|
+
}
|
|
10767
|
+
return { ...$1, token };
|
|
10715
10768
|
});
|
|
10716
10769
|
function ModuleSpecifier(ctx, state) {
|
|
10717
10770
|
return $EVENT(ctx, state, "ModuleSpecifier", ModuleSpecifier$0);
|
|
@@ -10733,18 +10786,28 @@ var require_parser = __commonJS({
|
|
|
10733
10786
|
function ImportedBinding(ctx, state) {
|
|
10734
10787
|
return $EVENT(ctx, state, "ImportedBinding", ImportedBinding$0);
|
|
10735
10788
|
}
|
|
10736
|
-
var ExportDeclaration$0 = $TS($S(
|
|
10789
|
+
var ExportDeclaration$0 = $TS($S(Export, $E(_), Equals, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
10790
|
+
const exp = [
|
|
10791
|
+
{ ...$1, ts: true },
|
|
10792
|
+
{ ...$1, token: "module.exports", js: true }
|
|
10793
|
+
];
|
|
10794
|
+
return {
|
|
10795
|
+
type: "ExportDeclaration",
|
|
10796
|
+
children: [exp, $0.slice(1)]
|
|
10797
|
+
};
|
|
10798
|
+
});
|
|
10799
|
+
var ExportDeclaration$1 = $TS($S($E(Decorators), Export, __, Default, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
10737
10800
|
var declaration = $6;
|
|
10738
10801
|
return { type: "ExportDeclaration", declaration, children: $0 };
|
|
10739
10802
|
});
|
|
10740
|
-
var ExportDeclaration$
|
|
10803
|
+
var ExportDeclaration$2 = $TS($S(Export, __, ExportFromClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
10741
10804
|
return { type: "ExportDeclaration", ts: $3.ts, children: $0 };
|
|
10742
10805
|
});
|
|
10743
|
-
var ExportDeclaration$
|
|
10806
|
+
var ExportDeclaration$3 = $TS($S($E(Decorators), Export, __, $C(Declaration, VariableStatement, TypeAndNamedExports, ExportVarDec)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
10744
10807
|
var declaration = $4;
|
|
10745
10808
|
return { type: "ExportDeclaration", declaration, ts: declaration.ts, children: $0 };
|
|
10746
10809
|
});
|
|
10747
|
-
var ExportDeclaration$$ = [ExportDeclaration$0, ExportDeclaration$1, ExportDeclaration$2];
|
|
10810
|
+
var ExportDeclaration$$ = [ExportDeclaration$0, ExportDeclaration$1, ExportDeclaration$2, ExportDeclaration$3];
|
|
10748
10811
|
function ExportDeclaration(ctx, state) {
|
|
10749
10812
|
return $EVENT_C(ctx, state, "ExportDeclaration", ExportDeclaration$$);
|
|
10750
10813
|
}
|
|
@@ -10772,7 +10835,7 @@ var require_parser = __commonJS({
|
|
|
10772
10835
|
return $EVENT(ctx, state, "TypeAndNamedExports", TypeAndNamedExports$0);
|
|
10773
10836
|
}
|
|
10774
10837
|
var NamedExports$0 = $S(OpenBrace, $Q(ExportSpecifier), $E($S(__, Comma)), __, CloseBrace);
|
|
10775
|
-
var NamedExports$1 = $TS($S(InsertInlineOpenBrace, ImplicitExportSpecifier, $Q($S(
|
|
10838
|
+
var NamedExports$1 = $TS($S(InsertInlineOpenBrace, ImplicitExportSpecifier, $Q($S(ImplicitObjectPropertyDelimiter, ImplicitExportSpecifier)), InsertCloseBrace, $Y($C(StatementDelimiter, $S(__, From)))), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
10776
10839
|
var open = $1;
|
|
10777
10840
|
var first = $2;
|
|
10778
10841
|
var rest = $3;
|
|
@@ -10854,13 +10917,13 @@ var require_parser = __commonJS({
|
|
|
10854
10917
|
function LexicalDeclaration(ctx, state) {
|
|
10855
10918
|
return $EVENT_C(ctx, state, "LexicalDeclaration", LexicalDeclaration$$);
|
|
10856
10919
|
}
|
|
10857
|
-
var ConstAssignment$0 = $TV($C($EXPECT($
|
|
10920
|
+
var ConstAssignment$0 = $TV($C($EXPECT($L111, 'ConstAssignment ":="'), $EXPECT($L112, 'ConstAssignment "\u2254"')), function($skip, $loc, $0, $1) {
|
|
10858
10921
|
return { $loc, token: "=" };
|
|
10859
10922
|
});
|
|
10860
10923
|
function ConstAssignment(ctx, state) {
|
|
10861
10924
|
return $EVENT(ctx, state, "ConstAssignment", ConstAssignment$0);
|
|
10862
10925
|
}
|
|
10863
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
10926
|
+
var LetAssignment$0 = $TV($EXPECT($L113, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10864
10927
|
return { $loc, token: "=" };
|
|
10865
10928
|
});
|
|
10866
10929
|
function LetAssignment(ctx, state) {
|
|
@@ -11266,7 +11329,7 @@ var require_parser = __commonJS({
|
|
|
11266
11329
|
function MultiLineComment(ctx, state) {
|
|
11267
11330
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
11268
11331
|
}
|
|
11269
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
11332
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L114, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L115, 'JSMultiLineComment "*/"')), $EXPECT($R59, "JSMultiLineComment /./"))), $EXPECT($L115, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
11270
11333
|
return { type: "Comment", $loc, token: $1 };
|
|
11271
11334
|
});
|
|
11272
11335
|
function JSMultiLineComment(ctx, state) {
|
|
@@ -11312,7 +11375,7 @@ var require_parser = __commonJS({
|
|
|
11312
11375
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R65, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11313
11376
|
return { $loc, token: $0 };
|
|
11314
11377
|
});
|
|
11315
|
-
var NonNewlineWhitespace$1 = $T($S($EXPECT($
|
|
11378
|
+
var NonNewlineWhitespace$1 = $T($S($EXPECT($L116, 'NonNewlineWhitespace "\\\\\\\\"'), CoffeeLineContinuationEnabled, EOL), function(value) {
|
|
11316
11379
|
return " ";
|
|
11317
11380
|
});
|
|
11318
11381
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
@@ -11358,7 +11421,7 @@ var require_parser = __commonJS({
|
|
|
11358
11421
|
}
|
|
11359
11422
|
var StatementDelimiter$0 = $Y(EOS);
|
|
11360
11423
|
var StatementDelimiter$1 = SemicolonDelimiter;
|
|
11361
|
-
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L29, 'StatementDelimiter "}"'), $EXPECT($
|
|
11424
|
+
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L29, 'StatementDelimiter "}"'), $EXPECT($L117, 'StatementDelimiter ")"'), $EXPECT($L38, 'StatementDelimiter "]"'))));
|
|
11362
11425
|
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2];
|
|
11363
11426
|
function StatementDelimiter(ctx, state) {
|
|
11364
11427
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
@@ -11382,7 +11445,7 @@ var require_parser = __commonJS({
|
|
|
11382
11445
|
function Loc(ctx, state) {
|
|
11383
11446
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
11384
11447
|
}
|
|
11385
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
11448
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L118, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L15, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
11386
11449
|
return { $loc, token: $1, ts: true };
|
|
11387
11450
|
});
|
|
11388
11451
|
function Abstract(ctx, state) {
|
|
@@ -11394,43 +11457,43 @@ var require_parser = __commonJS({
|
|
|
11394
11457
|
function Ampersand(ctx, state) {
|
|
11395
11458
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
11396
11459
|
}
|
|
11397
|
-
var As$0 = $TS($S($EXPECT($
|
|
11460
|
+
var As$0 = $TS($S($EXPECT($L119, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11398
11461
|
return { $loc, token: $1 };
|
|
11399
11462
|
});
|
|
11400
11463
|
function As(ctx, state) {
|
|
11401
11464
|
return $EVENT(ctx, state, "As", As$0);
|
|
11402
11465
|
}
|
|
11403
|
-
var At$0 = $TV($EXPECT($
|
|
11466
|
+
var At$0 = $TV($EXPECT($L120, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
11404
11467
|
return { $loc, token: $1 };
|
|
11405
11468
|
});
|
|
11406
11469
|
function At(ctx, state) {
|
|
11407
11470
|
return $EVENT(ctx, state, "At", At$0);
|
|
11408
11471
|
}
|
|
11409
|
-
var AtAt$0 = $TV($EXPECT($
|
|
11472
|
+
var AtAt$0 = $TV($EXPECT($L121, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
11410
11473
|
return { $loc, token: "@" };
|
|
11411
11474
|
});
|
|
11412
11475
|
function AtAt(ctx, state) {
|
|
11413
11476
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
11414
11477
|
}
|
|
11415
|
-
var Async$0 = $TS($S($EXPECT($
|
|
11478
|
+
var Async$0 = $TS($S($EXPECT($L122, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11416
11479
|
return { $loc, token: $1, type: "Async" };
|
|
11417
11480
|
});
|
|
11418
11481
|
function Async(ctx, state) {
|
|
11419
11482
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
11420
11483
|
}
|
|
11421
|
-
var Await$0 = $TS($S($EXPECT($
|
|
11484
|
+
var Await$0 = $TS($S($EXPECT($L123, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11422
11485
|
return { $loc, token: $1, type: "Await" };
|
|
11423
11486
|
});
|
|
11424
11487
|
function Await(ctx, state) {
|
|
11425
11488
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
11426
11489
|
}
|
|
11427
|
-
var Backtick$0 = $TV($EXPECT($
|
|
11490
|
+
var Backtick$0 = $TV($EXPECT($L124, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
11428
11491
|
return { $loc, token: $1 };
|
|
11429
11492
|
});
|
|
11430
11493
|
function Backtick(ctx, state) {
|
|
11431
11494
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
11432
11495
|
}
|
|
11433
|
-
var By$0 = $TS($S($EXPECT($
|
|
11496
|
+
var By$0 = $TS($S($EXPECT($L125, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11434
11497
|
return { $loc, token: $1 };
|
|
11435
11498
|
});
|
|
11436
11499
|
function By(ctx, state) {
|
|
@@ -11442,19 +11505,19 @@ var require_parser = __commonJS({
|
|
|
11442
11505
|
function Caret(ctx, state) {
|
|
11443
11506
|
return $EVENT(ctx, state, "Caret", Caret$0);
|
|
11444
11507
|
}
|
|
11445
|
-
var Case$0 = $TS($S($EXPECT($
|
|
11508
|
+
var Case$0 = $TS($S($EXPECT($L126, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11446
11509
|
return { $loc, token: $1 };
|
|
11447
11510
|
});
|
|
11448
11511
|
function Case(ctx, state) {
|
|
11449
11512
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
11450
11513
|
}
|
|
11451
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
11514
|
+
var Catch$0 = $TS($S($EXPECT($L127, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11452
11515
|
return { $loc, token: $1 };
|
|
11453
11516
|
});
|
|
11454
11517
|
function Catch(ctx, state) {
|
|
11455
11518
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
11456
11519
|
}
|
|
11457
|
-
var Class$0 = $TS($S($EXPECT($
|
|
11520
|
+
var Class$0 = $TS($S($EXPECT($L128, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11458
11521
|
return { $loc, token: $1 };
|
|
11459
11522
|
});
|
|
11460
11523
|
function Class(ctx, state) {
|
|
@@ -11478,13 +11541,13 @@ var require_parser = __commonJS({
|
|
|
11478
11541
|
function CloseBracket(ctx, state) {
|
|
11479
11542
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
11480
11543
|
}
|
|
11481
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
11544
|
+
var CloseParen$0 = $TV($EXPECT($L117, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
11482
11545
|
return { $loc, token: $1 };
|
|
11483
11546
|
});
|
|
11484
11547
|
function CloseParen(ctx, state) {
|
|
11485
11548
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
11486
11549
|
}
|
|
11487
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
11550
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L129, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
11488
11551
|
return { $loc, token: "${" };
|
|
11489
11552
|
});
|
|
11490
11553
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
@@ -11502,31 +11565,31 @@ var require_parser = __commonJS({
|
|
|
11502
11565
|
function Comma(ctx, state) {
|
|
11503
11566
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
11504
11567
|
}
|
|
11505
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
11568
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L120, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
11506
11569
|
return { $loc, token: "constructor" };
|
|
11507
11570
|
});
|
|
11508
11571
|
function ConstructorShorthand(ctx, state) {
|
|
11509
11572
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
11510
11573
|
}
|
|
11511
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
11574
|
+
var Declare$0 = $TS($S($EXPECT($L130, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11512
11575
|
return { $loc, token: $1 };
|
|
11513
11576
|
});
|
|
11514
11577
|
function Declare(ctx, state) {
|
|
11515
11578
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
11516
11579
|
}
|
|
11517
|
-
var Default$0 = $TS($S($EXPECT($
|
|
11580
|
+
var Default$0 = $TS($S($EXPECT($L131, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11518
11581
|
return { $loc, token: $1 };
|
|
11519
11582
|
});
|
|
11520
11583
|
function Default(ctx, state) {
|
|
11521
11584
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
11522
11585
|
}
|
|
11523
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
11586
|
+
var Delete$0 = $TS($S($EXPECT($L132, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11524
11587
|
return { $loc, token: $1 };
|
|
11525
11588
|
});
|
|
11526
11589
|
function Delete(ctx, state) {
|
|
11527
11590
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
11528
11591
|
}
|
|
11529
|
-
var Do$0 = $TS($S($EXPECT($
|
|
11592
|
+
var Do$0 = $TS($S($EXPECT($L133, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11530
11593
|
return { $loc, token: $1 };
|
|
11531
11594
|
});
|
|
11532
11595
|
function Do(ctx, state) {
|
|
@@ -11546,45 +11609,45 @@ var require_parser = __commonJS({
|
|
|
11546
11609
|
function Dot(ctx, state) {
|
|
11547
11610
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
11548
11611
|
}
|
|
11549
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
11612
|
+
var DotDot$0 = $TS($S($EXPECT($L134, 'DotDot ".."'), $N($EXPECT($L7, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
11550
11613
|
return { $loc, token: $1 };
|
|
11551
11614
|
});
|
|
11552
|
-
var DotDot$1 = $TV($EXPECT($
|
|
11615
|
+
var DotDot$1 = $TV($EXPECT($L135, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
11553
11616
|
return { $loc, token: ".." };
|
|
11554
11617
|
});
|
|
11555
11618
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
11556
11619
|
function DotDot(ctx, state) {
|
|
11557
11620
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
11558
11621
|
}
|
|
11559
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
11622
|
+
var DotDotDot$0 = $TV($EXPECT($L136, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
11560
11623
|
return { $loc, token: $1 };
|
|
11561
11624
|
});
|
|
11562
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
11625
|
+
var DotDotDot$1 = $TV($EXPECT($L137, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
11563
11626
|
return { $loc, token: "..." };
|
|
11564
11627
|
});
|
|
11565
11628
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
11566
11629
|
function DotDotDot(ctx, state) {
|
|
11567
11630
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
11568
11631
|
}
|
|
11569
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
11632
|
+
var DoubleColon$0 = $TV($EXPECT($L138, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
11570
11633
|
return { $loc, token: $1 };
|
|
11571
11634
|
});
|
|
11572
11635
|
function DoubleColon(ctx, state) {
|
|
11573
11636
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
11574
11637
|
}
|
|
11575
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
11638
|
+
var DoubleQuote$0 = $TV($EXPECT($L139, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
11576
11639
|
return { $loc, token: $1 };
|
|
11577
11640
|
});
|
|
11578
11641
|
function DoubleQuote(ctx, state) {
|
|
11579
11642
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
11580
11643
|
}
|
|
11581
|
-
var Each$0 = $TS($S($EXPECT($
|
|
11644
|
+
var Each$0 = $TS($S($EXPECT($L140, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11582
11645
|
return { $loc, token: $1 };
|
|
11583
11646
|
});
|
|
11584
11647
|
function Each(ctx, state) {
|
|
11585
11648
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
11586
11649
|
}
|
|
11587
|
-
var Else$0 = $TS($S($EXPECT($
|
|
11650
|
+
var Else$0 = $TS($S($EXPECT($L141, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11588
11651
|
return { $loc, token: $1 };
|
|
11589
11652
|
});
|
|
11590
11653
|
function Else(ctx, state) {
|
|
@@ -11602,55 +11665,55 @@ var require_parser = __commonJS({
|
|
|
11602
11665
|
function ExclamationPoint(ctx, state) {
|
|
11603
11666
|
return $EVENT(ctx, state, "ExclamationPoint", ExclamationPoint$0);
|
|
11604
11667
|
}
|
|
11605
|
-
var Export$0 = $TS($S($EXPECT($
|
|
11668
|
+
var Export$0 = $TS($S($EXPECT($L142, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11606
11669
|
return { $loc, token: $1 };
|
|
11607
11670
|
});
|
|
11608
11671
|
function Export(ctx, state) {
|
|
11609
11672
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
11610
11673
|
}
|
|
11611
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
11674
|
+
var Extends$0 = $TS($S($EXPECT($L143, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11612
11675
|
return { $loc, token: $1 };
|
|
11613
11676
|
});
|
|
11614
11677
|
function Extends(ctx, state) {
|
|
11615
11678
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
11616
11679
|
}
|
|
11617
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
11680
|
+
var Finally$0 = $TS($S($EXPECT($L144, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11618
11681
|
return { $loc, token: $1 };
|
|
11619
11682
|
});
|
|
11620
11683
|
function Finally(ctx, state) {
|
|
11621
11684
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
11622
11685
|
}
|
|
11623
|
-
var For$0 = $TS($S($EXPECT($
|
|
11686
|
+
var For$0 = $TS($S($EXPECT($L145, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11624
11687
|
return { $loc, token: $1 };
|
|
11625
11688
|
});
|
|
11626
11689
|
function For(ctx, state) {
|
|
11627
11690
|
return $EVENT(ctx, state, "For", For$0);
|
|
11628
11691
|
}
|
|
11629
|
-
var From$0 = $TS($S($EXPECT($
|
|
11692
|
+
var From$0 = $TS($S($EXPECT($L146, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11630
11693
|
return { $loc, token: $1 };
|
|
11631
11694
|
});
|
|
11632
11695
|
function From(ctx, state) {
|
|
11633
11696
|
return $EVENT(ctx, state, "From", From$0);
|
|
11634
11697
|
}
|
|
11635
|
-
var Function$0 = $TS($S($EXPECT($
|
|
11698
|
+
var Function$0 = $TS($S($EXPECT($L147, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11636
11699
|
return { $loc, token: $1 };
|
|
11637
11700
|
});
|
|
11638
11701
|
function Function(ctx, state) {
|
|
11639
11702
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
11640
11703
|
}
|
|
11641
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
11704
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L148, 'GetOrSet "get"'), $EXPECT($L149, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11642
11705
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
11643
11706
|
});
|
|
11644
11707
|
function GetOrSet(ctx, state) {
|
|
11645
11708
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
11646
11709
|
}
|
|
11647
|
-
var Hash$0 = $TV($EXPECT($
|
|
11710
|
+
var Hash$0 = $TV($EXPECT($L150, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
11648
11711
|
return { $loc, token: $1 };
|
|
11649
11712
|
});
|
|
11650
11713
|
function Hash(ctx, state) {
|
|
11651
11714
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
11652
11715
|
}
|
|
11653
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
11716
|
+
var If$0 = $TV($TEXT($S($EXPECT($L151, 'If "if"'), NonIdContinue, $E($EXPECT($L15, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
11654
11717
|
return { $loc, token: $1 };
|
|
11655
11718
|
});
|
|
11656
11719
|
function If(ctx, state) {
|
|
@@ -11662,25 +11725,25 @@ var require_parser = __commonJS({
|
|
|
11662
11725
|
function Import(ctx, state) {
|
|
11663
11726
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
11664
11727
|
}
|
|
11665
|
-
var In$0 = $TS($S($EXPECT($
|
|
11728
|
+
var In$0 = $TS($S($EXPECT($L152, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11666
11729
|
return { $loc, token: $1 };
|
|
11667
11730
|
});
|
|
11668
11731
|
function In(ctx, state) {
|
|
11669
11732
|
return $EVENT(ctx, state, "In", In$0);
|
|
11670
11733
|
}
|
|
11671
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
11734
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L153, 'LetOrConst "let"'), $EXPECT($L154, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11672
11735
|
return { $loc, token: $1 };
|
|
11673
11736
|
});
|
|
11674
11737
|
function LetOrConst(ctx, state) {
|
|
11675
11738
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
11676
11739
|
}
|
|
11677
|
-
var Const$0 = $TS($S($EXPECT($
|
|
11740
|
+
var Const$0 = $TS($S($EXPECT($L154, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11678
11741
|
return { $loc, token: $1 };
|
|
11679
11742
|
});
|
|
11680
11743
|
function Const(ctx, state) {
|
|
11681
11744
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
11682
11745
|
}
|
|
11683
|
-
var Is$0 = $TS($S($EXPECT($
|
|
11746
|
+
var Is$0 = $TS($S($EXPECT($L155, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11684
11747
|
return { $loc, token: $1 };
|
|
11685
11748
|
});
|
|
11686
11749
|
function Is(ctx, state) {
|
|
@@ -11692,25 +11755,25 @@ var require_parser = __commonJS({
|
|
|
11692
11755
|
function LetOrConstOrVar(ctx, state) {
|
|
11693
11756
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
11694
11757
|
}
|
|
11695
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
11758
|
+
var Loop$0 = $TS($S($EXPECT($L156, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11696
11759
|
return { $loc, token: "while(true)" };
|
|
11697
11760
|
});
|
|
11698
11761
|
function Loop(ctx, state) {
|
|
11699
11762
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
11700
11763
|
}
|
|
11701
|
-
var New$0 = $TS($S($EXPECT($
|
|
11764
|
+
var New$0 = $TS($S($EXPECT($L157, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11702
11765
|
return { $loc, token: $1 };
|
|
11703
11766
|
});
|
|
11704
11767
|
function New(ctx, state) {
|
|
11705
11768
|
return $EVENT(ctx, state, "New", New$0);
|
|
11706
11769
|
}
|
|
11707
|
-
var Not$0 = $TS($S($EXPECT($
|
|
11770
|
+
var Not$0 = $TS($S($EXPECT($L158, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L14, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
11708
11771
|
return { $loc, token: "!" };
|
|
11709
11772
|
});
|
|
11710
11773
|
function Not(ctx, state) {
|
|
11711
11774
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
11712
11775
|
}
|
|
11713
|
-
var Of$0 = $TS($S($EXPECT($
|
|
11776
|
+
var Of$0 = $TS($S($EXPECT($L159, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11714
11777
|
return { $loc, token: $1 };
|
|
11715
11778
|
});
|
|
11716
11779
|
function Of(ctx, state) {
|
|
@@ -11728,7 +11791,7 @@ var require_parser = __commonJS({
|
|
|
11728
11791
|
function OpenBrace(ctx, state) {
|
|
11729
11792
|
return $EVENT(ctx, state, "OpenBrace", OpenBrace$0);
|
|
11730
11793
|
}
|
|
11731
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
11794
|
+
var OpenBracket$0 = $TV($EXPECT($L160, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
11732
11795
|
return { $loc, token: $1 };
|
|
11733
11796
|
});
|
|
11734
11797
|
function OpenBracket(ctx, state) {
|
|
@@ -11740,43 +11803,43 @@ var require_parser = __commonJS({
|
|
|
11740
11803
|
function OpenParen(ctx, state) {
|
|
11741
11804
|
return $EVENT(ctx, state, "OpenParen", OpenParen$0);
|
|
11742
11805
|
}
|
|
11743
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
11806
|
+
var Operator$0 = $TS($S($EXPECT($L161, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11744
11807
|
return { $loc, token: $1 };
|
|
11745
11808
|
});
|
|
11746
11809
|
function Operator(ctx, state) {
|
|
11747
11810
|
return $EVENT(ctx, state, "Operator", Operator$0);
|
|
11748
11811
|
}
|
|
11749
|
-
var Own$0 = $TS($S($EXPECT($
|
|
11812
|
+
var Own$0 = $TS($S($EXPECT($L162, 'Own "own"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11750
11813
|
return { $loc, token: $1 };
|
|
11751
11814
|
});
|
|
11752
11815
|
function Own(ctx, state) {
|
|
11753
11816
|
return $EVENT(ctx, state, "Own", Own$0);
|
|
11754
11817
|
}
|
|
11755
|
-
var Public$0 = $TS($S($EXPECT($
|
|
11818
|
+
var Public$0 = $TS($S($EXPECT($L163, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11756
11819
|
return { $loc, token: $1 };
|
|
11757
11820
|
});
|
|
11758
11821
|
function Public(ctx, state) {
|
|
11759
11822
|
return $EVENT(ctx, state, "Public", Public$0);
|
|
11760
11823
|
}
|
|
11761
|
-
var Private$0 = $TS($S($EXPECT($
|
|
11824
|
+
var Private$0 = $TS($S($EXPECT($L164, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11762
11825
|
return { $loc, token: $1 };
|
|
11763
11826
|
});
|
|
11764
11827
|
function Private(ctx, state) {
|
|
11765
11828
|
return $EVENT(ctx, state, "Private", Private$0);
|
|
11766
11829
|
}
|
|
11767
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
11830
|
+
var Protected$0 = $TS($S($EXPECT($L165, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11768
11831
|
return { $loc, token: $1 };
|
|
11769
11832
|
});
|
|
11770
11833
|
function Protected(ctx, state) {
|
|
11771
11834
|
return $EVENT(ctx, state, "Protected", Protected$0);
|
|
11772
11835
|
}
|
|
11773
|
-
var Pipe$0 = $TV($C($EXPECT($
|
|
11836
|
+
var Pipe$0 = $TV($C($EXPECT($L166, 'Pipe "||>"'), $EXPECT($L167, 'Pipe "|\u25B7"')), function($skip, $loc, $0, $1) {
|
|
11774
11837
|
return { $loc, token: "||>" };
|
|
11775
11838
|
});
|
|
11776
|
-
var Pipe$1 = $TV($C($EXPECT($
|
|
11839
|
+
var Pipe$1 = $TV($C($EXPECT($L168, 'Pipe "|>="'), $EXPECT($L169, 'Pipe "\u25B7="')), function($skip, $loc, $0, $1) {
|
|
11777
11840
|
return { $loc, token: "|>=" };
|
|
11778
11841
|
});
|
|
11779
|
-
var Pipe$2 = $TV($C($EXPECT($
|
|
11842
|
+
var Pipe$2 = $TV($C($EXPECT($L170, 'Pipe "|>"'), $EXPECT($L171, 'Pipe "\u25B7"')), function($skip, $loc, $0, $1) {
|
|
11780
11843
|
return { $loc, token: "|>" };
|
|
11781
11844
|
});
|
|
11782
11845
|
var Pipe$$ = [Pipe$0, Pipe$1, Pipe$2];
|
|
@@ -11789,31 +11852,31 @@ var require_parser = __commonJS({
|
|
|
11789
11852
|
function QuestionMark(ctx, state) {
|
|
11790
11853
|
return $EVENT(ctx, state, "QuestionMark", QuestionMark$0);
|
|
11791
11854
|
}
|
|
11792
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
11855
|
+
var Readonly$0 = $TS($S($EXPECT($L172, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11793
11856
|
return { $loc, token: $1, ts: true };
|
|
11794
11857
|
});
|
|
11795
11858
|
function Readonly(ctx, state) {
|
|
11796
11859
|
return $EVENT(ctx, state, "Readonly", Readonly$0);
|
|
11797
11860
|
}
|
|
11798
|
-
var Return$0 = $TS($S($EXPECT($
|
|
11861
|
+
var Return$0 = $TS($S($EXPECT($L173, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11799
11862
|
return { $loc, token: $1 };
|
|
11800
11863
|
});
|
|
11801
11864
|
function Return(ctx, state) {
|
|
11802
11865
|
return $EVENT(ctx, state, "Return", Return$0);
|
|
11803
11866
|
}
|
|
11804
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
11867
|
+
var Satisfies$0 = $TS($S($EXPECT($L174, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11805
11868
|
return { $loc, token: $1 };
|
|
11806
11869
|
});
|
|
11807
11870
|
function Satisfies(ctx, state) {
|
|
11808
11871
|
return $EVENT(ctx, state, "Satisfies", Satisfies$0);
|
|
11809
11872
|
}
|
|
11810
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
11873
|
+
var Semicolon$0 = $TV($EXPECT($L104, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
11811
11874
|
return { $loc, token: $1 };
|
|
11812
11875
|
});
|
|
11813
11876
|
function Semicolon(ctx, state) {
|
|
11814
11877
|
return $EVENT(ctx, state, "Semicolon", Semicolon$0);
|
|
11815
11878
|
}
|
|
11816
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
11879
|
+
var SingleQuote$0 = $TV($EXPECT($L175, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
11817
11880
|
return { $loc, token: $1 };
|
|
11818
11881
|
});
|
|
11819
11882
|
function SingleQuote(ctx, state) {
|
|
@@ -11825,137 +11888,137 @@ var require_parser = __commonJS({
|
|
|
11825
11888
|
function Star(ctx, state) {
|
|
11826
11889
|
return $EVENT(ctx, state, "Star", Star$0);
|
|
11827
11890
|
}
|
|
11828
|
-
var Static$0 = $TS($S($EXPECT($
|
|
11891
|
+
var Static$0 = $TS($S($EXPECT($L176, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11829
11892
|
return { $loc, token: $1 };
|
|
11830
11893
|
});
|
|
11831
|
-
var Static$1 = $TS($S($EXPECT($
|
|
11894
|
+
var Static$1 = $TS($S($EXPECT($L120, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L120, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
11832
11895
|
return { $loc, token: "static " };
|
|
11833
11896
|
});
|
|
11834
11897
|
var Static$$ = [Static$0, Static$1];
|
|
11835
11898
|
function Static(ctx, state) {
|
|
11836
11899
|
return $EVENT_C(ctx, state, "Static", Static$$);
|
|
11837
11900
|
}
|
|
11838
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
11901
|
+
var SubstitutionStart$0 = $TV($EXPECT($L177, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
11839
11902
|
return { $loc, token: $1 };
|
|
11840
11903
|
});
|
|
11841
11904
|
function SubstitutionStart(ctx, state) {
|
|
11842
11905
|
return $EVENT(ctx, state, "SubstitutionStart", SubstitutionStart$0);
|
|
11843
11906
|
}
|
|
11844
|
-
var Super$0 = $TS($S($EXPECT($
|
|
11907
|
+
var Super$0 = $TS($S($EXPECT($L178, 'Super "super"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11845
11908
|
return { $loc, token: $1 };
|
|
11846
11909
|
});
|
|
11847
11910
|
function Super(ctx, state) {
|
|
11848
11911
|
return $EVENT(ctx, state, "Super", Super$0);
|
|
11849
11912
|
}
|
|
11850
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
11913
|
+
var Switch$0 = $TS($S($EXPECT($L179, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11851
11914
|
return { $loc, token: $1 };
|
|
11852
11915
|
});
|
|
11853
11916
|
function Switch(ctx, state) {
|
|
11854
11917
|
return $EVENT(ctx, state, "Switch", Switch$0);
|
|
11855
11918
|
}
|
|
11856
|
-
var Target$0 = $TS($S($EXPECT($
|
|
11919
|
+
var Target$0 = $TS($S($EXPECT($L180, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11857
11920
|
return { $loc, token: $1 };
|
|
11858
11921
|
});
|
|
11859
11922
|
function Target(ctx, state) {
|
|
11860
11923
|
return $EVENT(ctx, state, "Target", Target$0);
|
|
11861
11924
|
}
|
|
11862
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
11925
|
+
var Then$0 = $TS($S(__, $EXPECT($L181, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
11863
11926
|
return { $loc, token: "" };
|
|
11864
11927
|
});
|
|
11865
11928
|
function Then(ctx, state) {
|
|
11866
11929
|
return $EVENT(ctx, state, "Then", Then$0);
|
|
11867
11930
|
}
|
|
11868
|
-
var This$0 = $TS($S($EXPECT($
|
|
11931
|
+
var This$0 = $TS($S($EXPECT($L182, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11869
11932
|
return { $loc, token: $1 };
|
|
11870
11933
|
});
|
|
11871
11934
|
function This(ctx, state) {
|
|
11872
11935
|
return $EVENT(ctx, state, "This", This$0);
|
|
11873
11936
|
}
|
|
11874
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
11937
|
+
var Throw$0 = $TS($S($EXPECT($L183, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11875
11938
|
return { $loc, token: $1 };
|
|
11876
11939
|
});
|
|
11877
11940
|
function Throw(ctx, state) {
|
|
11878
11941
|
return $EVENT(ctx, state, "Throw", Throw$0);
|
|
11879
11942
|
}
|
|
11880
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
11943
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L184, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
11881
11944
|
return { $loc, token: "`" };
|
|
11882
11945
|
});
|
|
11883
11946
|
function TripleDoubleQuote(ctx, state) {
|
|
11884
11947
|
return $EVENT(ctx, state, "TripleDoubleQuote", TripleDoubleQuote$0);
|
|
11885
11948
|
}
|
|
11886
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
11949
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L185, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
11887
11950
|
return { $loc, token: "`" };
|
|
11888
11951
|
});
|
|
11889
11952
|
function TripleSingleQuote(ctx, state) {
|
|
11890
11953
|
return $EVENT(ctx, state, "TripleSingleQuote", TripleSingleQuote$0);
|
|
11891
11954
|
}
|
|
11892
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
11955
|
+
var TripleSlash$0 = $TV($EXPECT($L186, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
11893
11956
|
return { $loc, token: "/" };
|
|
11894
11957
|
});
|
|
11895
11958
|
function TripleSlash(ctx, state) {
|
|
11896
11959
|
return $EVENT(ctx, state, "TripleSlash", TripleSlash$0);
|
|
11897
11960
|
}
|
|
11898
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
11961
|
+
var TripleTick$0 = $TV($EXPECT($L187, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
11899
11962
|
return { $loc, token: "`" };
|
|
11900
11963
|
});
|
|
11901
11964
|
function TripleTick(ctx, state) {
|
|
11902
11965
|
return $EVENT(ctx, state, "TripleTick", TripleTick$0);
|
|
11903
11966
|
}
|
|
11904
|
-
var Try$0 = $TS($S($EXPECT($
|
|
11967
|
+
var Try$0 = $TS($S($EXPECT($L188, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11905
11968
|
return { $loc, token: $1 };
|
|
11906
11969
|
});
|
|
11907
11970
|
function Try(ctx, state) {
|
|
11908
11971
|
return $EVENT(ctx, state, "Try", Try$0);
|
|
11909
11972
|
}
|
|
11910
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
11973
|
+
var Typeof$0 = $TS($S($EXPECT($L189, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11911
11974
|
return { $loc, token: $1 };
|
|
11912
11975
|
});
|
|
11913
11976
|
function Typeof(ctx, state) {
|
|
11914
11977
|
return $EVENT(ctx, state, "Typeof", Typeof$0);
|
|
11915
11978
|
}
|
|
11916
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
11979
|
+
var Unless$0 = $TS($S($EXPECT($L190, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11917
11980
|
return { $loc, token: $1, negated: true };
|
|
11918
11981
|
});
|
|
11919
11982
|
function Unless(ctx, state) {
|
|
11920
11983
|
return $EVENT(ctx, state, "Unless", Unless$0);
|
|
11921
11984
|
}
|
|
11922
|
-
var Until$0 = $TS($S($EXPECT($
|
|
11985
|
+
var Until$0 = $TS($S($EXPECT($L191, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11923
11986
|
return { $loc, token: $1 };
|
|
11924
11987
|
});
|
|
11925
11988
|
function Until(ctx, state) {
|
|
11926
11989
|
return $EVENT(ctx, state, "Until", Until$0);
|
|
11927
11990
|
}
|
|
11928
|
-
var Using$0 = $TS($S($EXPECT($
|
|
11991
|
+
var Using$0 = $TS($S($EXPECT($L192, 'Using "using"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11929
11992
|
return { $loc, token: $1 };
|
|
11930
11993
|
});
|
|
11931
11994
|
function Using(ctx, state) {
|
|
11932
11995
|
return $EVENT(ctx, state, "Using", Using$0);
|
|
11933
11996
|
}
|
|
11934
|
-
var Var$0 = $TS($S($EXPECT($
|
|
11997
|
+
var Var$0 = $TS($S($EXPECT($L193, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11935
11998
|
return { $loc, token: $1 };
|
|
11936
11999
|
});
|
|
11937
12000
|
function Var(ctx, state) {
|
|
11938
12001
|
return $EVENT(ctx, state, "Var", Var$0);
|
|
11939
12002
|
}
|
|
11940
|
-
var Void$0 = $TS($S($EXPECT($
|
|
12003
|
+
var Void$0 = $TS($S($EXPECT($L194, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11941
12004
|
return { $loc, token: $1 };
|
|
11942
12005
|
});
|
|
11943
12006
|
function Void(ctx, state) {
|
|
11944
12007
|
return $EVENT(ctx, state, "Void", Void$0);
|
|
11945
12008
|
}
|
|
11946
|
-
var When$0 = $TS($S($EXPECT($
|
|
12009
|
+
var When$0 = $TS($S($EXPECT($L195, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11947
12010
|
return { $loc, token: "case" };
|
|
11948
12011
|
});
|
|
11949
12012
|
function When(ctx, state) {
|
|
11950
12013
|
return $EVENT(ctx, state, "When", When$0);
|
|
11951
12014
|
}
|
|
11952
|
-
var While$0 = $TS($S($EXPECT($
|
|
12015
|
+
var While$0 = $TS($S($EXPECT($L196, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11953
12016
|
return { $loc, token: $1 };
|
|
11954
12017
|
});
|
|
11955
12018
|
function While(ctx, state) {
|
|
11956
12019
|
return $EVENT(ctx, state, "While", While$0);
|
|
11957
12020
|
}
|
|
11958
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
12021
|
+
var Yield$0 = $TS($S($EXPECT($L197, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11959
12022
|
return { $loc, token: $1, type: "Yield" };
|
|
11960
12023
|
});
|
|
11961
12024
|
function Yield(ctx, state) {
|
|
@@ -12034,7 +12097,7 @@ var require_parser = __commonJS({
|
|
|
12034
12097
|
function JSXElement(ctx, state) {
|
|
12035
12098
|
return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
|
|
12036
12099
|
}
|
|
12037
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L16, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($
|
|
12100
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L16, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L198, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
12038
12101
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
12039
12102
|
});
|
|
12040
12103
|
function JSXSelfClosingElement(ctx, state) {
|
|
@@ -12068,7 +12131,7 @@ var require_parser = __commonJS({
|
|
|
12068
12131
|
function JSXOptionalClosingElement(ctx, state) {
|
|
12069
12132
|
return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
|
|
12070
12133
|
}
|
|
12071
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
12134
|
+
var JSXClosingElement$0 = $S($EXPECT($L199, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L37, 'JSXClosingElement ">"'));
|
|
12072
12135
|
function JSXClosingElement(ctx, state) {
|
|
12073
12136
|
return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
|
|
12074
12137
|
}
|
|
@@ -12089,7 +12152,7 @@ var require_parser = __commonJS({
|
|
|
12089
12152
|
];
|
|
12090
12153
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
12091
12154
|
});
|
|
12092
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
12155
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L200, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
12093
12156
|
var children = $3;
|
|
12094
12157
|
$0 = $0.slice(1);
|
|
12095
12158
|
return {
|
|
@@ -12102,7 +12165,7 @@ var require_parser = __commonJS({
|
|
|
12102
12165
|
function JSXFragment(ctx, state) {
|
|
12103
12166
|
return $EVENT_C(ctx, state, "JSXFragment", JSXFragment$$);
|
|
12104
12167
|
}
|
|
12105
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
12168
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L200, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
12106
12169
|
module2.JSXTagStack.push("");
|
|
12107
12170
|
return $1;
|
|
12108
12171
|
});
|
|
@@ -12119,11 +12182,11 @@ var require_parser = __commonJS({
|
|
|
12119
12182
|
function JSXOptionalClosingFragment(ctx, state) {
|
|
12120
12183
|
return $EVENT_C(ctx, state, "JSXOptionalClosingFragment", JSXOptionalClosingFragment$$);
|
|
12121
12184
|
}
|
|
12122
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
12185
|
+
var JSXClosingFragment$0 = $EXPECT($L201, 'JSXClosingFragment "</>"');
|
|
12123
12186
|
function JSXClosingFragment(ctx, state) {
|
|
12124
12187
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
12125
12188
|
}
|
|
12126
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
12189
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L150, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
12127
12190
|
return module2.config.defaultElement;
|
|
12128
12191
|
});
|
|
12129
12192
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -12301,7 +12364,7 @@ var require_parser = __commonJS({
|
|
|
12301
12364
|
}
|
|
12302
12365
|
return $skip;
|
|
12303
12366
|
});
|
|
12304
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
12367
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L150, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
12305
12368
|
return [" ", "id=", $2];
|
|
12306
12369
|
});
|
|
12307
12370
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -12593,7 +12656,7 @@ var require_parser = __commonJS({
|
|
|
12593
12656
|
function JSXChild(ctx, state) {
|
|
12594
12657
|
return $EVENT_C(ctx, state, "JSXChild", JSXChild$$);
|
|
12595
12658
|
}
|
|
12596
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
12659
|
+
var JSXComment$0 = $TS($S($EXPECT($L202, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L203, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
12597
12660
|
return ["{/*", $2, "*/}"];
|
|
12598
12661
|
});
|
|
12599
12662
|
function JSXComment(ctx, state) {
|
|
@@ -12725,37 +12788,37 @@ var require_parser = __commonJS({
|
|
|
12725
12788
|
function InterfaceExtendsTarget(ctx, state) {
|
|
12726
12789
|
return $EVENT(ctx, state, "InterfaceExtendsTarget", InterfaceExtendsTarget$0);
|
|
12727
12790
|
}
|
|
12728
|
-
var TypeKeyword$0 = $TS($S($EXPECT($
|
|
12791
|
+
var TypeKeyword$0 = $TS($S($EXPECT($L204, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12729
12792
|
return { $loc, token: $1 };
|
|
12730
12793
|
});
|
|
12731
12794
|
function TypeKeyword(ctx, state) {
|
|
12732
12795
|
return $EVENT(ctx, state, "TypeKeyword", TypeKeyword$0);
|
|
12733
12796
|
}
|
|
12734
|
-
var Enum$0 = $TS($S($EXPECT($
|
|
12797
|
+
var Enum$0 = $TS($S($EXPECT($L205, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12735
12798
|
return { $loc, token: $1 };
|
|
12736
12799
|
});
|
|
12737
12800
|
function Enum(ctx, state) {
|
|
12738
12801
|
return $EVENT(ctx, state, "Enum", Enum$0);
|
|
12739
12802
|
}
|
|
12740
|
-
var Interface$0 = $TS($S($EXPECT($
|
|
12803
|
+
var Interface$0 = $TS($S($EXPECT($L206, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12741
12804
|
return { $loc, token: $1 };
|
|
12742
12805
|
});
|
|
12743
12806
|
function Interface(ctx, state) {
|
|
12744
12807
|
return $EVENT(ctx, state, "Interface", Interface$0);
|
|
12745
12808
|
}
|
|
12746
|
-
var Global$0 = $TS($S($EXPECT($
|
|
12809
|
+
var Global$0 = $TS($S($EXPECT($L207, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12747
12810
|
return { $loc, token: $1 };
|
|
12748
12811
|
});
|
|
12749
12812
|
function Global(ctx, state) {
|
|
12750
12813
|
return $EVENT(ctx, state, "Global", Global$0);
|
|
12751
12814
|
}
|
|
12752
|
-
var Module$0 = $TS($S($EXPECT($
|
|
12815
|
+
var Module$0 = $TS($S($EXPECT($L208, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12753
12816
|
return { $loc, token: $1 };
|
|
12754
12817
|
});
|
|
12755
12818
|
function Module(ctx, state) {
|
|
12756
12819
|
return $EVENT(ctx, state, "Module", Module$0);
|
|
12757
12820
|
}
|
|
12758
|
-
var Namespace$0 = $TS($S($EXPECT($
|
|
12821
|
+
var Namespace$0 = $TS($S($EXPECT($L209, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12759
12822
|
return { $loc, token: $1 };
|
|
12760
12823
|
});
|
|
12761
12824
|
function Namespace(ctx, state) {
|
|
@@ -13028,7 +13091,7 @@ var require_parser = __commonJS({
|
|
|
13028
13091
|
function ReturnTypeSuffix(ctx, state) {
|
|
13029
13092
|
return $EVENT(ctx, state, "ReturnTypeSuffix", ReturnTypeSuffix$0);
|
|
13030
13093
|
}
|
|
13031
|
-
var ReturnType$0 = $TS($S($E($S(__, $EXPECT($
|
|
13094
|
+
var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L210, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
|
|
13032
13095
|
var asserts = $1;
|
|
13033
13096
|
var t = $2;
|
|
13034
13097
|
if (asserts) {
|
|
@@ -13049,7 +13112,7 @@ var require_parser = __commonJS({
|
|
|
13049
13112
|
function ReturnType(ctx, state) {
|
|
13050
13113
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
13051
13114
|
}
|
|
13052
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
13115
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L155, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
13053
13116
|
var lhs = $1;
|
|
13054
13117
|
var rhs = $2;
|
|
13055
13118
|
if (!rhs)
|
|
@@ -13107,9 +13170,9 @@ var require_parser = __commonJS({
|
|
|
13107
13170
|
function TypeUnarySuffix(ctx, state) {
|
|
13108
13171
|
return $EVENT_C(ctx, state, "TypeUnarySuffix", TypeUnarySuffix$$);
|
|
13109
13172
|
}
|
|
13110
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
13111
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
13112
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
13173
|
+
var TypeUnaryOp$0 = $S($EXPECT($L211, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
13174
|
+
var TypeUnaryOp$1 = $S($EXPECT($L212, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
13175
|
+
var TypeUnaryOp$2 = $S($EXPECT($L172, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
13113
13176
|
var TypeUnaryOp$$ = [TypeUnaryOp$0, TypeUnaryOp$1, TypeUnaryOp$2];
|
|
13114
13177
|
function TypeUnaryOp(ctx, state) {
|
|
13115
13178
|
return $EVENT_C(ctx, state, "TypeUnaryOp", TypeUnaryOp$$);
|
|
@@ -13139,7 +13202,7 @@ var require_parser = __commonJS({
|
|
|
13139
13202
|
function TypeIndexedAccess(ctx, state) {
|
|
13140
13203
|
return $EVENT_C(ctx, state, "TypeIndexedAccess", TypeIndexedAccess$$);
|
|
13141
13204
|
}
|
|
13142
|
-
var UnknownAlias$0 = $TV($EXPECT($
|
|
13205
|
+
var UnknownAlias$0 = $TV($EXPECT($L213, 'UnknownAlias "???"'), function($skip, $loc, $0, $1) {
|
|
13143
13206
|
return { $loc, token: "unknown" };
|
|
13144
13207
|
});
|
|
13145
13208
|
function UnknownAlias(ctx, state) {
|
|
@@ -13348,10 +13411,10 @@ var require_parser = __commonJS({
|
|
|
13348
13411
|
}
|
|
13349
13412
|
var TypeLiteral$0 = TypeTemplateLiteral;
|
|
13350
13413
|
var TypeLiteral$1 = Literal;
|
|
13351
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
13414
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L194, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13352
13415
|
return { type: "VoidType", $loc, token: $1 };
|
|
13353
13416
|
});
|
|
13354
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
13417
|
+
var TypeLiteral$3 = $TV($EXPECT($L214, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
13355
13418
|
return { $loc, token: "[]" };
|
|
13356
13419
|
});
|
|
13357
13420
|
var TypeLiteral$$ = [TypeLiteral$0, TypeLiteral$1, TypeLiteral$2, TypeLiteral$3];
|
|
@@ -13370,7 +13433,7 @@ var require_parser = __commonJS({
|
|
|
13370
13433
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
13371
13434
|
return value[1];
|
|
13372
13435
|
});
|
|
13373
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L14, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($
|
|
13436
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L14, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L117, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L38, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L29, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
13374
13437
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
13375
13438
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
13376
13439
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
@@ -13434,11 +13497,11 @@ var require_parser = __commonJS({
|
|
|
13434
13497
|
function TypeParameters(ctx, state) {
|
|
13435
13498
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
13436
13499
|
}
|
|
13437
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
13500
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L154, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
13438
13501
|
function TypeParameter(ctx, state) {
|
|
13439
13502
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
13440
13503
|
}
|
|
13441
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
13504
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L143, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
13442
13505
|
function TypeConstraint(ctx, state) {
|
|
13443
13506
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
13444
13507
|
}
|
|
@@ -13477,7 +13540,7 @@ var require_parser = __commonJS({
|
|
|
13477
13540
|
function CivetPrologue(ctx, state) {
|
|
13478
13541
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
13479
13542
|
}
|
|
13480
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
13543
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L215, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R85, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
13481
13544
|
var options = $3;
|
|
13482
13545
|
return {
|
|
13483
13546
|
type: "CivetPrologue",
|
|
@@ -13960,9 +14023,9 @@ var require_parser = __commonJS({
|
|
|
13960
14023
|
preludeVar,
|
|
13961
14024
|
ref,
|
|
13962
14025
|
typeSuffix,
|
|
13963
|
-
" = (lhs, rhs) => ((rhs",
|
|
14026
|
+
" = (lhs, rhs) => (((rhs",
|
|
13964
14027
|
asAny,
|
|
13965
|
-
")?.[Symbol.isConcatSpreadable] ? (lhs",
|
|
14028
|
+
")?.[Symbol.isConcatSpreadable] ?? Array.isArray(rhs)) ? (lhs",
|
|
13966
14029
|
asAny,
|
|
13967
14030
|
").push.apply(lhs, rhs",
|
|
13968
14031
|
asAny,
|
|
@@ -14164,20 +14227,20 @@ var require_parser = __commonJS({
|
|
|
14164
14227
|
function Dedented(ctx, state) {
|
|
14165
14228
|
return $EVENT(ctx, state, "Dedented", Dedented$0);
|
|
14166
14229
|
}
|
|
14167
|
-
var
|
|
14230
|
+
var parser = function() {
|
|
14168
14231
|
const { fail, validate, reset } = Validator();
|
|
14169
14232
|
let ctx = { expectation: "", fail };
|
|
14170
14233
|
return {
|
|
14171
14234
|
parse: (input, options = {}) => {
|
|
14172
14235
|
if (typeof input !== "string")
|
|
14173
14236
|
throw new Error("Input must be a string");
|
|
14174
|
-
const
|
|
14175
|
-
if (!
|
|
14237
|
+
const parser2 = options.startRule != null ? grammar[options.startRule] : Object.values(grammar)[0];
|
|
14238
|
+
if (!parser2)
|
|
14176
14239
|
throw new Error(`Could not find rule with name '${options.startRule}'`);
|
|
14177
14240
|
const filename = options.filename || "<anonymous>";
|
|
14178
14241
|
reset();
|
|
14179
14242
|
Object.assign(ctx, { ...options.events, tokenize: options.tokenize });
|
|
14180
|
-
return validate(input,
|
|
14243
|
+
return validate(input, parser2(ctx, {
|
|
14181
14244
|
input,
|
|
14182
14245
|
pos: 0
|
|
14183
14246
|
}), {
|
|
@@ -14186,8 +14249,8 @@ var require_parser = __commonJS({
|
|
|
14186
14249
|
}
|
|
14187
14250
|
};
|
|
14188
14251
|
}();
|
|
14189
|
-
exports2.default =
|
|
14190
|
-
exports2.parse =
|
|
14252
|
+
exports2.default = parser;
|
|
14253
|
+
exports2.parse = parser.parse;
|
|
14191
14254
|
exports2.Program = Program;
|
|
14192
14255
|
exports2.TopLevelStatements = TopLevelStatements;
|
|
14193
14256
|
exports2.NestedTopLevelStatements = NestedTopLevelStatements;
|
|
@@ -14233,6 +14296,7 @@ var require_parser = __commonJS({
|
|
|
14233
14296
|
exports2.UnaryWithoutParenthesizedAssignmentBody = UnaryWithoutParenthesizedAssignmentBody;
|
|
14234
14297
|
exports2.UnaryPostfix = UnaryPostfix;
|
|
14235
14298
|
exports2.TypePostfix = TypePostfix;
|
|
14299
|
+
exports2.NWTypePostfix = NWTypePostfix;
|
|
14236
14300
|
exports2.UpdateExpression = UpdateExpression;
|
|
14237
14301
|
exports2.UpdateExpressionSymbol = UpdateExpressionSymbol;
|
|
14238
14302
|
exports2.AssignmentExpression = AssignmentExpression;
|
|
@@ -14345,6 +14409,7 @@ var require_parser = __commonJS({
|
|
|
14345
14409
|
exports2.OperatorDeclaration = OperatorDeclaration;
|
|
14346
14410
|
exports2.OperatorSignature = OperatorSignature;
|
|
14347
14411
|
exports2.AmpersandBlockRHS = AmpersandBlockRHS;
|
|
14412
|
+
exports2.AmpersandTypeSuffix = AmpersandTypeSuffix;
|
|
14348
14413
|
exports2.AmpersandBlockRHSBody = AmpersandBlockRHSBody;
|
|
14349
14414
|
exports2.ThinArrowFunction = ThinArrowFunction;
|
|
14350
14415
|
exports2.Arrow = Arrow;
|
|
@@ -14401,8 +14466,10 @@ var require_parser = __commonJS({
|
|
|
14401
14466
|
exports2.NestedImplicitPropertyDefinition = NestedImplicitPropertyDefinition;
|
|
14402
14467
|
exports2.NestedPropertyDefinitions = NestedPropertyDefinitions;
|
|
14403
14468
|
exports2.NestedPropertyDefinition = NestedPropertyDefinition;
|
|
14469
|
+
exports2.ImplicitObjectLiteral = ImplicitObjectLiteral;
|
|
14470
|
+
exports2.ImplicitObjectPropertyDelimiter = ImplicitObjectPropertyDelimiter;
|
|
14404
14471
|
exports2.InlineObjectLiteral = InlineObjectLiteral;
|
|
14405
|
-
exports2.
|
|
14472
|
+
exports2.InlineObjectPropertyDelimiter = InlineObjectPropertyDelimiter;
|
|
14406
14473
|
exports2.ObjectPropertyDelimiter = ObjectPropertyDelimiter;
|
|
14407
14474
|
exports2.PropertyDefinition = PropertyDefinition;
|
|
14408
14475
|
exports2.NamedProperty = NamedProperty;
|
|
@@ -14917,7 +14984,7 @@ __export(main_exports, {
|
|
|
14917
14984
|
generate: () => generate_default,
|
|
14918
14985
|
isCompileError: () => isCompileError,
|
|
14919
14986
|
lib: () => lib_exports,
|
|
14920
|
-
parse: () =>
|
|
14987
|
+
parse: () => import_parser.parse,
|
|
14921
14988
|
prune: () => prune2,
|
|
14922
14989
|
util: () => util_exports
|
|
14923
14990
|
});
|
|
@@ -15382,7 +15449,6 @@ var StateCache = class {
|
|
|
15382
15449
|
};
|
|
15383
15450
|
|
|
15384
15451
|
// source/main.civet
|
|
15385
|
-
var { parse: parse2 } = import_parser.default;
|
|
15386
15452
|
var { SourceMap: SourceMap2 } = util_exports;
|
|
15387
15453
|
var uncacheable = /* @__PURE__ */ new Set([
|
|
15388
15454
|
// Meta
|
|
@@ -15444,8 +15510,8 @@ function compile(src, options) {
|
|
|
15444
15510
|
}
|
|
15445
15511
|
let ast;
|
|
15446
15512
|
try {
|
|
15447
|
-
|
|
15448
|
-
ast = prune2(
|
|
15513
|
+
import_parser.parse.config = options.parseOptions || {};
|
|
15514
|
+
ast = prune2((0, import_parser.parse)(src, {
|
|
15449
15515
|
filename,
|
|
15450
15516
|
events
|
|
15451
15517
|
}));
|
|
@@ -15554,7 +15620,7 @@ function makeCache({ hits, trace } = {}) {
|
|
|
15554
15620
|
const key = [tagKey, stateKey, state.pos, ruleName];
|
|
15555
15621
|
stateCache.set(key, result);
|
|
15556
15622
|
}
|
|
15557
|
-
if (
|
|
15623
|
+
if (import_parser.parse.config.verbose && result) {
|
|
15558
15624
|
console.log(`Parsed ${JSON.stringify(state.input.slice(state.pos, result.pos))} [pos ${state.pos}-${result.pos}] as ${ruleName}`);
|
|
15559
15625
|
}
|
|
15560
15626
|
if (trace) {
|
|
@@ -15570,7 +15636,7 @@ var isCompileError = function(err) {
|
|
|
15570
15636
|
return err instanceof Error && //@ts-ignore
|
|
15571
15637
|
[err.message, err.name, err.filename, err.line, err.column, err.offset].every(($1) => $1 !== void 0);
|
|
15572
15638
|
};
|
|
15573
|
-
var main_default = { parse:
|
|
15639
|
+
var main_default = { parse: import_parser.parse, generate: generate_default, util: util_exports, compile, isCompileError };
|
|
15574
15640
|
// Annotate the CommonJS export names for ESM import in node:
|
|
15575
15641
|
0 && (module.exports = {
|
|
15576
15642
|
compile,
|