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