@danielx/civet 0.6.73 → 0.6.74
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 +426 -402
- package/dist/main.js +426 -402
- package/dist/main.mjs +426 -402
- package/package.json +2 -2
package/dist/browser.js
CHANGED
|
@@ -1251,15 +1251,15 @@ var Civet = (() => {
|
|
|
1251
1251
|
}
|
|
1252
1252
|
function insertHoistDec(block, node, dec) {
|
|
1253
1253
|
const { expressions } = block;
|
|
1254
|
-
const index = expressions.findIndex((exp) =>
|
|
1255
|
-
|
|
1254
|
+
const index = expressions.findIndex((exp) => {
|
|
1255
|
+
return exp === node || Array.isArray(exp) && exp[1] === node;
|
|
1256
|
+
});
|
|
1257
|
+
if (index < 0) {
|
|
1256
1258
|
throw new Error("Couldn't find expression in block for hoistable declaration.");
|
|
1257
|
-
if (expressions[index] === node) {
|
|
1258
|
-
expressions.splice(index, 0, ["", dec, ";"]);
|
|
1259
|
-
} else {
|
|
1260
|
-
const indent = expressions[index][0];
|
|
1261
|
-
expressions.splice(index, 0, [indent, dec, ";"]);
|
|
1262
1259
|
}
|
|
1260
|
+
const statement = [expressions[index][0], dec, ";"];
|
|
1261
|
+
expressions[index][0] = "";
|
|
1262
|
+
expressions.splice(index, 0, statement);
|
|
1263
1263
|
addParentPointers(dec, block);
|
|
1264
1264
|
}
|
|
1265
1265
|
function patternAsValue(pattern) {
|
|
@@ -1425,6 +1425,9 @@ var Civet = (() => {
|
|
|
1425
1425
|
function isGeneratorVoidType(t) {
|
|
1426
1426
|
return t?.type === "IdentifierType" && (t.raw === "Iterator" || t.raw === "Generator") && t.args?.types?.length >= 2 && isVoidType(t.args.types[1]);
|
|
1427
1427
|
}
|
|
1428
|
+
function isAsyncGeneratorVoidType(t) {
|
|
1429
|
+
return t?.type === "IdentifierType" && (t.raw === "AsyncIterator" || t.raw === "AsyncGenerator") && t.args?.types?.length >= 2 && isVoidType(t.args.types[1]);
|
|
1430
|
+
}
|
|
1428
1431
|
function isWhitespaceOrEmpty(node) {
|
|
1429
1432
|
if (!node)
|
|
1430
1433
|
return true;
|
|
@@ -1827,6 +1830,7 @@ var Civet = (() => {
|
|
|
1827
1830
|
case "IterationExpression":
|
|
1828
1831
|
case "CallExpression":
|
|
1829
1832
|
case "MemberExpression":
|
|
1833
|
+
case "NewExpression":
|
|
1830
1834
|
case "ParenthesizedExpression":
|
|
1831
1835
|
case "IfExpression":
|
|
1832
1836
|
case "DebuggerExpression":
|
|
@@ -1874,6 +1878,9 @@ var Civet = (() => {
|
|
|
1874
1878
|
}
|
|
1875
1879
|
}
|
|
1876
1880
|
function lastAccessInCallExpression(exp) {
|
|
1881
|
+
if (exp.type === "Identifier") {
|
|
1882
|
+
return exp;
|
|
1883
|
+
}
|
|
1877
1884
|
let children, i;
|
|
1878
1885
|
do {
|
|
1879
1886
|
({ children } = exp);
|
|
@@ -2261,7 +2268,7 @@ var Civet = (() => {
|
|
|
2261
2268
|
const { async, generator, set } = modifier;
|
|
2262
2269
|
const isMethod = f.type === "MethodDefinition";
|
|
2263
2270
|
const isConstructor = isMethod && name === "constructor";
|
|
2264
|
-
const isVoid = isVoidType(returnType2?.t) || async && isPromiseVoidType(returnType2?.t) || !async && generator && isGeneratorVoidType(returnType2?.t);
|
|
2271
|
+
const isVoid = isVoidType(returnType2?.t) || async && (isPromiseVoidType(returnType2?.t) || generator && isAsyncGeneratorVoidType(returnType2?.t)) || !async && generator && isGeneratorVoidType(returnType2?.t);
|
|
2265
2272
|
if (block?.type === "BlockStatement") {
|
|
2266
2273
|
if (isVoid || set || isConstructor) {
|
|
2267
2274
|
if (block.bare && block.implicitlyReturned) {
|
|
@@ -4481,6 +4488,7 @@ ${input.slice(result.pos)}
|
|
|
4481
4488
|
LexicalDeclaration,
|
|
4482
4489
|
ConstAssignment,
|
|
4483
4490
|
LetAssignment,
|
|
4491
|
+
TypeAssignment,
|
|
4484
4492
|
LexicalBinding,
|
|
4485
4493
|
Initializer,
|
|
4486
4494
|
VariableStatement,
|
|
@@ -4756,7 +4764,7 @@ ${input.slice(result.pos)}
|
|
|
4756
4764
|
InlineBasicInterfaceProperty,
|
|
4757
4765
|
InlineInterfacePropertyDelimiter,
|
|
4758
4766
|
TypeBinaryOp,
|
|
4759
|
-
|
|
4767
|
+
TypeFunction,
|
|
4760
4768
|
TypeArrowFunction,
|
|
4761
4769
|
TypeArguments,
|
|
4762
4770
|
TypeArgument,
|
|
@@ -4798,6 +4806,7 @@ ${input.slice(result.pos)}
|
|
|
4798
4806
|
InsertDot,
|
|
4799
4807
|
InsertBreak,
|
|
4800
4808
|
InsertVar,
|
|
4809
|
+
InsertType,
|
|
4801
4810
|
CoffeeBinaryExistentialEnabled,
|
|
4802
4811
|
CoffeeBooleansEnabled,
|
|
4803
4812
|
CoffeeClassesEnabled,
|
|
@@ -4938,108 +4947,109 @@ ${input.slice(result.pos)}
|
|
|
4938
4947
|
var $L111 = $L(":=");
|
|
4939
4948
|
var $L112 = $L("\u2254");
|
|
4940
4949
|
var $L113 = $L(".=");
|
|
4941
|
-
var $L114 = $L("
|
|
4942
|
-
var $L115 = $L("
|
|
4943
|
-
var $L116 = $L("
|
|
4944
|
-
var $L117 = $L("
|
|
4945
|
-
var $L118 = $L("
|
|
4946
|
-
var $L119 = $L("
|
|
4947
|
-
var $L120 = $L("
|
|
4948
|
-
var $L121 = $L("
|
|
4949
|
-
var $L122 = $L("
|
|
4950
|
-
var $L123 = $L("
|
|
4951
|
-
var $L124 = $L("
|
|
4952
|
-
var $L125 = $L("
|
|
4953
|
-
var $L126 = $L("
|
|
4954
|
-
var $L127 = $L("
|
|
4955
|
-
var $L128 = $L("
|
|
4956
|
-
var $L129 = $L("
|
|
4957
|
-
var $L130 = $L("
|
|
4958
|
-
var $L131 = $L("
|
|
4959
|
-
var $L132 = $L("
|
|
4960
|
-
var $L133 = $L("
|
|
4961
|
-
var $L134 = $L("
|
|
4962
|
-
var $L135 = $L("
|
|
4963
|
-
var $L136 = $L("
|
|
4964
|
-
var $L137 = $L("
|
|
4965
|
-
var $L138 = $L("
|
|
4966
|
-
var $L139 = $L(
|
|
4967
|
-
var $L140 = $L("
|
|
4968
|
-
var $L141 = $L("
|
|
4969
|
-
var $L142 = $L("
|
|
4970
|
-
var $L143 = $L("
|
|
4971
|
-
var $L144 = $L("
|
|
4972
|
-
var $L145 = $L("
|
|
4973
|
-
var $L146 = $L("
|
|
4974
|
-
var $L147 = $L("
|
|
4975
|
-
var $L148 = $L("
|
|
4976
|
-
var $L149 = $L("
|
|
4977
|
-
var $L150 = $L("
|
|
4978
|
-
var $L151 = $L("
|
|
4979
|
-
var $L152 = $L("
|
|
4980
|
-
var $L153 = $L("
|
|
4981
|
-
var $L154 = $L("
|
|
4982
|
-
var $L155 = $L("
|
|
4983
|
-
var $L156 = $L("
|
|
4984
|
-
var $L157 = $L("
|
|
4985
|
-
var $L158 = $L("
|
|
4986
|
-
var $L159 = $L("
|
|
4987
|
-
var $L160 = $L("
|
|
4988
|
-
var $L161 = $L("
|
|
4989
|
-
var $L162 = $L("
|
|
4990
|
-
var $L163 = $L("
|
|
4991
|
-
var $L164 = $L("
|
|
4992
|
-
var $L165 = $L("
|
|
4993
|
-
var $L166 = $L("
|
|
4994
|
-
var $L167 = $L("
|
|
4995
|
-
var $L168 = $L("
|
|
4996
|
-
var $L169 = $L("
|
|
4997
|
-
var $L170 = $L("
|
|
4998
|
-
var $L171 = $L("
|
|
4999
|
-
var $L172 = $L("
|
|
5000
|
-
var $L173 = $L("
|
|
5001
|
-
var $L174 = $L("
|
|
5002
|
-
var $L175 = $L("
|
|
5003
|
-
var $L176 = $L("
|
|
5004
|
-
var $L177 = $L("
|
|
5005
|
-
var $L178 = $L("
|
|
5006
|
-
var $L179 = $L("
|
|
5007
|
-
var $L180 = $L("
|
|
5008
|
-
var $L181 = $L("
|
|
5009
|
-
var $L182 = $L("
|
|
5010
|
-
var $L183 = $L("
|
|
5011
|
-
var $L184 = $L("
|
|
5012
|
-
var $L185 = $L(
|
|
5013
|
-
var $L186 = $L("'
|
|
5014
|
-
var $L187 = $L("
|
|
5015
|
-
var $L188 = $L("
|
|
5016
|
-
var $L189 = $L("
|
|
5017
|
-
var $L190 = $L("
|
|
5018
|
-
var $L191 = $L("
|
|
5019
|
-
var $L192 = $L("
|
|
5020
|
-
var $L193 = $L("
|
|
5021
|
-
var $L194 = $L("
|
|
5022
|
-
var $L195 = $L("
|
|
5023
|
-
var $L196 = $L("
|
|
5024
|
-
var $L197 = $L("
|
|
5025
|
-
var $L198 = $L("
|
|
5026
|
-
var $L199 = $L("
|
|
5027
|
-
var $L200 = $L("
|
|
5028
|
-
var $L201 = $L("
|
|
5029
|
-
var $L202 = $L("
|
|
5030
|
-
var $L203 = $L("
|
|
5031
|
-
var $L204 = $L("
|
|
5032
|
-
var $L205 = $L("
|
|
5033
|
-
var $L206 = $L("
|
|
5034
|
-
var $L207 = $L("
|
|
5035
|
-
var $L208 = $L("
|
|
5036
|
-
var $L209 = $L("
|
|
5037
|
-
var $L210 = $L("
|
|
5038
|
-
var $L211 = $L("
|
|
5039
|
-
var $L212 = $L("
|
|
5040
|
-
var $L213 = $L("
|
|
5041
|
-
var $L214 = $L("
|
|
5042
|
-
var $L215 = $L("
|
|
4950
|
+
var $L114 = $L("::=");
|
|
4951
|
+
var $L115 = $L("/*");
|
|
4952
|
+
var $L116 = $L("*/");
|
|
4953
|
+
var $L117 = $L("\\");
|
|
4954
|
+
var $L118 = $L(")");
|
|
4955
|
+
var $L119 = $L("abstract");
|
|
4956
|
+
var $L120 = $L("as");
|
|
4957
|
+
var $L121 = $L("@");
|
|
4958
|
+
var $L122 = $L("@@");
|
|
4959
|
+
var $L123 = $L("async");
|
|
4960
|
+
var $L124 = $L("await");
|
|
4961
|
+
var $L125 = $L("`");
|
|
4962
|
+
var $L126 = $L("by");
|
|
4963
|
+
var $L127 = $L("case");
|
|
4964
|
+
var $L128 = $L("catch");
|
|
4965
|
+
var $L129 = $L("class");
|
|
4966
|
+
var $L130 = $L("#{");
|
|
4967
|
+
var $L131 = $L("declare");
|
|
4968
|
+
var $L132 = $L("default");
|
|
4969
|
+
var $L133 = $L("delete");
|
|
4970
|
+
var $L134 = $L("do");
|
|
4971
|
+
var $L135 = $L("..");
|
|
4972
|
+
var $L136 = $L("\u2025");
|
|
4973
|
+
var $L137 = $L("...");
|
|
4974
|
+
var $L138 = $L("\u2026");
|
|
4975
|
+
var $L139 = $L("::");
|
|
4976
|
+
var $L140 = $L('"');
|
|
4977
|
+
var $L141 = $L("each");
|
|
4978
|
+
var $L142 = $L("else");
|
|
4979
|
+
var $L143 = $L("export");
|
|
4980
|
+
var $L144 = $L("extends");
|
|
4981
|
+
var $L145 = $L("finally");
|
|
4982
|
+
var $L146 = $L("for");
|
|
4983
|
+
var $L147 = $L("from");
|
|
4984
|
+
var $L148 = $L("function");
|
|
4985
|
+
var $L149 = $L("get");
|
|
4986
|
+
var $L150 = $L("set");
|
|
4987
|
+
var $L151 = $L("#");
|
|
4988
|
+
var $L152 = $L("if");
|
|
4989
|
+
var $L153 = $L("in");
|
|
4990
|
+
var $L154 = $L("infer");
|
|
4991
|
+
var $L155 = $L("let");
|
|
4992
|
+
var $L156 = $L("const");
|
|
4993
|
+
var $L157 = $L("is");
|
|
4994
|
+
var $L158 = $L("loop");
|
|
4995
|
+
var $L159 = $L("new");
|
|
4996
|
+
var $L160 = $L("not");
|
|
4997
|
+
var $L161 = $L("of");
|
|
4998
|
+
var $L162 = $L("[");
|
|
4999
|
+
var $L163 = $L("operator");
|
|
5000
|
+
var $L164 = $L("own");
|
|
5001
|
+
var $L165 = $L("public");
|
|
5002
|
+
var $L166 = $L("private");
|
|
5003
|
+
var $L167 = $L("protected");
|
|
5004
|
+
var $L168 = $L("||>");
|
|
5005
|
+
var $L169 = $L("|\u25B7");
|
|
5006
|
+
var $L170 = $L("|>=");
|
|
5007
|
+
var $L171 = $L("\u25B7=");
|
|
5008
|
+
var $L172 = $L("|>");
|
|
5009
|
+
var $L173 = $L("\u25B7");
|
|
5010
|
+
var $L174 = $L("readonly");
|
|
5011
|
+
var $L175 = $L("return");
|
|
5012
|
+
var $L176 = $L("satisfies");
|
|
5013
|
+
var $L177 = $L("'");
|
|
5014
|
+
var $L178 = $L("static");
|
|
5015
|
+
var $L179 = $L("${");
|
|
5016
|
+
var $L180 = $L("super");
|
|
5017
|
+
var $L181 = $L("switch");
|
|
5018
|
+
var $L182 = $L("target");
|
|
5019
|
+
var $L183 = $L("then");
|
|
5020
|
+
var $L184 = $L("this");
|
|
5021
|
+
var $L185 = $L("throw");
|
|
5022
|
+
var $L186 = $L('"""');
|
|
5023
|
+
var $L187 = $L("'''");
|
|
5024
|
+
var $L188 = $L("///");
|
|
5025
|
+
var $L189 = $L("```");
|
|
5026
|
+
var $L190 = $L("try");
|
|
5027
|
+
var $L191 = $L("typeof");
|
|
5028
|
+
var $L192 = $L("unless");
|
|
5029
|
+
var $L193 = $L("until");
|
|
5030
|
+
var $L194 = $L("using");
|
|
5031
|
+
var $L195 = $L("var");
|
|
5032
|
+
var $L196 = $L("void");
|
|
5033
|
+
var $L197 = $L("when");
|
|
5034
|
+
var $L198 = $L("while");
|
|
5035
|
+
var $L199 = $L("yield");
|
|
5036
|
+
var $L200 = $L("/>");
|
|
5037
|
+
var $L201 = $L("</");
|
|
5038
|
+
var $L202 = $L("<>");
|
|
5039
|
+
var $L203 = $L("</>");
|
|
5040
|
+
var $L204 = $L("<!--");
|
|
5041
|
+
var $L205 = $L("-->");
|
|
5042
|
+
var $L206 = $L("type");
|
|
5043
|
+
var $L207 = $L("enum");
|
|
5044
|
+
var $L208 = $L("interface");
|
|
5045
|
+
var $L209 = $L("global");
|
|
5046
|
+
var $L210 = $L("module");
|
|
5047
|
+
var $L211 = $L("namespace");
|
|
5048
|
+
var $L212 = $L("asserts");
|
|
5049
|
+
var $L213 = $L("keyof");
|
|
5050
|
+
var $L214 = $L("???");
|
|
5051
|
+
var $L215 = $L("[]");
|
|
5052
|
+
var $L216 = $L("civet");
|
|
5043
5053
|
var $R0 = $R(new RegExp("(?=debugger|if|unless|do|for|loop|until|while|switch|throw|try)", "suy"));
|
|
5044
5054
|
var $R1 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
5045
5055
|
var $R2 = $R(new RegExp("[0-9]", "suy"));
|
|
@@ -5057,70 +5067,70 @@ ${input.slice(result.pos)}
|
|
|
5057
5067
|
var $R14 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
5058
5068
|
var $R15 = $R(new RegExp("(?=\\[)", "suy"));
|
|
5059
5069
|
var $R16 = $R(new RegExp("[!+-]", "suy"));
|
|
5060
|
-
var $R17 = $R(new RegExp("
|
|
5061
|
-
var $R18 = $R(new RegExp("
|
|
5062
|
-
var $R19 = $R(new RegExp("
|
|
5063
|
-
var $R20 = $R(new RegExp("[
|
|
5064
|
-
var $R21 = $R(new RegExp("
|
|
5065
|
-
var $R22 = $R(new RegExp("(?=loop|
|
|
5066
|
-
var $R23 = $R(new RegExp("(?=
|
|
5067
|
-
var $R24 = $R(new RegExp(
|
|
5068
|
-
var $R25 = $R(new RegExp("
|
|
5069
|
-
var $R26 = $R(new RegExp("(
|
|
5070
|
-
var $R27 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)
|
|
5071
|
-
var $R28 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(
|
|
5072
|
-
var $R29 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
5073
|
-
var $R30 = $R(new RegExp("(
|
|
5074
|
-
var $R31 = $R(new RegExp("
|
|
5075
|
-
var $R32 = $R(new RegExp("0[
|
|
5076
|
-
var $R33 = $R(new RegExp("0[
|
|
5077
|
-
var $R34 = $R(new RegExp("(
|
|
5078
|
-
var $R35 = $R(new RegExp("(
|
|
5079
|
-
var $R36 = $R(new RegExp(
|
|
5080
|
-
var $R37 = $R(new RegExp(
|
|
5081
|
-
var $R38 = $R(new RegExp(
|
|
5082
|
-
var $R39 = $R(new RegExp(
|
|
5083
|
-
var $R40 = $R(new RegExp('(
|
|
5084
|
-
var $R41 = $R(new RegExp(
|
|
5085
|
-
var $R42 = $R(new RegExp("(
|
|
5086
|
-
var $R43 = $R(new RegExp("
|
|
5087
|
-
var $R44 = $R(new RegExp("
|
|
5088
|
-
var $R45 = $R(new RegExp("
|
|
5089
|
-
var $R46 = $R(new RegExp("[
|
|
5090
|
-
var $R47 = $R(new RegExp("
|
|
5091
|
-
var $R48 = $R(new RegExp("(
|
|
5092
|
-
var $R49 = $R(new RegExp("(
|
|
5093
|
-
var $R50 = $R(new RegExp("(
|
|
5094
|
-
var $R51 = $R(new RegExp("(?:\\$(?!\\{)
|
|
5095
|
-
var $R52 = $R(new RegExp("(
|
|
5096
|
-
var $R53 = $R(new RegExp("(?:
|
|
5097
|
-
var $R54 = $R(new RegExp("(?:
|
|
5098
|
-
var $R55 = $R(new RegExp("(?:
|
|
5099
|
-
var $R56 = $R(new RegExp("(?:
|
|
5100
|
-
var $R57 = $R(new RegExp("(
|
|
5101
|
-
var $R58 = $R(new RegExp("
|
|
5102
|
-
var $R59 = $R(new RegExp("
|
|
5103
|
-
var $R60 = $R(new RegExp("
|
|
5104
|
-
var $R61 = $R(new RegExp("[
|
|
5105
|
-
var $R62 = $R(new RegExp("
|
|
5106
|
-
var $R63 = $R(new RegExp("
|
|
5107
|
-
var $R64 = $R(new RegExp("(
|
|
5108
|
-
var $R65 = $R(new RegExp("[ \\t]
|
|
5109
|
-
var $R66 = $R(new RegExp("
|
|
5110
|
-
var $R67 = $R(new RegExp("(
|
|
5111
|
-
var $R68 = $R(new RegExp("
|
|
5112
|
-
var $R69 = $R(new RegExp("
|
|
5113
|
-
var $R70 = $R(new RegExp("
|
|
5114
|
-
var $R71 = $R(new RegExp("(
|
|
5115
|
-
var $R72 = $R(new RegExp("[\\
|
|
5116
|
-
var $R73 = $R(new RegExp("
|
|
5117
|
-
var $R74 = $R(new RegExp(
|
|
5118
|
-
var $R75 = $R(new RegExp("[
|
|
5119
|
-
var $R76 = $R(new RegExp("[
|
|
5120
|
-
var $R77 = $R(new RegExp("
|
|
5121
|
-
var $R78 = $R(new RegExp("[
|
|
5122
|
-
var $R79 = $R(new RegExp("[
|
|
5123
|
-
var $R80 = $R(new RegExp("[+-]", "suy"));
|
|
5070
|
+
var $R17 = $R(new RegExp("[+-]", "suy"));
|
|
5071
|
+
var $R18 = $R(new RegExp("(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>\u29FA+-])", "suy"));
|
|
5072
|
+
var $R19 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
5073
|
+
var $R20 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s)", "suy"));
|
|
5074
|
+
var $R21 = $R(new RegExp("[:.]", "suy"));
|
|
5075
|
+
var $R22 = $R(new RegExp("(?=for|if|loop|unless|until|while)", "suy"));
|
|
5076
|
+
var $R23 = $R(new RegExp("(?=loop|do|for|until|while)", "suy"));
|
|
5077
|
+
var $R24 = $R(new RegExp("(?=[\\s\\),])", "suy"));
|
|
5078
|
+
var $R25 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
5079
|
+
var $R26 = $R(new RegExp("(?=[0-9.])", "suy"));
|
|
5080
|
+
var $R27 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
5081
|
+
var $R28 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
5082
|
+
var $R29 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
5083
|
+
var $R30 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
5084
|
+
var $R31 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
5085
|
+
var $R32 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
5086
|
+
var $R33 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
5087
|
+
var $R34 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
5088
|
+
var $R35 = $R(new RegExp("(?=[0-9])", "suy"));
|
|
5089
|
+
var $R36 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
5090
|
+
var $R37 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
5091
|
+
var $R38 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
5092
|
+
var $R39 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
5093
|
+
var $R40 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
5094
|
+
var $R41 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
5095
|
+
var $R42 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
5096
|
+
var $R43 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
5097
|
+
var $R44 = $R(new RegExp("[\\s]+", "suy"));
|
|
5098
|
+
var $R45 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
5099
|
+
var $R46 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
5100
|
+
var $R47 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
5101
|
+
var $R48 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
5102
|
+
var $R49 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
5103
|
+
var $R50 = $R(new RegExp("(?=[`'\"])", "suy"));
|
|
5104
|
+
var $R51 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
5105
|
+
var $R52 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
5106
|
+
var $R53 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
5107
|
+
var $R54 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
5108
|
+
var $R55 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
5109
|
+
var $R56 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
5110
|
+
var $R57 = $R(new RegExp("(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
5111
|
+
var $R58 = $R(new RegExp("(?=\\/|#)", "suy"));
|
|
5112
|
+
var $R59 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
5113
|
+
var $R60 = $R(new RegExp(".", "suy"));
|
|
5114
|
+
var $R61 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
5115
|
+
var $R62 = $R(new RegExp("[^]*?###", "suy"));
|
|
5116
|
+
var $R63 = $R(new RegExp("###(?!#)", "suy"));
|
|
5117
|
+
var $R64 = $R(new RegExp("\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\/", "suy"));
|
|
5118
|
+
var $R65 = $R(new RegExp("(?=[ \\t\\/\\\\])", "suy"));
|
|
5119
|
+
var $R66 = $R(new RegExp("[ \\t]+", "suy"));
|
|
5120
|
+
var $R67 = $R(new RegExp("(?=\\s|\\/|#)", "suy"));
|
|
5121
|
+
var $R68 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
5122
|
+
var $R69 = $R(new RegExp("['\u2019]s", "suy"));
|
|
5123
|
+
var $R70 = $R(new RegExp("\\s", "suy"));
|
|
5124
|
+
var $R71 = $R(new RegExp("(?=[<])", "suy"));
|
|
5125
|
+
var $R72 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
5126
|
+
var $R73 = $R(new RegExp("[\\s>]|\\/>", "suy"));
|
|
5127
|
+
var $R74 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
5128
|
+
var $R75 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
|
|
5129
|
+
var $R76 = $R(new RegExp("[<>]", "suy"));
|
|
5130
|
+
var $R77 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
5131
|
+
var $R78 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
5132
|
+
var $R79 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
5133
|
+
var $R80 = $R(new RegExp("[+-]?", "suy"));
|
|
5124
5134
|
var $R81 = $R(new RegExp("(?=if|unless)", "suy"));
|
|
5125
5135
|
var $R82 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
5126
5136
|
var $R83 = $R(new RegExp("[\\t ]*", "suy"));
|
|
@@ -6269,7 +6279,14 @@ ${input.slice(result.pos)}
|
|
|
6269
6279
|
function AtThis(ctx, state) {
|
|
6270
6280
|
return $EVENT(ctx, state, "AtThis", AtThis$0);
|
|
6271
6281
|
}
|
|
6272
|
-
var LeftHandSideExpression$0 = $S($P($S(New, $N($C($EXPECT($L7, 'LeftHandSideExpression "."'), $EXPECT($L14, 'LeftHandSideExpression ":"'))), __)), CallExpression)
|
|
6282
|
+
var LeftHandSideExpression$0 = $TS($S($P($S(New, $N($C($EXPECT($L7, 'LeftHandSideExpression "."'), $EXPECT($L14, 'LeftHandSideExpression ":"'))), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
6283
|
+
var expression = $2;
|
|
6284
|
+
return {
|
|
6285
|
+
type: "NewExpression",
|
|
6286
|
+
children: $0,
|
|
6287
|
+
expression
|
|
6288
|
+
};
|
|
6289
|
+
});
|
|
6273
6290
|
var LeftHandSideExpression$1 = CallExpression;
|
|
6274
6291
|
var LeftHandSideExpression$$ = [LeftHandSideExpression$0, LeftHandSideExpression$1];
|
|
6275
6292
|
function LeftHandSideExpression(ctx, state) {
|
|
@@ -7362,22 +7379,7 @@ ${input.slice(result.pos)}
|
|
|
7362
7379
|
};
|
|
7363
7380
|
});
|
|
7364
7381
|
var FunctionExpression$5 = AmpersandFunctionExpression;
|
|
7365
|
-
var FunctionExpression
|
|
7366
|
-
var id = $1;
|
|
7367
|
-
var ws = $4;
|
|
7368
|
-
var fn = $5;
|
|
7369
|
-
return {
|
|
7370
|
-
...fn,
|
|
7371
|
-
id,
|
|
7372
|
-
children: [
|
|
7373
|
-
...fn.children.slice(0, 3),
|
|
7374
|
-
insertTrimmingSpace(ws, " "),
|
|
7375
|
-
id,
|
|
7376
|
-
...fn.children.slice(3)
|
|
7377
|
-
]
|
|
7378
|
-
};
|
|
7379
|
-
});
|
|
7380
|
-
var FunctionExpression$$ = [FunctionExpression$0, FunctionExpression$1, FunctionExpression$2, FunctionExpression$3, FunctionExpression$4, FunctionExpression$5, FunctionExpression$6];
|
|
7382
|
+
var FunctionExpression$$ = [FunctionExpression$0, FunctionExpression$1, FunctionExpression$2, FunctionExpression$3, FunctionExpression$4, FunctionExpression$5];
|
|
7381
7383
|
function FunctionExpression(ctx, state) {
|
|
7382
7384
|
return $EVENT_C(ctx, state, "FunctionExpression", FunctionExpression$$);
|
|
7383
7385
|
}
|
|
@@ -8502,22 +8504,26 @@ ${input.slice(result.pos)}
|
|
|
8502
8504
|
value: exp
|
|
8503
8505
|
};
|
|
8504
8506
|
});
|
|
8505
|
-
var PropertyDefinition$4 = $TS($S($E(_), $N(EOS), CallExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
8507
|
+
var PropertyDefinition$4 = $TS($S($E(_), $N(EOS), $Q(UnaryOp), CallExpression, $E(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
8506
8508
|
var ws = $1;
|
|
8507
|
-
var
|
|
8508
|
-
|
|
8509
|
-
|
|
8510
|
-
|
|
8511
|
-
|
|
8512
|
-
|
|
8513
|
-
|
|
8514
|
-
|
|
8515
|
-
|
|
8516
|
-
|
|
8517
|
-
|
|
8518
|
-
|
|
8519
|
-
|
|
8520
|
-
|
|
8509
|
+
var pre = $3;
|
|
8510
|
+
var value = $4;
|
|
8511
|
+
var post = $5;
|
|
8512
|
+
if (!pre.length && !post) {
|
|
8513
|
+
switch (value.type) {
|
|
8514
|
+
case "Identifier":
|
|
8515
|
+
return { ...value, children: [ws, ...value.children] };
|
|
8516
|
+
case "ObjectExpression":
|
|
8517
|
+
let first = value.properties[0];
|
|
8518
|
+
if (first) {
|
|
8519
|
+
first = {
|
|
8520
|
+
...first,
|
|
8521
|
+
children: [ws, ...first.children],
|
|
8522
|
+
hoistDec: value.hoistDec
|
|
8523
|
+
};
|
|
8524
|
+
}
|
|
8525
|
+
return [first, ...value.properties.slice(1)];
|
|
8526
|
+
}
|
|
8521
8527
|
}
|
|
8522
8528
|
const last = lastAccessInCallExpression(value);
|
|
8523
8529
|
if (!last)
|
|
@@ -8565,7 +8571,7 @@ ${input.slice(result.pos)}
|
|
|
8565
8571
|
name = name.slice(1);
|
|
8566
8572
|
return {
|
|
8567
8573
|
type: "Property",
|
|
8568
|
-
children: [ws, name, ": ", value],
|
|
8574
|
+
children: [ws, name, ": ", processUnaryExpression(pre, value, post)],
|
|
8569
8575
|
name,
|
|
8570
8576
|
names: [],
|
|
8571
8577
|
value,
|
|
@@ -8634,7 +8640,7 @@ ${input.slice(result.pos)}
|
|
|
8634
8640
|
implicit: true
|
|
8635
8641
|
};
|
|
8636
8642
|
});
|
|
8637
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
8643
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($R17, "ComputedPropertyName /[+-]/"), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8638
8644
|
const expression = [$2, $3];
|
|
8639
8645
|
return {
|
|
8640
8646
|
type: "ComputedPropertyName",
|
|
@@ -8672,7 +8678,7 @@ ${input.slice(result.pos)}
|
|
|
8672
8678
|
ts: true
|
|
8673
8679
|
};
|
|
8674
8680
|
});
|
|
8675
|
-
var MethodDefinition$1 = $TS($S(MethodSignature, $N(PropertyAccess), $E(BracedBlock)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8681
|
+
var MethodDefinition$1 = $TS($S(MethodSignature, $N($C(PropertyAccess, UnaryPostfix)), $E(BracedBlock)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8676
8682
|
var signature = $1;
|
|
8677
8683
|
var block = $3;
|
|
8678
8684
|
let children = $0;
|
|
@@ -9012,7 +9018,7 @@ ${input.slice(result.pos)}
|
|
|
9012
9018
|
function IdentifierBinaryOp(ctx, state) {
|
|
9013
9019
|
return $EVENT(ctx, state, "IdentifierBinaryOp", IdentifierBinaryOp$0);
|
|
9014
9020
|
}
|
|
9015
|
-
var BinaryOp$0 = $T($S($EXPECT($
|
|
9021
|
+
var BinaryOp$0 = $T($S($EXPECT($R18, "BinaryOp /(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>\u29FA+-])/"), _BinaryOp), function(value) {
|
|
9016
9022
|
var op = value[1];
|
|
9017
9023
|
return op;
|
|
9018
9024
|
});
|
|
@@ -9144,7 +9150,7 @@ ${input.slice(result.pos)}
|
|
|
9144
9150
|
special: true
|
|
9145
9151
|
};
|
|
9146
9152
|
});
|
|
9147
|
-
var BinaryOpSymbol$35 = $TV($C($EXPECT($
|
|
9153
|
+
var BinaryOpSymbol$35 = $TV($C($EXPECT($R19, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L93, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
9148
9154
|
return {
|
|
9149
9155
|
call: module.getRef("xnor"),
|
|
9150
9156
|
special: true
|
|
@@ -9297,18 +9303,18 @@ ${input.slice(result.pos)}
|
|
|
9297
9303
|
function Xor(ctx, state) {
|
|
9298
9304
|
return $EVENT_C(ctx, state, "Xor", Xor$$);
|
|
9299
9305
|
}
|
|
9300
|
-
var Xnor$0 = $R$0($EXPECT($
|
|
9306
|
+
var Xnor$0 = $R$0($EXPECT($R19, "Xnor /!\\^\\^?/"));
|
|
9301
9307
|
var Xnor$1 = $EXPECT($L93, 'Xnor "xnor"');
|
|
9302
9308
|
var Xnor$$ = [Xnor$0, Xnor$1];
|
|
9303
9309
|
function Xnor(ctx, state) {
|
|
9304
9310
|
return $EVENT_C(ctx, state, "Xnor", Xnor$$);
|
|
9305
9311
|
}
|
|
9306
|
-
var UnaryOp$0 = $TR($EXPECT($
|
|
9312
|
+
var UnaryOp$0 = $TR($EXPECT($R20, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9307
9313
|
return { $loc, token: $0 };
|
|
9308
9314
|
});
|
|
9309
9315
|
var UnaryOp$1 = AwaitOp;
|
|
9310
|
-
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($R$0($EXPECT($
|
|
9311
|
-
var UnaryOp$3 = $T($S(Not, $N($EXPECT($
|
|
9316
|
+
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($R$0($EXPECT($R21, "UnaryOp /[:.]/"))), $E(_));
|
|
9317
|
+
var UnaryOp$3 = $T($S(Not, $N($EXPECT($R21, "UnaryOp /[:.]/")), $E($EXPECT($L15, 'UnaryOp " "')), $E(_)), function(value) {
|
|
9312
9318
|
return [value[0], value[3]];
|
|
9313
9319
|
});
|
|
9314
9320
|
var UnaryOp$$ = [UnaryOp$0, UnaryOp$1, UnaryOp$2, UnaryOp$3];
|
|
@@ -9406,7 +9412,7 @@ ${input.slice(result.pos)}
|
|
|
9406
9412
|
function NonPipelinePostfixedExpression(ctx, state) {
|
|
9407
9413
|
return $EVENT(ctx, state, "NonPipelinePostfixedExpression", NonPipelinePostfixedExpression$0);
|
|
9408
9414
|
}
|
|
9409
|
-
var PostfixStatement$0 = $T($S($EXPECT($
|
|
9415
|
+
var PostfixStatement$0 = $T($S($EXPECT($R22, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
|
|
9410
9416
|
return value[1];
|
|
9411
9417
|
});
|
|
9412
9418
|
function PostfixStatement(ctx, state) {
|
|
@@ -9653,7 +9659,7 @@ ${input.slice(result.pos)}
|
|
|
9653
9659
|
function BlockExpressionPart(ctx, state) {
|
|
9654
9660
|
return $EVENT(ctx, state, "BlockExpressionPart", BlockExpressionPart$0);
|
|
9655
9661
|
}
|
|
9656
|
-
var IterationStatement$0 = $T($S($EXPECT($
|
|
9662
|
+
var IterationStatement$0 = $T($S($EXPECT($R23, "IterationStatement /(?=loop|do|for|until|while)/"), _IterationStatement), function(value) {
|
|
9657
9663
|
return value[1];
|
|
9658
9664
|
});
|
|
9659
9665
|
function IterationStatement(ctx, state) {
|
|
@@ -10006,7 +10012,7 @@ ${input.slice(result.pos)}
|
|
|
10006
10012
|
names: binding.names
|
|
10007
10013
|
};
|
|
10008
10014
|
});
|
|
10009
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
10015
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R24, "ForDeclaration /(?=[\\s\\),])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
10010
10016
|
var c = $1;
|
|
10011
10017
|
var binding = $2;
|
|
10012
10018
|
return {
|
|
@@ -10827,7 +10833,7 @@ ${input.slice(result.pos)}
|
|
|
10827
10833
|
function UnprocessedModuleSpecifier(ctx, state) {
|
|
10828
10834
|
return $EVENT_C(ctx, state, "UnprocessedModuleSpecifier", UnprocessedModuleSpecifier$$);
|
|
10829
10835
|
}
|
|
10830
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
10836
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R25, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
10831
10837
|
var spec = $0;
|
|
10832
10838
|
return { $loc, token: `"${spec}"` };
|
|
10833
10839
|
});
|
|
@@ -10980,16 +10986,10 @@ ${input.slice(result.pos)}
|
|
|
10980
10986
|
thisAssignments: bindings.flatMap((b) => b.thisAssignments)
|
|
10981
10987
|
};
|
|
10982
10988
|
});
|
|
10983
|
-
var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment,
|
|
10989
|
+
var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, PostfixedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
10984
10990
|
return processAssignmentDeclaration(...$0);
|
|
10985
10991
|
});
|
|
10986
|
-
var LexicalDeclaration$2 = $TS($S(InsertLet, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, LetAssignment,
|
|
10987
|
-
var l = $1;
|
|
10988
|
-
var id = $2;
|
|
10989
|
-
var suffix = $3;
|
|
10990
|
-
var ws = $4;
|
|
10991
|
-
var la = $5;
|
|
10992
|
-
var e = $6;
|
|
10992
|
+
var LexicalDeclaration$2 = $TS($S(InsertLet, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, LetAssignment, PostfixedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
10993
10993
|
return processAssignmentDeclaration(...$0);
|
|
10994
10994
|
});
|
|
10995
10995
|
var LexicalDeclaration$$ = [LexicalDeclaration$0, LexicalDeclaration$1, LexicalDeclaration$2];
|
|
@@ -11008,6 +11008,12 @@ ${input.slice(result.pos)}
|
|
|
11008
11008
|
function LetAssignment(ctx, state) {
|
|
11009
11009
|
return $EVENT(ctx, state, "LetAssignment", LetAssignment$0);
|
|
11010
11010
|
}
|
|
11011
|
+
var TypeAssignment$0 = $TV($EXPECT($L114, 'TypeAssignment "::="'), function($skip, $loc, $0, $1) {
|
|
11012
|
+
return { $loc, token: "=" };
|
|
11013
|
+
});
|
|
11014
|
+
function TypeAssignment(ctx, state) {
|
|
11015
|
+
return $EVENT(ctx, state, "TypeAssignment", TypeAssignment$0);
|
|
11016
|
+
}
|
|
11011
11017
|
var LexicalBinding$0 = $TS($S(BindingPattern, $E(TypeSuffix), Initializer), function($skip, $loc, $0, $1, $2, $3) {
|
|
11012
11018
|
var pattern = $1;
|
|
11013
11019
|
var suffix = $2;
|
|
@@ -11071,7 +11077,7 @@ ${input.slice(result.pos)}
|
|
|
11071
11077
|
function VariableDeclarationList(ctx, state) {
|
|
11072
11078
|
return $EVENT(ctx, state, "VariableDeclarationList", VariableDeclarationList$0);
|
|
11073
11079
|
}
|
|
11074
|
-
var NumericLiteral$0 = $TS($S($EXPECT($
|
|
11080
|
+
var NumericLiteral$0 = $TS($S($EXPECT($R26, "NumericLiteral /(?=[0-9.])/"), NumericLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
11075
11081
|
var token = $2;
|
|
11076
11082
|
return { type: "NumericLiteral", $loc, token };
|
|
11077
11083
|
});
|
|
@@ -11087,36 +11093,36 @@ ${input.slice(result.pos)}
|
|
|
11087
11093
|
function NumericLiteralKind(ctx, state) {
|
|
11088
11094
|
return $EVENT_C(ctx, state, "NumericLiteralKind", NumericLiteralKind$$);
|
|
11089
11095
|
}
|
|
11090
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
11096
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R27, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
11091
11097
|
function DecimalBigIntegerLiteral(ctx, state) {
|
|
11092
11098
|
return $EVENT(ctx, state, "DecimalBigIntegerLiteral", DecimalBigIntegerLiteral$0);
|
|
11093
11099
|
}
|
|
11094
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
11100
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R28, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
11095
11101
|
return $1 + ".";
|
|
11096
11102
|
});
|
|
11097
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
11098
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
11103
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R29, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
11104
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R30, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
11099
11105
|
var DecimalLiteral$$ = [DecimalLiteral$0, DecimalLiteral$1, DecimalLiteral$2];
|
|
11100
11106
|
function DecimalLiteral(ctx, state) {
|
|
11101
11107
|
return $EVENT_C(ctx, state, "DecimalLiteral", DecimalLiteral$$);
|
|
11102
11108
|
}
|
|
11103
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
11109
|
+
var ExponentPart$0 = $R$0($EXPECT($R31, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
11104
11110
|
function ExponentPart(ctx, state) {
|
|
11105
11111
|
return $EVENT(ctx, state, "ExponentPart", ExponentPart$0);
|
|
11106
11112
|
}
|
|
11107
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
11113
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R32, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
11108
11114
|
function BinaryIntegerLiteral(ctx, state) {
|
|
11109
11115
|
return $EVENT(ctx, state, "BinaryIntegerLiteral", BinaryIntegerLiteral$0);
|
|
11110
11116
|
}
|
|
11111
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11117
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R33, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
11112
11118
|
function OctalIntegerLiteral(ctx, state) {
|
|
11113
11119
|
return $EVENT(ctx, state, "OctalIntegerLiteral", OctalIntegerLiteral$0);
|
|
11114
11120
|
}
|
|
11115
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
11121
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R34, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
11116
11122
|
function HexIntegerLiteral(ctx, state) {
|
|
11117
11123
|
return $EVENT(ctx, state, "HexIntegerLiteral", HexIntegerLiteral$0);
|
|
11118
11124
|
}
|
|
11119
|
-
var IntegerLiteral$0 = $TS($S($EXPECT($
|
|
11125
|
+
var IntegerLiteral$0 = $TS($S($EXPECT($R35, "IntegerLiteral /(?=[0-9])/"), IntegerLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
11120
11126
|
var token = $2;
|
|
11121
11127
|
return { $loc, token };
|
|
11122
11128
|
});
|
|
@@ -11132,7 +11138,7 @@ ${input.slice(result.pos)}
|
|
|
11132
11138
|
function IntegerLiteralKind(ctx, state) {
|
|
11133
11139
|
return $EVENT_C(ctx, state, "IntegerLiteralKind", IntegerLiteralKind$$);
|
|
11134
11140
|
}
|
|
11135
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
11141
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R36, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
11136
11142
|
function DecimalIntegerLiteral(ctx, state) {
|
|
11137
11143
|
return $EVENT(ctx, state, "DecimalIntegerLiteral", DecimalIntegerLiteral$0);
|
|
11138
11144
|
}
|
|
@@ -11156,25 +11162,25 @@ ${input.slice(result.pos)}
|
|
|
11156
11162
|
function StringLiteral(ctx, state) {
|
|
11157
11163
|
return $EVENT_C(ctx, state, "StringLiteral", StringLiteral$$);
|
|
11158
11164
|
}
|
|
11159
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
11165
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R37, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11160
11166
|
return { $loc, token: $0 };
|
|
11161
11167
|
});
|
|
11162
11168
|
function DoubleStringCharacters(ctx, state) {
|
|
11163
11169
|
return $EVENT(ctx, state, "DoubleStringCharacters", DoubleStringCharacters$0);
|
|
11164
11170
|
}
|
|
11165
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
11171
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R38, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11166
11172
|
return { $loc, token: $0 };
|
|
11167
11173
|
});
|
|
11168
11174
|
function SingleStringCharacters(ctx, state) {
|
|
11169
11175
|
return $EVENT(ctx, state, "SingleStringCharacters", SingleStringCharacters$0);
|
|
11170
11176
|
}
|
|
11171
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
11177
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R39, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11172
11178
|
return { $loc, token: $0 };
|
|
11173
11179
|
});
|
|
11174
11180
|
function TripleDoubleStringCharacters(ctx, state) {
|
|
11175
11181
|
return $EVENT(ctx, state, "TripleDoubleStringCharacters", TripleDoubleStringCharacters$0);
|
|
11176
11182
|
}
|
|
11177
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
11183
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R40, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11178
11184
|
return { $loc, token: $0 };
|
|
11179
11185
|
});
|
|
11180
11186
|
function TripleSingleStringCharacters(ctx, state) {
|
|
@@ -11193,7 +11199,7 @@ ${input.slice(result.pos)}
|
|
|
11193
11199
|
function CoffeeInterpolatedDoubleQuotedString(ctx, state) {
|
|
11194
11200
|
return $EVENT(ctx, state, "CoffeeInterpolatedDoubleQuotedString", CoffeeInterpolatedDoubleQuotedString$0);
|
|
11195
11201
|
}
|
|
11196
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
11202
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R41, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11197
11203
|
return { $loc, token: $0 };
|
|
11198
11204
|
});
|
|
11199
11205
|
function CoffeeDoubleQuotedStringCharacters(ctx, state) {
|
|
@@ -11213,7 +11219,7 @@ ${input.slice(result.pos)}
|
|
|
11213
11219
|
function RegularExpressionClass(ctx, state) {
|
|
11214
11220
|
return $EVENT(ctx, state, "RegularExpressionClass", RegularExpressionClass$0);
|
|
11215
11221
|
}
|
|
11216
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
11222
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R42, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11217
11223
|
return { $loc, token: $0 };
|
|
11218
11224
|
});
|
|
11219
11225
|
function RegularExpressionClassCharacters(ctx, state) {
|
|
@@ -11270,7 +11276,7 @@ ${input.slice(result.pos)}
|
|
|
11270
11276
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
11271
11277
|
return { "type": "Substitution", "children": value[0] };
|
|
11272
11278
|
});
|
|
11273
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
11279
|
+
var HeregexPart$3 = $TR($EXPECT($R43, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11274
11280
|
let token = $0;
|
|
11275
11281
|
switch ($0[1]) {
|
|
11276
11282
|
case "\n":
|
|
@@ -11288,13 +11294,13 @@ ${input.slice(result.pos)}
|
|
|
11288
11294
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
11289
11295
|
return { $loc, token: "" };
|
|
11290
11296
|
});
|
|
11291
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
11297
|
+
var HeregexPart$5 = $TR($EXPECT($R44, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11292
11298
|
return { $loc, token: "" };
|
|
11293
11299
|
});
|
|
11294
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
11300
|
+
var HeregexPart$6 = $TR($EXPECT($R45, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11295
11301
|
return { $loc, token: "\\/" };
|
|
11296
11302
|
});
|
|
11297
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
11303
|
+
var HeregexPart$7 = $TR($EXPECT($R46, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11298
11304
|
return { $loc, token: $0 };
|
|
11299
11305
|
});
|
|
11300
11306
|
var HeregexPart$$ = [HeregexPart$0, HeregexPart$1, HeregexPart$2, HeregexPart$3, HeregexPart$4, HeregexPart$5, HeregexPart$6, HeregexPart$7];
|
|
@@ -11307,7 +11313,7 @@ ${input.slice(result.pos)}
|
|
|
11307
11313
|
function HeregexComment(ctx, state) {
|
|
11308
11314
|
return $EVENT_C(ctx, state, "HeregexComment", HeregexComment$$);
|
|
11309
11315
|
}
|
|
11310
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
11316
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R47, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
11311
11317
|
function RegularExpressionBody(ctx, state) {
|
|
11312
11318
|
return $EVENT(ctx, state, "RegularExpressionBody", RegularExpressionBody$0);
|
|
11313
11319
|
}
|
|
@@ -11317,15 +11323,15 @@ ${input.slice(result.pos)}
|
|
|
11317
11323
|
function RegExpPart(ctx, state) {
|
|
11318
11324
|
return $EVENT_C(ctx, state, "RegExpPart", RegExpPart$$);
|
|
11319
11325
|
}
|
|
11320
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
11326
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R48, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
11321
11327
|
function RegExpCharacter(ctx, state) {
|
|
11322
11328
|
return $EVENT(ctx, state, "RegExpCharacter", RegExpCharacter$0);
|
|
11323
11329
|
}
|
|
11324
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
11330
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R49, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
11325
11331
|
function RegularExpressionFlags(ctx, state) {
|
|
11326
11332
|
return $EVENT(ctx, state, "RegularExpressionFlags", RegularExpressionFlags$0);
|
|
11327
11333
|
}
|
|
11328
|
-
var TemplateLiteral$0 = $T($S($EXPECT($
|
|
11334
|
+
var TemplateLiteral$0 = $T($S($EXPECT($R50, "TemplateLiteral /(?=[`'\"])/"), _TemplateLiteral), function(value) {
|
|
11329
11335
|
return value[1];
|
|
11330
11336
|
});
|
|
11331
11337
|
function TemplateLiteral(ctx, state) {
|
|
@@ -11361,28 +11367,28 @@ ${input.slice(result.pos)}
|
|
|
11361
11367
|
function TemplateSubstitution(ctx, state) {
|
|
11362
11368
|
return $EVENT(ctx, state, "TemplateSubstitution", TemplateSubstitution$0);
|
|
11363
11369
|
}
|
|
11364
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
11370
|
+
var TemplateCharacters$0 = $TR($EXPECT($R51, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11365
11371
|
return { $loc, token: $0 };
|
|
11366
11372
|
});
|
|
11367
11373
|
function TemplateCharacters(ctx, state) {
|
|
11368
11374
|
return $EVENT(ctx, state, "TemplateCharacters", TemplateCharacters$0);
|
|
11369
11375
|
}
|
|
11370
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
11376
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R52, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11371
11377
|
return { $loc, token: $0 };
|
|
11372
11378
|
});
|
|
11373
11379
|
function TemplateBlockCharacters(ctx, state) {
|
|
11374
11380
|
return $EVENT(ctx, state, "TemplateBlockCharacters", TemplateBlockCharacters$0);
|
|
11375
11381
|
}
|
|
11376
|
-
var ReservedWord$0 = $S($R$0($EXPECT($
|
|
11377
|
-
var ReservedWord$1 = $S($R$0($EXPECT($
|
|
11378
|
-
var ReservedWord$2 = $S($R$0($EXPECT($
|
|
11379
|
-
var ReservedWord$3 = $S($R$0($EXPECT($
|
|
11380
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
11382
|
+
var ReservedWord$0 = $S($R$0($EXPECT($R53, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")), CoffeeBooleansEnabled);
|
|
11383
|
+
var ReservedWord$1 = $S($R$0($EXPECT($R54, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")), CoffeeIsntEnabled);
|
|
11384
|
+
var ReservedWord$2 = $S($R$0($EXPECT($R55, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")), CoffeeForLoopsEnabled);
|
|
11385
|
+
var ReservedWord$3 = $S($R$0($EXPECT($R56, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")), CoffeeOfEnabled);
|
|
11386
|
+
var ReservedWord$4 = $R$0($EXPECT($R57, "ReservedWord /(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
11381
11387
|
var ReservedWord$$ = [ReservedWord$0, ReservedWord$1, ReservedWord$2, ReservedWord$3, ReservedWord$4];
|
|
11382
11388
|
function ReservedWord(ctx, state) {
|
|
11383
11389
|
return $EVENT_C(ctx, state, "ReservedWord", ReservedWord$$);
|
|
11384
11390
|
}
|
|
11385
|
-
var Comment$0 = $T($S($EXPECT($
|
|
11391
|
+
var Comment$0 = $T($S($EXPECT($R58, "Comment /(?=\\/|#)/"), _Comment), function(value) {
|
|
11386
11392
|
return value[1];
|
|
11387
11393
|
});
|
|
11388
11394
|
function Comment(ctx, state) {
|
|
@@ -11400,7 +11406,7 @@ ${input.slice(result.pos)}
|
|
|
11400
11406
|
function SingleLineComment(ctx, state) {
|
|
11401
11407
|
return $EVENT_C(ctx, state, "SingleLineComment", SingleLineComment$$);
|
|
11402
11408
|
}
|
|
11403
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
11409
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R59, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11404
11410
|
return { type: "Comment", $loc, token: $0 };
|
|
11405
11411
|
});
|
|
11406
11412
|
function JSSingleLineComment(ctx, state) {
|
|
@@ -11412,30 +11418,30 @@ ${input.slice(result.pos)}
|
|
|
11412
11418
|
function MultiLineComment(ctx, state) {
|
|
11413
11419
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
11414
11420
|
}
|
|
11415
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
11421
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L115, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L116, 'JSMultiLineComment "*/"')), $EXPECT($R60, "JSMultiLineComment /./"))), $EXPECT($L116, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
11416
11422
|
return { type: "Comment", $loc, token: $1 };
|
|
11417
11423
|
});
|
|
11418
11424
|
function JSMultiLineComment(ctx, state) {
|
|
11419
11425
|
return $EVENT(ctx, state, "JSMultiLineComment", JSMultiLineComment$0);
|
|
11420
11426
|
}
|
|
11421
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
11427
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R61, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11422
11428
|
return { type: "Comment", $loc, token: `//${$1}` };
|
|
11423
11429
|
});
|
|
11424
11430
|
function CoffeeSingleLineComment(ctx, state) {
|
|
11425
11431
|
return $EVENT(ctx, state, "CoffeeSingleLineComment", CoffeeSingleLineComment$0);
|
|
11426
11432
|
}
|
|
11427
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
11433
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R62, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
11428
11434
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
11429
11435
|
return { type: "Comment", $loc, token: `/*${$2}*/` };
|
|
11430
11436
|
});
|
|
11431
11437
|
function CoffeeMultiLineComment(ctx, state) {
|
|
11432
11438
|
return $EVENT(ctx, state, "CoffeeMultiLineComment", CoffeeMultiLineComment$0);
|
|
11433
11439
|
}
|
|
11434
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
11440
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R63, "CoffeeHereCommentStart /###(?!#)/"));
|
|
11435
11441
|
function CoffeeHereCommentStart(ctx, state) {
|
|
11436
11442
|
return $EVENT(ctx, state, "CoffeeHereCommentStart", CoffeeHereCommentStart$0);
|
|
11437
11443
|
}
|
|
11438
|
-
var InlineComment$0 = $TR($EXPECT($
|
|
11444
|
+
var InlineComment$0 = $TR($EXPECT($R64, "InlineComment /\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\//"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11439
11445
|
return { $loc, token: $0 };
|
|
11440
11446
|
});
|
|
11441
11447
|
function InlineComment(ctx, state) {
|
|
@@ -11449,16 +11455,16 @@ ${input.slice(result.pos)}
|
|
|
11449
11455
|
function TrailingComment(ctx, state) {
|
|
11450
11456
|
return $EVENT(ctx, state, "TrailingComment", TrailingComment$0);
|
|
11451
11457
|
}
|
|
11452
|
-
var _$0 = $T($S($EXPECT($
|
|
11458
|
+
var _$0 = $T($S($EXPECT($R65, "_ /(?=[ \\t\\/\\\\])/"), $P($C(NonNewlineWhitespace, InlineComment))), function(value) {
|
|
11453
11459
|
return value[1];
|
|
11454
11460
|
});
|
|
11455
11461
|
function _(ctx, state) {
|
|
11456
11462
|
return $EVENT(ctx, state, "_", _$0);
|
|
11457
11463
|
}
|
|
11458
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
11464
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R66, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11459
11465
|
return { $loc, token: $0 };
|
|
11460
11466
|
});
|
|
11461
|
-
var NonNewlineWhitespace$1 = $T($S($EXPECT($
|
|
11467
|
+
var NonNewlineWhitespace$1 = $T($S($EXPECT($L117, 'NonNewlineWhitespace "\\\\\\\\"'), CoffeeLineContinuationEnabled, EOL), function(value) {
|
|
11462
11468
|
return " ";
|
|
11463
11469
|
});
|
|
11464
11470
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
@@ -11472,7 +11478,7 @@ ${input.slice(result.pos)}
|
|
|
11472
11478
|
function Trimmed_(ctx, state) {
|
|
11473
11479
|
return $EVENT(ctx, state, "Trimmed_", Trimmed_$0);
|
|
11474
11480
|
}
|
|
11475
|
-
var __$0 = $T($S($EXPECT($
|
|
11481
|
+
var __$0 = $T($S($EXPECT($R67, "__ /(?=\\s|\\/|#)/"), $Q($C(Whitespace, Comment))), function(value) {
|
|
11476
11482
|
return value[1];
|
|
11477
11483
|
});
|
|
11478
11484
|
var __$1 = $EXPECT($L0, '__ ""');
|
|
@@ -11480,7 +11486,7 @@ ${input.slice(result.pos)}
|
|
|
11480
11486
|
function __(ctx, state) {
|
|
11481
11487
|
return $EVENT_C(ctx, state, "__", __$$);
|
|
11482
11488
|
}
|
|
11483
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
11489
|
+
var Whitespace$0 = $TR($EXPECT($R44, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11484
11490
|
return { $loc, token: $0 };
|
|
11485
11491
|
});
|
|
11486
11492
|
function Whitespace(ctx, state) {
|
|
@@ -11504,7 +11510,7 @@ ${input.slice(result.pos)}
|
|
|
11504
11510
|
}
|
|
11505
11511
|
var StatementDelimiter$0 = $Y(EOS);
|
|
11506
11512
|
var StatementDelimiter$1 = SemicolonDelimiter;
|
|
11507
|
-
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L29, 'StatementDelimiter "}"'), $EXPECT($
|
|
11513
|
+
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L29, 'StatementDelimiter "}"'), $EXPECT($L118, 'StatementDelimiter ")"'), $EXPECT($L38, 'StatementDelimiter "]"'))));
|
|
11508
11514
|
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2];
|
|
11509
11515
|
function StatementDelimiter(ctx, state) {
|
|
11510
11516
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
@@ -11518,7 +11524,7 @@ ${input.slice(result.pos)}
|
|
|
11518
11524
|
function SemicolonDelimiter(ctx, state) {
|
|
11519
11525
|
return $EVENT(ctx, state, "SemicolonDelimiter", SemicolonDelimiter$0);
|
|
11520
11526
|
}
|
|
11521
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
11527
|
+
var NonIdContinue$0 = $R$0($EXPECT($R68, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
11522
11528
|
function NonIdContinue(ctx, state) {
|
|
11523
11529
|
return $EVENT(ctx, state, "NonIdContinue", NonIdContinue$0);
|
|
11524
11530
|
}
|
|
@@ -11528,7 +11534,7 @@ ${input.slice(result.pos)}
|
|
|
11528
11534
|
function Loc(ctx, state) {
|
|
11529
11535
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
11530
11536
|
}
|
|
11531
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
11537
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L119, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L15, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
11532
11538
|
return { $loc, token: $1, ts: true };
|
|
11533
11539
|
});
|
|
11534
11540
|
function Abstract(ctx, state) {
|
|
@@ -11540,43 +11546,43 @@ ${input.slice(result.pos)}
|
|
|
11540
11546
|
function Ampersand(ctx, state) {
|
|
11541
11547
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
11542
11548
|
}
|
|
11543
|
-
var As$0 = $TS($S($EXPECT($
|
|
11549
|
+
var As$0 = $TS($S($EXPECT($L120, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11544
11550
|
return { $loc, token: $1 };
|
|
11545
11551
|
});
|
|
11546
11552
|
function As(ctx, state) {
|
|
11547
11553
|
return $EVENT(ctx, state, "As", As$0);
|
|
11548
11554
|
}
|
|
11549
|
-
var At$0 = $TV($EXPECT($
|
|
11555
|
+
var At$0 = $TV($EXPECT($L121, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
11550
11556
|
return { $loc, token: $1 };
|
|
11551
11557
|
});
|
|
11552
11558
|
function At(ctx, state) {
|
|
11553
11559
|
return $EVENT(ctx, state, "At", At$0);
|
|
11554
11560
|
}
|
|
11555
|
-
var AtAt$0 = $TV($EXPECT($
|
|
11561
|
+
var AtAt$0 = $TV($EXPECT($L122, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
11556
11562
|
return { $loc, token: "@" };
|
|
11557
11563
|
});
|
|
11558
11564
|
function AtAt(ctx, state) {
|
|
11559
11565
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
11560
11566
|
}
|
|
11561
|
-
var Async$0 = $TS($S($EXPECT($
|
|
11567
|
+
var Async$0 = $TS($S($EXPECT($L123, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11562
11568
|
return { $loc, token: $1, type: "Async" };
|
|
11563
11569
|
});
|
|
11564
11570
|
function Async(ctx, state) {
|
|
11565
11571
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
11566
11572
|
}
|
|
11567
|
-
var Await$0 = $TS($S($EXPECT($
|
|
11573
|
+
var Await$0 = $TS($S($EXPECT($L124, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11568
11574
|
return { $loc, token: $1, type: "Await" };
|
|
11569
11575
|
});
|
|
11570
11576
|
function Await(ctx, state) {
|
|
11571
11577
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
11572
11578
|
}
|
|
11573
|
-
var Backtick$0 = $TV($EXPECT($
|
|
11579
|
+
var Backtick$0 = $TV($EXPECT($L125, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
11574
11580
|
return { $loc, token: $1 };
|
|
11575
11581
|
});
|
|
11576
11582
|
function Backtick(ctx, state) {
|
|
11577
11583
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
11578
11584
|
}
|
|
11579
|
-
var By$0 = $TS($S($EXPECT($
|
|
11585
|
+
var By$0 = $TS($S($EXPECT($L126, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11580
11586
|
return { $loc, token: $1 };
|
|
11581
11587
|
});
|
|
11582
11588
|
function By(ctx, state) {
|
|
@@ -11588,19 +11594,19 @@ ${input.slice(result.pos)}
|
|
|
11588
11594
|
function Caret(ctx, state) {
|
|
11589
11595
|
return $EVENT(ctx, state, "Caret", Caret$0);
|
|
11590
11596
|
}
|
|
11591
|
-
var Case$0 = $TS($S($EXPECT($
|
|
11597
|
+
var Case$0 = $TS($S($EXPECT($L127, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11592
11598
|
return { $loc, token: $1 };
|
|
11593
11599
|
});
|
|
11594
11600
|
function Case(ctx, state) {
|
|
11595
11601
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
11596
11602
|
}
|
|
11597
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
11603
|
+
var Catch$0 = $TS($S($EXPECT($L128, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11598
11604
|
return { $loc, token: $1 };
|
|
11599
11605
|
});
|
|
11600
11606
|
function Catch(ctx, state) {
|
|
11601
11607
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
11602
11608
|
}
|
|
11603
|
-
var Class$0 = $TS($S($EXPECT($
|
|
11609
|
+
var Class$0 = $TS($S($EXPECT($L129, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11604
11610
|
return { $loc, token: $1 };
|
|
11605
11611
|
});
|
|
11606
11612
|
function Class(ctx, state) {
|
|
@@ -11624,13 +11630,13 @@ ${input.slice(result.pos)}
|
|
|
11624
11630
|
function CloseBracket(ctx, state) {
|
|
11625
11631
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
11626
11632
|
}
|
|
11627
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
11633
|
+
var CloseParen$0 = $TV($EXPECT($L118, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
11628
11634
|
return { $loc, token: $1 };
|
|
11629
11635
|
});
|
|
11630
11636
|
function CloseParen(ctx, state) {
|
|
11631
11637
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
11632
11638
|
}
|
|
11633
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
11639
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L130, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
11634
11640
|
return { $loc, token: "${" };
|
|
11635
11641
|
});
|
|
11636
11642
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
@@ -11648,31 +11654,31 @@ ${input.slice(result.pos)}
|
|
|
11648
11654
|
function Comma(ctx, state) {
|
|
11649
11655
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
11650
11656
|
}
|
|
11651
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
11657
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L121, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
11652
11658
|
return { $loc, token: "constructor" };
|
|
11653
11659
|
});
|
|
11654
11660
|
function ConstructorShorthand(ctx, state) {
|
|
11655
11661
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
11656
11662
|
}
|
|
11657
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
11663
|
+
var Declare$0 = $TS($S($EXPECT($L131, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11658
11664
|
return { $loc, token: $1 };
|
|
11659
11665
|
});
|
|
11660
11666
|
function Declare(ctx, state) {
|
|
11661
11667
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
11662
11668
|
}
|
|
11663
|
-
var Default$0 = $TS($S($EXPECT($
|
|
11669
|
+
var Default$0 = $TS($S($EXPECT($L132, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11664
11670
|
return { $loc, token: $1 };
|
|
11665
11671
|
});
|
|
11666
11672
|
function Default(ctx, state) {
|
|
11667
11673
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
11668
11674
|
}
|
|
11669
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
11675
|
+
var Delete$0 = $TS($S($EXPECT($L133, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11670
11676
|
return { $loc, token: $1 };
|
|
11671
11677
|
});
|
|
11672
11678
|
function Delete(ctx, state) {
|
|
11673
11679
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
11674
11680
|
}
|
|
11675
|
-
var Do$0 = $TS($S($EXPECT($
|
|
11681
|
+
var Do$0 = $TS($S($EXPECT($L134, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11676
11682
|
return { $loc, token: $1 };
|
|
11677
11683
|
});
|
|
11678
11684
|
function Do(ctx, state) {
|
|
@@ -11681,7 +11687,7 @@ ${input.slice(result.pos)}
|
|
|
11681
11687
|
var Dot$0 = $TV($EXPECT($L7, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
11682
11688
|
return { $loc, token: $1 };
|
|
11683
11689
|
});
|
|
11684
|
-
var Dot$1 = $TS($S($EXPECT($
|
|
11690
|
+
var Dot$1 = $TS($S($EXPECT($R69, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
|
|
11685
11691
|
var ws = $2;
|
|
11686
11692
|
return [
|
|
11687
11693
|
{ $loc, token: "." },
|
|
@@ -11692,45 +11698,45 @@ ${input.slice(result.pos)}
|
|
|
11692
11698
|
function Dot(ctx, state) {
|
|
11693
11699
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
11694
11700
|
}
|
|
11695
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
11701
|
+
var DotDot$0 = $TS($S($EXPECT($L135, 'DotDot ".."'), $N($EXPECT($L7, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
11696
11702
|
return { $loc, token: $1 };
|
|
11697
11703
|
});
|
|
11698
|
-
var DotDot$1 = $TV($EXPECT($
|
|
11704
|
+
var DotDot$1 = $TV($EXPECT($L136, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
11699
11705
|
return { $loc, token: ".." };
|
|
11700
11706
|
});
|
|
11701
11707
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
11702
11708
|
function DotDot(ctx, state) {
|
|
11703
11709
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
11704
11710
|
}
|
|
11705
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
11711
|
+
var DotDotDot$0 = $TV($EXPECT($L137, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
11706
11712
|
return { $loc, token: $1 };
|
|
11707
11713
|
});
|
|
11708
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
11714
|
+
var DotDotDot$1 = $TV($EXPECT($L138, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
11709
11715
|
return { $loc, token: "..." };
|
|
11710
11716
|
});
|
|
11711
11717
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
11712
11718
|
function DotDotDot(ctx, state) {
|
|
11713
11719
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
11714
11720
|
}
|
|
11715
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
11721
|
+
var DoubleColon$0 = $TV($EXPECT($L139, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
11716
11722
|
return { $loc, token: $1 };
|
|
11717
11723
|
});
|
|
11718
11724
|
function DoubleColon(ctx, state) {
|
|
11719
11725
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
11720
11726
|
}
|
|
11721
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
11727
|
+
var DoubleQuote$0 = $TV($EXPECT($L140, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
11722
11728
|
return { $loc, token: $1 };
|
|
11723
11729
|
});
|
|
11724
11730
|
function DoubleQuote(ctx, state) {
|
|
11725
11731
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
11726
11732
|
}
|
|
11727
|
-
var Each$0 = $TS($S($EXPECT($
|
|
11733
|
+
var Each$0 = $TS($S($EXPECT($L141, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11728
11734
|
return { $loc, token: $1 };
|
|
11729
11735
|
});
|
|
11730
11736
|
function Each(ctx, state) {
|
|
11731
11737
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
11732
11738
|
}
|
|
11733
|
-
var Else$0 = $TS($S($EXPECT($
|
|
11739
|
+
var Else$0 = $TS($S($EXPECT($L142, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11734
11740
|
return { $loc, token: $1 };
|
|
11735
11741
|
});
|
|
11736
11742
|
function Else(ctx, state) {
|
|
@@ -11748,91 +11754,91 @@ ${input.slice(result.pos)}
|
|
|
11748
11754
|
function ExclamationPoint(ctx, state) {
|
|
11749
11755
|
return $EVENT(ctx, state, "ExclamationPoint", ExclamationPoint$0);
|
|
11750
11756
|
}
|
|
11751
|
-
var Export$0 = $TS($S($EXPECT($
|
|
11757
|
+
var Export$0 = $TS($S($EXPECT($L143, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11752
11758
|
return { $loc, token: $1 };
|
|
11753
11759
|
});
|
|
11754
11760
|
function Export(ctx, state) {
|
|
11755
11761
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
11756
11762
|
}
|
|
11757
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
11763
|
+
var Extends$0 = $TS($S($EXPECT($L144, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11758
11764
|
return { $loc, token: $1 };
|
|
11759
11765
|
});
|
|
11760
11766
|
function Extends(ctx, state) {
|
|
11761
11767
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
11762
11768
|
}
|
|
11763
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
11769
|
+
var Finally$0 = $TS($S($EXPECT($L145, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11764
11770
|
return { $loc, token: $1 };
|
|
11765
11771
|
});
|
|
11766
11772
|
function Finally(ctx, state) {
|
|
11767
11773
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
11768
11774
|
}
|
|
11769
|
-
var For$0 = $TS($S($EXPECT($
|
|
11775
|
+
var For$0 = $TS($S($EXPECT($L146, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11770
11776
|
return { $loc, token: $1 };
|
|
11771
11777
|
});
|
|
11772
11778
|
function For(ctx, state) {
|
|
11773
11779
|
return $EVENT(ctx, state, "For", For$0);
|
|
11774
11780
|
}
|
|
11775
|
-
var From$0 = $TS($S($EXPECT($
|
|
11781
|
+
var From$0 = $TS($S($EXPECT($L147, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11776
11782
|
return { $loc, token: $1 };
|
|
11777
11783
|
});
|
|
11778
11784
|
function From(ctx, state) {
|
|
11779
11785
|
return $EVENT(ctx, state, "From", From$0);
|
|
11780
11786
|
}
|
|
11781
|
-
var Function$0 = $TS($S($EXPECT($
|
|
11787
|
+
var Function$0 = $TS($S($EXPECT($L148, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11782
11788
|
return { $loc, token: $1 };
|
|
11783
11789
|
});
|
|
11784
11790
|
function Function(ctx, state) {
|
|
11785
11791
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
11786
11792
|
}
|
|
11787
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
11793
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L149, 'GetOrSet "get"'), $EXPECT($L150, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11788
11794
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
11789
11795
|
});
|
|
11790
11796
|
function GetOrSet(ctx, state) {
|
|
11791
11797
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
11792
11798
|
}
|
|
11793
|
-
var Hash$0 = $TV($EXPECT($
|
|
11799
|
+
var Hash$0 = $TV($EXPECT($L151, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
11794
11800
|
return { $loc, token: $1 };
|
|
11795
11801
|
});
|
|
11796
11802
|
function Hash(ctx, state) {
|
|
11797
11803
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
11798
11804
|
}
|
|
11799
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
11805
|
+
var If$0 = $TV($TEXT($S($EXPECT($L152, 'If "if"'), NonIdContinue, $E($EXPECT($L15, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
11800
11806
|
return { $loc, token: $1 };
|
|
11801
11807
|
});
|
|
11802
11808
|
function If(ctx, state) {
|
|
11803
11809
|
return $EVENT(ctx, state, "If", If$0);
|
|
11804
11810
|
}
|
|
11805
|
-
var Import$0 = $TS($S($EXPECT($L19, 'Import "import"'), $Y($EXPECT($
|
|
11811
|
+
var Import$0 = $TS($S($EXPECT($L19, 'Import "import"'), $Y($EXPECT($R70, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
11806
11812
|
return { $loc, token: $1 };
|
|
11807
11813
|
});
|
|
11808
11814
|
function Import(ctx, state) {
|
|
11809
11815
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
11810
11816
|
}
|
|
11811
|
-
var In$0 = $TS($S($EXPECT($
|
|
11817
|
+
var In$0 = $TS($S($EXPECT($L153, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11812
11818
|
return { $loc, token: $1 };
|
|
11813
11819
|
});
|
|
11814
11820
|
function In(ctx, state) {
|
|
11815
11821
|
return $EVENT(ctx, state, "In", In$0);
|
|
11816
11822
|
}
|
|
11817
|
-
var Infer$0 = $TS($S($EXPECT($
|
|
11823
|
+
var Infer$0 = $TS($S($EXPECT($L154, 'Infer "infer"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11818
11824
|
return { $loc, token: $1 };
|
|
11819
11825
|
});
|
|
11820
11826
|
function Infer(ctx, state) {
|
|
11821
11827
|
return $EVENT(ctx, state, "Infer", Infer$0);
|
|
11822
11828
|
}
|
|
11823
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
11829
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L155, 'LetOrConst "let"'), $EXPECT($L156, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11824
11830
|
return { $loc, token: $1 };
|
|
11825
11831
|
});
|
|
11826
11832
|
function LetOrConst(ctx, state) {
|
|
11827
11833
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
11828
11834
|
}
|
|
11829
|
-
var Const$0 = $TS($S($EXPECT($
|
|
11835
|
+
var Const$0 = $TS($S($EXPECT($L156, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11830
11836
|
return { $loc, token: $1 };
|
|
11831
11837
|
});
|
|
11832
11838
|
function Const(ctx, state) {
|
|
11833
11839
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
11834
11840
|
}
|
|
11835
|
-
var Is$0 = $TS($S($EXPECT($
|
|
11841
|
+
var Is$0 = $TS($S($EXPECT($L157, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11836
11842
|
return { $loc, token: $1 };
|
|
11837
11843
|
});
|
|
11838
11844
|
function Is(ctx, state) {
|
|
@@ -11844,25 +11850,25 @@ ${input.slice(result.pos)}
|
|
|
11844
11850
|
function LetOrConstOrVar(ctx, state) {
|
|
11845
11851
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
11846
11852
|
}
|
|
11847
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
11853
|
+
var Loop$0 = $TS($S($EXPECT($L158, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11848
11854
|
return { $loc, token: "while(true)" };
|
|
11849
11855
|
});
|
|
11850
11856
|
function Loop(ctx, state) {
|
|
11851
11857
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
11852
11858
|
}
|
|
11853
|
-
var New$0 = $TS($S($EXPECT($
|
|
11859
|
+
var New$0 = $TS($S($EXPECT($L159, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11854
11860
|
return { $loc, token: $1 };
|
|
11855
11861
|
});
|
|
11856
11862
|
function New(ctx, state) {
|
|
11857
11863
|
return $EVENT(ctx, state, "New", New$0);
|
|
11858
11864
|
}
|
|
11859
|
-
var Not$0 = $TS($S($EXPECT($
|
|
11865
|
+
var Not$0 = $TS($S($EXPECT($L160, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L14, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
11860
11866
|
return { $loc, token: "!" };
|
|
11861
11867
|
});
|
|
11862
11868
|
function Not(ctx, state) {
|
|
11863
11869
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
11864
11870
|
}
|
|
11865
|
-
var Of$0 = $TS($S($EXPECT($
|
|
11871
|
+
var Of$0 = $TS($S($EXPECT($L161, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11866
11872
|
return { $loc, token: $1 };
|
|
11867
11873
|
});
|
|
11868
11874
|
function Of(ctx, state) {
|
|
@@ -11880,7 +11886,7 @@ ${input.slice(result.pos)}
|
|
|
11880
11886
|
function OpenBrace(ctx, state) {
|
|
11881
11887
|
return $EVENT(ctx, state, "OpenBrace", OpenBrace$0);
|
|
11882
11888
|
}
|
|
11883
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
11889
|
+
var OpenBracket$0 = $TV($EXPECT($L162, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
11884
11890
|
return { $loc, token: $1 };
|
|
11885
11891
|
});
|
|
11886
11892
|
function OpenBracket(ctx, state) {
|
|
@@ -11892,43 +11898,43 @@ ${input.slice(result.pos)}
|
|
|
11892
11898
|
function OpenParen(ctx, state) {
|
|
11893
11899
|
return $EVENT(ctx, state, "OpenParen", OpenParen$0);
|
|
11894
11900
|
}
|
|
11895
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
11901
|
+
var Operator$0 = $TS($S($EXPECT($L163, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11896
11902
|
return { $loc, token: $1 };
|
|
11897
11903
|
});
|
|
11898
11904
|
function Operator(ctx, state) {
|
|
11899
11905
|
return $EVENT(ctx, state, "Operator", Operator$0);
|
|
11900
11906
|
}
|
|
11901
|
-
var Own$0 = $TS($S($EXPECT($
|
|
11907
|
+
var Own$0 = $TS($S($EXPECT($L164, 'Own "own"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11902
11908
|
return { $loc, token: $1 };
|
|
11903
11909
|
});
|
|
11904
11910
|
function Own(ctx, state) {
|
|
11905
11911
|
return $EVENT(ctx, state, "Own", Own$0);
|
|
11906
11912
|
}
|
|
11907
|
-
var Public$0 = $TS($S($EXPECT($
|
|
11913
|
+
var Public$0 = $TS($S($EXPECT($L165, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11908
11914
|
return { $loc, token: $1 };
|
|
11909
11915
|
});
|
|
11910
11916
|
function Public(ctx, state) {
|
|
11911
11917
|
return $EVENT(ctx, state, "Public", Public$0);
|
|
11912
11918
|
}
|
|
11913
|
-
var Private$0 = $TS($S($EXPECT($
|
|
11919
|
+
var Private$0 = $TS($S($EXPECT($L166, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11914
11920
|
return { $loc, token: $1 };
|
|
11915
11921
|
});
|
|
11916
11922
|
function Private(ctx, state) {
|
|
11917
11923
|
return $EVENT(ctx, state, "Private", Private$0);
|
|
11918
11924
|
}
|
|
11919
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
11925
|
+
var Protected$0 = $TS($S($EXPECT($L167, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11920
11926
|
return { $loc, token: $1 };
|
|
11921
11927
|
});
|
|
11922
11928
|
function Protected(ctx, state) {
|
|
11923
11929
|
return $EVENT(ctx, state, "Protected", Protected$0);
|
|
11924
11930
|
}
|
|
11925
|
-
var Pipe$0 = $TV($C($EXPECT($
|
|
11931
|
+
var Pipe$0 = $TV($C($EXPECT($L168, 'Pipe "||>"'), $EXPECT($L169, 'Pipe "|\u25B7"')), function($skip, $loc, $0, $1) {
|
|
11926
11932
|
return { $loc, token: "||>" };
|
|
11927
11933
|
});
|
|
11928
|
-
var Pipe$1 = $TV($C($EXPECT($
|
|
11934
|
+
var Pipe$1 = $TV($C($EXPECT($L170, 'Pipe "|>="'), $EXPECT($L171, 'Pipe "\u25B7="')), function($skip, $loc, $0, $1) {
|
|
11929
11935
|
return { $loc, token: "|>=" };
|
|
11930
11936
|
});
|
|
11931
|
-
var Pipe$2 = $TV($C($EXPECT($
|
|
11937
|
+
var Pipe$2 = $TV($C($EXPECT($L172, 'Pipe "|>"'), $EXPECT($L173, 'Pipe "\u25B7"')), function($skip, $loc, $0, $1) {
|
|
11932
11938
|
return { $loc, token: "|>" };
|
|
11933
11939
|
});
|
|
11934
11940
|
var Pipe$$ = [Pipe$0, Pipe$1, Pipe$2];
|
|
@@ -11941,19 +11947,19 @@ ${input.slice(result.pos)}
|
|
|
11941
11947
|
function QuestionMark(ctx, state) {
|
|
11942
11948
|
return $EVENT(ctx, state, "QuestionMark", QuestionMark$0);
|
|
11943
11949
|
}
|
|
11944
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
11950
|
+
var Readonly$0 = $TS($S($EXPECT($L174, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11945
11951
|
return { $loc, token: $1, ts: true };
|
|
11946
11952
|
});
|
|
11947
11953
|
function Readonly(ctx, state) {
|
|
11948
11954
|
return $EVENT(ctx, state, "Readonly", Readonly$0);
|
|
11949
11955
|
}
|
|
11950
|
-
var Return$0 = $TS($S($EXPECT($
|
|
11956
|
+
var Return$0 = $TS($S($EXPECT($L175, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11951
11957
|
return { $loc, token: $1 };
|
|
11952
11958
|
});
|
|
11953
11959
|
function Return(ctx, state) {
|
|
11954
11960
|
return $EVENT(ctx, state, "Return", Return$0);
|
|
11955
11961
|
}
|
|
11956
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
11962
|
+
var Satisfies$0 = $TS($S($EXPECT($L176, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11957
11963
|
return { $loc, token: $1 };
|
|
11958
11964
|
});
|
|
11959
11965
|
function Satisfies(ctx, state) {
|
|
@@ -11965,7 +11971,7 @@ ${input.slice(result.pos)}
|
|
|
11965
11971
|
function Semicolon(ctx, state) {
|
|
11966
11972
|
return $EVENT(ctx, state, "Semicolon", Semicolon$0);
|
|
11967
11973
|
}
|
|
11968
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
11974
|
+
var SingleQuote$0 = $TV($EXPECT($L177, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
11969
11975
|
return { $loc, token: $1 };
|
|
11970
11976
|
});
|
|
11971
11977
|
function SingleQuote(ctx, state) {
|
|
@@ -11977,137 +11983,137 @@ ${input.slice(result.pos)}
|
|
|
11977
11983
|
function Star(ctx, state) {
|
|
11978
11984
|
return $EVENT(ctx, state, "Star", Star$0);
|
|
11979
11985
|
}
|
|
11980
|
-
var Static$0 = $TS($S($EXPECT($
|
|
11986
|
+
var Static$0 = $TS($S($EXPECT($L178, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11981
11987
|
return { $loc, token: $1 };
|
|
11982
11988
|
});
|
|
11983
|
-
var Static$1 = $TS($S($EXPECT($
|
|
11989
|
+
var Static$1 = $TS($S($EXPECT($L121, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L121, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
11984
11990
|
return { $loc, token: "static " };
|
|
11985
11991
|
});
|
|
11986
11992
|
var Static$$ = [Static$0, Static$1];
|
|
11987
11993
|
function Static(ctx, state) {
|
|
11988
11994
|
return $EVENT_C(ctx, state, "Static", Static$$);
|
|
11989
11995
|
}
|
|
11990
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
11996
|
+
var SubstitutionStart$0 = $TV($EXPECT($L179, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
11991
11997
|
return { $loc, token: $1 };
|
|
11992
11998
|
});
|
|
11993
11999
|
function SubstitutionStart(ctx, state) {
|
|
11994
12000
|
return $EVENT(ctx, state, "SubstitutionStart", SubstitutionStart$0);
|
|
11995
12001
|
}
|
|
11996
|
-
var Super$0 = $TS($S($EXPECT($
|
|
12002
|
+
var Super$0 = $TS($S($EXPECT($L180, 'Super "super"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11997
12003
|
return { $loc, token: $1 };
|
|
11998
12004
|
});
|
|
11999
12005
|
function Super(ctx, state) {
|
|
12000
12006
|
return $EVENT(ctx, state, "Super", Super$0);
|
|
12001
12007
|
}
|
|
12002
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
12008
|
+
var Switch$0 = $TS($S($EXPECT($L181, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12003
12009
|
return { $loc, token: $1 };
|
|
12004
12010
|
});
|
|
12005
12011
|
function Switch(ctx, state) {
|
|
12006
12012
|
return $EVENT(ctx, state, "Switch", Switch$0);
|
|
12007
12013
|
}
|
|
12008
|
-
var Target$0 = $TS($S($EXPECT($
|
|
12014
|
+
var Target$0 = $TS($S($EXPECT($L182, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12009
12015
|
return { $loc, token: $1 };
|
|
12010
12016
|
});
|
|
12011
12017
|
function Target(ctx, state) {
|
|
12012
12018
|
return $EVENT(ctx, state, "Target", Target$0);
|
|
12013
12019
|
}
|
|
12014
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
12020
|
+
var Then$0 = $TS($S(__, $EXPECT($L183, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
12015
12021
|
return { $loc, token: "" };
|
|
12016
12022
|
});
|
|
12017
12023
|
function Then(ctx, state) {
|
|
12018
12024
|
return $EVENT(ctx, state, "Then", Then$0);
|
|
12019
12025
|
}
|
|
12020
|
-
var This$0 = $TS($S($EXPECT($
|
|
12026
|
+
var This$0 = $TS($S($EXPECT($L184, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12021
12027
|
return { $loc, token: $1 };
|
|
12022
12028
|
});
|
|
12023
12029
|
function This(ctx, state) {
|
|
12024
12030
|
return $EVENT(ctx, state, "This", This$0);
|
|
12025
12031
|
}
|
|
12026
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
12032
|
+
var Throw$0 = $TS($S($EXPECT($L185, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12027
12033
|
return { $loc, token: $1 };
|
|
12028
12034
|
});
|
|
12029
12035
|
function Throw(ctx, state) {
|
|
12030
12036
|
return $EVENT(ctx, state, "Throw", Throw$0);
|
|
12031
12037
|
}
|
|
12032
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
12038
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L186, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
12033
12039
|
return { $loc, token: "`" };
|
|
12034
12040
|
});
|
|
12035
12041
|
function TripleDoubleQuote(ctx, state) {
|
|
12036
12042
|
return $EVENT(ctx, state, "TripleDoubleQuote", TripleDoubleQuote$0);
|
|
12037
12043
|
}
|
|
12038
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
12044
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L187, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
12039
12045
|
return { $loc, token: "`" };
|
|
12040
12046
|
});
|
|
12041
12047
|
function TripleSingleQuote(ctx, state) {
|
|
12042
12048
|
return $EVENT(ctx, state, "TripleSingleQuote", TripleSingleQuote$0);
|
|
12043
12049
|
}
|
|
12044
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
12050
|
+
var TripleSlash$0 = $TV($EXPECT($L188, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
12045
12051
|
return { $loc, token: "/" };
|
|
12046
12052
|
});
|
|
12047
12053
|
function TripleSlash(ctx, state) {
|
|
12048
12054
|
return $EVENT(ctx, state, "TripleSlash", TripleSlash$0);
|
|
12049
12055
|
}
|
|
12050
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
12056
|
+
var TripleTick$0 = $TV($EXPECT($L189, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
12051
12057
|
return { $loc, token: "`" };
|
|
12052
12058
|
});
|
|
12053
12059
|
function TripleTick(ctx, state) {
|
|
12054
12060
|
return $EVENT(ctx, state, "TripleTick", TripleTick$0);
|
|
12055
12061
|
}
|
|
12056
|
-
var Try$0 = $TS($S($EXPECT($
|
|
12062
|
+
var Try$0 = $TS($S($EXPECT($L190, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12057
12063
|
return { $loc, token: $1 };
|
|
12058
12064
|
});
|
|
12059
12065
|
function Try(ctx, state) {
|
|
12060
12066
|
return $EVENT(ctx, state, "Try", Try$0);
|
|
12061
12067
|
}
|
|
12062
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
12068
|
+
var Typeof$0 = $TS($S($EXPECT($L191, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12063
12069
|
return { $loc, token: $1 };
|
|
12064
12070
|
});
|
|
12065
12071
|
function Typeof(ctx, state) {
|
|
12066
12072
|
return $EVENT(ctx, state, "Typeof", Typeof$0);
|
|
12067
12073
|
}
|
|
12068
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
12074
|
+
var Unless$0 = $TS($S($EXPECT($L192, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12069
12075
|
return { $loc, token: $1, negated: true };
|
|
12070
12076
|
});
|
|
12071
12077
|
function Unless(ctx, state) {
|
|
12072
12078
|
return $EVENT(ctx, state, "Unless", Unless$0);
|
|
12073
12079
|
}
|
|
12074
|
-
var Until$0 = $TS($S($EXPECT($
|
|
12080
|
+
var Until$0 = $TS($S($EXPECT($L193, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12075
12081
|
return { $loc, token: $1 };
|
|
12076
12082
|
});
|
|
12077
12083
|
function Until(ctx, state) {
|
|
12078
12084
|
return $EVENT(ctx, state, "Until", Until$0);
|
|
12079
12085
|
}
|
|
12080
|
-
var Using$0 = $TS($S($EXPECT($
|
|
12086
|
+
var Using$0 = $TS($S($EXPECT($L194, 'Using "using"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12081
12087
|
return { $loc, token: $1 };
|
|
12082
12088
|
});
|
|
12083
12089
|
function Using(ctx, state) {
|
|
12084
12090
|
return $EVENT(ctx, state, "Using", Using$0);
|
|
12085
12091
|
}
|
|
12086
|
-
var Var$0 = $TS($S($EXPECT($
|
|
12092
|
+
var Var$0 = $TS($S($EXPECT($L195, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12087
12093
|
return { $loc, token: $1 };
|
|
12088
12094
|
});
|
|
12089
12095
|
function Var(ctx, state) {
|
|
12090
12096
|
return $EVENT(ctx, state, "Var", Var$0);
|
|
12091
12097
|
}
|
|
12092
|
-
var Void$0 = $TS($S($EXPECT($
|
|
12098
|
+
var Void$0 = $TS($S($EXPECT($L196, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12093
12099
|
return { $loc, token: $1 };
|
|
12094
12100
|
});
|
|
12095
12101
|
function Void(ctx, state) {
|
|
12096
12102
|
return $EVENT(ctx, state, "Void", Void$0);
|
|
12097
12103
|
}
|
|
12098
|
-
var When$0 = $TS($S($EXPECT($
|
|
12104
|
+
var When$0 = $TS($S($EXPECT($L197, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12099
12105
|
return { $loc, token: "case" };
|
|
12100
12106
|
});
|
|
12101
12107
|
function When(ctx, state) {
|
|
12102
12108
|
return $EVENT(ctx, state, "When", When$0);
|
|
12103
12109
|
}
|
|
12104
|
-
var While$0 = $TS($S($EXPECT($
|
|
12110
|
+
var While$0 = $TS($S($EXPECT($L198, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12105
12111
|
return { $loc, token: $1 };
|
|
12106
12112
|
});
|
|
12107
12113
|
function While(ctx, state) {
|
|
12108
12114
|
return $EVENT(ctx, state, "While", While$0);
|
|
12109
12115
|
}
|
|
12110
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
12116
|
+
var Yield$0 = $TS($S($EXPECT($L199, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12111
12117
|
return { $loc, token: $1, type: "Yield" };
|
|
12112
12118
|
});
|
|
12113
12119
|
function Yield(ctx, state) {
|
|
@@ -12136,7 +12142,7 @@ ${input.slice(result.pos)}
|
|
|
12136
12142
|
function JSXImplicitFragment(ctx, state) {
|
|
12137
12143
|
return $EVENT(ctx, state, "JSXImplicitFragment", JSXImplicitFragment$0);
|
|
12138
12144
|
}
|
|
12139
|
-
var JSXTag$0 = $T($S($EXPECT($
|
|
12145
|
+
var JSXTag$0 = $T($S($EXPECT($R71, "JSXTag /(?=[<])/"), _JSXTag), function(value) {
|
|
12140
12146
|
return value[1];
|
|
12141
12147
|
});
|
|
12142
12148
|
function JSXTag(ctx, state) {
|
|
@@ -12186,7 +12192,7 @@ ${input.slice(result.pos)}
|
|
|
12186
12192
|
function JSXElement(ctx, state) {
|
|
12187
12193
|
return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
|
|
12188
12194
|
}
|
|
12189
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L16, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($
|
|
12195
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L16, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L200, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
12190
12196
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
12191
12197
|
});
|
|
12192
12198
|
function JSXSelfClosingElement(ctx, state) {
|
|
@@ -12220,7 +12226,7 @@ ${input.slice(result.pos)}
|
|
|
12220
12226
|
function JSXOptionalClosingElement(ctx, state) {
|
|
12221
12227
|
return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
|
|
12222
12228
|
}
|
|
12223
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
12229
|
+
var JSXClosingElement$0 = $S($EXPECT($L201, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L37, 'JSXClosingElement ">"'));
|
|
12224
12230
|
function JSXClosingElement(ctx, state) {
|
|
12225
12231
|
return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
|
|
12226
12232
|
}
|
|
@@ -12241,7 +12247,7 @@ ${input.slice(result.pos)}
|
|
|
12241
12247
|
];
|
|
12242
12248
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
12243
12249
|
});
|
|
12244
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
12250
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L202, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
12245
12251
|
var children = $3;
|
|
12246
12252
|
$0 = $0.slice(1);
|
|
12247
12253
|
return {
|
|
@@ -12254,7 +12260,7 @@ ${input.slice(result.pos)}
|
|
|
12254
12260
|
function JSXFragment(ctx, state) {
|
|
12255
12261
|
return $EVENT_C(ctx, state, "JSXFragment", JSXFragment$$);
|
|
12256
12262
|
}
|
|
12257
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
12263
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L202, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
12258
12264
|
module.JSXTagStack.push("");
|
|
12259
12265
|
return $1;
|
|
12260
12266
|
});
|
|
@@ -12271,11 +12277,11 @@ ${input.slice(result.pos)}
|
|
|
12271
12277
|
function JSXOptionalClosingFragment(ctx, state) {
|
|
12272
12278
|
return $EVENT_C(ctx, state, "JSXOptionalClosingFragment", JSXOptionalClosingFragment$$);
|
|
12273
12279
|
}
|
|
12274
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
12280
|
+
var JSXClosingFragment$0 = $EXPECT($L203, 'JSXClosingFragment "</>"');
|
|
12275
12281
|
function JSXClosingFragment(ctx, state) {
|
|
12276
12282
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
12277
12283
|
}
|
|
12278
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
12284
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L151, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
12279
12285
|
return module.config.defaultElement;
|
|
12280
12286
|
});
|
|
12281
12287
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -12283,7 +12289,7 @@ ${input.slice(result.pos)}
|
|
|
12283
12289
|
function JSXElementName(ctx, state) {
|
|
12284
12290
|
return $EVENT_C(ctx, state, "JSXElementName", JSXElementName$$);
|
|
12285
12291
|
}
|
|
12286
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
12292
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R72, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
12287
12293
|
function JSXIdentifierName(ctx, state) {
|
|
12288
12294
|
return $EVENT(ctx, state, "JSXIdentifierName", JSXIdentifierName$0);
|
|
12289
12295
|
}
|
|
@@ -12453,7 +12459,7 @@ ${input.slice(result.pos)}
|
|
|
12453
12459
|
}
|
|
12454
12460
|
return $skip;
|
|
12455
12461
|
});
|
|
12456
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
12462
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L151, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
12457
12463
|
return [" ", "id=", $2];
|
|
12458
12464
|
});
|
|
12459
12465
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -12472,11 +12478,11 @@ ${input.slice(result.pos)}
|
|
|
12472
12478
|
function JSXAttribute(ctx, state) {
|
|
12473
12479
|
return $EVENT_C(ctx, state, "JSXAttribute", JSXAttribute$$);
|
|
12474
12480
|
}
|
|
12475
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
12481
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R73, "JSXAttributeSpace /[\\s>]|\\/>/"));
|
|
12476
12482
|
function JSXAttributeSpace(ctx, state) {
|
|
12477
12483
|
return $EVENT(ctx, state, "JSXAttributeSpace", JSXAttributeSpace$0);
|
|
12478
12484
|
}
|
|
12479
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
12485
|
+
var JSXShorthandString$0 = $TR($EXPECT($R74, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12480
12486
|
return quoteString($0);
|
|
12481
12487
|
});
|
|
12482
12488
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -12510,7 +12516,7 @@ ${input.slice(result.pos)}
|
|
|
12510
12516
|
}
|
|
12511
12517
|
return [open, value, close];
|
|
12512
12518
|
});
|
|
12513
|
-
var JSXAttributeValue$4 = $R$0($EXPECT($
|
|
12519
|
+
var JSXAttributeValue$4 = $R$0($EXPECT($R75, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
|
|
12514
12520
|
var JSXAttributeValue$$ = [JSXAttributeValue$0, JSXAttributeValue$1, JSXAttributeValue$2, JSXAttributeValue$3, JSXAttributeValue$4];
|
|
12515
12521
|
function JSXAttributeValue(ctx, state) {
|
|
12516
12522
|
return $EVENT_C(ctx, state, "JSXAttributeValue", JSXAttributeValue$$);
|
|
@@ -12523,7 +12529,7 @@ ${input.slice(result.pos)}
|
|
|
12523
12529
|
function InlineJSXAttributeValue(ctx, state) {
|
|
12524
12530
|
return $EVENT(ctx, state, "InlineJSXAttributeValue", InlineJSXAttributeValue$0);
|
|
12525
12531
|
}
|
|
12526
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
12532
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R76, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
12527
12533
|
var op = $2;
|
|
12528
12534
|
var rhs = $3;
|
|
12529
12535
|
return [[], op, [], rhs];
|
|
@@ -12540,7 +12546,7 @@ ${input.slice(result.pos)}
|
|
|
12540
12546
|
function InlineJSXUnaryExpression(ctx, state) {
|
|
12541
12547
|
return $EVENT(ctx, state, "InlineJSXUnaryExpression", InlineJSXUnaryExpression$0);
|
|
12542
12548
|
}
|
|
12543
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
12549
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R77, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12544
12550
|
return { $loc, token: $0 };
|
|
12545
12551
|
});
|
|
12546
12552
|
function InlineJSXUnaryOp(ctx, state) {
|
|
@@ -12745,19 +12751,19 @@ ${input.slice(result.pos)}
|
|
|
12745
12751
|
function JSXChild(ctx, state) {
|
|
12746
12752
|
return $EVENT_C(ctx, state, "JSXChild", JSXChild$$);
|
|
12747
12753
|
}
|
|
12748
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
12754
|
+
var JSXComment$0 = $TS($S($EXPECT($L204, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L205, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
12749
12755
|
return ["{/*", $2, "*/}"];
|
|
12750
12756
|
});
|
|
12751
12757
|
function JSXComment(ctx, state) {
|
|
12752
12758
|
return $EVENT(ctx, state, "JSXComment", JSXComment$0);
|
|
12753
12759
|
}
|
|
12754
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
12760
|
+
var JSXCommentContent$0 = $TR($EXPECT($R78, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12755
12761
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
12756
12762
|
});
|
|
12757
12763
|
function JSXCommentContent(ctx, state) {
|
|
12758
12764
|
return $EVENT(ctx, state, "JSXCommentContent", JSXCommentContent$0);
|
|
12759
12765
|
}
|
|
12760
|
-
var JSXText$0 = $TR($EXPECT($
|
|
12766
|
+
var JSXText$0 = $TR($EXPECT($R79, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12761
12767
|
return {
|
|
12762
12768
|
type: "JSXText",
|
|
12763
12769
|
token: $0,
|
|
@@ -12856,7 +12862,7 @@ ${input.slice(result.pos)}
|
|
|
12856
12862
|
function TypeDeclarationRest(ctx, state) {
|
|
12857
12863
|
return $EVENT_C(ctx, state, "TypeDeclarationRest", TypeDeclarationRest$$);
|
|
12858
12864
|
}
|
|
12859
|
-
var TypeAliasDeclaration$0 = $TS($S(TypeKeyword, $E(_), IdentifierName, $E(TypeParameters), OptionalEquals, $C(
|
|
12865
|
+
var TypeAliasDeclaration$0 = $TS($S(TypeKeyword, $E(_), IdentifierName, $E(TypeParameters), OptionalEquals, $C(MaybeIndentedType, $S(__, Type))), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
12860
12866
|
var id = $3;
|
|
12861
12867
|
return {
|
|
12862
12868
|
type: "TypeDeclaration",
|
|
@@ -12865,8 +12871,18 @@ ${input.slice(result.pos)}
|
|
|
12865
12871
|
ts: true
|
|
12866
12872
|
};
|
|
12867
12873
|
});
|
|
12874
|
+
var TypeAliasDeclaration$1 = $TS($S(InsertType, IdentifierName, $E(TypeParameters), __, TypeAssignment, $C(MaybeIndentedType, $S(__, Type))), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
12875
|
+
var id = $2;
|
|
12876
|
+
return {
|
|
12877
|
+
type: "TypeDeclaration",
|
|
12878
|
+
id,
|
|
12879
|
+
children: $0,
|
|
12880
|
+
ts: true
|
|
12881
|
+
};
|
|
12882
|
+
});
|
|
12883
|
+
var TypeAliasDeclaration$$ = [TypeAliasDeclaration$0, TypeAliasDeclaration$1];
|
|
12868
12884
|
function TypeAliasDeclaration(ctx, state) {
|
|
12869
|
-
return $
|
|
12885
|
+
return $EVENT_C(ctx, state, "TypeAliasDeclaration", TypeAliasDeclaration$$);
|
|
12870
12886
|
}
|
|
12871
12887
|
var InterfaceDeclaration$0 = $TS($S(Interface, $E(_), IdentifierName, $E(TypeParameters), $E(InterfaceExtendsClause), InterfaceBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
12872
12888
|
var id = $3;
|
|
@@ -12922,37 +12938,37 @@ ${input.slice(result.pos)}
|
|
|
12922
12938
|
function InterfaceExtendsTarget(ctx, state) {
|
|
12923
12939
|
return $EVENT(ctx, state, "InterfaceExtendsTarget", InterfaceExtendsTarget$0);
|
|
12924
12940
|
}
|
|
12925
|
-
var TypeKeyword$0 = $TS($S($EXPECT($
|
|
12941
|
+
var TypeKeyword$0 = $TS($S($EXPECT($L206, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12926
12942
|
return { $loc, token: $1 };
|
|
12927
12943
|
});
|
|
12928
12944
|
function TypeKeyword(ctx, state) {
|
|
12929
12945
|
return $EVENT(ctx, state, "TypeKeyword", TypeKeyword$0);
|
|
12930
12946
|
}
|
|
12931
|
-
var Enum$0 = $TS($S($EXPECT($
|
|
12947
|
+
var Enum$0 = $TS($S($EXPECT($L207, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12932
12948
|
return { $loc, token: $1 };
|
|
12933
12949
|
});
|
|
12934
12950
|
function Enum(ctx, state) {
|
|
12935
12951
|
return $EVENT(ctx, state, "Enum", Enum$0);
|
|
12936
12952
|
}
|
|
12937
|
-
var Interface$0 = $TS($S($EXPECT($
|
|
12953
|
+
var Interface$0 = $TS($S($EXPECT($L208, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12938
12954
|
return { $loc, token: $1 };
|
|
12939
12955
|
});
|
|
12940
12956
|
function Interface(ctx, state) {
|
|
12941
12957
|
return $EVENT(ctx, state, "Interface", Interface$0);
|
|
12942
12958
|
}
|
|
12943
|
-
var Global$0 = $TS($S($EXPECT($
|
|
12959
|
+
var Global$0 = $TS($S($EXPECT($L209, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12944
12960
|
return { $loc, token: $1 };
|
|
12945
12961
|
});
|
|
12946
12962
|
function Global(ctx, state) {
|
|
12947
12963
|
return $EVENT(ctx, state, "Global", Global$0);
|
|
12948
12964
|
}
|
|
12949
|
-
var Module$0 = $TS($S($EXPECT($
|
|
12965
|
+
var Module$0 = $TS($S($EXPECT($L210, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12950
12966
|
return { $loc, token: $1 };
|
|
12951
12967
|
});
|
|
12952
12968
|
function Module(ctx, state) {
|
|
12953
12969
|
return $EVENT(ctx, state, "Module", Module$0);
|
|
12954
12970
|
}
|
|
12955
|
-
var Namespace$0 = $TS($S($EXPECT($
|
|
12971
|
+
var Namespace$0 = $TS($S($EXPECT($L211, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12956
12972
|
return { $loc, token: $1 };
|
|
12957
12973
|
});
|
|
12958
12974
|
function Namespace(ctx, state) {
|
|
@@ -13168,7 +13184,7 @@ ${input.slice(result.pos)}
|
|
|
13168
13184
|
function TypeProperty(ctx, state) {
|
|
13169
13185
|
return $EVENT(ctx, state, "TypeProperty", TypeProperty$0);
|
|
13170
13186
|
}
|
|
13171
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
13187
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R80, "TypeIndexSignature /[+-]?/")), Readonly, NotDedented)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R17, "TypeIndexSignature /[+-]/")), $Y($S($E(_), QuestionMark)))));
|
|
13172
13188
|
function TypeIndexSignature(ctx, state) {
|
|
13173
13189
|
return $EVENT(ctx, state, "TypeIndexSignature", TypeIndexSignature$0);
|
|
13174
13190
|
}
|
|
@@ -13226,7 +13242,7 @@ ${input.slice(result.pos)}
|
|
|
13226
13242
|
function ReturnTypeSuffix(ctx, state) {
|
|
13227
13243
|
return $EVENT(ctx, state, "ReturnTypeSuffix", ReturnTypeSuffix$0);
|
|
13228
13244
|
}
|
|
13229
|
-
var ReturnType$0 = $TS($S($E($S(__, $EXPECT($
|
|
13245
|
+
var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L212, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
|
|
13230
13246
|
var asserts = $1;
|
|
13231
13247
|
var t = $2;
|
|
13232
13248
|
if (asserts) {
|
|
@@ -13247,7 +13263,7 @@ ${input.slice(result.pos)}
|
|
|
13247
13263
|
function ReturnType(ctx, state) {
|
|
13248
13264
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
13249
13265
|
}
|
|
13250
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
13266
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L157, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
13251
13267
|
var lhs = $1;
|
|
13252
13268
|
var rhs = $2;
|
|
13253
13269
|
if (!rhs)
|
|
@@ -13305,8 +13321,8 @@ ${input.slice(result.pos)}
|
|
|
13305
13321
|
function TypeUnarySuffix(ctx, state) {
|
|
13306
13322
|
return $EVENT_C(ctx, state, "TypeUnarySuffix", TypeUnarySuffix$$);
|
|
13307
13323
|
}
|
|
13308
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
13309
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
13324
|
+
var TypeUnaryOp$0 = $S($EXPECT($L213, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
13325
|
+
var TypeUnaryOp$1 = $S($EXPECT($L174, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
13310
13326
|
var TypeUnaryOp$$ = [TypeUnaryOp$0, TypeUnaryOp$1];
|
|
13311
13327
|
function TypeUnaryOp(ctx, state) {
|
|
13312
13328
|
return $EVENT_C(ctx, state, "TypeUnaryOp", TypeUnaryOp$$);
|
|
@@ -13336,7 +13352,7 @@ ${input.slice(result.pos)}
|
|
|
13336
13352
|
function TypeIndexedAccess(ctx, state) {
|
|
13337
13353
|
return $EVENT_C(ctx, state, "TypeIndexedAccess", TypeIndexedAccess$$);
|
|
13338
13354
|
}
|
|
13339
|
-
var UnknownAlias$0 = $TV($EXPECT($
|
|
13355
|
+
var UnknownAlias$0 = $TV($EXPECT($L214, 'UnknownAlias "???"'), function($skip, $loc, $0, $1) {
|
|
13340
13356
|
return { $loc, token: "unknown" };
|
|
13341
13357
|
});
|
|
13342
13358
|
function UnknownAlias(ctx, state) {
|
|
@@ -13353,7 +13369,7 @@ ${input.slice(result.pos)}
|
|
|
13353
13369
|
return { ...$2, children: [$1, ...$2.children] };
|
|
13354
13370
|
});
|
|
13355
13371
|
var TypePrimary$3 = InterfaceBlock;
|
|
13356
|
-
var TypePrimary$4 = $S($E(_),
|
|
13372
|
+
var TypePrimary$4 = $S($E(_), TypeFunction);
|
|
13357
13373
|
var TypePrimary$5 = $S($E(_), InlineInterfaceLiteral);
|
|
13358
13374
|
var TypePrimary$6 = $TS($S($E(_), ImportType), function($skip, $loc, $0, $1, $2) {
|
|
13359
13375
|
var t = $2;
|
|
@@ -13542,10 +13558,10 @@ ${input.slice(result.pos)}
|
|
|
13542
13558
|
}
|
|
13543
13559
|
var TypeLiteral$0 = TypeTemplateLiteral;
|
|
13544
13560
|
var TypeLiteral$1 = Literal;
|
|
13545
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
13561
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L196, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
13546
13562
|
return { type: "VoidType", $loc, token: $1 };
|
|
13547
13563
|
});
|
|
13548
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
13564
|
+
var TypeLiteral$3 = $TV($EXPECT($L215, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
13549
13565
|
return { $loc, token: "[]" };
|
|
13550
13566
|
});
|
|
13551
13567
|
var TypeLiteral$$ = [TypeLiteral$0, TypeLiteral$1, TypeLiteral$2, TypeLiteral$3];
|
|
@@ -13564,7 +13580,7 @@ ${input.slice(result.pos)}
|
|
|
13564
13580
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
13565
13581
|
return value[1];
|
|
13566
13582
|
});
|
|
13567
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L14, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($
|
|
13583
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L14, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L118, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L38, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L29, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
13568
13584
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
13569
13585
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
13570
13586
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
@@ -13580,15 +13596,15 @@ ${input.slice(result.pos)}
|
|
|
13580
13596
|
function TypeBinaryOp(ctx, state) {
|
|
13581
13597
|
return $EVENT_C(ctx, state, "TypeBinaryOp", TypeBinaryOp$$);
|
|
13582
13598
|
}
|
|
13583
|
-
var
|
|
13599
|
+
var TypeFunction$0 = $TS($S($E($S($E($S(Abstract, $E(_))), New, $E(_))), Parameters, __, TypeArrowFunction, $E(ReturnType)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
13584
13600
|
var type = $5;
|
|
13585
13601
|
if (type) {
|
|
13586
13602
|
return $0;
|
|
13587
13603
|
}
|
|
13588
13604
|
return [...$0, "void"];
|
|
13589
13605
|
});
|
|
13590
|
-
function
|
|
13591
|
-
return $EVENT(ctx, state, "
|
|
13606
|
+
function TypeFunction(ctx, state) {
|
|
13607
|
+
return $EVENT(ctx, state, "TypeFunction", TypeFunction$0);
|
|
13592
13608
|
}
|
|
13593
13609
|
var TypeArrowFunction$0 = $TV($C($EXPECT($L12, 'TypeArrowFunction "=>"'), $EXPECT($L13, 'TypeArrowFunction "\u21D2"'), $EXPECT($L27, 'TypeArrowFunction "->"'), $EXPECT($L28, 'TypeArrowFunction "\u2192"')), function($skip, $loc, $0, $1) {
|
|
13594
13610
|
return { $loc, token: "=>" };
|
|
@@ -13616,8 +13632,8 @@ ${input.slice(result.pos)}
|
|
|
13616
13632
|
function TypeArgumentDelimiter(ctx, state) {
|
|
13617
13633
|
return $EVENT(ctx, state, "TypeArgumentDelimiter", TypeArgumentDelimiter$0);
|
|
13618
13634
|
}
|
|
13619
|
-
var TypeParameters$0 = $TS($S(
|
|
13620
|
-
var parameters = $
|
|
13635
|
+
var TypeParameters$0 = $TS($S(OpenAngleBracket, $P(TypeParameter), __, CloseAngleBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
13636
|
+
var parameters = $2;
|
|
13621
13637
|
return {
|
|
13622
13638
|
type: "TypeParameters",
|
|
13623
13639
|
parameters,
|
|
@@ -13628,11 +13644,11 @@ ${input.slice(result.pos)}
|
|
|
13628
13644
|
function TypeParameters(ctx, state) {
|
|
13629
13645
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
13630
13646
|
}
|
|
13631
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
13647
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L156, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
13632
13648
|
function TypeParameter(ctx, state) {
|
|
13633
13649
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
13634
13650
|
}
|
|
13635
|
-
var TypeConstraint$0 = $S(__,
|
|
13651
|
+
var TypeConstraint$0 = $S(__, ExtendsToken, Type);
|
|
13636
13652
|
function TypeConstraint(ctx, state) {
|
|
13637
13653
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
13638
13654
|
}
|
|
@@ -13671,7 +13687,7 @@ ${input.slice(result.pos)}
|
|
|
13671
13687
|
function CivetPrologue(ctx, state) {
|
|
13672
13688
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
13673
13689
|
}
|
|
13674
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
13690
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L216, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R85, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
13675
13691
|
var options = $3;
|
|
13676
13692
|
return {
|
|
13677
13693
|
type: "CivetPrologue",
|
|
@@ -13855,6 +13871,12 @@ ${input.slice(result.pos)}
|
|
|
13855
13871
|
function InsertVar(ctx, state) {
|
|
13856
13872
|
return $EVENT(ctx, state, "InsertVar", InsertVar$0);
|
|
13857
13873
|
}
|
|
13874
|
+
var InsertType$0 = $TV($EXPECT($L0, 'InsertType ""'), function($skip, $loc, $0, $1) {
|
|
13875
|
+
return { $loc, token: "type " };
|
|
13876
|
+
});
|
|
13877
|
+
function InsertType(ctx, state) {
|
|
13878
|
+
return $EVENT(ctx, state, "InsertType", InsertType$0);
|
|
13879
|
+
}
|
|
13858
13880
|
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L0, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
13859
13881
|
if (module.config.coffeeBinaryExistential)
|
|
13860
13882
|
return;
|
|
@@ -14074,9 +14096,9 @@ ${input.slice(result.pos)}
|
|
|
14074
14096
|
hasProp(hasPropRef) {
|
|
14075
14097
|
const typeSuffix = {
|
|
14076
14098
|
ts: true,
|
|
14077
|
-
children: [": <T>(object: T, prop:
|
|
14099
|
+
children: [": <T>(object: T, prop: PropertyKey) => boolean"]
|
|
14078
14100
|
};
|
|
14079
|
-
module.prelude.push(["", [preludeVar, hasPropRef, typeSuffix, " = {}.constructor
|
|
14101
|
+
module.prelude.push(["", [preludeVar, hasPropRef, typeSuffix, " = ({}.constructor", asAny, ").hasOwn;\n"]]);
|
|
14080
14102
|
},
|
|
14081
14103
|
is(isRef) {
|
|
14082
14104
|
const typeSuffix = {
|
|
@@ -14766,6 +14788,7 @@ ${input.slice(result.pos)}
|
|
|
14766
14788
|
exports.LexicalDeclaration = LexicalDeclaration;
|
|
14767
14789
|
exports.ConstAssignment = ConstAssignment;
|
|
14768
14790
|
exports.LetAssignment = LetAssignment;
|
|
14791
|
+
exports.TypeAssignment = TypeAssignment;
|
|
14769
14792
|
exports.LexicalBinding = LexicalBinding;
|
|
14770
14793
|
exports.Initializer = Initializer;
|
|
14771
14794
|
exports.VariableStatement = VariableStatement;
|
|
@@ -15041,7 +15064,7 @@ ${input.slice(result.pos)}
|
|
|
15041
15064
|
exports.InlineBasicInterfaceProperty = InlineBasicInterfaceProperty;
|
|
15042
15065
|
exports.InlineInterfacePropertyDelimiter = InlineInterfacePropertyDelimiter;
|
|
15043
15066
|
exports.TypeBinaryOp = TypeBinaryOp;
|
|
15044
|
-
exports.
|
|
15067
|
+
exports.TypeFunction = TypeFunction;
|
|
15045
15068
|
exports.TypeArrowFunction = TypeArrowFunction;
|
|
15046
15069
|
exports.TypeArguments = TypeArguments;
|
|
15047
15070
|
exports.TypeArgument = TypeArgument;
|
|
@@ -15083,6 +15106,7 @@ ${input.slice(result.pos)}
|
|
|
15083
15106
|
exports.InsertDot = InsertDot;
|
|
15084
15107
|
exports.InsertBreak = InsertBreak;
|
|
15085
15108
|
exports.InsertVar = InsertVar;
|
|
15109
|
+
exports.InsertType = InsertType;
|
|
15086
15110
|
exports.CoffeeBinaryExistentialEnabled = CoffeeBinaryExistentialEnabled;
|
|
15087
15111
|
exports.CoffeeBooleansEnabled = CoffeeBooleansEnabled;
|
|
15088
15112
|
exports.CoffeeClassesEnabled = CoffeeClassesEnabled;
|