@danielx/civet 0.6.41 → 0.6.43
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 +622 -480
- package/dist/main.js +622 -480
- package/dist/main.mjs +622 -480
- package/dist/ts-diagnostic.js +0 -61
- package/dist/ts-diagnostic.mjs +0 -49
- package/package.json +2 -2
package/dist/browser.js
CHANGED
|
@@ -859,14 +859,36 @@ ${input.slice(result.pos)}
|
|
|
859
859
|
})
|
|
860
860
|
);
|
|
861
861
|
}
|
|
862
|
+
function negateCondition(condition) {
|
|
863
|
+
let { expression } = condition;
|
|
864
|
+
const children = condition.children.slice();
|
|
865
|
+
const i = children.indexOf(expression);
|
|
866
|
+
if (i < 0) {
|
|
867
|
+
throw new Error(`Could not find expression in condition`);
|
|
868
|
+
}
|
|
869
|
+
children[i] = expression = {
|
|
870
|
+
type: "UnaryExpression",
|
|
871
|
+
children: [
|
|
872
|
+
"!",
|
|
873
|
+
makeLeftHandSideExpression(expression)
|
|
874
|
+
]
|
|
875
|
+
};
|
|
876
|
+
return { ...condition, expression, children };
|
|
877
|
+
}
|
|
862
878
|
function expressionizeIfClause(clause, b, e) {
|
|
863
|
-
const
|
|
864
|
-
children.
|
|
879
|
+
const { condition } = clause;
|
|
880
|
+
const [...condRest] = condition.children, [closeParen] = condRest.splice(-1);
|
|
881
|
+
const children = [
|
|
882
|
+
...condRest,
|
|
883
|
+
"?",
|
|
884
|
+
b
|
|
885
|
+
];
|
|
865
886
|
if (e) {
|
|
866
887
|
children.push(e[0], ":", ...e.slice(2));
|
|
867
888
|
} else {
|
|
868
889
|
children.push(":void 0");
|
|
869
890
|
}
|
|
891
|
+
children.push(closeParen);
|
|
870
892
|
return {
|
|
871
893
|
type: "IfExpression",
|
|
872
894
|
children
|
|
@@ -1550,7 +1572,6 @@ ${input.slice(result.pos)}
|
|
|
1550
1572
|
const [, exp, semi] = node;
|
|
1551
1573
|
if (semi?.type === "SemicolonDelimiter")
|
|
1552
1574
|
return;
|
|
1553
|
-
let indent = getIndent(node);
|
|
1554
1575
|
if (!exp)
|
|
1555
1576
|
return;
|
|
1556
1577
|
switch (exp.type) {
|
|
@@ -1975,6 +1996,7 @@ ${input.slice(result.pos)}
|
|
|
1975
1996
|
case "CallExpression":
|
|
1976
1997
|
case "MemberExpression":
|
|
1977
1998
|
case "ParenthesizedExpression":
|
|
1999
|
+
case "IfExpression":
|
|
1978
2000
|
case "DebuggerExpression":
|
|
1979
2001
|
case "SwitchExpression":
|
|
1980
2002
|
case "ThrowExpression":
|
|
@@ -2214,7 +2236,7 @@ ${input.slice(result.pos)}
|
|
|
2214
2236
|
children
|
|
2215
2237
|
};
|
|
2216
2238
|
}
|
|
2217
|
-
function processDeclarationCondition(condition) {
|
|
2239
|
+
function processDeclarationCondition(condition, rootCondition) {
|
|
2218
2240
|
if (!(condition.type === "DeclarationCondition")) {
|
|
2219
2241
|
return;
|
|
2220
2242
|
}
|
|
@@ -2222,7 +2244,7 @@ ${input.slice(result.pos)}
|
|
|
2222
2244
|
const { decl, bindings } = condition.declaration;
|
|
2223
2245
|
const binding = bindings[0];
|
|
2224
2246
|
const { pattern, suffix, initializer, splices, thisAssignments } = binding;
|
|
2225
|
-
|
|
2247
|
+
Object.assign(condition, {
|
|
2226
2248
|
type: "AssignmentExpression",
|
|
2227
2249
|
children: [ref, initializer],
|
|
2228
2250
|
hoistDec: {
|
|
@@ -2230,14 +2252,15 @@ ${input.slice(result.pos)}
|
|
|
2230
2252
|
children: ["let ", ref, suffix],
|
|
2231
2253
|
names: []
|
|
2232
2254
|
},
|
|
2255
|
+
pattern,
|
|
2256
|
+
ref
|
|
2257
|
+
});
|
|
2258
|
+
Object.assign(rootCondition, {
|
|
2233
2259
|
blockPrefix: [
|
|
2234
2260
|
["", [decl, pattern, suffix, " = ", ref, ...splices], ";"],
|
|
2235
2261
|
...thisAssignments
|
|
2236
|
-
]
|
|
2237
|
-
|
|
2238
|
-
ref
|
|
2239
|
-
};
|
|
2240
|
-
Object.assign(condition, initCondition);
|
|
2262
|
+
]
|
|
2263
|
+
});
|
|
2241
2264
|
}
|
|
2242
2265
|
function processDeclarationConditions(node) {
|
|
2243
2266
|
gatherRecursiveAll(node, (n) => {
|
|
@@ -2249,8 +2272,15 @@ ${input.slice(result.pos)}
|
|
|
2249
2272
|
if (!condition?.expression) {
|
|
2250
2273
|
return;
|
|
2251
2274
|
}
|
|
2252
|
-
|
|
2253
|
-
|
|
2275
|
+
;
|
|
2276
|
+
let { expression } = condition;
|
|
2277
|
+
if (typeof expression === "object" && expression != null && "type" in expression && expression.type === "UnaryExpression" && "children" in expression && Array.isArray(expression.children) && expression.children.length === 2 && expression.children[0] === "!" && typeof expression.children[1] === "object" && expression.children[1] != null && "type" in expression.children[1] && expression.children[1].type === "ParenthesizedExpression" && "expression" in expression.children[1]) {
|
|
2278
|
+
const { type: type1, children: [, { type: type2, expression: expression2 }] } = expression;
|
|
2279
|
+
const type = [type1, type2];
|
|
2280
|
+
expression = expression2;
|
|
2281
|
+
}
|
|
2282
|
+
processDeclarationCondition(expression, condition.expression);
|
|
2283
|
+
const { ref, pattern } = expression;
|
|
2254
2284
|
if (pattern) {
|
|
2255
2285
|
let conditions = [];
|
|
2256
2286
|
getPatternConditions(pattern, ref, conditions);
|
|
@@ -3542,6 +3572,7 @@ ${input.slice(result.pos)}
|
|
|
3542
3572
|
maybeRef,
|
|
3543
3573
|
modifyString,
|
|
3544
3574
|
needsRef,
|
|
3575
|
+
negateCondition,
|
|
3545
3576
|
processAssignmentDeclaration,
|
|
3546
3577
|
processBinaryOpExpression,
|
|
3547
3578
|
processCallMemberExpression,
|
|
@@ -3606,6 +3637,7 @@ ${input.slice(result.pos)}
|
|
|
3606
3637
|
NestedNonAssignmentExtendedExpression,
|
|
3607
3638
|
ExpressionizedStatementWithTrailingCallExpressions,
|
|
3608
3639
|
ExpressionizedStatement,
|
|
3640
|
+
_ExpressionizedStatement,
|
|
3609
3641
|
Expression,
|
|
3610
3642
|
Arguments,
|
|
3611
3643
|
ImplicitArguments,
|
|
@@ -3697,6 +3729,7 @@ ${input.slice(result.pos)}
|
|
|
3697
3729
|
MemberBracketContent,
|
|
3698
3730
|
SliceParameters,
|
|
3699
3731
|
AccessStart,
|
|
3732
|
+
PropertyAccessModifier,
|
|
3700
3733
|
PropertyAccess,
|
|
3701
3734
|
PropertyGlob,
|
|
3702
3735
|
PropertyBind,
|
|
@@ -3767,12 +3800,14 @@ ${input.slice(result.pos)}
|
|
|
3767
3800
|
LiteralContent,
|
|
3768
3801
|
NullLiteral,
|
|
3769
3802
|
BooleanLiteral,
|
|
3803
|
+
_BooleanLiteral,
|
|
3770
3804
|
CoffeeScriptBooleanLiteral,
|
|
3771
3805
|
Identifier,
|
|
3772
3806
|
IdentifierName,
|
|
3773
3807
|
IdentifierReference,
|
|
3774
3808
|
UpcomingAssignment,
|
|
3775
3809
|
ArrayLiteral,
|
|
3810
|
+
_ArrayLiteral,
|
|
3776
3811
|
RangeExpression,
|
|
3777
3812
|
ArrayLiteralContent,
|
|
3778
3813
|
NestedElementList,
|
|
@@ -3814,6 +3849,8 @@ ${input.slice(result.pos)}
|
|
|
3814
3849
|
IdentifierBinaryOp,
|
|
3815
3850
|
BinaryOp,
|
|
3816
3851
|
BinaryOpSymbol,
|
|
3852
|
+
CoffeeOfOp,
|
|
3853
|
+
NotOp,
|
|
3817
3854
|
Xor,
|
|
3818
3855
|
Xnor,
|
|
3819
3856
|
UnaryOp,
|
|
@@ -3824,6 +3861,7 @@ ${input.slice(result.pos)}
|
|
|
3824
3861
|
PostfixedExpression,
|
|
3825
3862
|
NonPipelinePostfixedExpression,
|
|
3826
3863
|
PostfixStatement,
|
|
3864
|
+
_PostfixStatement,
|
|
3827
3865
|
Statement,
|
|
3828
3866
|
EmptyStatement,
|
|
3829
3867
|
BlockStatement,
|
|
@@ -3843,6 +3881,7 @@ ${input.slice(result.pos)}
|
|
|
3843
3881
|
NestedBlockExpression,
|
|
3844
3882
|
BlockExpressionPart,
|
|
3845
3883
|
IterationStatement,
|
|
3884
|
+
_IterationStatement,
|
|
3846
3885
|
IterationExpression,
|
|
3847
3886
|
LoopStatement,
|
|
3848
3887
|
LoopClause,
|
|
@@ -3979,11 +4018,13 @@ ${input.slice(result.pos)}
|
|
|
3979
4018
|
RegExpCharacter,
|
|
3980
4019
|
RegularExpressionFlags,
|
|
3981
4020
|
TemplateLiteral,
|
|
4021
|
+
_TemplateLiteral,
|
|
3982
4022
|
TemplateSubstitution,
|
|
3983
4023
|
TemplateCharacters,
|
|
3984
4024
|
TemplateBlockCharacters,
|
|
3985
4025
|
ReservedWord,
|
|
3986
4026
|
Comment,
|
|
4027
|
+
_Comment,
|
|
3987
4028
|
SingleLineComment,
|
|
3988
4029
|
JSSingleLineComment,
|
|
3989
4030
|
MultiLineComment,
|
|
@@ -4283,8 +4324,8 @@ ${input.slice(result.pos)}
|
|
|
4283
4324
|
var $L8 = $L("--");
|
|
4284
4325
|
var $L9 = $L("=>");
|
|
4285
4326
|
var $L10 = $L("\u21D2");
|
|
4286
|
-
var $L11 = $L("
|
|
4287
|
-
var $L12 = $L("
|
|
4327
|
+
var $L11 = $L(":");
|
|
4328
|
+
var $L12 = $L(" ");
|
|
4288
4329
|
var $L13 = $L("implements");
|
|
4289
4330
|
var $L14 = $L("<:");
|
|
4290
4331
|
var $L15 = $L("import");
|
|
@@ -4356,77 +4397,77 @@ ${input.slice(result.pos)}
|
|
|
4356
4397
|
var $L81 = $L("\u2A75");
|
|
4357
4398
|
var $L82 = $L("and");
|
|
4358
4399
|
var $L83 = $L("&&");
|
|
4359
|
-
var $L84 = $L("
|
|
4360
|
-
var $L85 = $L("
|
|
4361
|
-
var $L86 = $L("
|
|
4362
|
-
var $L87 = $L("
|
|
4363
|
-
var $L88 = $L("
|
|
4364
|
-
var $L89 = $L("
|
|
4365
|
-
var $L90 = $L("
|
|
4366
|
-
var $L91 = $L("
|
|
4367
|
-
var $L92 = $L("
|
|
4368
|
-
var $L93 = $L("
|
|
4369
|
-
var $L94 = $L("\
|
|
4370
|
-
var $L95 = $L("\
|
|
4371
|
-
var $L96 = $L("\
|
|
4372
|
-
var $L97 = $L("
|
|
4373
|
-
var $L98 = $L("
|
|
4374
|
-
var $L99 = $L("
|
|
4375
|
-
var $L100 = $L("
|
|
4376
|
-
var $L101 = $L("
|
|
4377
|
-
var $L102 = $L("
|
|
4378
|
-
var $L103 = $L("
|
|
4379
|
-
var $L104 = $L("
|
|
4380
|
-
var $L105 = $L("
|
|
4381
|
-
var $L106 = $L("
|
|
4382
|
-
var $L107 = $L("
|
|
4383
|
-
var $L108 = $L("
|
|
4384
|
-
var $L109 = $L("
|
|
4385
|
-
var $L110 = $L("
|
|
4386
|
-
var $L111 = $L("
|
|
4387
|
-
var $L112 = $L("
|
|
4388
|
-
var $L113 = $L("
|
|
4389
|
-
var $L114 = $L("
|
|
4390
|
-
var $L115 = $L("
|
|
4391
|
-
var $L116 = $L("
|
|
4392
|
-
var $L117 = $L("
|
|
4393
|
-
var $L118 = $L("
|
|
4394
|
-
var $L119 = $L("
|
|
4395
|
-
var $L120 = $L("
|
|
4396
|
-
var $L121 = $L("
|
|
4397
|
-
var $L122 = $L("
|
|
4398
|
-
var $L123 = $L("
|
|
4399
|
-
var $L124 = $L("
|
|
4400
|
-
var $L125 = $L("
|
|
4401
|
-
var $L126 = $L("
|
|
4402
|
-
var $L127 = $L("
|
|
4403
|
-
var $L128 = $L("
|
|
4404
|
-
var $L129 = $L("
|
|
4405
|
-
var $L130 = $L("
|
|
4406
|
-
var $L131 = $L("
|
|
4407
|
-
var $L132 = $L("
|
|
4408
|
-
var $L133 = $L("
|
|
4409
|
-
var $L134 = $L("
|
|
4410
|
-
var $L135 = $L(
|
|
4411
|
-
var $L136 = $L("
|
|
4412
|
-
var $L137 = $L("
|
|
4413
|
-
var $L138 = $L("
|
|
4414
|
-
var $L139 = $L("
|
|
4415
|
-
var $L140 = $L("
|
|
4416
|
-
var $L141 = $L("
|
|
4417
|
-
var $L142 = $L("
|
|
4418
|
-
var $L143 = $L("
|
|
4419
|
-
var $L144 = $L("
|
|
4420
|
-
var $L145 = $L("
|
|
4421
|
-
var $L146 = $L("
|
|
4422
|
-
var $L147 = $L("
|
|
4423
|
-
var $L148 = $L("
|
|
4424
|
-
var $L149 = $L("
|
|
4425
|
-
var $L150 = $L("
|
|
4426
|
-
var $L151 = $L("
|
|
4427
|
-
var $L152 = $L("
|
|
4428
|
-
var $L153 = $L("
|
|
4429
|
-
var $L154 = $L("
|
|
4400
|
+
var $L84 = $L("or");
|
|
4401
|
+
var $L85 = $L("||");
|
|
4402
|
+
var $L86 = $L("\u2016");
|
|
4403
|
+
var $L87 = $L("^^");
|
|
4404
|
+
var $L88 = $L("xor");
|
|
4405
|
+
var $L89 = $L("xnor");
|
|
4406
|
+
var $L90 = $L("??");
|
|
4407
|
+
var $L91 = $L("\u2047");
|
|
4408
|
+
var $L92 = $L("instanceof");
|
|
4409
|
+
var $L93 = $L("\u2208");
|
|
4410
|
+
var $L94 = $L("\u220B");
|
|
4411
|
+
var $L95 = $L("\u220C");
|
|
4412
|
+
var $L96 = $L("\u2209");
|
|
4413
|
+
var $L97 = $L("&");
|
|
4414
|
+
var $L98 = $L("|");
|
|
4415
|
+
var $L99 = $L(";");
|
|
4416
|
+
var $L100 = $L("$:");
|
|
4417
|
+
var $L101 = $L("break");
|
|
4418
|
+
var $L102 = $L("continue");
|
|
4419
|
+
var $L103 = $L("debugger");
|
|
4420
|
+
var $L104 = $L("assert");
|
|
4421
|
+
var $L105 = $L(":=");
|
|
4422
|
+
var $L106 = $L("\u2254");
|
|
4423
|
+
var $L107 = $L(".=");
|
|
4424
|
+
var $L108 = $L("/*");
|
|
4425
|
+
var $L109 = $L("*/");
|
|
4426
|
+
var $L110 = $L("\\");
|
|
4427
|
+
var $L111 = $L("[");
|
|
4428
|
+
var $L112 = $L("`");
|
|
4429
|
+
var $L113 = $L(")");
|
|
4430
|
+
var $L114 = $L("abstract");
|
|
4431
|
+
var $L115 = $L("as");
|
|
4432
|
+
var $L116 = $L("@");
|
|
4433
|
+
var $L117 = $L("@@");
|
|
4434
|
+
var $L118 = $L("async");
|
|
4435
|
+
var $L119 = $L("await");
|
|
4436
|
+
var $L120 = $L("by");
|
|
4437
|
+
var $L121 = $L("case");
|
|
4438
|
+
var $L122 = $L("catch");
|
|
4439
|
+
var $L123 = $L("class");
|
|
4440
|
+
var $L124 = $L("#{");
|
|
4441
|
+
var $L125 = $L("declare");
|
|
4442
|
+
var $L126 = $L("default");
|
|
4443
|
+
var $L127 = $L("delete");
|
|
4444
|
+
var $L128 = $L("do");
|
|
4445
|
+
var $L129 = $L("..");
|
|
4446
|
+
var $L130 = $L("\u2025");
|
|
4447
|
+
var $L131 = $L("...");
|
|
4448
|
+
var $L132 = $L("\u2026");
|
|
4449
|
+
var $L133 = $L("::");
|
|
4450
|
+
var $L134 = $L('"');
|
|
4451
|
+
var $L135 = $L("each");
|
|
4452
|
+
var $L136 = $L("else");
|
|
4453
|
+
var $L137 = $L("export");
|
|
4454
|
+
var $L138 = $L("extends");
|
|
4455
|
+
var $L139 = $L("finally");
|
|
4456
|
+
var $L140 = $L("for");
|
|
4457
|
+
var $L141 = $L("from");
|
|
4458
|
+
var $L142 = $L("function");
|
|
4459
|
+
var $L143 = $L("get");
|
|
4460
|
+
var $L144 = $L("set");
|
|
4461
|
+
var $L145 = $L("#");
|
|
4462
|
+
var $L146 = $L("if");
|
|
4463
|
+
var $L147 = $L("in");
|
|
4464
|
+
var $L148 = $L("let");
|
|
4465
|
+
var $L149 = $L("const");
|
|
4466
|
+
var $L150 = $L("is");
|
|
4467
|
+
var $L151 = $L("loop");
|
|
4468
|
+
var $L152 = $L("new");
|
|
4469
|
+
var $L153 = $L("not");
|
|
4470
|
+
var $L154 = $L("of");
|
|
4430
4471
|
var $L155 = $L("<");
|
|
4431
4472
|
var $L156 = $L("operator");
|
|
4432
4473
|
var $L157 = $L("own");
|
|
@@ -4483,74 +4524,91 @@ ${input.slice(result.pos)}
|
|
|
4483
4524
|
var $L208 = $L("???");
|
|
4484
4525
|
var $L209 = $L("[]");
|
|
4485
4526
|
var $L210 = $L("civet");
|
|
4486
|
-
var $R0 = $R(new RegExp("(
|
|
4487
|
-
var $R1 = $R(new RegExp("[
|
|
4488
|
-
var $R2 = $R(new RegExp("[
|
|
4489
|
-
var $R3 = $R(new RegExp("[
|
|
4490
|
-
var $R4 = $R(new RegExp("[
|
|
4491
|
-
var $R5 = $R(new RegExp("(
|
|
4492
|
-
var $R6 = $R(new RegExp("[
|
|
4493
|
-
var $R7 = $R(new RegExp("
|
|
4494
|
-
var $R8 = $R(new RegExp("
|
|
4495
|
-
var $R9 = $R(new RegExp(
|
|
4496
|
-
var $R10 = $R(new RegExp("(?=
|
|
4497
|
-
var $R11 = $R(new RegExp(
|
|
4498
|
-
var $R12 = $R(new RegExp("(
|
|
4499
|
-
var $R13 = $R(new RegExp("(
|
|
4500
|
-
var $R14 = $R(new RegExp("
|
|
4501
|
-
var $R15 = $R(new RegExp("(
|
|
4502
|
-
var $R16 = $R(new RegExp("
|
|
4503
|
-
var $R17 = $R(new RegExp("
|
|
4504
|
-
var $R18 = $R(new RegExp("
|
|
4505
|
-
var $R19 = $R(new RegExp("
|
|
4506
|
-
var $R20 = $R(new RegExp("(
|
|
4507
|
-
var $R21 = $R(new RegExp('
|
|
4508
|
-
var $R22 = $R(new RegExp("(
|
|
4509
|
-
var $R23 = $R(new RegExp(
|
|
4510
|
-
var $R24 = $R(new RegExp("(?:
|
|
4511
|
-
var $R25 = $R(new RegExp(
|
|
4512
|
-
var $R26 = $R(new RegExp("(
|
|
4513
|
-
var $R27 = $R(new RegExp("(
|
|
4514
|
-
var $R28 = $R(new RegExp("[
|
|
4515
|
-
var $R29 = $R(new RegExp("
|
|
4516
|
-
var $R30 = $R(new RegExp("[
|
|
4517
|
-
var $R31 = $R(new RegExp("[
|
|
4518
|
-
var $R32 = $R(new RegExp("(
|
|
4519
|
-
var $R33 = $R(new RegExp(
|
|
4520
|
-
var $R34 = $R(new RegExp("(
|
|
4521
|
-
var $R35 = $R(new RegExp("(
|
|
4522
|
-
var $R36 = $R(new RegExp("(?:
|
|
4523
|
-
var $R37 = $R(new RegExp(
|
|
4524
|
-
var $R38 = $R(new RegExp("(
|
|
4525
|
-
var $R39 = $R(new RegExp("(
|
|
4526
|
-
var $R40 = $R(new RegExp("
|
|
4527
|
-
var $R41 = $R(new RegExp("
|
|
4528
|
-
var $R42 = $R(new RegExp("
|
|
4529
|
-
var $R43 = $R(new RegExp("
|
|
4530
|
-
var $R44 = $R(new RegExp("[^]
|
|
4531
|
-
var $R45 = $R(new RegExp("
|
|
4532
|
-
var $R46 = $R(new RegExp("
|
|
4533
|
-
var $R47 = $R(new RegExp("[
|
|
4534
|
-
var $R48 = $R(new RegExp("(?!\\
|
|
4535
|
-
var $R49 = $R(new RegExp("
|
|
4536
|
-
var $R50 = $R(new RegExp("
|
|
4537
|
-
var $R51 = $R(new RegExp("(
|
|
4538
|
-
var $R52 = $R(new RegExp("
|
|
4539
|
-
var $R53 = $R(new RegExp("(?:
|
|
4540
|
-
var $R54 = $R(new RegExp(
|
|
4541
|
-
var $R55 = $R(new RegExp("[
|
|
4542
|
-
var $R56 = $R(new RegExp("
|
|
4543
|
-
var $R57 = $R(new RegExp("(
|
|
4544
|
-
var $R58 = $R(new RegExp("[^
|
|
4545
|
-
var $R59 = $R(new RegExp("
|
|
4546
|
-
var $R60 = $R(new RegExp("[
|
|
4547
|
-
var $R61 = $R(new RegExp("
|
|
4548
|
-
var $R62 = $R(new RegExp("[\\t
|
|
4549
|
-
var $R63 = $R(new RegExp("
|
|
4550
|
-
var $R64 = $R(new RegExp("
|
|
4551
|
-
var $R65 = $R(new RegExp("
|
|
4552
|
-
var $R66 = $R(new RegExp("\\
|
|
4553
|
-
var $R67 = $R(new RegExp("[
|
|
4527
|
+
var $R0 = $R(new RegExp("(?=debugger|if|unless|do|for|loop|until|while|switch|throw|try)", "suy"));
|
|
4528
|
+
var $R1 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
4529
|
+
var $R2 = $R(new RegExp("[0-9]", "suy"));
|
|
4530
|
+
var $R3 = $R(new RegExp("[ \\t]", "suy"));
|
|
4531
|
+
var $R4 = $R(new RegExp("(?=['\"`])", "suy"));
|
|
4532
|
+
var $R5 = $R(new RegExp("(?=[\\/?])", "suy"));
|
|
4533
|
+
var $R6 = $R(new RegExp("[)}]", "suy"));
|
|
4534
|
+
var $R7 = $R(new RegExp("[&]", "suy"));
|
|
4535
|
+
var $R8 = $R(new RegExp("[!~+-]+", "suy"));
|
|
4536
|
+
var $R9 = $R(new RegExp(`(?=[0-9.'"tfyno])`, "suy"));
|
|
4537
|
+
var $R10 = $R(new RegExp("(?=true|false|yes|no|on|off)", "suy"));
|
|
4538
|
+
var $R11 = $R(new RegExp("(?=\\p{ID_Start}|[_$])", "suy"));
|
|
4539
|
+
var $R12 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
4540
|
+
var $R13 = $R(new RegExp("(?=\\[)", "suy"));
|
|
4541
|
+
var $R14 = $R(new RegExp("[!+-]", "suy"));
|
|
4542
|
+
var $R15 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
|
|
4543
|
+
var $R16 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
4544
|
+
var $R17 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])", "suy"));
|
|
4545
|
+
var $R18 = $R(new RegExp("(?=for|if|loop|unless|until|while)", "suy"));
|
|
4546
|
+
var $R19 = $R(new RegExp("(?=loop|do|for|until|while)", "suy"));
|
|
4547
|
+
var $R20 = $R(new RegExp("(?=[\\s\\),])", "suy"));
|
|
4548
|
+
var $R21 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
4549
|
+
var $R22 = $R(new RegExp("(?=[0-9.])", "suy"));
|
|
4550
|
+
var $R23 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
4551
|
+
var $R24 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
4552
|
+
var $R25 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
4553
|
+
var $R26 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4554
|
+
var $R27 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
4555
|
+
var $R28 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
4556
|
+
var $R29 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
4557
|
+
var $R30 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
4558
|
+
var $R31 = $R(new RegExp("(?=[0-9])", "suy"));
|
|
4559
|
+
var $R32 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4560
|
+
var $R33 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
4561
|
+
var $R34 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
4562
|
+
var $R35 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
4563
|
+
var $R36 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
4564
|
+
var $R37 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
4565
|
+
var $R38 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
4566
|
+
var $R39 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
4567
|
+
var $R40 = $R(new RegExp("[\\s]+", "suy"));
|
|
4568
|
+
var $R41 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
4569
|
+
var $R42 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
4570
|
+
var $R43 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
4571
|
+
var $R44 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
4572
|
+
var $R45 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
4573
|
+
var $R46 = $R(new RegExp("(?=[`'\"])", "suy"));
|
|
4574
|
+
var $R47 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
4575
|
+
var $R48 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
4576
|
+
var $R49 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
4577
|
+
var $R50 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
4578
|
+
var $R51 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
4579
|
+
var $R52 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
4580
|
+
var $R53 = $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"));
|
|
4581
|
+
var $R54 = $R(new RegExp("(?=\\/|#)", "suy"));
|
|
4582
|
+
var $R55 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
4583
|
+
var $R56 = $R(new RegExp(".", "suy"));
|
|
4584
|
+
var $R57 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
4585
|
+
var $R58 = $R(new RegExp("[^]*?###", "suy"));
|
|
4586
|
+
var $R59 = $R(new RegExp("###(?!#)", "suy"));
|
|
4587
|
+
var $R60 = $R(new RegExp("\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\/", "suy"));
|
|
4588
|
+
var $R61 = $R(new RegExp("(?=[ \\t\\/\\\\])", "suy"));
|
|
4589
|
+
var $R62 = $R(new RegExp("[ \\t]+", "suy"));
|
|
4590
|
+
var $R63 = $R(new RegExp("(?=\\s|\\/|#)", "suy"));
|
|
4591
|
+
var $R64 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
4592
|
+
var $R65 = $R(new RegExp("['\u2019]s", "suy"));
|
|
4593
|
+
var $R66 = $R(new RegExp("\\s", "suy"));
|
|
4594
|
+
var $R67 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
4595
|
+
var $R68 = $R(new RegExp("[\\s>]|\\/>", "suy"));
|
|
4596
|
+
var $R69 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
4597
|
+
var $R70 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
|
|
4598
|
+
var $R71 = $R(new RegExp("[<>]", "suy"));
|
|
4599
|
+
var $R72 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
4600
|
+
var $R73 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
4601
|
+
var $R74 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
4602
|
+
var $R75 = $R(new RegExp("[+-]?", "suy"));
|
|
4603
|
+
var $R76 = $R(new RegExp("[+-]", "suy"));
|
|
4604
|
+
var $R77 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
4605
|
+
var $R78 = $R(new RegExp("[\\t ]*", "suy"));
|
|
4606
|
+
var $R79 = $R(new RegExp("[\\s]*", "suy"));
|
|
4607
|
+
var $R80 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
4608
|
+
var $R81 = $R(new RegExp("\\/\\/\\/[^\\r\\n]*", "suy"));
|
|
4609
|
+
var $R82 = $R(new RegExp("(?=[ \\t\\r\\n\\/#]|$)", "suy"));
|
|
4610
|
+
var $R83 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
4611
|
+
var $R84 = $R(new RegExp("[ \\t]*", "suy"));
|
|
4554
4612
|
var Program$0 = $TS($S(Reset, Init, $E(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
4555
4613
|
var statements = $4;
|
|
4556
4614
|
processProgram({
|
|
@@ -4681,16 +4739,22 @@ ${input.slice(result.pos)}
|
|
|
4681
4739
|
function ExpressionizedStatementWithTrailingCallExpressions(ctx, state) {
|
|
4682
4740
|
return $EVENT(ctx, state, "ExpressionizedStatementWithTrailingCallExpressions", ExpressionizedStatementWithTrailingCallExpressions$0);
|
|
4683
4741
|
}
|
|
4684
|
-
var ExpressionizedStatement$0 =
|
|
4685
|
-
|
|
4686
|
-
|
|
4687
|
-
var ExpressionizedStatement$3 = IterationExpression;
|
|
4688
|
-
var ExpressionizedStatement$4 = SwitchExpression;
|
|
4689
|
-
var ExpressionizedStatement$5 = ThrowExpression;
|
|
4690
|
-
var ExpressionizedStatement$6 = TryExpression;
|
|
4691
|
-
var ExpressionizedStatement$$ = [ExpressionizedStatement$0, ExpressionizedStatement$1, ExpressionizedStatement$2, ExpressionizedStatement$3, ExpressionizedStatement$4, ExpressionizedStatement$5, ExpressionizedStatement$6];
|
|
4742
|
+
var ExpressionizedStatement$0 = $T($S($EXPECT($R0, "ExpressionizedStatement /(?=debugger|if|unless|do|for|loop|until|while|switch|throw|try)/"), _ExpressionizedStatement), function(value) {
|
|
4743
|
+
return value[1];
|
|
4744
|
+
});
|
|
4692
4745
|
function ExpressionizedStatement(ctx, state) {
|
|
4693
|
-
return $
|
|
4746
|
+
return $EVENT(ctx, state, "ExpressionizedStatement", ExpressionizedStatement$0);
|
|
4747
|
+
}
|
|
4748
|
+
var _ExpressionizedStatement$0 = DebuggerExpression;
|
|
4749
|
+
var _ExpressionizedStatement$1 = IfExpression;
|
|
4750
|
+
var _ExpressionizedStatement$2 = UnlessExpression;
|
|
4751
|
+
var _ExpressionizedStatement$3 = IterationExpression;
|
|
4752
|
+
var _ExpressionizedStatement$4 = SwitchExpression;
|
|
4753
|
+
var _ExpressionizedStatement$5 = ThrowExpression;
|
|
4754
|
+
var _ExpressionizedStatement$6 = TryExpression;
|
|
4755
|
+
var _ExpressionizedStatement$$ = [_ExpressionizedStatement$0, _ExpressionizedStatement$1, _ExpressionizedStatement$2, _ExpressionizedStatement$3, _ExpressionizedStatement$4, _ExpressionizedStatement$5, _ExpressionizedStatement$6];
|
|
4756
|
+
function _ExpressionizedStatement(ctx, state) {
|
|
4757
|
+
return $EVENT_C(ctx, state, "_ExpressionizedStatement", _ExpressionizedStatement$$);
|
|
4694
4758
|
}
|
|
4695
4759
|
var Expression$0 = $TS($S(AssignmentExpression, $Q($S(CommaDelimiter, AssignmentExpression))), function($skip, $loc, $0, $1, $2) {
|
|
4696
4760
|
if ($2.length == 0)
|
|
@@ -4735,7 +4799,7 @@ ${input.slice(result.pos)}
|
|
|
4735
4799
|
function ApplicationStart(ctx, state) {
|
|
4736
4800
|
return $EVENT_C(ctx, state, "ApplicationStart", ApplicationStart$$);
|
|
4737
4801
|
}
|
|
4738
|
-
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($
|
|
4802
|
+
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R1, "ForbiddenImplicitCalls /(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
4739
4803
|
var ForbiddenImplicitCalls$1 = $EXPECT($L2, 'ForbiddenImplicitCalls "/ "');
|
|
4740
4804
|
var ForbiddenImplicitCalls$2 = $S(ClassImplicitCallForbidden, $C(Class, AtAt));
|
|
4741
4805
|
var ForbiddenImplicitCalls$3 = $S(Identifier, $EXPECT($L3, 'ForbiddenImplicitCalls "="'), Whitespace);
|
|
@@ -4767,7 +4831,7 @@ ${input.slice(result.pos)}
|
|
|
4767
4831
|
function ArgumentsWithTrailingMemberExpressions(ctx, state) {
|
|
4768
4832
|
return $EVENT(ctx, state, "ArgumentsWithTrailingMemberExpressions", ArgumentsWithTrailingMemberExpressions$0);
|
|
4769
4833
|
}
|
|
4770
|
-
var TrailingMemberExpressions$0 = $TS($S($Q(MemberExpressionRest), $Q($S(IndentedAtLeast, $Y($S($E($EXPECT($L5, 'TrailingMemberExpressions "?"')), $EXPECT($L6, 'TrailingMemberExpressions "."'), $N($EXPECT($
|
|
4834
|
+
var TrailingMemberExpressions$0 = $TS($S($Q(MemberExpressionRest), $Q($S(IndentedAtLeast, $Y($S($E($EXPECT($L5, 'TrailingMemberExpressions "?"')), $EXPECT($L6, 'TrailingMemberExpressions "."'), $N($EXPECT($R2, "TrailingMemberExpressions /[0-9]/")))), MemberExpressionRest))), function($skip, $loc, $0, $1, $2) {
|
|
4771
4835
|
return $1.concat($2);
|
|
4772
4836
|
});
|
|
4773
4837
|
function TrailingMemberExpressions(ctx, state) {
|
|
@@ -4781,7 +4845,7 @@ ${input.slice(result.pos)}
|
|
|
4781
4845
|
function AllowedTrailingMemberExpressions(ctx, state) {
|
|
4782
4846
|
return $EVENT_C(ctx, state, "AllowedTrailingMemberExpressions", AllowedTrailingMemberExpressions$$);
|
|
4783
4847
|
}
|
|
4784
|
-
var TrailingCallExpressions$0 = $P($S(IndentedAtLeast, $Y($S($E($EXPECT($L5, 'TrailingCallExpressions "?"')), $EXPECT($L6, 'TrailingCallExpressions "."'), $N($R$0($EXPECT($
|
|
4848
|
+
var TrailingCallExpressions$0 = $P($S(IndentedAtLeast, $Y($S($E($EXPECT($L5, 'TrailingCallExpressions "?"')), $EXPECT($L6, 'TrailingCallExpressions "."'), $N($R$0($EXPECT($R2, "TrailingCallExpressions /[0-9]/"))))), $P(CallExpressionRest)));
|
|
4785
4849
|
function TrailingCallExpressions(ctx, state) {
|
|
4786
4850
|
return $EVENT(ctx, state, "TrailingCallExpressions", TrailingCallExpressions$0);
|
|
4787
4851
|
}
|
|
@@ -5099,7 +5163,7 @@ ${input.slice(result.pos)}
|
|
|
5099
5163
|
function FatArrow(ctx, state) {
|
|
5100
5164
|
return $EVENT(ctx, state, "FatArrow", FatArrow$0);
|
|
5101
5165
|
}
|
|
5102
|
-
var TrailingDeclaration$0 = $S($
|
|
5166
|
+
var TrailingDeclaration$0 = $S($E(_), $C(ConstAssignment, LetAssignment));
|
|
5103
5167
|
function TrailingDeclaration(ctx, state) {
|
|
5104
5168
|
return $EVENT(ctx, state, "TrailingDeclaration", TrailingDeclaration$0);
|
|
5105
5169
|
}
|
|
@@ -5122,7 +5186,7 @@ ${input.slice(result.pos)}
|
|
|
5122
5186
|
return $EVENT(ctx, state, "ConditionalExpression", ConditionalExpression$0);
|
|
5123
5187
|
}
|
|
5124
5188
|
var TernaryRest$0 = NestedTernaryRest;
|
|
5125
|
-
var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($
|
|
5189
|
+
var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($R3, "TernaryRest /[ \\t]/")), _, QuestionMark, ExtendedExpression, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
5126
5190
|
return $0.slice(2);
|
|
5127
5191
|
});
|
|
5128
5192
|
var TernaryRest$$ = [TernaryRest$0, TernaryRest$1];
|
|
@@ -5236,7 +5300,7 @@ ${input.slice(result.pos)}
|
|
|
5236
5300
|
function ClassDeclaration(ctx, state) {
|
|
5237
5301
|
return $EVENT(ctx, state, "ClassDeclaration", ClassDeclaration$0);
|
|
5238
5302
|
}
|
|
5239
|
-
var ClassExpression$0 = $S($E(Decorators), $E($S(Abstract, __)), Class, $N($EXPECT($
|
|
5303
|
+
var ClassExpression$0 = $S($E(Decorators), $E($S(Abstract, __)), Class, $N($EXPECT($L11, 'ClassExpression ":"')), $E(ClassBinding), $E(ClassHeritage), ClassBody);
|
|
5240
5304
|
function ClassExpression(ctx, state) {
|
|
5241
5305
|
return $EVENT(ctx, state, "ClassExpression", ClassExpression$0);
|
|
5242
5306
|
}
|
|
@@ -5256,7 +5320,7 @@ ${input.slice(result.pos)}
|
|
|
5256
5320
|
function ExtendsClause(ctx, state) {
|
|
5257
5321
|
return $EVENT(ctx, state, "ExtendsClause", ExtendsClause$0);
|
|
5258
5322
|
}
|
|
5259
|
-
var ExtendsToken$0 = $TS($S(Loc, __, OpenAngleBracket, $E($EXPECT($
|
|
5323
|
+
var ExtendsToken$0 = $TS($S(Loc, __, OpenAngleBracket, $E($EXPECT($L12, 'ExtendsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5260
5324
|
var l = $1;
|
|
5261
5325
|
var ws = $2;
|
|
5262
5326
|
var lt = $3;
|
|
@@ -5294,7 +5358,7 @@ ${input.slice(result.pos)}
|
|
|
5294
5358
|
function ImplementsClause(ctx, state) {
|
|
5295
5359
|
return $EVENT(ctx, state, "ImplementsClause", ImplementsClause$0);
|
|
5296
5360
|
}
|
|
5297
|
-
var ImplementsToken$0 = $TS($S(Loc, __, ImplementsShorthand, $E($EXPECT($
|
|
5361
|
+
var ImplementsToken$0 = $TS($S(Loc, __, ImplementsShorthand, $E($EXPECT($L12, 'ImplementsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5298
5362
|
var l = $1;
|
|
5299
5363
|
var ws = $2;
|
|
5300
5364
|
var token = $3;
|
|
@@ -5524,7 +5588,7 @@ ${input.slice(result.pos)}
|
|
|
5524
5588
|
function AtThis(ctx, state) {
|
|
5525
5589
|
return $EVENT(ctx, state, "AtThis", AtThis$0);
|
|
5526
5590
|
}
|
|
5527
|
-
var LeftHandSideExpression$0 = $S($P($S(New, $N($C($EXPECT($L6, 'LeftHandSideExpression "."'), $EXPECT($
|
|
5591
|
+
var LeftHandSideExpression$0 = $S($P($S(New, $N($C($EXPECT($L6, 'LeftHandSideExpression "."'), $EXPECT($L11, 'LeftHandSideExpression ":"'))), __)), CallExpression, $E(TypeArguments));
|
|
5528
5592
|
var LeftHandSideExpression$1 = CallExpression;
|
|
5529
5593
|
var LeftHandSideExpression$$ = [LeftHandSideExpression$0, LeftHandSideExpression$1];
|
|
5530
5594
|
function LeftHandSideExpression(ctx, state) {
|
|
@@ -5562,13 +5626,14 @@ ${input.slice(result.pos)}
|
|
|
5562
5626
|
return $EVENT_C(ctx, state, "CallExpression", CallExpression$$);
|
|
5563
5627
|
}
|
|
5564
5628
|
var CallExpressionRest$0 = MemberExpressionRest;
|
|
5565
|
-
var CallExpressionRest$1 = $
|
|
5566
|
-
|
|
5567
|
-
|
|
5629
|
+
var CallExpressionRest$1 = $TS($S($EXPECT($R4, "CallExpressionRest /(?=['\"`])/"), $C(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2) {
|
|
5630
|
+
var literal = $2;
|
|
5631
|
+
if (literal.type === "StringLiteral") {
|
|
5632
|
+
return "`" + literal.token.slice(1, -1).replace(/(`|\$\{)/g, "\\$1") + "`";
|
|
5568
5633
|
}
|
|
5569
|
-
return
|
|
5634
|
+
return literal;
|
|
5570
5635
|
});
|
|
5571
|
-
var CallExpressionRest$2 = $TS($S($E(
|
|
5636
|
+
var CallExpressionRest$2 = $TS($S($E(OptionalShorthand), ArgumentsWithTrailingMemberExpressions), function($skip, $loc, $0, $1, $2) {
|
|
5572
5637
|
if (!$1)
|
|
5573
5638
|
return $2;
|
|
5574
5639
|
return [$1, ...$2];
|
|
@@ -5577,17 +5642,19 @@ ${input.slice(result.pos)}
|
|
|
5577
5642
|
function CallExpressionRest(ctx, state) {
|
|
5578
5643
|
return $EVENT_C(ctx, state, "CallExpressionRest", CallExpressionRest$$);
|
|
5579
5644
|
}
|
|
5580
|
-
var OptionalShorthand$0 = $TS($S($Q(InlineComment), QuestionMark, OptionalDot), function($skip, $loc, $0, $1, $2, $3) {
|
|
5645
|
+
var OptionalShorthand$0 = $TS($S($EXPECT($R5, "OptionalShorthand /(?=[\\/?])/"), $Q(InlineComment), QuestionMark, OptionalDot), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5581
5646
|
return {
|
|
5582
5647
|
type: "Optional",
|
|
5583
5648
|
children: $0
|
|
5584
5649
|
};
|
|
5585
5650
|
});
|
|
5651
|
+
var OptionalShorthand$1 = NonNullAssertion;
|
|
5652
|
+
var OptionalShorthand$$ = [OptionalShorthand$0, OptionalShorthand$1];
|
|
5586
5653
|
function OptionalShorthand(ctx, state) {
|
|
5587
|
-
return $
|
|
5654
|
+
return $EVENT_C(ctx, state, "OptionalShorthand", OptionalShorthand$$);
|
|
5588
5655
|
}
|
|
5589
5656
|
var OptionalDot$0 = $S($Q(InlineComment), Dot);
|
|
5590
|
-
var OptionalDot$1 =
|
|
5657
|
+
var OptionalDot$1 = InsertDot;
|
|
5591
5658
|
var OptionalDot$$ = [OptionalDot$0, OptionalDot$1];
|
|
5592
5659
|
function OptionalDot(ctx, state) {
|
|
5593
5660
|
return $EVENT_C(ctx, state, "OptionalDot", OptionalDot$$);
|
|
@@ -5631,7 +5698,7 @@ ${input.slice(result.pos)}
|
|
|
5631
5698
|
function MemberExpressionRest(ctx, state) {
|
|
5632
5699
|
return $EVENT(ctx, state, "MemberExpressionRest", MemberExpressionRest$0);
|
|
5633
5700
|
}
|
|
5634
|
-
var MemberExpressionRestBody$0 = $TS($S($E(
|
|
5701
|
+
var MemberExpressionRestBody$0 = $TS($S($E(OptionalShorthand), $Q(InlineComment), MemberBracketContent), function($skip, $loc, $0, $1, $2, $3) {
|
|
5635
5702
|
var dot = $1;
|
|
5636
5703
|
var comments = $2;
|
|
5637
5704
|
var content = $3;
|
|
@@ -5675,35 +5742,21 @@ ${input.slice(result.pos)}
|
|
|
5675
5742
|
expression
|
|
5676
5743
|
};
|
|
5677
5744
|
});
|
|
5678
|
-
var MemberBracketContent$1 = $TS($S(Dot, $C(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2) {
|
|
5679
|
-
var dot = $1;
|
|
5680
|
-
var str = $2;
|
|
5681
|
-
if (Array.isArray(dot))
|
|
5682
|
-
dot = dot[0];
|
|
5683
|
-
return {
|
|
5684
|
-
type: "Index",
|
|
5685
|
-
children: [
|
|
5686
|
-
{ token: "[", $loc: dot.$loc },
|
|
5687
|
-
str,
|
|
5688
|
-
"]"
|
|
5689
|
-
]
|
|
5690
|
-
};
|
|
5691
|
-
});
|
|
5692
|
-
var MemberBracketContent$2 = $TS($S(Dot, IntegerLiteral), function($skip, $loc, $0, $1, $2) {
|
|
5745
|
+
var MemberBracketContent$1 = $TS($S(Dot, $C(TemplateLiteral, StringLiteral, IntegerLiteral)), function($skip, $loc, $0, $1, $2) {
|
|
5693
5746
|
var dot = $1;
|
|
5694
|
-
var
|
|
5747
|
+
var literal = $2;
|
|
5695
5748
|
if (Array.isArray(dot))
|
|
5696
5749
|
dot = dot[0];
|
|
5697
5750
|
return {
|
|
5698
5751
|
type: "Index",
|
|
5699
5752
|
children: [
|
|
5700
5753
|
{ token: "[", $loc: dot.$loc },
|
|
5701
|
-
|
|
5754
|
+
literal,
|
|
5702
5755
|
"]"
|
|
5703
5756
|
]
|
|
5704
5757
|
};
|
|
5705
5758
|
});
|
|
5706
|
-
var MemberBracketContent$
|
|
5759
|
+
var MemberBracketContent$2 = $TS($S(Dot, $EXPECT($L18, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
5707
5760
|
var dot = $1;
|
|
5708
5761
|
var neg = $2;
|
|
5709
5762
|
var num = $3;
|
|
@@ -5713,7 +5766,7 @@ ${input.slice(result.pos)}
|
|
|
5713
5766
|
{ type: "Call", children: ["(", neg, num, ")"] }
|
|
5714
5767
|
];
|
|
5715
5768
|
});
|
|
5716
|
-
var MemberBracketContent$$ = [MemberBracketContent$0, MemberBracketContent$1, MemberBracketContent$2
|
|
5769
|
+
var MemberBracketContent$$ = [MemberBracketContent$0, MemberBracketContent$1, MemberBracketContent$2];
|
|
5717
5770
|
function MemberBracketContent(ctx, state) {
|
|
5718
5771
|
return $EVENT_C(ctx, state, "MemberBracketContent", MemberBracketContent$$);
|
|
5719
5772
|
}
|
|
@@ -5781,7 +5834,7 @@ ${input.slice(result.pos)}
|
|
|
5781
5834
|
function SliceParameters(ctx, state) {
|
|
5782
5835
|
return $EVENT_C(ctx, state, "SliceParameters", SliceParameters$$);
|
|
5783
5836
|
}
|
|
5784
|
-
var AccessStart$0 = $TS($S($E(
|
|
5837
|
+
var AccessStart$0 = $TS($S($E(PropertyAccessModifier), Dot, $N(Dot)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5785
5838
|
if ($1)
|
|
5786
5839
|
return [$1, $2];
|
|
5787
5840
|
return $2;
|
|
@@ -5789,6 +5842,12 @@ ${input.slice(result.pos)}
|
|
|
5789
5842
|
function AccessStart(ctx, state) {
|
|
5790
5843
|
return $EVENT(ctx, state, "AccessStart", AccessStart$0);
|
|
5791
5844
|
}
|
|
5845
|
+
var PropertyAccessModifier$0 = QuestionMark;
|
|
5846
|
+
var PropertyAccessModifier$1 = NonNullAssertion;
|
|
5847
|
+
var PropertyAccessModifier$$ = [PropertyAccessModifier$0, PropertyAccessModifier$1];
|
|
5848
|
+
function PropertyAccessModifier(ctx, state) {
|
|
5849
|
+
return $EVENT_C(ctx, state, "PropertyAccessModifier", PropertyAccessModifier$$);
|
|
5850
|
+
}
|
|
5792
5851
|
var PropertyAccess$0 = $TS($S(AccessStart, $Q(InlineComment), $C(IdentifierName, PrivateIdentifier)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5793
5852
|
var access = $1;
|
|
5794
5853
|
var comments = $2;
|
|
@@ -5821,7 +5880,7 @@ ${input.slice(result.pos)}
|
|
|
5821
5880
|
function PropertyAccess(ctx, state) {
|
|
5822
5881
|
return $EVENT_C(ctx, state, "PropertyAccess", PropertyAccess$$);
|
|
5823
5882
|
}
|
|
5824
|
-
var PropertyGlob$0 = $TS($S($S($E(
|
|
5883
|
+
var PropertyGlob$0 = $TS($S($S($E(PropertyAccessModifier), OptionalDot), $Q(InlineComment), BracedObjectLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
5825
5884
|
var dot = $1;
|
|
5826
5885
|
var object = $3;
|
|
5827
5886
|
return {
|
|
@@ -5834,7 +5893,7 @@ ${input.slice(result.pos)}
|
|
|
5834
5893
|
function PropertyGlob(ctx, state) {
|
|
5835
5894
|
return $EVENT(ctx, state, "PropertyGlob", PropertyGlob$0);
|
|
5836
5895
|
}
|
|
5837
|
-
var PropertyBind$0 = $TS($S($E(
|
|
5896
|
+
var PropertyBind$0 = $TS($S($E(PropertyAccessModifier), At, OptionalDot, $C(IdentifierName, PrivateIdentifier)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5838
5897
|
var modifier = $1;
|
|
5839
5898
|
var dot = $3;
|
|
5840
5899
|
var id = $4;
|
|
@@ -5849,7 +5908,7 @@ ${input.slice(result.pos)}
|
|
|
5849
5908
|
return $EVENT(ctx, state, "PropertyBind", PropertyBind$0);
|
|
5850
5909
|
}
|
|
5851
5910
|
var SuperProperty$0 = $S(Super, MemberBracketContent);
|
|
5852
|
-
var SuperProperty$1 = $S(Super, $N(
|
|
5911
|
+
var SuperProperty$1 = $S(Super, $N(PropertyAccessModifier), PropertyAccess);
|
|
5853
5912
|
var SuperProperty$$ = [SuperProperty$0, SuperProperty$1];
|
|
5854
5913
|
function SuperProperty(ctx, state) {
|
|
5855
5914
|
return $EVENT_C(ctx, state, "SuperProperty", SuperProperty$$);
|
|
@@ -5957,8 +6016,8 @@ ${input.slice(result.pos)}
|
|
|
5957
6016
|
function NonEmptyParameters(ctx, state) {
|
|
5958
6017
|
return $EVENT(ctx, state, "NonEmptyParameters", NonEmptyParameters$0);
|
|
5959
6018
|
}
|
|
5960
|
-
var FunctionRestParameter$0 = $TS($S(BindingRestElement, $E(TypeSuffix), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3) {
|
|
5961
|
-
var id = $
|
|
6019
|
+
var FunctionRestParameter$0 = $TS($S(__, BindingRestElement, $E(TypeSuffix), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6020
|
+
var id = $2;
|
|
5962
6021
|
return {
|
|
5963
6022
|
type: "FunctionRestParameter",
|
|
5964
6023
|
children: $0,
|
|
@@ -5981,7 +6040,7 @@ ${input.slice(result.pos)}
|
|
|
5981
6040
|
return $EVENT(ctx, state, "ParameterElement", ParameterElement$0);
|
|
5982
6041
|
}
|
|
5983
6042
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
5984
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $R$0($EXPECT($
|
|
6043
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $R$0($EXPECT($R6, "ParameterElementDelimiter /[)}]/"))));
|
|
5985
6044
|
var ParameterElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
5986
6045
|
return value[1];
|
|
5987
6046
|
});
|
|
@@ -6055,10 +6114,14 @@ ${input.slice(result.pos)}
|
|
|
6055
6114
|
return $EVENT_C(ctx, state, "BindingPattern", BindingPattern$$);
|
|
6056
6115
|
}
|
|
6057
6116
|
var ObjectBindingPattern$0 = $TS($S($E(_), OpenBrace, ObjectBindingPatternContent, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
6117
|
+
var ws1 = $1;
|
|
6118
|
+
var open = $2;
|
|
6058
6119
|
var c = $3;
|
|
6120
|
+
var ws2 = $4;
|
|
6121
|
+
var close = $5;
|
|
6059
6122
|
return {
|
|
6060
6123
|
type: "ObjectBindingPattern",
|
|
6061
|
-
children: [
|
|
6124
|
+
children: [ws1, open, c.children, ws2, close],
|
|
6062
6125
|
names: c.names,
|
|
6063
6126
|
properties: c.children
|
|
6064
6127
|
};
|
|
@@ -6091,13 +6154,17 @@ ${input.slice(result.pos)}
|
|
|
6091
6154
|
return $EVENT(ctx, state, "BindingPropertyList", BindingPropertyList$0);
|
|
6092
6155
|
}
|
|
6093
6156
|
var ArrayBindingPattern$0 = $TS($S($E(_), OpenBracket, ArrayBindingPatternContent, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
6157
|
+
var ws1 = $1;
|
|
6158
|
+
var open = $2;
|
|
6094
6159
|
var c = $3;
|
|
6160
|
+
var ws2 = $4;
|
|
6161
|
+
var close = $5;
|
|
6095
6162
|
return {
|
|
6096
6163
|
...c,
|
|
6097
6164
|
// names, blockPrefix, length
|
|
6098
6165
|
type: "ArrayBindingPattern",
|
|
6099
6166
|
elements: c.children,
|
|
6100
|
-
children: [
|
|
6167
|
+
children: [ws1, open, c.children, ws2, close]
|
|
6101
6168
|
};
|
|
6102
6169
|
});
|
|
6103
6170
|
function ArrayBindingPattern(ctx, state) {
|
|
@@ -6539,7 +6606,7 @@ ${input.slice(result.pos)}
|
|
|
6539
6606
|
function AmpersandBlockRHS(ctx, state) {
|
|
6540
6607
|
return $EVENT(ctx, state, "AmpersandBlockRHS", AmpersandBlockRHS$0);
|
|
6541
6608
|
}
|
|
6542
|
-
var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S($N($EXPECT($
|
|
6609
|
+
var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S($N($EXPECT($R7, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2, $3) {
|
|
6543
6610
|
var callExpRest = $1;
|
|
6544
6611
|
var unaryPostfix = $2;
|
|
6545
6612
|
var binopRHS = $3;
|
|
@@ -6569,7 +6636,7 @@ ${input.slice(result.pos)}
|
|
|
6569
6636
|
function AmpersandBlockRHSBody(ctx, state) {
|
|
6570
6637
|
return $EVENT(ctx, state, "AmpersandBlockRHSBody", AmpersandBlockRHSBody$0);
|
|
6571
6638
|
}
|
|
6572
|
-
var AmpersandUnaryPrefix$0 = $R$0($EXPECT($
|
|
6639
|
+
var AmpersandUnaryPrefix$0 = $R$0($EXPECT($R8, "AmpersandUnaryPrefix /[!~+-]+/"));
|
|
6573
6640
|
function AmpersandUnaryPrefix(ctx, state) {
|
|
6574
6641
|
return $EVENT(ctx, state, "AmpersandUnaryPrefix", AmpersandUnaryPrefix$0);
|
|
6575
6642
|
}
|
|
@@ -6903,12 +6970,13 @@ ${input.slice(result.pos)}
|
|
|
6903
6970
|
function BlockStatementPart(ctx, state) {
|
|
6904
6971
|
return $EVENT(ctx, state, "BlockStatementPart", BlockStatementPart$0);
|
|
6905
6972
|
}
|
|
6906
|
-
var Literal$0 = $TS($S(LiteralContent), function($skip, $loc, $0, $1) {
|
|
6973
|
+
var Literal$0 = $TS($S($EXPECT($R9, `Literal /(?=[0-9.'"tfyno])/`), LiteralContent), function($skip, $loc, $0, $1, $2) {
|
|
6974
|
+
var literal = $2;
|
|
6907
6975
|
return {
|
|
6908
6976
|
type: "Literal",
|
|
6909
|
-
subtype:
|
|
6910
|
-
children:
|
|
6911
|
-
raw:
|
|
6977
|
+
subtype: literal.type,
|
|
6978
|
+
children: [literal],
|
|
6979
|
+
raw: literal.token
|
|
6912
6980
|
};
|
|
6913
6981
|
});
|
|
6914
6982
|
function Literal(ctx, state) {
|
|
@@ -6928,15 +6996,21 @@ ${input.slice(result.pos)}
|
|
|
6928
6996
|
function NullLiteral(ctx, state) {
|
|
6929
6997
|
return $EVENT(ctx, state, "NullLiteral", NullLiteral$0);
|
|
6930
6998
|
}
|
|
6931
|
-
var BooleanLiteral$0 = $T($S(
|
|
6999
|
+
var BooleanLiteral$0 = $T($S($EXPECT($R10, "BooleanLiteral /(?=true|false|yes|no|on|off)/"), _BooleanLiteral), function(value) {
|
|
6932
7000
|
return value[1];
|
|
6933
7001
|
});
|
|
6934
|
-
|
|
7002
|
+
function BooleanLiteral(ctx, state) {
|
|
7003
|
+
return $EVENT(ctx, state, "BooleanLiteral", BooleanLiteral$0);
|
|
7004
|
+
}
|
|
7005
|
+
var _BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
7006
|
+
return value[1];
|
|
7007
|
+
});
|
|
7008
|
+
var _BooleanLiteral$1 = $TS($S($C($EXPECT($L27, '_BooleanLiteral "true"'), $EXPECT($L28, '_BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6935
7009
|
return { $loc, token: $1 };
|
|
6936
7010
|
});
|
|
6937
|
-
var
|
|
6938
|
-
function
|
|
6939
|
-
return $EVENT_C(ctx, state, "
|
|
7011
|
+
var _BooleanLiteral$$ = [_BooleanLiteral$0, _BooleanLiteral$1];
|
|
7012
|
+
function _BooleanLiteral(ctx, state) {
|
|
7013
|
+
return $EVENT_C(ctx, state, "_BooleanLiteral", _BooleanLiteral$$);
|
|
6940
7014
|
}
|
|
6941
7015
|
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L29, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L30, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6942
7016
|
return { $loc, token: "true" };
|
|
@@ -6948,13 +7022,14 @@ ${input.slice(result.pos)}
|
|
|
6948
7022
|
function CoffeeScriptBooleanLiteral(ctx, state) {
|
|
6949
7023
|
return $EVENT_C(ctx, state, "CoffeeScriptBooleanLiteral", CoffeeScriptBooleanLiteral$$);
|
|
6950
7024
|
}
|
|
6951
|
-
var Identifier$0 = $T($S($N(ReservedWord), IdentifierName), function(value) {
|
|
6952
|
-
|
|
7025
|
+
var Identifier$0 = $T($S($EXPECT($R11, "Identifier /(?=\\p{ID_Start}|[_$])/"), $N(ReservedWord), IdentifierName), function(value) {
|
|
7026
|
+
var id = value[2];
|
|
7027
|
+
return id;
|
|
6953
7028
|
});
|
|
6954
7029
|
function Identifier(ctx, state) {
|
|
6955
7030
|
return $EVENT(ctx, state, "Identifier", Identifier$0);
|
|
6956
7031
|
}
|
|
6957
|
-
var IdentifierName$0 = $TR($EXPECT($
|
|
7032
|
+
var IdentifierName$0 = $TR($EXPECT($R12, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
6958
7033
|
return {
|
|
6959
7034
|
type: "Identifier",
|
|
6960
7035
|
name: $0,
|
|
@@ -6976,10 +7051,16 @@ ${input.slice(result.pos)}
|
|
|
6976
7051
|
function UpcomingAssignment(ctx, state) {
|
|
6977
7052
|
return $EVENT(ctx, state, "UpcomingAssignment", UpcomingAssignment$0);
|
|
6978
7053
|
}
|
|
6979
|
-
var ArrayLiteral$0 = $T($S(
|
|
7054
|
+
var ArrayLiteral$0 = $T($S($EXPECT($R13, "ArrayLiteral /(?=\\[)/"), _ArrayLiteral), function(value) {
|
|
7055
|
+
return value[1];
|
|
7056
|
+
});
|
|
7057
|
+
function ArrayLiteral(ctx, state) {
|
|
7058
|
+
return $EVENT(ctx, state, "ArrayLiteral", ArrayLiteral$0);
|
|
7059
|
+
}
|
|
7060
|
+
var _ArrayLiteral$0 = $T($S(ArrayBindingPattern, UpcomingAssignment), function(value) {
|
|
6980
7061
|
return value[0];
|
|
6981
7062
|
});
|
|
6982
|
-
var
|
|
7063
|
+
var _ArrayLiteral$1 = $TS($S(OpenBracket, AllowAll, $E($S(ArrayLiteralContent, __, CloseBracket)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6983
7064
|
var open = $1;
|
|
6984
7065
|
if (!$3)
|
|
6985
7066
|
return $skip;
|
|
@@ -7003,9 +7084,9 @@ ${input.slice(result.pos)}
|
|
|
7003
7084
|
names
|
|
7004
7085
|
};
|
|
7005
7086
|
});
|
|
7006
|
-
var
|
|
7007
|
-
function
|
|
7008
|
-
return $EVENT_C(ctx, state, "
|
|
7087
|
+
var _ArrayLiteral$$ = [_ArrayLiteral$0, _ArrayLiteral$1];
|
|
7088
|
+
function _ArrayLiteral(ctx, state) {
|
|
7089
|
+
return $EVENT_C(ctx, state, "_ArrayLiteral", _ArrayLiteral$$);
|
|
7009
7090
|
}
|
|
7010
7091
|
var RangeExpression$0 = $TS($S(ExtendedExpression, __, $C(DotDotDot, DotDot), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7011
7092
|
var s = $1;
|
|
@@ -7370,7 +7451,7 @@ ${input.slice(result.pos)}
|
|
|
7370
7451
|
children: [ws, ...prop.children]
|
|
7371
7452
|
};
|
|
7372
7453
|
});
|
|
7373
|
-
var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($
|
|
7454
|
+
var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($R14, "PropertyDefinition /[!+-]/")), PropertyName), function($skip, $loc, $0, $1, $2, $3) {
|
|
7374
7455
|
var ws = $1;
|
|
7375
7456
|
var toggle = $2;
|
|
7376
7457
|
var id = $3;
|
|
@@ -7962,7 +8043,7 @@ ${input.slice(result.pos)}
|
|
|
7962
8043
|
var BinaryOpSymbol$14 = $T($EXPECT($L66, 'BinaryOpSymbol "\xAB"'), function(value) {
|
|
7963
8044
|
return "<<";
|
|
7964
8045
|
});
|
|
7965
|
-
var BinaryOpSymbol$15 = $TR($EXPECT($
|
|
8046
|
+
var BinaryOpSymbol$15 = $TR($EXPECT($R15, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7966
8047
|
return "<";
|
|
7967
8048
|
});
|
|
7968
8049
|
var BinaryOpSymbol$16 = $EXPECT($L67, 'BinaryOpSymbol ">>>"');
|
|
@@ -8001,36 +8082,33 @@ ${input.slice(result.pos)}
|
|
|
8001
8082
|
return "&&";
|
|
8002
8083
|
});
|
|
8003
8084
|
var BinaryOpSymbol$29 = $EXPECT($L83, 'BinaryOpSymbol "&&"');
|
|
8004
|
-
var BinaryOpSymbol$30 = $T($S(
|
|
8005
|
-
return "in";
|
|
8006
|
-
});
|
|
8007
|
-
var BinaryOpSymbol$31 = $T($S($EXPECT($L85, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
8085
|
+
var BinaryOpSymbol$30 = $T($S($EXPECT($L84, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
8008
8086
|
return "||";
|
|
8009
8087
|
});
|
|
8010
|
-
var BinaryOpSymbol$
|
|
8011
|
-
var BinaryOpSymbol$
|
|
8088
|
+
var BinaryOpSymbol$31 = $EXPECT($L85, 'BinaryOpSymbol "||"');
|
|
8089
|
+
var BinaryOpSymbol$32 = $T($EXPECT($L86, 'BinaryOpSymbol "\u2016"'), function(value) {
|
|
8012
8090
|
return "||";
|
|
8013
8091
|
});
|
|
8014
|
-
var BinaryOpSymbol$
|
|
8092
|
+
var BinaryOpSymbol$33 = $TV($C($EXPECT($L87, 'BinaryOpSymbol "^^"'), $S($EXPECT($L88, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8015
8093
|
return {
|
|
8016
8094
|
call: module.getRef("xor"),
|
|
8017
8095
|
special: true
|
|
8018
8096
|
};
|
|
8019
8097
|
});
|
|
8020
|
-
var BinaryOpSymbol$
|
|
8098
|
+
var BinaryOpSymbol$34 = $TV($C($EXPECT($R16, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L89, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8021
8099
|
return {
|
|
8022
8100
|
call: module.getRef("xnor"),
|
|
8023
8101
|
special: true
|
|
8024
8102
|
};
|
|
8025
8103
|
});
|
|
8026
|
-
var BinaryOpSymbol$
|
|
8027
|
-
var BinaryOpSymbol$
|
|
8104
|
+
var BinaryOpSymbol$35 = $EXPECT($L90, 'BinaryOpSymbol "??"');
|
|
8105
|
+
var BinaryOpSymbol$36 = $T($EXPECT($L91, 'BinaryOpSymbol "\u2047"'), function(value) {
|
|
8028
8106
|
return "??";
|
|
8029
8107
|
});
|
|
8030
|
-
var BinaryOpSymbol$
|
|
8108
|
+
var BinaryOpSymbol$37 = $T($S($EXPECT($L5, 'BinaryOpSymbol "?"'), CoffeeBinaryExistentialEnabled), function(value) {
|
|
8031
8109
|
return "??";
|
|
8032
8110
|
});
|
|
8033
|
-
var BinaryOpSymbol$
|
|
8111
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L92, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8034
8112
|
return {
|
|
8035
8113
|
$loc,
|
|
8036
8114
|
token: $1,
|
|
@@ -8039,24 +8117,15 @@ ${input.slice(result.pos)}
|
|
|
8039
8117
|
// for typeof shorthand
|
|
8040
8118
|
};
|
|
8041
8119
|
});
|
|
8042
|
-
var BinaryOpSymbol$
|
|
8043
|
-
|
|
8044
|
-
|
|
8045
|
-
token: "instanceof",
|
|
8046
|
-
relational: true,
|
|
8047
|
-
special: true,
|
|
8048
|
-
negated: true
|
|
8049
|
-
};
|
|
8120
|
+
var BinaryOpSymbol$39 = $T($S(CoffeeOfEnabled, CoffeeOfOp), function(value) {
|
|
8121
|
+
var op = value[1];
|
|
8122
|
+
return op;
|
|
8050
8123
|
});
|
|
8051
|
-
var BinaryOpSymbol$
|
|
8052
|
-
|
|
8053
|
-
|
|
8054
|
-
token: "in",
|
|
8055
|
-
special: true,
|
|
8056
|
-
negated: true
|
|
8057
|
-
};
|
|
8124
|
+
var BinaryOpSymbol$40 = $TS($S(Not, __, NotOp), function($skip, $loc, $0, $1, $2, $3) {
|
|
8125
|
+
var op = $3;
|
|
8126
|
+
return { ...op, $loc };
|
|
8058
8127
|
});
|
|
8059
|
-
var BinaryOpSymbol$
|
|
8128
|
+
var BinaryOpSymbol$41 = $TV($C($S(Is, __, In), $EXPECT($L93, 'BinaryOpSymbol "\u2208"')), function($skip, $loc, $0, $1) {
|
|
8060
8129
|
return {
|
|
8061
8130
|
method: "includes",
|
|
8062
8131
|
relational: true,
|
|
@@ -8064,14 +8133,14 @@ ${input.slice(result.pos)}
|
|
|
8064
8133
|
special: true
|
|
8065
8134
|
};
|
|
8066
8135
|
});
|
|
8067
|
-
var BinaryOpSymbol$
|
|
8136
|
+
var BinaryOpSymbol$42 = $TV($EXPECT($L94, 'BinaryOpSymbol "\u220B"'), function($skip, $loc, $0, $1) {
|
|
8068
8137
|
return {
|
|
8069
8138
|
method: "includes",
|
|
8070
8139
|
relational: true,
|
|
8071
8140
|
special: true
|
|
8072
8141
|
};
|
|
8073
8142
|
});
|
|
8074
|
-
var BinaryOpSymbol$
|
|
8143
|
+
var BinaryOpSymbol$43 = $TV($EXPECT($L95, 'BinaryOpSymbol "\u220C"'), function($skip, $loc, $0, $1) {
|
|
8075
8144
|
return {
|
|
8076
8145
|
method: "includes",
|
|
8077
8146
|
relational: true,
|
|
@@ -8079,16 +8148,7 @@ ${input.slice(result.pos)}
|
|
|
8079
8148
|
negated: true
|
|
8080
8149
|
};
|
|
8081
8150
|
});
|
|
8082
|
-
var BinaryOpSymbol$
|
|
8083
|
-
return {
|
|
8084
|
-
call: [module.getRef("indexOf"), ".call"],
|
|
8085
|
-
relational: true,
|
|
8086
|
-
reversed: true,
|
|
8087
|
-
suffix: " >= 0",
|
|
8088
|
-
special: true
|
|
8089
|
-
};
|
|
8090
|
-
});
|
|
8091
|
-
var BinaryOpSymbol$46 = $TV($C($S(Is, __, Not, __, In), $EXPECT($L97, 'BinaryOpSymbol "\u2209"')), function($skip, $loc, $0, $1) {
|
|
8151
|
+
var BinaryOpSymbol$44 = $TV($C($S(Is, __, Not, __, In), $EXPECT($L96, 'BinaryOpSymbol "\u2209"')), function($skip, $loc, $0, $1) {
|
|
8092
8152
|
return {
|
|
8093
8153
|
method: "includes",
|
|
8094
8154
|
relational: true,
|
|
@@ -8097,16 +8157,7 @@ ${input.slice(result.pos)}
|
|
|
8097
8157
|
negated: true
|
|
8098
8158
|
};
|
|
8099
8159
|
});
|
|
8100
|
-
var BinaryOpSymbol$
|
|
8101
|
-
return {
|
|
8102
|
-
call: [module.getRef("indexOf"), ".call"],
|
|
8103
|
-
relational: true,
|
|
8104
|
-
reversed: true,
|
|
8105
|
-
suffix: " < 0",
|
|
8106
|
-
special: true
|
|
8107
|
-
};
|
|
8108
|
-
});
|
|
8109
|
-
var BinaryOpSymbol$48 = $TS($S($N(CoffeeNotEnabled), Is, __, Not), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8160
|
+
var BinaryOpSymbol$45 = $TS($S($N(CoffeeNotEnabled), Is, __, Not), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8110
8161
|
if (module.config.objectIs) {
|
|
8111
8162
|
return {
|
|
8112
8163
|
call: module.getRef("is"),
|
|
@@ -8118,7 +8169,7 @@ ${input.slice(result.pos)}
|
|
|
8118
8169
|
}
|
|
8119
8170
|
return "!==";
|
|
8120
8171
|
});
|
|
8121
|
-
var BinaryOpSymbol$
|
|
8172
|
+
var BinaryOpSymbol$46 = $TS($S(Is), function($skip, $loc, $0, $1) {
|
|
8122
8173
|
if (module.config.objectIs) {
|
|
8123
8174
|
return {
|
|
8124
8175
|
call: module.getRef("is"),
|
|
@@ -8129,34 +8180,86 @@ ${input.slice(result.pos)}
|
|
|
8129
8180
|
}
|
|
8130
8181
|
return "===";
|
|
8131
8182
|
});
|
|
8132
|
-
var BinaryOpSymbol$
|
|
8133
|
-
|
|
8134
|
-
|
|
8135
|
-
var BinaryOpSymbol$
|
|
8136
|
-
var BinaryOpSymbol
|
|
8137
|
-
var BinaryOpSymbol$53 = $EXPECT($L99, 'BinaryOpSymbol "|"');
|
|
8138
|
-
var BinaryOpSymbol$$ = [BinaryOpSymbol$0, BinaryOpSymbol$1, BinaryOpSymbol$2, BinaryOpSymbol$3, BinaryOpSymbol$4, BinaryOpSymbol$5, BinaryOpSymbol$6, BinaryOpSymbol$7, BinaryOpSymbol$8, BinaryOpSymbol$9, BinaryOpSymbol$10, BinaryOpSymbol$11, BinaryOpSymbol$12, BinaryOpSymbol$13, BinaryOpSymbol$14, BinaryOpSymbol$15, BinaryOpSymbol$16, BinaryOpSymbol$17, BinaryOpSymbol$18, BinaryOpSymbol$19, BinaryOpSymbol$20, BinaryOpSymbol$21, BinaryOpSymbol$22, BinaryOpSymbol$23, BinaryOpSymbol$24, BinaryOpSymbol$25, BinaryOpSymbol$26, BinaryOpSymbol$27, BinaryOpSymbol$28, BinaryOpSymbol$29, BinaryOpSymbol$30, BinaryOpSymbol$31, BinaryOpSymbol$32, BinaryOpSymbol$33, BinaryOpSymbol$34, BinaryOpSymbol$35, BinaryOpSymbol$36, BinaryOpSymbol$37, BinaryOpSymbol$38, BinaryOpSymbol$39, BinaryOpSymbol$40, BinaryOpSymbol$41, BinaryOpSymbol$42, BinaryOpSymbol$43, BinaryOpSymbol$44, BinaryOpSymbol$45, BinaryOpSymbol$46, BinaryOpSymbol$47, BinaryOpSymbol$48, BinaryOpSymbol$49, BinaryOpSymbol$50, BinaryOpSymbol$51, BinaryOpSymbol$52, BinaryOpSymbol$53];
|
|
8183
|
+
var BinaryOpSymbol$47 = In;
|
|
8184
|
+
var BinaryOpSymbol$48 = $EXPECT($L97, 'BinaryOpSymbol "&"');
|
|
8185
|
+
var BinaryOpSymbol$49 = $EXPECT($L17, 'BinaryOpSymbol "^"');
|
|
8186
|
+
var BinaryOpSymbol$50 = $EXPECT($L98, 'BinaryOpSymbol "|"');
|
|
8187
|
+
var BinaryOpSymbol$$ = [BinaryOpSymbol$0, BinaryOpSymbol$1, BinaryOpSymbol$2, BinaryOpSymbol$3, BinaryOpSymbol$4, BinaryOpSymbol$5, BinaryOpSymbol$6, BinaryOpSymbol$7, BinaryOpSymbol$8, BinaryOpSymbol$9, BinaryOpSymbol$10, BinaryOpSymbol$11, BinaryOpSymbol$12, BinaryOpSymbol$13, BinaryOpSymbol$14, BinaryOpSymbol$15, BinaryOpSymbol$16, BinaryOpSymbol$17, BinaryOpSymbol$18, BinaryOpSymbol$19, BinaryOpSymbol$20, BinaryOpSymbol$21, BinaryOpSymbol$22, BinaryOpSymbol$23, BinaryOpSymbol$24, BinaryOpSymbol$25, BinaryOpSymbol$26, BinaryOpSymbol$27, BinaryOpSymbol$28, BinaryOpSymbol$29, BinaryOpSymbol$30, BinaryOpSymbol$31, BinaryOpSymbol$32, BinaryOpSymbol$33, BinaryOpSymbol$34, BinaryOpSymbol$35, BinaryOpSymbol$36, BinaryOpSymbol$37, BinaryOpSymbol$38, BinaryOpSymbol$39, BinaryOpSymbol$40, BinaryOpSymbol$41, BinaryOpSymbol$42, BinaryOpSymbol$43, BinaryOpSymbol$44, BinaryOpSymbol$45, BinaryOpSymbol$46, BinaryOpSymbol$47, BinaryOpSymbol$48, BinaryOpSymbol$49, BinaryOpSymbol$50];
|
|
8139
8188
|
function BinaryOpSymbol(ctx, state) {
|
|
8140
8189
|
return $EVENT_C(ctx, state, "BinaryOpSymbol", BinaryOpSymbol$$);
|
|
8141
8190
|
}
|
|
8142
|
-
var
|
|
8143
|
-
|
|
8191
|
+
var CoffeeOfOp$0 = $T($S(Of), function(value) {
|
|
8192
|
+
return "in";
|
|
8193
|
+
});
|
|
8194
|
+
var CoffeeOfOp$1 = $TS($S(In), function($skip, $loc, $0, $1) {
|
|
8195
|
+
return {
|
|
8196
|
+
call: [module.getRef("indexOf"), ".call"],
|
|
8197
|
+
relational: true,
|
|
8198
|
+
reversed: true,
|
|
8199
|
+
suffix: " >= 0",
|
|
8200
|
+
special: true
|
|
8201
|
+
};
|
|
8202
|
+
});
|
|
8203
|
+
var CoffeeOfOp$2 = $TS($S(Not, __, Of, NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8204
|
+
return {
|
|
8205
|
+
$loc,
|
|
8206
|
+
token: "in",
|
|
8207
|
+
special: true,
|
|
8208
|
+
negated: true
|
|
8209
|
+
};
|
|
8210
|
+
});
|
|
8211
|
+
var CoffeeOfOp$3 = $TS($S(Not, __, In), function($skip, $loc, $0, $1, $2, $3) {
|
|
8212
|
+
return {
|
|
8213
|
+
call: [module.getRef("indexOf"), ".call"],
|
|
8214
|
+
relational: true,
|
|
8215
|
+
reversed: true,
|
|
8216
|
+
suffix: " < 0",
|
|
8217
|
+
special: true
|
|
8218
|
+
};
|
|
8219
|
+
});
|
|
8220
|
+
var CoffeeOfOp$$ = [CoffeeOfOp$0, CoffeeOfOp$1, CoffeeOfOp$2, CoffeeOfOp$3];
|
|
8221
|
+
function CoffeeOfOp(ctx, state) {
|
|
8222
|
+
return $EVENT_C(ctx, state, "CoffeeOfOp", CoffeeOfOp$$);
|
|
8223
|
+
}
|
|
8224
|
+
var NotOp$0 = $TS($S($EXPECT($L92, 'NotOp "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8225
|
+
return {
|
|
8226
|
+
$loc,
|
|
8227
|
+
token: "instanceof",
|
|
8228
|
+
relational: true,
|
|
8229
|
+
special: true,
|
|
8230
|
+
negated: true
|
|
8231
|
+
};
|
|
8232
|
+
});
|
|
8233
|
+
var NotOp$1 = $TS($S(In), function($skip, $loc, $0, $1) {
|
|
8234
|
+
return {
|
|
8235
|
+
$loc,
|
|
8236
|
+
token: "in",
|
|
8237
|
+
special: true,
|
|
8238
|
+
negated: true
|
|
8239
|
+
};
|
|
8240
|
+
});
|
|
8241
|
+
var NotOp$$ = [NotOp$0, NotOp$1];
|
|
8242
|
+
function NotOp(ctx, state) {
|
|
8243
|
+
return $EVENT_C(ctx, state, "NotOp", NotOp$$);
|
|
8244
|
+
}
|
|
8245
|
+
var Xor$0 = $EXPECT($L87, 'Xor "^^"');
|
|
8246
|
+
var Xor$1 = $S($EXPECT($L88, 'Xor "xor"'), NonIdContinue);
|
|
8144
8247
|
var Xor$$ = [Xor$0, Xor$1];
|
|
8145
8248
|
function Xor(ctx, state) {
|
|
8146
8249
|
return $EVENT_C(ctx, state, "Xor", Xor$$);
|
|
8147
8250
|
}
|
|
8148
|
-
var Xnor$0 = $R$0($EXPECT($
|
|
8149
|
-
var Xnor$1 = $EXPECT($
|
|
8251
|
+
var Xnor$0 = $R$0($EXPECT($R16, "Xnor /!\\^\\^?/"));
|
|
8252
|
+
var Xnor$1 = $EXPECT($L89, 'Xnor "xnor"');
|
|
8150
8253
|
var Xnor$$ = [Xnor$0, Xnor$1];
|
|
8151
8254
|
function Xnor(ctx, state) {
|
|
8152
8255
|
return $EVENT_C(ctx, state, "Xnor", Xnor$$);
|
|
8153
8256
|
}
|
|
8154
|
-
var UnaryOp$0 = $TR($EXPECT($
|
|
8257
|
+
var UnaryOp$0 = $TR($EXPECT($R17, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8155
8258
|
return { $loc, token: $0 };
|
|
8156
8259
|
});
|
|
8157
8260
|
var UnaryOp$1 = AwaitOp;
|
|
8158
|
-
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($EXPECT($
|
|
8159
|
-
var UnaryOp$3 = $T($S(Not, $E($EXPECT($
|
|
8261
|
+
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($EXPECT($L11, 'UnaryOp ":"')), $E(_));
|
|
8262
|
+
var UnaryOp$3 = $T($S(Not, $E($EXPECT($L12, 'UnaryOp " "')), $E(_)), function(value) {
|
|
8160
8263
|
return [value[0], value[2]];
|
|
8161
8264
|
});
|
|
8162
8265
|
var UnaryOp$$ = [UnaryOp$0, UnaryOp$1, UnaryOp$2, UnaryOp$3];
|
|
@@ -8222,14 +8325,20 @@ ${input.slice(result.pos)}
|
|
|
8222
8325
|
function NonPipelinePostfixedExpression(ctx, state) {
|
|
8223
8326
|
return $EVENT(ctx, state, "NonPipelinePostfixedExpression", NonPipelinePostfixedExpression$0);
|
|
8224
8327
|
}
|
|
8225
|
-
var PostfixStatement$0 =
|
|
8226
|
-
|
|
8227
|
-
|
|
8228
|
-
var PostfixStatement$3 = UnlessClause;
|
|
8229
|
-
var PostfixStatement$4 = WhileClause;
|
|
8230
|
-
var PostfixStatement$$ = [PostfixStatement$0, PostfixStatement$1, PostfixStatement$2, PostfixStatement$3, PostfixStatement$4];
|
|
8328
|
+
var PostfixStatement$0 = $T($S($EXPECT($R18, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
|
|
8329
|
+
return value[1];
|
|
8330
|
+
});
|
|
8231
8331
|
function PostfixStatement(ctx, state) {
|
|
8232
|
-
return $
|
|
8332
|
+
return $EVENT(ctx, state, "PostfixStatement", PostfixStatement$0);
|
|
8333
|
+
}
|
|
8334
|
+
var _PostfixStatement$0 = ForClause;
|
|
8335
|
+
var _PostfixStatement$1 = IfClause;
|
|
8336
|
+
var _PostfixStatement$2 = LoopClause;
|
|
8337
|
+
var _PostfixStatement$3 = UnlessClause;
|
|
8338
|
+
var _PostfixStatement$4 = WhileClause;
|
|
8339
|
+
var _PostfixStatement$$ = [_PostfixStatement$0, _PostfixStatement$1, _PostfixStatement$2, _PostfixStatement$3, _PostfixStatement$4];
|
|
8340
|
+
function _PostfixStatement(ctx, state) {
|
|
8341
|
+
return $EVENT_C(ctx, state, "_PostfixStatement", _PostfixStatement$$);
|
|
8233
8342
|
}
|
|
8234
8343
|
var Statement$0 = KeywordStatement;
|
|
8235
8344
|
var Statement$1 = VariableStatement;
|
|
@@ -8250,7 +8359,7 @@ ${input.slice(result.pos)}
|
|
|
8250
8359
|
function Statement(ctx, state) {
|
|
8251
8360
|
return $EVENT_C(ctx, state, "Statement", Statement$$);
|
|
8252
8361
|
}
|
|
8253
|
-
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($
|
|
8362
|
+
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L99, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
|
|
8254
8363
|
return { type: "EmptyStatement", children: $1 || [] };
|
|
8255
8364
|
});
|
|
8256
8365
|
function EmptyStatement(ctx, state) {
|
|
@@ -8272,7 +8381,7 @@ ${input.slice(result.pos)}
|
|
|
8272
8381
|
var w = $3;
|
|
8273
8382
|
return [id, colon, w];
|
|
8274
8383
|
});
|
|
8275
|
-
var Label$1 = $S($EXPECT($
|
|
8384
|
+
var Label$1 = $S($EXPECT($L100, 'Label "$:"'), Whitespace);
|
|
8276
8385
|
var Label$$ = [Label$0, Label$1];
|
|
8277
8386
|
function Label(ctx, state) {
|
|
8278
8387
|
return $EVENT_C(ctx, state, "Label", Label$$);
|
|
@@ -8321,10 +8430,10 @@ ${input.slice(result.pos)}
|
|
|
8321
8430
|
kind = { ...kind, token: "if" };
|
|
8322
8431
|
kind.token += getTrimmingSpace(condition);
|
|
8323
8432
|
condition = insertTrimmingSpace(condition, "");
|
|
8433
|
+
condition = negateCondition(condition);
|
|
8324
8434
|
return {
|
|
8325
8435
|
type: "IfStatement",
|
|
8326
|
-
|
|
8327
|
-
children: [kind, ["(!", condition, ")"]],
|
|
8436
|
+
children: [kind, condition],
|
|
8328
8437
|
condition
|
|
8329
8438
|
};
|
|
8330
8439
|
});
|
|
@@ -8445,18 +8554,24 @@ ${input.slice(result.pos)}
|
|
|
8445
8554
|
function BlockExpressionPart(ctx, state) {
|
|
8446
8555
|
return $EVENT(ctx, state, "BlockExpressionPart", BlockExpressionPart$0);
|
|
8447
8556
|
}
|
|
8448
|
-
var IterationStatement$0 =
|
|
8449
|
-
|
|
8557
|
+
var IterationStatement$0 = $T($S($EXPECT($R19, "IterationStatement /(?=loop|do|for|until|while)/"), _IterationStatement), function(value) {
|
|
8558
|
+
return value[1];
|
|
8559
|
+
});
|
|
8560
|
+
function IterationStatement(ctx, state) {
|
|
8561
|
+
return $EVENT(ctx, state, "IterationStatement", IterationStatement$0);
|
|
8562
|
+
}
|
|
8563
|
+
var _IterationStatement$0 = LoopStatement;
|
|
8564
|
+
var _IterationStatement$1 = $T($S($N(CoffeeDoEnabled), DoWhileStatement), function(value) {
|
|
8450
8565
|
return value[1];
|
|
8451
8566
|
});
|
|
8452
|
-
var
|
|
8567
|
+
var _IterationStatement$2 = $T($S($N(CoffeeDoEnabled), DoStatement), function(value) {
|
|
8453
8568
|
return value[1];
|
|
8454
8569
|
});
|
|
8455
|
-
var
|
|
8456
|
-
var
|
|
8457
|
-
var
|
|
8458
|
-
function
|
|
8459
|
-
return $EVENT_C(ctx, state, "
|
|
8570
|
+
var _IterationStatement$3 = WhileStatement;
|
|
8571
|
+
var _IterationStatement$4 = ForStatement;
|
|
8572
|
+
var _IterationStatement$$ = [_IterationStatement$0, _IterationStatement$1, _IterationStatement$2, _IterationStatement$3, _IterationStatement$4];
|
|
8573
|
+
function _IterationStatement(ctx, state) {
|
|
8574
|
+
return $EVENT_C(ctx, state, "_IterationStatement", _IterationStatement$$);
|
|
8460
8575
|
}
|
|
8461
8576
|
var IterationExpression$0 = $TS($S($E($S(Async, __)), IterationStatement), function($skip, $loc, $0, $1, $2) {
|
|
8462
8577
|
var async = $1;
|
|
@@ -8527,16 +8642,12 @@ ${input.slice(result.pos)}
|
|
|
8527
8642
|
var ws = $2;
|
|
8528
8643
|
var condition = $3;
|
|
8529
8644
|
if (kind.token === "until") {
|
|
8530
|
-
kind
|
|
8531
|
-
|
|
8532
|
-
type: "IterationStatement",
|
|
8533
|
-
children: [kind, ...ws, ["(!", ...condition.children, ")"]],
|
|
8534
|
-
condition
|
|
8535
|
-
};
|
|
8645
|
+
kind = { ...kind, token: "while" };
|
|
8646
|
+
condition = negateCondition(condition);
|
|
8536
8647
|
}
|
|
8537
8648
|
return {
|
|
8538
8649
|
type: "IterationStatement",
|
|
8539
|
-
children: [kind,
|
|
8650
|
+
children: [kind, ws, condition],
|
|
8540
8651
|
condition
|
|
8541
8652
|
};
|
|
8542
8653
|
});
|
|
@@ -8795,7 +8906,7 @@ ${input.slice(result.pos)}
|
|
|
8795
8906
|
names: binding.names
|
|
8796
8907
|
};
|
|
8797
8908
|
});
|
|
8798
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
8909
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R20, "ForDeclaration /(?=[\\s\\),])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
8799
8910
|
var c = $1;
|
|
8800
8911
|
var binding = $2;
|
|
8801
8912
|
return {
|
|
@@ -9021,7 +9132,7 @@ ${input.slice(result.pos)}
|
|
|
9021
9132
|
function IgnoreColon(ctx, state) {
|
|
9022
9133
|
return $EVENT(ctx, state, "IgnoreColon", IgnoreColon$0);
|
|
9023
9134
|
}
|
|
9024
|
-
var TryStatement$0 = $TS($S(Try, $N($EXPECT($
|
|
9135
|
+
var TryStatement$0 = $TS($S(Try, $N($EXPECT($L11, 'TryStatement ":"')), NoPostfixBracedOrEmptyBlock, $E(CatchClause), $E(FinallyClause)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
9025
9136
|
var t = $1;
|
|
9026
9137
|
var b = $3;
|
|
9027
9138
|
var c = $4;
|
|
@@ -9329,7 +9440,7 @@ ${input.slice(result.pos)}
|
|
|
9329
9440
|
};
|
|
9330
9441
|
});
|
|
9331
9442
|
var KeywordStatement$2 = DebuggerStatement;
|
|
9332
|
-
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($
|
|
9443
|
+
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L11, 'KeywordStatement ":"'), $EXPECT($L6, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
|
|
9333
9444
|
var expression = value[2];
|
|
9334
9445
|
return { "type": "ReturnStatement", "expression": expression, "children": value };
|
|
9335
9446
|
});
|
|
@@ -9350,19 +9461,19 @@ ${input.slice(result.pos)}
|
|
|
9350
9461
|
function ThrowStatement(ctx, state) {
|
|
9351
9462
|
return $EVENT(ctx, state, "ThrowStatement", ThrowStatement$0);
|
|
9352
9463
|
}
|
|
9353
|
-
var Break$0 = $TS($S($EXPECT($
|
|
9464
|
+
var Break$0 = $TS($S($EXPECT($L101, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9354
9465
|
return { $loc, token: $1 };
|
|
9355
9466
|
});
|
|
9356
9467
|
function Break(ctx, state) {
|
|
9357
9468
|
return $EVENT(ctx, state, "Break", Break$0);
|
|
9358
9469
|
}
|
|
9359
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
9470
|
+
var Continue$0 = $TS($S($EXPECT($L102, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9360
9471
|
return { $loc, token: $1 };
|
|
9361
9472
|
});
|
|
9362
9473
|
function Continue(ctx, state) {
|
|
9363
9474
|
return $EVENT(ctx, state, "Continue", Continue$0);
|
|
9364
9475
|
}
|
|
9365
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
9476
|
+
var Debugger$0 = $TS($S($EXPECT($L103, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9366
9477
|
return { $loc, token: $1 };
|
|
9367
9478
|
});
|
|
9368
9479
|
function Debugger(ctx, state) {
|
|
@@ -9483,7 +9594,7 @@ ${input.slice(result.pos)}
|
|
|
9483
9594
|
function FromClause(ctx, state) {
|
|
9484
9595
|
return $EVENT(ctx, state, "FromClause", FromClause$0);
|
|
9485
9596
|
}
|
|
9486
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
9597
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L104, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
9487
9598
|
function ImportAssertion(ctx, state) {
|
|
9488
9599
|
return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
|
|
9489
9600
|
}
|
|
@@ -9531,7 +9642,7 @@ ${input.slice(result.pos)}
|
|
|
9531
9642
|
return $EVENT_C(ctx, state, "ImportSpecifier", ImportSpecifier$$);
|
|
9532
9643
|
}
|
|
9533
9644
|
var ImportAsToken$0 = $S(__, As);
|
|
9534
|
-
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($
|
|
9645
|
+
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($L12, 'ImportAsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
9535
9646
|
var l = $1;
|
|
9536
9647
|
var ws = $2;
|
|
9537
9648
|
var c = $3;
|
|
@@ -9571,7 +9682,7 @@ ${input.slice(result.pos)}
|
|
|
9571
9682
|
function UnprocessedModuleSpecifier(ctx, state) {
|
|
9572
9683
|
return $EVENT_C(ctx, state, "UnprocessedModuleSpecifier", UnprocessedModuleSpecifier$$);
|
|
9573
9684
|
}
|
|
9574
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
9685
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R21, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
9575
9686
|
var spec = $0;
|
|
9576
9687
|
return { $loc, token: `"${spec}"` };
|
|
9577
9688
|
});
|
|
@@ -9703,13 +9814,13 @@ ${input.slice(result.pos)}
|
|
|
9703
9814
|
function LexicalDeclaration(ctx, state) {
|
|
9704
9815
|
return $EVENT_C(ctx, state, "LexicalDeclaration", LexicalDeclaration$$);
|
|
9705
9816
|
}
|
|
9706
|
-
var ConstAssignment$0 = $TV($C($EXPECT($
|
|
9817
|
+
var ConstAssignment$0 = $TV($C($EXPECT($L105, 'ConstAssignment ":="'), $EXPECT($L106, 'ConstAssignment "\u2254"')), function($skip, $loc, $0, $1) {
|
|
9707
9818
|
return { $loc, token: "=" };
|
|
9708
9819
|
});
|
|
9709
9820
|
function ConstAssignment(ctx, state) {
|
|
9710
9821
|
return $EVENT(ctx, state, "ConstAssignment", ConstAssignment$0);
|
|
9711
9822
|
}
|
|
9712
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
9823
|
+
var LetAssignment$0 = $TV($EXPECT($L107, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
9713
9824
|
return { $loc, token: "=" };
|
|
9714
9825
|
});
|
|
9715
9826
|
function LetAssignment(ctx, state) {
|
|
@@ -9777,8 +9888,9 @@ ${input.slice(result.pos)}
|
|
|
9777
9888
|
function VariableDeclarationList(ctx, state) {
|
|
9778
9889
|
return $EVENT(ctx, state, "VariableDeclarationList", VariableDeclarationList$0);
|
|
9779
9890
|
}
|
|
9780
|
-
var NumericLiteral$0 = $TS($S(NumericLiteralKind), function($skip, $loc, $0, $1) {
|
|
9781
|
-
|
|
9891
|
+
var NumericLiteral$0 = $TS($S($EXPECT($R22, "NumericLiteral /(?=[0-9.])/"), NumericLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
9892
|
+
var token = $2;
|
|
9893
|
+
return { type: "NumericLiteral", $loc, token };
|
|
9782
9894
|
});
|
|
9783
9895
|
function NumericLiteral(ctx, state) {
|
|
9784
9896
|
return $EVENT(ctx, state, "NumericLiteral", NumericLiteral$0);
|
|
@@ -9792,37 +9904,38 @@ ${input.slice(result.pos)}
|
|
|
9792
9904
|
function NumericLiteralKind(ctx, state) {
|
|
9793
9905
|
return $EVENT_C(ctx, state, "NumericLiteralKind", NumericLiteralKind$$);
|
|
9794
9906
|
}
|
|
9795
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
9907
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R23, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
9796
9908
|
function DecimalBigIntegerLiteral(ctx, state) {
|
|
9797
9909
|
return $EVENT(ctx, state, "DecimalBigIntegerLiteral", DecimalBigIntegerLiteral$0);
|
|
9798
9910
|
}
|
|
9799
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
9911
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R24, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
9800
9912
|
return $1 + ".";
|
|
9801
9913
|
});
|
|
9802
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
9803
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
9914
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R25, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
9915
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R26, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
9804
9916
|
var DecimalLiteral$$ = [DecimalLiteral$0, DecimalLiteral$1, DecimalLiteral$2];
|
|
9805
9917
|
function DecimalLiteral(ctx, state) {
|
|
9806
9918
|
return $EVENT_C(ctx, state, "DecimalLiteral", DecimalLiteral$$);
|
|
9807
9919
|
}
|
|
9808
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
9920
|
+
var ExponentPart$0 = $R$0($EXPECT($R27, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
9809
9921
|
function ExponentPart(ctx, state) {
|
|
9810
9922
|
return $EVENT(ctx, state, "ExponentPart", ExponentPart$0);
|
|
9811
9923
|
}
|
|
9812
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
9924
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R28, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
9813
9925
|
function BinaryIntegerLiteral(ctx, state) {
|
|
9814
9926
|
return $EVENT(ctx, state, "BinaryIntegerLiteral", BinaryIntegerLiteral$0);
|
|
9815
9927
|
}
|
|
9816
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
9928
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R29, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
9817
9929
|
function OctalIntegerLiteral(ctx, state) {
|
|
9818
9930
|
return $EVENT(ctx, state, "OctalIntegerLiteral", OctalIntegerLiteral$0);
|
|
9819
9931
|
}
|
|
9820
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
9932
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R30, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
9821
9933
|
function HexIntegerLiteral(ctx, state) {
|
|
9822
9934
|
return $EVENT(ctx, state, "HexIntegerLiteral", HexIntegerLiteral$0);
|
|
9823
9935
|
}
|
|
9824
|
-
var IntegerLiteral$0 = $TS($S(IntegerLiteralKind), function($skip, $loc, $0, $1) {
|
|
9825
|
-
|
|
9936
|
+
var IntegerLiteral$0 = $TS($S($EXPECT($R31, "IntegerLiteral /(?=[0-9])/"), IntegerLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
9937
|
+
var token = $2;
|
|
9938
|
+
return { $loc, token };
|
|
9826
9939
|
});
|
|
9827
9940
|
function IntegerLiteral(ctx, state) {
|
|
9828
9941
|
return $EVENT(ctx, state, "IntegerLiteral", IntegerLiteral$0);
|
|
@@ -9836,7 +9949,7 @@ ${input.slice(result.pos)}
|
|
|
9836
9949
|
function IntegerLiteralKind(ctx, state) {
|
|
9837
9950
|
return $EVENT_C(ctx, state, "IntegerLiteralKind", IntegerLiteralKind$$);
|
|
9838
9951
|
}
|
|
9839
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
9952
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R32, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
9840
9953
|
function DecimalIntegerLiteral(ctx, state) {
|
|
9841
9954
|
return $EVENT(ctx, state, "DecimalIntegerLiteral", DecimalIntegerLiteral$0);
|
|
9842
9955
|
}
|
|
@@ -9860,25 +9973,25 @@ ${input.slice(result.pos)}
|
|
|
9860
9973
|
function StringLiteral(ctx, state) {
|
|
9861
9974
|
return $EVENT_C(ctx, state, "StringLiteral", StringLiteral$$);
|
|
9862
9975
|
}
|
|
9863
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
9976
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R33, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9864
9977
|
return { $loc, token: $0 };
|
|
9865
9978
|
});
|
|
9866
9979
|
function DoubleStringCharacters(ctx, state) {
|
|
9867
9980
|
return $EVENT(ctx, state, "DoubleStringCharacters", DoubleStringCharacters$0);
|
|
9868
9981
|
}
|
|
9869
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
9982
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R34, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9870
9983
|
return { $loc, token: $0 };
|
|
9871
9984
|
});
|
|
9872
9985
|
function SingleStringCharacters(ctx, state) {
|
|
9873
9986
|
return $EVENT(ctx, state, "SingleStringCharacters", SingleStringCharacters$0);
|
|
9874
9987
|
}
|
|
9875
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
9988
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R35, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9876
9989
|
return { $loc, token: $0 };
|
|
9877
9990
|
});
|
|
9878
9991
|
function TripleDoubleStringCharacters(ctx, state) {
|
|
9879
9992
|
return $EVENT(ctx, state, "TripleDoubleStringCharacters", TripleDoubleStringCharacters$0);
|
|
9880
9993
|
}
|
|
9881
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
9994
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R36, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9882
9995
|
return { $loc, token: $0 };
|
|
9883
9996
|
});
|
|
9884
9997
|
function TripleSingleStringCharacters(ctx, state) {
|
|
@@ -9897,7 +10010,7 @@ ${input.slice(result.pos)}
|
|
|
9897
10010
|
function CoffeeInterpolatedDoubleQuotedString(ctx, state) {
|
|
9898
10011
|
return $EVENT(ctx, state, "CoffeeInterpolatedDoubleQuotedString", CoffeeInterpolatedDoubleQuotedString$0);
|
|
9899
10012
|
}
|
|
9900
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
10013
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R37, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9901
10014
|
return { $loc, token: $0 };
|
|
9902
10015
|
});
|
|
9903
10016
|
function CoffeeDoubleQuotedStringCharacters(ctx, state) {
|
|
@@ -9917,7 +10030,7 @@ ${input.slice(result.pos)}
|
|
|
9917
10030
|
function RegularExpressionClass(ctx, state) {
|
|
9918
10031
|
return $EVENT(ctx, state, "RegularExpressionClass", RegularExpressionClass$0);
|
|
9919
10032
|
}
|
|
9920
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
10033
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R38, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9921
10034
|
return { $loc, token: $0 };
|
|
9922
10035
|
});
|
|
9923
10036
|
function RegularExpressionClassCharacters(ctx, state) {
|
|
@@ -9971,7 +10084,7 @@ ${input.slice(result.pos)}
|
|
|
9971
10084
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
9972
10085
|
return { "type": "Substitution", "children": value[0] };
|
|
9973
10086
|
});
|
|
9974
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
10087
|
+
var HeregexPart$3 = $TR($EXPECT($R39, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9975
10088
|
let token = $0;
|
|
9976
10089
|
switch ($0[1]) {
|
|
9977
10090
|
case "\n":
|
|
@@ -9989,13 +10102,13 @@ ${input.slice(result.pos)}
|
|
|
9989
10102
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
9990
10103
|
return { $loc, token: "" };
|
|
9991
10104
|
});
|
|
9992
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
10105
|
+
var HeregexPart$5 = $TR($EXPECT($R40, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9993
10106
|
return { $loc, token: "" };
|
|
9994
10107
|
});
|
|
9995
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
10108
|
+
var HeregexPart$6 = $TR($EXPECT($R41, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9996
10109
|
return { $loc, token: "\\/" };
|
|
9997
10110
|
});
|
|
9998
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
10111
|
+
var HeregexPart$7 = $TR($EXPECT($R42, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9999
10112
|
return { $loc, token: $0 };
|
|
10000
10113
|
});
|
|
10001
10114
|
var HeregexPart$$ = [HeregexPart$0, HeregexPart$1, HeregexPart$2, HeregexPart$3, HeregexPart$4, HeregexPart$5, HeregexPart$6, HeregexPart$7];
|
|
@@ -10008,7 +10121,7 @@ ${input.slice(result.pos)}
|
|
|
10008
10121
|
function HeregexComment(ctx, state) {
|
|
10009
10122
|
return $EVENT_C(ctx, state, "HeregexComment", HeregexComment$$);
|
|
10010
10123
|
}
|
|
10011
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
10124
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R43, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
10012
10125
|
function RegularExpressionBody(ctx, state) {
|
|
10013
10126
|
return $EVENT(ctx, state, "RegularExpressionBody", RegularExpressionBody$0);
|
|
10014
10127
|
}
|
|
@@ -10018,27 +10131,33 @@ ${input.slice(result.pos)}
|
|
|
10018
10131
|
function RegExpPart(ctx, state) {
|
|
10019
10132
|
return $EVENT_C(ctx, state, "RegExpPart", RegExpPart$$);
|
|
10020
10133
|
}
|
|
10021
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
10134
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R44, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
10022
10135
|
function RegExpCharacter(ctx, state) {
|
|
10023
10136
|
return $EVENT(ctx, state, "RegExpCharacter", RegExpCharacter$0);
|
|
10024
10137
|
}
|
|
10025
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
10138
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R45, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
10026
10139
|
function RegularExpressionFlags(ctx, state) {
|
|
10027
10140
|
return $EVENT(ctx, state, "RegularExpressionFlags", RegularExpressionFlags$0);
|
|
10028
10141
|
}
|
|
10029
|
-
var TemplateLiteral$0 = $
|
|
10142
|
+
var TemplateLiteral$0 = $T($S($EXPECT($R46, "TemplateLiteral /(?=[`'\"])/"), _TemplateLiteral), function(value) {
|
|
10143
|
+
return value[1];
|
|
10144
|
+
});
|
|
10145
|
+
function TemplateLiteral(ctx, state) {
|
|
10146
|
+
return $EVENT(ctx, state, "TemplateLiteral", TemplateLiteral$0);
|
|
10147
|
+
}
|
|
10148
|
+
var _TemplateLiteral$0 = $TS($S(TripleTick, $Q($C(TemplateBlockCharacters, TemplateSubstitution)), TripleTick), function($skip, $loc, $0, $1, $2, $3) {
|
|
10030
10149
|
return dedentBlockSubstitutions($0, module.config.tab);
|
|
10031
10150
|
});
|
|
10032
|
-
var
|
|
10151
|
+
var _TemplateLiteral$1 = $TS($S(Backtick, $Q($C(TemplateCharacters, TemplateSubstitution)), Backtick), function($skip, $loc, $0, $1, $2, $3) {
|
|
10033
10152
|
return {
|
|
10034
10153
|
type: "TemplateLiteral",
|
|
10035
10154
|
children: $0
|
|
10036
10155
|
};
|
|
10037
10156
|
});
|
|
10038
|
-
var
|
|
10157
|
+
var _TemplateLiteral$2 = $TS($S(TripleDoubleQuote, $Q($C(TripleDoubleStringCharacters, CoffeeStringSubstitution)), TripleDoubleQuote), function($skip, $loc, $0, $1, $2, $3) {
|
|
10039
10158
|
return dedentBlockSubstitutions($0, module.config.tab);
|
|
10040
10159
|
});
|
|
10041
|
-
var
|
|
10160
|
+
var _TemplateLiteral$3 = $TS($S(TripleSingleQuote, TripleSingleStringCharacters, TripleSingleQuote), function($skip, $loc, $0, $1, $2, $3) {
|
|
10042
10161
|
var s = $1;
|
|
10043
10162
|
var str = $2;
|
|
10044
10163
|
var e = $3;
|
|
@@ -10047,41 +10166,47 @@ ${input.slice(result.pos)}
|
|
|
10047
10166
|
children: [s, dedentBlockString(str, module.config.tab), e]
|
|
10048
10167
|
};
|
|
10049
10168
|
});
|
|
10050
|
-
var
|
|
10051
|
-
var
|
|
10052
|
-
function
|
|
10053
|
-
return $EVENT_C(ctx, state, "
|
|
10169
|
+
var _TemplateLiteral$4 = CoffeeInterpolatedDoubleQuotedString;
|
|
10170
|
+
var _TemplateLiteral$$ = [_TemplateLiteral$0, _TemplateLiteral$1, _TemplateLiteral$2, _TemplateLiteral$3, _TemplateLiteral$4];
|
|
10171
|
+
function _TemplateLiteral(ctx, state) {
|
|
10172
|
+
return $EVENT_C(ctx, state, "_TemplateLiteral", _TemplateLiteral$$);
|
|
10054
10173
|
}
|
|
10055
10174
|
var TemplateSubstitution$0 = $S(SubstitutionStart, PostfixedExpression, __, CloseBrace);
|
|
10056
10175
|
function TemplateSubstitution(ctx, state) {
|
|
10057
10176
|
return $EVENT(ctx, state, "TemplateSubstitution", TemplateSubstitution$0);
|
|
10058
10177
|
}
|
|
10059
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
10178
|
+
var TemplateCharacters$0 = $TR($EXPECT($R47, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10060
10179
|
return { $loc, token: $0 };
|
|
10061
10180
|
});
|
|
10062
10181
|
function TemplateCharacters(ctx, state) {
|
|
10063
10182
|
return $EVENT(ctx, state, "TemplateCharacters", TemplateCharacters$0);
|
|
10064
10183
|
}
|
|
10065
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
10184
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R48, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10066
10185
|
return { $loc, token: $0 };
|
|
10067
10186
|
});
|
|
10068
10187
|
function TemplateBlockCharacters(ctx, state) {
|
|
10069
10188
|
return $EVENT(ctx, state, "TemplateBlockCharacters", TemplateBlockCharacters$0);
|
|
10070
10189
|
}
|
|
10071
|
-
var ReservedWord$0 = $S(
|
|
10072
|
-
var ReservedWord$1 = $S(
|
|
10073
|
-
var ReservedWord$2 = $S(
|
|
10074
|
-
var ReservedWord$3 = $S(
|
|
10075
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
10190
|
+
var ReservedWord$0 = $S($R$0($EXPECT($R49, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")), CoffeeBooleansEnabled);
|
|
10191
|
+
var ReservedWord$1 = $S($R$0($EXPECT($R50, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")), CoffeeIsntEnabled);
|
|
10192
|
+
var ReservedWord$2 = $S($R$0($EXPECT($R51, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")), CoffeeForLoopsEnabled);
|
|
10193
|
+
var ReservedWord$3 = $S($R$0($EXPECT($R52, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")), CoffeeOfEnabled);
|
|
10194
|
+
var ReservedWord$4 = $R$0($EXPECT($R53, "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})/"));
|
|
10076
10195
|
var ReservedWord$$ = [ReservedWord$0, ReservedWord$1, ReservedWord$2, ReservedWord$3, ReservedWord$4];
|
|
10077
10196
|
function ReservedWord(ctx, state) {
|
|
10078
10197
|
return $EVENT_C(ctx, state, "ReservedWord", ReservedWord$$);
|
|
10079
10198
|
}
|
|
10080
|
-
var Comment$0 =
|
|
10081
|
-
|
|
10082
|
-
|
|
10199
|
+
var Comment$0 = $T($S($EXPECT($R54, "Comment /(?=\\/|#)/"), _Comment), function(value) {
|
|
10200
|
+
return value[1];
|
|
10201
|
+
});
|
|
10083
10202
|
function Comment(ctx, state) {
|
|
10084
|
-
return $
|
|
10203
|
+
return $EVENT(ctx, state, "Comment", Comment$0);
|
|
10204
|
+
}
|
|
10205
|
+
var _Comment$0 = MultiLineComment;
|
|
10206
|
+
var _Comment$1 = SingleLineComment;
|
|
10207
|
+
var _Comment$$ = [_Comment$0, _Comment$1];
|
|
10208
|
+
function _Comment(ctx, state) {
|
|
10209
|
+
return $EVENT_C(ctx, state, "_Comment", _Comment$$);
|
|
10085
10210
|
}
|
|
10086
10211
|
var SingleLineComment$0 = JSSingleLineComment;
|
|
10087
10212
|
var SingleLineComment$1 = $S(CoffeeCommentEnabled, CoffeeSingleLineComment);
|
|
@@ -10089,7 +10214,7 @@ ${input.slice(result.pos)}
|
|
|
10089
10214
|
function SingleLineComment(ctx, state) {
|
|
10090
10215
|
return $EVENT_C(ctx, state, "SingleLineComment", SingleLineComment$$);
|
|
10091
10216
|
}
|
|
10092
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
10217
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R55, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10093
10218
|
return { type: "Comment", $loc, token: $0 };
|
|
10094
10219
|
});
|
|
10095
10220
|
function JSSingleLineComment(ctx, state) {
|
|
@@ -10101,30 +10226,30 @@ ${input.slice(result.pos)}
|
|
|
10101
10226
|
function MultiLineComment(ctx, state) {
|
|
10102
10227
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
10103
10228
|
}
|
|
10104
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
10229
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L108, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L109, 'JSMultiLineComment "*/"')), $EXPECT($R56, "JSMultiLineComment /./"))), $EXPECT($L109, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
10105
10230
|
return { type: "Comment", $loc, token: $1 };
|
|
10106
10231
|
});
|
|
10107
10232
|
function JSMultiLineComment(ctx, state) {
|
|
10108
10233
|
return $EVENT(ctx, state, "JSMultiLineComment", JSMultiLineComment$0);
|
|
10109
10234
|
}
|
|
10110
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
10235
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R57, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10111
10236
|
return { type: "Comment", $loc, token: `//${$1}` };
|
|
10112
10237
|
});
|
|
10113
10238
|
function CoffeeSingleLineComment(ctx, state) {
|
|
10114
10239
|
return $EVENT(ctx, state, "CoffeeSingleLineComment", CoffeeSingleLineComment$0);
|
|
10115
10240
|
}
|
|
10116
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
10241
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R58, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
10117
10242
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
10118
10243
|
return { type: "Comment", $loc, token: `/*${$2}*/` };
|
|
10119
10244
|
});
|
|
10120
10245
|
function CoffeeMultiLineComment(ctx, state) {
|
|
10121
10246
|
return $EVENT(ctx, state, "CoffeeMultiLineComment", CoffeeMultiLineComment$0);
|
|
10122
10247
|
}
|
|
10123
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
10248
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R59, "CoffeeHereCommentStart /###(?!#)/"));
|
|
10124
10249
|
function CoffeeHereCommentStart(ctx, state) {
|
|
10125
10250
|
return $EVENT(ctx, state, "CoffeeHereCommentStart", CoffeeHereCommentStart$0);
|
|
10126
10251
|
}
|
|
10127
|
-
var InlineComment$0 = $TR($EXPECT($
|
|
10252
|
+
var InlineComment$0 = $TR($EXPECT($R60, "InlineComment /\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\//"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10128
10253
|
return { $loc, token: $0 };
|
|
10129
10254
|
});
|
|
10130
10255
|
function InlineComment(ctx, state) {
|
|
@@ -10138,15 +10263,17 @@ ${input.slice(result.pos)}
|
|
|
10138
10263
|
function TrailingComment(ctx, state) {
|
|
10139
10264
|
return $EVENT(ctx, state, "TrailingComment", TrailingComment$0);
|
|
10140
10265
|
}
|
|
10141
|
-
var _$0 = $P($C(NonNewlineWhitespace, InlineComment))
|
|
10266
|
+
var _$0 = $T($S($EXPECT($R61, "_ /(?=[ \\t\\/\\\\])/"), $P($C(NonNewlineWhitespace, InlineComment))), function(value) {
|
|
10267
|
+
return value[1];
|
|
10268
|
+
});
|
|
10142
10269
|
function _(ctx, state) {
|
|
10143
10270
|
return $EVENT(ctx, state, "_", _$0);
|
|
10144
10271
|
}
|
|
10145
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
10272
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R62, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10146
10273
|
return { $loc, token: $0 };
|
|
10147
10274
|
});
|
|
10148
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
10149
|
-
return "";
|
|
10275
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L110, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
10276
|
+
return " ";
|
|
10150
10277
|
});
|
|
10151
10278
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
10152
10279
|
function NonNewlineWhitespace(ctx, state) {
|
|
@@ -10159,11 +10286,15 @@ ${input.slice(result.pos)}
|
|
|
10159
10286
|
function Trimmed_(ctx, state) {
|
|
10160
10287
|
return $EVENT(ctx, state, "Trimmed_", Trimmed_$0);
|
|
10161
10288
|
}
|
|
10162
|
-
var __$0 = $Q($C(Whitespace, Comment))
|
|
10289
|
+
var __$0 = $T($S($EXPECT($R63, "__ /(?=\\s|\\/|#)/"), $Q($C(Whitespace, Comment))), function(value) {
|
|
10290
|
+
return value[1];
|
|
10291
|
+
});
|
|
10292
|
+
var __$1 = $EXPECT($L0, '__ ""');
|
|
10293
|
+
var __$$ = [__$0, __$1];
|
|
10163
10294
|
function __(ctx, state) {
|
|
10164
|
-
return $
|
|
10295
|
+
return $EVENT_C(ctx, state, "__", __$$);
|
|
10165
10296
|
}
|
|
10166
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
10297
|
+
var Whitespace$0 = $TR($EXPECT($R40, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10167
10298
|
return { $loc, token: $0 };
|
|
10168
10299
|
});
|
|
10169
10300
|
function Whitespace(ctx, state) {
|
|
@@ -10186,9 +10317,9 @@ ${input.slice(result.pos)}
|
|
|
10186
10317
|
return $EVENT_C(ctx, state, "SimpleStatementDelimiter", SimpleStatementDelimiter$$);
|
|
10187
10318
|
}
|
|
10188
10319
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
10189
|
-
var StatementDelimiter$1 = $S($Y($S(Nested, $C($EXPECT($L4, 'StatementDelimiter "("'), $EXPECT($
|
|
10320
|
+
var StatementDelimiter$1 = $S($Y($S(Nested, $C($EXPECT($L4, 'StatementDelimiter "("'), $EXPECT($L111, 'StatementDelimiter "["'), $EXPECT($L112, 'StatementDelimiter "`"'), $EXPECT($L58, 'StatementDelimiter "+"'), $EXPECT($L18, 'StatementDelimiter "-"'), $EXPECT($L54, 'StatementDelimiter "*"'), $EXPECT($L55, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, FatArrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L4, 'StatementDelimiter "("'))))), InsertSemicolon);
|
|
10190
10321
|
var StatementDelimiter$2 = $Y(EOS);
|
|
10191
|
-
var StatementDelimiter$3 = $Y($S($Q(_), $C($EXPECT($L25, 'StatementDelimiter "}"'), $EXPECT($
|
|
10322
|
+
var StatementDelimiter$3 = $Y($S($Q(_), $C($EXPECT($L25, 'StatementDelimiter "}"'), $EXPECT($L113, 'StatementDelimiter ")"'), $EXPECT($L34, 'StatementDelimiter "]"'))));
|
|
10192
10323
|
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2, StatementDelimiter$3];
|
|
10193
10324
|
function StatementDelimiter(ctx, state) {
|
|
10194
10325
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
@@ -10202,7 +10333,7 @@ ${input.slice(result.pos)}
|
|
|
10202
10333
|
function SemicolonDelimiter(ctx, state) {
|
|
10203
10334
|
return $EVENT(ctx, state, "SemicolonDelimiter", SemicolonDelimiter$0);
|
|
10204
10335
|
}
|
|
10205
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
10336
|
+
var NonIdContinue$0 = $R$0($EXPECT($R64, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
10206
10337
|
function NonIdContinue(ctx, state) {
|
|
10207
10338
|
return $EVENT(ctx, state, "NonIdContinue", NonIdContinue$0);
|
|
10208
10339
|
}
|
|
@@ -10212,73 +10343,73 @@ ${input.slice(result.pos)}
|
|
|
10212
10343
|
function Loc(ctx, state) {
|
|
10213
10344
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
10214
10345
|
}
|
|
10215
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
10346
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L114, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L12, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
10216
10347
|
return { $loc, token: $1, ts: true };
|
|
10217
10348
|
});
|
|
10218
10349
|
function Abstract(ctx, state) {
|
|
10219
10350
|
return $EVENT(ctx, state, "Abstract", Abstract$0);
|
|
10220
10351
|
}
|
|
10221
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
10352
|
+
var Ampersand$0 = $TV($EXPECT($L97, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
10222
10353
|
return { $loc, token: $1 };
|
|
10223
10354
|
});
|
|
10224
10355
|
function Ampersand(ctx, state) {
|
|
10225
10356
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
10226
10357
|
}
|
|
10227
|
-
var As$0 = $TS($S($EXPECT($
|
|
10358
|
+
var As$0 = $TS($S($EXPECT($L115, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10228
10359
|
return { $loc, token: $1 };
|
|
10229
10360
|
});
|
|
10230
10361
|
function As(ctx, state) {
|
|
10231
10362
|
return $EVENT(ctx, state, "As", As$0);
|
|
10232
10363
|
}
|
|
10233
|
-
var At$0 = $TV($EXPECT($
|
|
10364
|
+
var At$0 = $TV($EXPECT($L116, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
10234
10365
|
return { $loc, token: $1 };
|
|
10235
10366
|
});
|
|
10236
10367
|
function At(ctx, state) {
|
|
10237
10368
|
return $EVENT(ctx, state, "At", At$0);
|
|
10238
10369
|
}
|
|
10239
|
-
var AtAt$0 = $TV($EXPECT($
|
|
10370
|
+
var AtAt$0 = $TV($EXPECT($L117, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
10240
10371
|
return { $loc, token: "@" };
|
|
10241
10372
|
});
|
|
10242
10373
|
function AtAt(ctx, state) {
|
|
10243
10374
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
10244
10375
|
}
|
|
10245
|
-
var Async$0 = $TS($S($EXPECT($
|
|
10376
|
+
var Async$0 = $TS($S($EXPECT($L118, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10246
10377
|
return { $loc, token: $1, type: "Async" };
|
|
10247
10378
|
});
|
|
10248
10379
|
function Async(ctx, state) {
|
|
10249
10380
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
10250
10381
|
}
|
|
10251
|
-
var Await$0 = $TS($S($EXPECT($
|
|
10382
|
+
var Await$0 = $TS($S($EXPECT($L119, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10252
10383
|
return { $loc, token: $1, type: "Await" };
|
|
10253
10384
|
});
|
|
10254
10385
|
function Await(ctx, state) {
|
|
10255
10386
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
10256
10387
|
}
|
|
10257
|
-
var Backtick$0 = $TV($EXPECT($
|
|
10388
|
+
var Backtick$0 = $TV($EXPECT($L112, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
10258
10389
|
return { $loc, token: $1 };
|
|
10259
10390
|
});
|
|
10260
10391
|
function Backtick(ctx, state) {
|
|
10261
10392
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
10262
10393
|
}
|
|
10263
|
-
var By$0 = $TS($S($EXPECT($
|
|
10394
|
+
var By$0 = $TS($S($EXPECT($L120, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10264
10395
|
return { $loc, token: $1 };
|
|
10265
10396
|
});
|
|
10266
10397
|
function By(ctx, state) {
|
|
10267
10398
|
return $EVENT(ctx, state, "By", By$0);
|
|
10268
10399
|
}
|
|
10269
|
-
var Case$0 = $TS($S($EXPECT($
|
|
10400
|
+
var Case$0 = $TS($S($EXPECT($L121, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10270
10401
|
return { $loc, token: $1 };
|
|
10271
10402
|
});
|
|
10272
10403
|
function Case(ctx, state) {
|
|
10273
10404
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
10274
10405
|
}
|
|
10275
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
10406
|
+
var Catch$0 = $TS($S($EXPECT($L122, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10276
10407
|
return { $loc, token: $1 };
|
|
10277
10408
|
});
|
|
10278
10409
|
function Catch(ctx, state) {
|
|
10279
10410
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
10280
10411
|
}
|
|
10281
|
-
var Class$0 = $TS($S($EXPECT($
|
|
10412
|
+
var Class$0 = $TS($S($EXPECT($L123, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10282
10413
|
return { $loc, token: $1 };
|
|
10283
10414
|
});
|
|
10284
10415
|
function Class(ctx, state) {
|
|
@@ -10296,19 +10427,19 @@ ${input.slice(result.pos)}
|
|
|
10296
10427
|
function CloseBracket(ctx, state) {
|
|
10297
10428
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
10298
10429
|
}
|
|
10299
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
10430
|
+
var CloseParen$0 = $TV($EXPECT($L113, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
10300
10431
|
return { $loc, token: $1 };
|
|
10301
10432
|
});
|
|
10302
10433
|
function CloseParen(ctx, state) {
|
|
10303
10434
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
10304
10435
|
}
|
|
10305
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
10436
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L124, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
10306
10437
|
return { $loc, token: "${" };
|
|
10307
10438
|
});
|
|
10308
10439
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
10309
10440
|
return $EVENT(ctx, state, "CoffeeSubstitutionStart", CoffeeSubstitutionStart$0);
|
|
10310
10441
|
}
|
|
10311
|
-
var Colon$0 = $TS($S($EXPECT($
|
|
10442
|
+
var Colon$0 = $TS($S($EXPECT($L11, 'Colon ":"'), $N($EXPECT($L3, 'Colon "="'))), function($skip, $loc, $0, $1, $2) {
|
|
10312
10443
|
return { $loc, token: $1 };
|
|
10313
10444
|
});
|
|
10314
10445
|
function Colon(ctx, state) {
|
|
@@ -10320,31 +10451,31 @@ ${input.slice(result.pos)}
|
|
|
10320
10451
|
function Comma(ctx, state) {
|
|
10321
10452
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
10322
10453
|
}
|
|
10323
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
10454
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L116, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
10324
10455
|
return { $loc, token: "constructor" };
|
|
10325
10456
|
});
|
|
10326
10457
|
function ConstructorShorthand(ctx, state) {
|
|
10327
10458
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
10328
10459
|
}
|
|
10329
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
10460
|
+
var Declare$0 = $TS($S($EXPECT($L125, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10330
10461
|
return { $loc, token: $1 };
|
|
10331
10462
|
});
|
|
10332
10463
|
function Declare(ctx, state) {
|
|
10333
10464
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
10334
10465
|
}
|
|
10335
|
-
var Default$0 = $TS($S($EXPECT($
|
|
10466
|
+
var Default$0 = $TS($S($EXPECT($L126, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10336
10467
|
return { $loc, token: $1 };
|
|
10337
10468
|
});
|
|
10338
10469
|
function Default(ctx, state) {
|
|
10339
10470
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
10340
10471
|
}
|
|
10341
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
10472
|
+
var Delete$0 = $TS($S($EXPECT($L127, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10342
10473
|
return { $loc, token: $1 };
|
|
10343
10474
|
});
|
|
10344
10475
|
function Delete(ctx, state) {
|
|
10345
10476
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
10346
10477
|
}
|
|
10347
|
-
var Do$0 = $TS($S($EXPECT($
|
|
10478
|
+
var Do$0 = $TS($S($EXPECT($L128, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10348
10479
|
return { $loc, token: $1 };
|
|
10349
10480
|
});
|
|
10350
10481
|
function Do(ctx, state) {
|
|
@@ -10353,7 +10484,7 @@ ${input.slice(result.pos)}
|
|
|
10353
10484
|
var Dot$0 = $TV($EXPECT($L6, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
10354
10485
|
return { $loc, token: $1 };
|
|
10355
10486
|
});
|
|
10356
|
-
var Dot$1 = $TS($S($EXPECT($
|
|
10487
|
+
var Dot$1 = $TS($S($EXPECT($R65, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
|
|
10357
10488
|
var ws = $2;
|
|
10358
10489
|
return [
|
|
10359
10490
|
{ $loc, token: "." },
|
|
@@ -10364,45 +10495,45 @@ ${input.slice(result.pos)}
|
|
|
10364
10495
|
function Dot(ctx, state) {
|
|
10365
10496
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
10366
10497
|
}
|
|
10367
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
10498
|
+
var DotDot$0 = $TS($S($EXPECT($L129, 'DotDot ".."'), $N($EXPECT($L6, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
10368
10499
|
return { $loc, token: $1 };
|
|
10369
10500
|
});
|
|
10370
|
-
var DotDot$1 = $TV($EXPECT($
|
|
10501
|
+
var DotDot$1 = $TV($EXPECT($L130, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
10371
10502
|
return { $loc, token: ".." };
|
|
10372
10503
|
});
|
|
10373
10504
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
10374
10505
|
function DotDot(ctx, state) {
|
|
10375
10506
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
10376
10507
|
}
|
|
10377
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
10508
|
+
var DotDotDot$0 = $TV($EXPECT($L131, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
10378
10509
|
return { $loc, token: $1 };
|
|
10379
10510
|
});
|
|
10380
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
10511
|
+
var DotDotDot$1 = $TV($EXPECT($L132, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
10381
10512
|
return { $loc, token: "..." };
|
|
10382
10513
|
});
|
|
10383
10514
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
10384
10515
|
function DotDotDot(ctx, state) {
|
|
10385
10516
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
10386
10517
|
}
|
|
10387
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
10518
|
+
var DoubleColon$0 = $TV($EXPECT($L133, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
10388
10519
|
return { $loc, token: $1 };
|
|
10389
10520
|
});
|
|
10390
10521
|
function DoubleColon(ctx, state) {
|
|
10391
10522
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
10392
10523
|
}
|
|
10393
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
10524
|
+
var DoubleQuote$0 = $TV($EXPECT($L134, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
10394
10525
|
return { $loc, token: $1 };
|
|
10395
10526
|
});
|
|
10396
10527
|
function DoubleQuote(ctx, state) {
|
|
10397
10528
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
10398
10529
|
}
|
|
10399
|
-
var Each$0 = $TS($S($EXPECT($
|
|
10530
|
+
var Each$0 = $TS($S($EXPECT($L135, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10400
10531
|
return { $loc, token: $1 };
|
|
10401
10532
|
});
|
|
10402
10533
|
function Each(ctx, state) {
|
|
10403
10534
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
10404
10535
|
}
|
|
10405
|
-
var Else$0 = $TS($S($EXPECT($
|
|
10536
|
+
var Else$0 = $TS($S($EXPECT($L136, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10406
10537
|
return { $loc, token: $1 };
|
|
10407
10538
|
});
|
|
10408
10539
|
function Else(ctx, state) {
|
|
@@ -10414,85 +10545,85 @@ ${input.slice(result.pos)}
|
|
|
10414
10545
|
function Equals(ctx, state) {
|
|
10415
10546
|
return $EVENT(ctx, state, "Equals", Equals$0);
|
|
10416
10547
|
}
|
|
10417
|
-
var Export$0 = $TS($S($EXPECT($
|
|
10548
|
+
var Export$0 = $TS($S($EXPECT($L137, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10418
10549
|
return { $loc, token: $1 };
|
|
10419
10550
|
});
|
|
10420
10551
|
function Export(ctx, state) {
|
|
10421
10552
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
10422
10553
|
}
|
|
10423
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
10554
|
+
var Extends$0 = $TS($S($EXPECT($L138, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10424
10555
|
return { $loc, token: $1 };
|
|
10425
10556
|
});
|
|
10426
10557
|
function Extends(ctx, state) {
|
|
10427
10558
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
10428
10559
|
}
|
|
10429
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
10560
|
+
var Finally$0 = $TS($S($EXPECT($L139, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10430
10561
|
return { $loc, token: $1 };
|
|
10431
10562
|
});
|
|
10432
10563
|
function Finally(ctx, state) {
|
|
10433
10564
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
10434
10565
|
}
|
|
10435
|
-
var For$0 = $TS($S($EXPECT($
|
|
10566
|
+
var For$0 = $TS($S($EXPECT($L140, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10436
10567
|
return { $loc, token: $1 };
|
|
10437
10568
|
});
|
|
10438
10569
|
function For(ctx, state) {
|
|
10439
10570
|
return $EVENT(ctx, state, "For", For$0);
|
|
10440
10571
|
}
|
|
10441
|
-
var From$0 = $TS($S($EXPECT($
|
|
10572
|
+
var From$0 = $TS($S($EXPECT($L141, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10442
10573
|
return { $loc, token: $1 };
|
|
10443
10574
|
});
|
|
10444
10575
|
function From(ctx, state) {
|
|
10445
10576
|
return $EVENT(ctx, state, "From", From$0);
|
|
10446
10577
|
}
|
|
10447
|
-
var Function$0 = $TS($S($EXPECT($
|
|
10578
|
+
var Function$0 = $TS($S($EXPECT($L142, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10448
10579
|
return { $loc, token: $1 };
|
|
10449
10580
|
});
|
|
10450
10581
|
function Function(ctx, state) {
|
|
10451
10582
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
10452
10583
|
}
|
|
10453
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
10584
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L143, 'GetOrSet "get"'), $EXPECT($L144, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10454
10585
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
10455
10586
|
});
|
|
10456
10587
|
function GetOrSet(ctx, state) {
|
|
10457
10588
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
10458
10589
|
}
|
|
10459
|
-
var Hash$0 = $TV($EXPECT($
|
|
10590
|
+
var Hash$0 = $TV($EXPECT($L145, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
10460
10591
|
return { $loc, token: $1 };
|
|
10461
10592
|
});
|
|
10462
10593
|
function Hash(ctx, state) {
|
|
10463
10594
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
10464
10595
|
}
|
|
10465
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
10596
|
+
var If$0 = $TV($TEXT($S($EXPECT($L146, 'If "if"'), NonIdContinue, $E($EXPECT($L12, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
10466
10597
|
return { $loc, token: $1 };
|
|
10467
10598
|
});
|
|
10468
10599
|
function If(ctx, state) {
|
|
10469
10600
|
return $EVENT(ctx, state, "If", If$0);
|
|
10470
10601
|
}
|
|
10471
|
-
var Import$0 = $TS($S($EXPECT($L15, 'Import "import"'), $Y($EXPECT($
|
|
10602
|
+
var Import$0 = $TS($S($EXPECT($L15, 'Import "import"'), $Y($EXPECT($R66, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
10472
10603
|
return { $loc, token: $1 };
|
|
10473
10604
|
});
|
|
10474
10605
|
function Import(ctx, state) {
|
|
10475
10606
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
10476
10607
|
}
|
|
10477
|
-
var In$0 = $TS($S($EXPECT($
|
|
10608
|
+
var In$0 = $TS($S($EXPECT($L147, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10478
10609
|
return { $loc, token: $1 };
|
|
10479
10610
|
});
|
|
10480
10611
|
function In(ctx, state) {
|
|
10481
10612
|
return $EVENT(ctx, state, "In", In$0);
|
|
10482
10613
|
}
|
|
10483
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
10614
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L148, 'LetOrConst "let"'), $EXPECT($L149, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10484
10615
|
return { $loc, token: $1 };
|
|
10485
10616
|
});
|
|
10486
10617
|
function LetOrConst(ctx, state) {
|
|
10487
10618
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
10488
10619
|
}
|
|
10489
|
-
var Const$0 = $TS($S($EXPECT($
|
|
10620
|
+
var Const$0 = $TS($S($EXPECT($L149, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10490
10621
|
return { $loc, token: $1 };
|
|
10491
10622
|
});
|
|
10492
10623
|
function Const(ctx, state) {
|
|
10493
10624
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
10494
10625
|
}
|
|
10495
|
-
var Is$0 = $TS($S($EXPECT($
|
|
10626
|
+
var Is$0 = $TS($S($EXPECT($L150, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10496
10627
|
return { $loc, token: $1 };
|
|
10497
10628
|
});
|
|
10498
10629
|
function Is(ctx, state) {
|
|
@@ -10504,25 +10635,25 @@ ${input.slice(result.pos)}
|
|
|
10504
10635
|
function LetOrConstOrVar(ctx, state) {
|
|
10505
10636
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
10506
10637
|
}
|
|
10507
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
10638
|
+
var Loop$0 = $TS($S($EXPECT($L151, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10508
10639
|
return { $loc, token: "while(true)" };
|
|
10509
10640
|
});
|
|
10510
10641
|
function Loop(ctx, state) {
|
|
10511
10642
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
10512
10643
|
}
|
|
10513
|
-
var New$0 = $TS($S($EXPECT($
|
|
10644
|
+
var New$0 = $TS($S($EXPECT($L152, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10514
10645
|
return { $loc, token: $1 };
|
|
10515
10646
|
});
|
|
10516
10647
|
function New(ctx, state) {
|
|
10517
10648
|
return $EVENT(ctx, state, "New", New$0);
|
|
10518
10649
|
}
|
|
10519
|
-
var Not$0 = $TS($S($EXPECT($
|
|
10650
|
+
var Not$0 = $TS($S($EXPECT($L153, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L11, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
10520
10651
|
return { $loc, token: "!" };
|
|
10521
10652
|
});
|
|
10522
10653
|
function Not(ctx, state) {
|
|
10523
10654
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
10524
10655
|
}
|
|
10525
|
-
var Of$0 = $TS($S($EXPECT($
|
|
10656
|
+
var Of$0 = $TS($S($EXPECT($L154, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10526
10657
|
return { $loc, token: $1 };
|
|
10527
10658
|
});
|
|
10528
10659
|
function Of(ctx, state) {
|
|
@@ -10540,7 +10671,7 @@ ${input.slice(result.pos)}
|
|
|
10540
10671
|
function OpenBrace(ctx, state) {
|
|
10541
10672
|
return $EVENT(ctx, state, "OpenBrace", OpenBrace$0);
|
|
10542
10673
|
}
|
|
10543
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
10674
|
+
var OpenBracket$0 = $TV($EXPECT($L111, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
10544
10675
|
return { $loc, token: $1 };
|
|
10545
10676
|
});
|
|
10546
10677
|
function OpenBracket(ctx, state) {
|
|
@@ -10619,7 +10750,7 @@ ${input.slice(result.pos)}
|
|
|
10619
10750
|
function Satisfies(ctx, state) {
|
|
10620
10751
|
return $EVENT(ctx, state, "Satisfies", Satisfies$0);
|
|
10621
10752
|
}
|
|
10622
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
10753
|
+
var Semicolon$0 = $TV($EXPECT($L99, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
10623
10754
|
return { $loc, token: $1 };
|
|
10624
10755
|
});
|
|
10625
10756
|
function Semicolon(ctx, state) {
|
|
@@ -10640,7 +10771,7 @@ ${input.slice(result.pos)}
|
|
|
10640
10771
|
var Static$0 = $TS($S($EXPECT($L171, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10641
10772
|
return { $loc, token: $1 };
|
|
10642
10773
|
});
|
|
10643
|
-
var Static$1 = $TS($S($EXPECT($
|
|
10774
|
+
var Static$1 = $TS($S($EXPECT($L116, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L116, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
10644
10775
|
return { $loc, token: "static " };
|
|
10645
10776
|
});
|
|
10646
10777
|
var Static$$ = [Static$0, Static$1];
|
|
@@ -10929,7 +11060,7 @@ ${input.slice(result.pos)}
|
|
|
10929
11060
|
function JSXClosingFragment(ctx, state) {
|
|
10930
11061
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
10931
11062
|
}
|
|
10932
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
11063
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L145, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
10933
11064
|
return module.config.defaultElement;
|
|
10934
11065
|
});
|
|
10935
11066
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -10937,7 +11068,7 @@ ${input.slice(result.pos)}
|
|
|
10937
11068
|
function JSXElementName(ctx, state) {
|
|
10938
11069
|
return $EVENT_C(ctx, state, "JSXElementName", JSXElementName$$);
|
|
10939
11070
|
}
|
|
10940
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
11071
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R67, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
10941
11072
|
function JSXIdentifierName(ctx, state) {
|
|
10942
11073
|
return $EVENT(ctx, state, "JSXIdentifierName", JSXIdentifierName$0);
|
|
10943
11074
|
}
|
|
@@ -11101,7 +11232,7 @@ ${input.slice(result.pos)}
|
|
|
11101
11232
|
}
|
|
11102
11233
|
return $skip;
|
|
11103
11234
|
});
|
|
11104
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
11235
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L145, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
11105
11236
|
return [" ", "id=", $2];
|
|
11106
11237
|
});
|
|
11107
11238
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -11110,7 +11241,7 @@ ${input.slice(result.pos)}
|
|
|
11110
11241
|
class: $2
|
|
11111
11242
|
};
|
|
11112
11243
|
});
|
|
11113
|
-
var JSXAttribute$7 = $TS($S($TEXT($EXPECT($
|
|
11244
|
+
var JSXAttribute$7 = $TS($S($TEXT($EXPECT($R14, "JSXAttribute /[!+-]/")), JSXAttributeName, $Y(JSXAttributeSpace)), function($skip, $loc, $0, $1, $2, $3) {
|
|
11114
11245
|
var toggle = $1;
|
|
11115
11246
|
var id = $2;
|
|
11116
11247
|
const value = toggle === "+" ? "true" : "false";
|
|
@@ -11120,11 +11251,11 @@ ${input.slice(result.pos)}
|
|
|
11120
11251
|
function JSXAttribute(ctx, state) {
|
|
11121
11252
|
return $EVENT_C(ctx, state, "JSXAttribute", JSXAttribute$$);
|
|
11122
11253
|
}
|
|
11123
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
11254
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R68, "JSXAttributeSpace /[\\s>]|\\/>/"));
|
|
11124
11255
|
function JSXAttributeSpace(ctx, state) {
|
|
11125
11256
|
return $EVENT(ctx, state, "JSXAttributeSpace", JSXAttributeSpace$0);
|
|
11126
11257
|
}
|
|
11127
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
11258
|
+
var JSXShorthandString$0 = $TR($EXPECT($R69, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11128
11259
|
return quoteString($0);
|
|
11129
11260
|
});
|
|
11130
11261
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -11158,7 +11289,7 @@ ${input.slice(result.pos)}
|
|
|
11158
11289
|
}
|
|
11159
11290
|
return [open, value, close];
|
|
11160
11291
|
});
|
|
11161
|
-
var JSXAttributeValue$4 = $R$0($EXPECT($
|
|
11292
|
+
var JSXAttributeValue$4 = $R$0($EXPECT($R70, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
|
|
11162
11293
|
var JSXAttributeValue$$ = [JSXAttributeValue$0, JSXAttributeValue$1, JSXAttributeValue$2, JSXAttributeValue$3, JSXAttributeValue$4];
|
|
11163
11294
|
function JSXAttributeValue(ctx, state) {
|
|
11164
11295
|
return $EVENT_C(ctx, state, "JSXAttributeValue", JSXAttributeValue$$);
|
|
@@ -11171,7 +11302,7 @@ ${input.slice(result.pos)}
|
|
|
11171
11302
|
function InlineJSXAttributeValue(ctx, state) {
|
|
11172
11303
|
return $EVENT(ctx, state, "InlineJSXAttributeValue", InlineJSXAttributeValue$0);
|
|
11173
11304
|
}
|
|
11174
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
11305
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R71, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
11175
11306
|
var op = $2;
|
|
11176
11307
|
var rhs = $3;
|
|
11177
11308
|
return [[], op, [], rhs];
|
|
@@ -11188,7 +11319,7 @@ ${input.slice(result.pos)}
|
|
|
11188
11319
|
function InlineJSXUnaryExpression(ctx, state) {
|
|
11189
11320
|
return $EVENT(ctx, state, "InlineJSXUnaryExpression", InlineJSXUnaryExpression$0);
|
|
11190
11321
|
}
|
|
11191
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
11322
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R72, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11192
11323
|
return { $loc, token: $0 };
|
|
11193
11324
|
});
|
|
11194
11325
|
function InlineJSXUnaryOp(ctx, state) {
|
|
@@ -11255,7 +11386,7 @@ ${input.slice(result.pos)}
|
|
|
11255
11386
|
}
|
|
11256
11387
|
return $1;
|
|
11257
11388
|
});
|
|
11258
|
-
var InlineJSXCallExpressionRest$2 = $TS($S($E(
|
|
11389
|
+
var InlineJSXCallExpressionRest$2 = $TS($S($E(OptionalShorthand), ExplicitArguments), function($skip, $loc, $0, $1, $2) {
|
|
11259
11390
|
var args = $2;
|
|
11260
11391
|
args = { type: "Call", children: args };
|
|
11261
11392
|
if (!$1)
|
|
@@ -11279,7 +11410,7 @@ ${input.slice(result.pos)}
|
|
|
11279
11410
|
function InlineJSXMemberExpression(ctx, state) {
|
|
11280
11411
|
return $EVENT(ctx, state, "InlineJSXMemberExpression", InlineJSXMemberExpression$0);
|
|
11281
11412
|
}
|
|
11282
|
-
var InlineJSXMemberExpressionRest$0 = $TS($S($E(
|
|
11413
|
+
var InlineJSXMemberExpressionRest$0 = $TS($S($E(OptionalShorthand), MemberBracketContent), function($skip, $loc, $0, $1, $2) {
|
|
11283
11414
|
if ($1) {
|
|
11284
11415
|
if ($1.type === "Optional" && $2.type === "SliceExpression") {
|
|
11285
11416
|
return [$1.children[0], $2];
|
|
@@ -11400,13 +11531,13 @@ ${input.slice(result.pos)}
|
|
|
11400
11531
|
function JSXComment(ctx, state) {
|
|
11401
11532
|
return $EVENT(ctx, state, "JSXComment", JSXComment$0);
|
|
11402
11533
|
}
|
|
11403
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
11534
|
+
var JSXCommentContent$0 = $TR($EXPECT($R73, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11404
11535
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
11405
11536
|
});
|
|
11406
11537
|
function JSXCommentContent(ctx, state) {
|
|
11407
11538
|
return $EVENT(ctx, state, "JSXCommentContent", JSXCommentContent$0);
|
|
11408
11539
|
}
|
|
11409
|
-
var JSXText$0 = $TR($EXPECT($
|
|
11540
|
+
var JSXText$0 = $TR($EXPECT($R74, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11410
11541
|
return {
|
|
11411
11542
|
type: "JSXText",
|
|
11412
11543
|
token: $0,
|
|
@@ -11771,7 +11902,7 @@ ${input.slice(result.pos)}
|
|
|
11771
11902
|
function TypeProperty(ctx, state) {
|
|
11772
11903
|
return $EVENT(ctx, state, "TypeProperty", TypeProperty$0);
|
|
11773
11904
|
}
|
|
11774
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
11905
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R75, "TypeIndexSignature /[+-]?/")), Readonly, NotDedented)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R76, "TypeIndexSignature /[+-]/")), $Y($S($E(_), QuestionMark)))));
|
|
11775
11906
|
function TypeIndexSignature(ctx, state) {
|
|
11776
11907
|
return $EVENT(ctx, state, "TypeIndexSignature", TypeIndexSignature$0);
|
|
11777
11908
|
}
|
|
@@ -11822,7 +11953,7 @@ ${input.slice(result.pos)}
|
|
|
11822
11953
|
function ReturnType(ctx, state) {
|
|
11823
11954
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
11824
11955
|
}
|
|
11825
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
11956
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L150, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
11826
11957
|
var lhs = $1;
|
|
11827
11958
|
var rhs = $2;
|
|
11828
11959
|
if (!rhs)
|
|
@@ -11984,7 +12115,7 @@ ${input.slice(result.pos)}
|
|
|
11984
12115
|
function NestedType(ctx, state) {
|
|
11985
12116
|
return $EVENT(ctx, state, "NestedType", NestedType$0);
|
|
11986
12117
|
}
|
|
11987
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
12118
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L138, 'TypeConditional "extends"'), NonIdContinue, Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
11988
12119
|
if ($2)
|
|
11989
12120
|
return $0;
|
|
11990
12121
|
return $1;
|
|
@@ -12044,16 +12175,16 @@ ${input.slice(result.pos)}
|
|
|
12044
12175
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
12045
12176
|
return value[1];
|
|
12046
12177
|
});
|
|
12047
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
12178
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L113, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L34, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L25, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
12048
12179
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
12049
12180
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
12050
12181
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
12051
12182
|
return $EVENT_C(ctx, state, "InlineInterfacePropertyDelimiter", InlineInterfacePropertyDelimiter$$);
|
|
12052
12183
|
}
|
|
12053
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
12184
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L98, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
12054
12185
|
return { $loc, token: "|" };
|
|
12055
12186
|
});
|
|
12056
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
12187
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L97, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
12057
12188
|
return { $loc, token: "&" };
|
|
12058
12189
|
});
|
|
12059
12190
|
var TypeBinaryOp$$ = [TypeBinaryOp$0, TypeBinaryOp$1];
|
|
@@ -12103,11 +12234,11 @@ ${input.slice(result.pos)}
|
|
|
12103
12234
|
function TypeParameters(ctx, state) {
|
|
12104
12235
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
12105
12236
|
}
|
|
12106
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
12237
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L149, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
12107
12238
|
function TypeParameter(ctx, state) {
|
|
12108
12239
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
12109
12240
|
}
|
|
12110
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
12241
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L138, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
12111
12242
|
function TypeConstraint(ctx, state) {
|
|
12112
12243
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
12113
12244
|
}
|
|
@@ -12130,15 +12261,15 @@ ${input.slice(result.pos)}
|
|
|
12130
12261
|
function ThisType(ctx, state) {
|
|
12131
12262
|
return $EVENT(ctx, state, "ThisType", ThisType$0);
|
|
12132
12263
|
}
|
|
12133
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
12264
|
+
var Shebang$0 = $S($R$0($EXPECT($R77, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
12134
12265
|
function Shebang(ctx, state) {
|
|
12135
12266
|
return $EVENT(ctx, state, "Shebang", Shebang$0);
|
|
12136
12267
|
}
|
|
12137
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
12268
|
+
var CivetPrologue$0 = $T($S($EXPECT($R78, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, SimpleStatementDelimiter, $E(EOS)), function(value) {
|
|
12138
12269
|
var content = value[2];
|
|
12139
12270
|
return content;
|
|
12140
12271
|
});
|
|
12141
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
12272
|
+
var CivetPrologue$1 = $T($S($EXPECT($R78, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, SimpleStatementDelimiter, $E(EOS)), function(value) {
|
|
12142
12273
|
var content = value[2];
|
|
12143
12274
|
return content;
|
|
12144
12275
|
});
|
|
@@ -12146,7 +12277,7 @@ ${input.slice(result.pos)}
|
|
|
12146
12277
|
function CivetPrologue(ctx, state) {
|
|
12147
12278
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
12148
12279
|
}
|
|
12149
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($
|
|
12280
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R79, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
12150
12281
|
var options = $3;
|
|
12151
12282
|
return {
|
|
12152
12283
|
type: "CivetPrologue",
|
|
@@ -12157,7 +12288,7 @@ ${input.slice(result.pos)}
|
|
|
12157
12288
|
function CivetPrologueContent(ctx, state) {
|
|
12158
12289
|
return $EVENT(ctx, state, "CivetPrologueContent", CivetPrologueContent$0);
|
|
12159
12290
|
}
|
|
12160
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
12291
|
+
var CivetOption$0 = $TR($EXPECT($R80, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12161
12292
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
12162
12293
|
if (l)
|
|
12163
12294
|
return l.toUpperCase();
|
|
@@ -12174,11 +12305,11 @@ ${input.slice(result.pos)}
|
|
|
12174
12305
|
function CivetOption(ctx, state) {
|
|
12175
12306
|
return $EVENT(ctx, state, "CivetOption", CivetOption$0);
|
|
12176
12307
|
}
|
|
12177
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
12308
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R78, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
12178
12309
|
function UnknownPrologue(ctx, state) {
|
|
12179
12310
|
return $EVENT(ctx, state, "UnknownPrologue", UnknownPrologue$0);
|
|
12180
12311
|
}
|
|
12181
|
-
var TripleSlashDirective$0 = $S($R$0($EXPECT($
|
|
12312
|
+
var TripleSlashDirective$0 = $S($R$0($EXPECT($R81, "TripleSlashDirective /\\/\\/\\/[^\\r\\n]*/")), $E(EOS));
|
|
12182
12313
|
function TripleSlashDirective(ctx, state) {
|
|
12183
12314
|
return $EVENT(ctx, state, "TripleSlashDirective", TripleSlashDirective$0);
|
|
12184
12315
|
}
|
|
@@ -12192,11 +12323,13 @@ ${input.slice(result.pos)}
|
|
|
12192
12323
|
function PrologueString(ctx, state) {
|
|
12193
12324
|
return $EVENT_C(ctx, state, "PrologueString", PrologueString$$);
|
|
12194
12325
|
}
|
|
12195
|
-
var EOS$0 = $P(RestOfLine)
|
|
12326
|
+
var EOS$0 = $T($S($EXPECT($R82, "EOS /(?=[ \\t\\r\\n\\/#]|$)/"), $P(RestOfLine)), function(value) {
|
|
12327
|
+
return value[1];
|
|
12328
|
+
});
|
|
12196
12329
|
function EOS(ctx, state) {
|
|
12197
12330
|
return $EVENT(ctx, state, "EOS", EOS$0);
|
|
12198
12331
|
}
|
|
12199
|
-
var EOL$0 = $TR($EXPECT($
|
|
12332
|
+
var EOL$0 = $TR($EXPECT($R83, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12200
12333
|
return { $loc, token: $0 };
|
|
12201
12334
|
});
|
|
12202
12335
|
function EOL(ctx, state) {
|
|
@@ -12690,7 +12823,7 @@ ${input.slice(result.pos)}
|
|
|
12690
12823
|
function Init(ctx, state) {
|
|
12691
12824
|
return $EVENT(ctx, state, "Init", Init$0);
|
|
12692
12825
|
}
|
|
12693
|
-
var Indent$0 = $TR($EXPECT($
|
|
12826
|
+
var Indent$0 = $TR($EXPECT($R84, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12694
12827
|
const level = getIndentLevel($0, module.config.tab);
|
|
12695
12828
|
return {
|
|
12696
12829
|
$loc,
|
|
@@ -12812,6 +12945,7 @@ ${input.slice(result.pos)}
|
|
|
12812
12945
|
exports.NestedNonAssignmentExtendedExpression = NestedNonAssignmentExtendedExpression;
|
|
12813
12946
|
exports.ExpressionizedStatementWithTrailingCallExpressions = ExpressionizedStatementWithTrailingCallExpressions;
|
|
12814
12947
|
exports.ExpressionizedStatement = ExpressionizedStatement;
|
|
12948
|
+
exports._ExpressionizedStatement = _ExpressionizedStatement;
|
|
12815
12949
|
exports.Expression = Expression;
|
|
12816
12950
|
exports.Arguments = Arguments;
|
|
12817
12951
|
exports.ImplicitArguments = ImplicitArguments;
|
|
@@ -12903,6 +13037,7 @@ ${input.slice(result.pos)}
|
|
|
12903
13037
|
exports.MemberBracketContent = MemberBracketContent;
|
|
12904
13038
|
exports.SliceParameters = SliceParameters;
|
|
12905
13039
|
exports.AccessStart = AccessStart;
|
|
13040
|
+
exports.PropertyAccessModifier = PropertyAccessModifier;
|
|
12906
13041
|
exports.PropertyAccess = PropertyAccess;
|
|
12907
13042
|
exports.PropertyGlob = PropertyGlob;
|
|
12908
13043
|
exports.PropertyBind = PropertyBind;
|
|
@@ -12973,12 +13108,14 @@ ${input.slice(result.pos)}
|
|
|
12973
13108
|
exports.LiteralContent = LiteralContent;
|
|
12974
13109
|
exports.NullLiteral = NullLiteral;
|
|
12975
13110
|
exports.BooleanLiteral = BooleanLiteral;
|
|
13111
|
+
exports._BooleanLiteral = _BooleanLiteral;
|
|
12976
13112
|
exports.CoffeeScriptBooleanLiteral = CoffeeScriptBooleanLiteral;
|
|
12977
13113
|
exports.Identifier = Identifier;
|
|
12978
13114
|
exports.IdentifierName = IdentifierName;
|
|
12979
13115
|
exports.IdentifierReference = IdentifierReference;
|
|
12980
13116
|
exports.UpcomingAssignment = UpcomingAssignment;
|
|
12981
13117
|
exports.ArrayLiteral = ArrayLiteral;
|
|
13118
|
+
exports._ArrayLiteral = _ArrayLiteral;
|
|
12982
13119
|
exports.RangeExpression = RangeExpression;
|
|
12983
13120
|
exports.ArrayLiteralContent = ArrayLiteralContent;
|
|
12984
13121
|
exports.NestedElementList = NestedElementList;
|
|
@@ -13020,6 +13157,8 @@ ${input.slice(result.pos)}
|
|
|
13020
13157
|
exports.IdentifierBinaryOp = IdentifierBinaryOp;
|
|
13021
13158
|
exports.BinaryOp = BinaryOp;
|
|
13022
13159
|
exports.BinaryOpSymbol = BinaryOpSymbol;
|
|
13160
|
+
exports.CoffeeOfOp = CoffeeOfOp;
|
|
13161
|
+
exports.NotOp = NotOp;
|
|
13023
13162
|
exports.Xor = Xor;
|
|
13024
13163
|
exports.Xnor = Xnor;
|
|
13025
13164
|
exports.UnaryOp = UnaryOp;
|
|
@@ -13030,6 +13169,7 @@ ${input.slice(result.pos)}
|
|
|
13030
13169
|
exports.PostfixedExpression = PostfixedExpression;
|
|
13031
13170
|
exports.NonPipelinePostfixedExpression = NonPipelinePostfixedExpression;
|
|
13032
13171
|
exports.PostfixStatement = PostfixStatement;
|
|
13172
|
+
exports._PostfixStatement = _PostfixStatement;
|
|
13033
13173
|
exports.Statement = Statement;
|
|
13034
13174
|
exports.EmptyStatement = EmptyStatement;
|
|
13035
13175
|
exports.BlockStatement = BlockStatement;
|
|
@@ -13049,6 +13189,7 @@ ${input.slice(result.pos)}
|
|
|
13049
13189
|
exports.NestedBlockExpression = NestedBlockExpression;
|
|
13050
13190
|
exports.BlockExpressionPart = BlockExpressionPart;
|
|
13051
13191
|
exports.IterationStatement = IterationStatement;
|
|
13192
|
+
exports._IterationStatement = _IterationStatement;
|
|
13052
13193
|
exports.IterationExpression = IterationExpression;
|
|
13053
13194
|
exports.LoopStatement = LoopStatement;
|
|
13054
13195
|
exports.LoopClause = LoopClause;
|
|
@@ -13185,11 +13326,13 @@ ${input.slice(result.pos)}
|
|
|
13185
13326
|
exports.RegExpCharacter = RegExpCharacter;
|
|
13186
13327
|
exports.RegularExpressionFlags = RegularExpressionFlags;
|
|
13187
13328
|
exports.TemplateLiteral = TemplateLiteral;
|
|
13329
|
+
exports._TemplateLiteral = _TemplateLiteral;
|
|
13188
13330
|
exports.TemplateSubstitution = TemplateSubstitution;
|
|
13189
13331
|
exports.TemplateCharacters = TemplateCharacters;
|
|
13190
13332
|
exports.TemplateBlockCharacters = TemplateBlockCharacters;
|
|
13191
13333
|
exports.ReservedWord = ReservedWord;
|
|
13192
13334
|
exports.Comment = Comment;
|
|
13335
|
+
exports._Comment = _Comment;
|
|
13193
13336
|
exports.SingleLineComment = SingleLineComment;
|
|
13194
13337
|
exports.JSSingleLineComment = JSSingleLineComment;
|
|
13195
13338
|
exports.MultiLineComment = MultiLineComment;
|
|
@@ -13504,6 +13647,7 @@ ${input.slice(result.pos)}
|
|
|
13504
13647
|
makeRef,
|
|
13505
13648
|
maybeRef,
|
|
13506
13649
|
modifyString,
|
|
13650
|
+
negateCondition,
|
|
13507
13651
|
processAssignmentDeclaration,
|
|
13508
13652
|
processBinaryOpExpression,
|
|
13509
13653
|
processCallMemberExpression,
|
|
@@ -14139,7 +14283,8 @@ ${counts}`;
|
|
|
14139
14283
|
return;
|
|
14140
14284
|
}
|
|
14141
14285
|
;
|
|
14142
|
-
const
|
|
14286
|
+
const [stateKey, tagKey] = getStateKey();
|
|
14287
|
+
const key = [tagKey, stateKey, state.pos, ruleName];
|
|
14143
14288
|
if (stateCache.has(key)) {
|
|
14144
14289
|
if (trace) {
|
|
14145
14290
|
logs.push("".padStart(stack.length * 2, " ") + ruleName + ":" + state.pos + "\u{1F4B0}");
|
|
@@ -14160,12 +14305,9 @@ ${counts}`;
|
|
|
14160
14305
|
({ getStateKey } = result.value);
|
|
14161
14306
|
}
|
|
14162
14307
|
if (!uncacheable.has(ruleName)) {
|
|
14163
|
-
const
|
|
14164
|
-
|
|
14165
|
-
|
|
14166
|
-
} else {
|
|
14167
|
-
stateCache.set(key, result);
|
|
14168
|
-
}
|
|
14308
|
+
const [stateKey, tagKey] = getStateKey();
|
|
14309
|
+
const key = [tagKey, stateKey, state.pos, ruleName];
|
|
14310
|
+
stateCache.set(key, result);
|
|
14169
14311
|
}
|
|
14170
14312
|
if (parse.config.verbose && result) {
|
|
14171
14313
|
console.log(`Parsed ${JSON.stringify(state.input.slice(state.pos, result.pos))} [pos ${state.pos}-${result.pos}] as ${ruleName}`);
|