@danielx/civet 0.6.42 → 0.6.44
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 +800 -533
- package/dist/main.js +800 -533
- package/dist/main.mjs +800 -533
- package/package.json +2 -2
package/dist/main.mjs
CHANGED
|
@@ -892,18 +892,18 @@ var require_lib = __commonJS({
|
|
|
892
892
|
}
|
|
893
893
|
if (subtype === "DoStatement") {
|
|
894
894
|
insertReturn(block);
|
|
895
|
-
children.splice(i, 1, ...wrapIIFE(statement, async));
|
|
895
|
+
children.splice(i, 1, ...wrapIIFE(["", statement, void 0], async));
|
|
896
896
|
return;
|
|
897
897
|
}
|
|
898
898
|
const resultsRef = makeRef("results");
|
|
899
899
|
insertPush(block, resultsRef);
|
|
900
|
+
braceBlock(block);
|
|
900
901
|
children.splice(
|
|
901
902
|
i,
|
|
902
903
|
1,
|
|
903
904
|
...wrapIIFE([
|
|
904
905
|
["", ["const ", resultsRef, "=[]"], ";"],
|
|
905
|
-
...children,
|
|
906
|
-
["", "; "],
|
|
906
|
+
...children.map((c) => ["", c, void 0]),
|
|
907
907
|
["", wrapWithReturn(resultsRef)]
|
|
908
908
|
], async)
|
|
909
909
|
);
|
|
@@ -1307,6 +1307,7 @@ var require_lib = __commonJS({
|
|
|
1307
1307
|
};
|
|
1308
1308
|
const prefix = splices.map((s) => ["let ", s]).concat(thisAssignments).map(
|
|
1309
1309
|
(s) => s.type ? {
|
|
1310
|
+
// TODO: figure out how to get JS only statement tuples
|
|
1310
1311
|
...s,
|
|
1311
1312
|
children: [indent, ...s.children, delimiter]
|
|
1312
1313
|
} : [indent, s, delimiter]
|
|
@@ -1705,6 +1706,31 @@ var require_lib = __commonJS({
|
|
|
1705
1706
|
return target.token.match(/^ ?/)[0];
|
|
1706
1707
|
return;
|
|
1707
1708
|
}
|
|
1709
|
+
function startsWith(target, value) {
|
|
1710
|
+
if (!target)
|
|
1711
|
+
return;
|
|
1712
|
+
if (Array.isArray(target)) {
|
|
1713
|
+
let i = 0;
|
|
1714
|
+
let l = target.length;
|
|
1715
|
+
while (i < l) {
|
|
1716
|
+
const t = target[i];
|
|
1717
|
+
if (t && (t.length || t.token || t.children)) {
|
|
1718
|
+
break;
|
|
1719
|
+
}
|
|
1720
|
+
i++;
|
|
1721
|
+
}
|
|
1722
|
+
if (i < l) {
|
|
1723
|
+
return startsWith(target[i], value);
|
|
1724
|
+
}
|
|
1725
|
+
}
|
|
1726
|
+
if (target.children)
|
|
1727
|
+
return startsWith(target.children, value);
|
|
1728
|
+
if (target.token)
|
|
1729
|
+
return value.test(target.token);
|
|
1730
|
+
if (typeof target === "string")
|
|
1731
|
+
return value.test(target);
|
|
1732
|
+
return;
|
|
1733
|
+
}
|
|
1708
1734
|
function processForInOf($0, getRef) {
|
|
1709
1735
|
let [awaits, eachOwn, open, declaration, declaration2, ws, inOf, exp, step, close] = $0;
|
|
1710
1736
|
if (exp.type === "RangeExpression" && inOf.token === "of" && !declaration2) {
|
|
@@ -1817,7 +1843,7 @@ var require_lib = __commonJS({
|
|
|
1817
1843
|
}
|
|
1818
1844
|
if (own) {
|
|
1819
1845
|
const hasPropRef = getRef("hasProp");
|
|
1820
|
-
blockPrefix.push(["", "if (!", hasPropRef, "(", insertTrimmingSpace(expRef2, ""), ", ", insertTrimmingSpace(binding, ""), ")) continue", ";"]);
|
|
1846
|
+
blockPrefix.push(["", ["if (!", hasPropRef, "(", insertTrimmingSpace(expRef2, ""), ", ", insertTrimmingSpace(binding, ""), ")) continue"], ";"]);
|
|
1821
1847
|
}
|
|
1822
1848
|
if (decl2) {
|
|
1823
1849
|
blockPrefix.push(["", {
|
|
@@ -1976,6 +2002,15 @@ var require_lib = __commonJS({
|
|
|
1976
2002
|
empty: true
|
|
1977
2003
|
};
|
|
1978
2004
|
}
|
|
2005
|
+
function braceBlock(block) {
|
|
2006
|
+
if (block.bare) {
|
|
2007
|
+
block.children.unshift(" {");
|
|
2008
|
+
block.children.push("}");
|
|
2009
|
+
return block.bare = false;
|
|
2010
|
+
}
|
|
2011
|
+
;
|
|
2012
|
+
return;
|
|
2013
|
+
}
|
|
1979
2014
|
function makeLeftHandSideExpression(expression) {
|
|
1980
2015
|
switch (expression.type) {
|
|
1981
2016
|
case "Ref":
|
|
@@ -2504,6 +2539,68 @@ var require_lib = __commonJS({
|
|
|
2504
2539
|
return exp.children.splice(index + 1, 0, ...tail);
|
|
2505
2540
|
});
|
|
2506
2541
|
}
|
|
2542
|
+
function processBlocks(statements) {
|
|
2543
|
+
insertSemicolon(statements);
|
|
2544
|
+
gatherRecursive(statements, ($) => $.type === "BlockStatement").forEach(function({ expressions }) {
|
|
2545
|
+
return processBlocks(expressions);
|
|
2546
|
+
});
|
|
2547
|
+
}
|
|
2548
|
+
function insertSemicolon(statements) {
|
|
2549
|
+
const l = statements.length;
|
|
2550
|
+
statements.forEach(function(s, i) {
|
|
2551
|
+
if (i < l - 1) {
|
|
2552
|
+
if (needsPrecedingSemicolon(statements[i + 1])) {
|
|
2553
|
+
const delim = s[2];
|
|
2554
|
+
if (!delim) {
|
|
2555
|
+
return s[2] = ";";
|
|
2556
|
+
} else if (typeof delim === "string" && !delim.match(/;/)) {
|
|
2557
|
+
return s[2] = `;${delim}`;
|
|
2558
|
+
}
|
|
2559
|
+
;
|
|
2560
|
+
return;
|
|
2561
|
+
}
|
|
2562
|
+
;
|
|
2563
|
+
return;
|
|
2564
|
+
}
|
|
2565
|
+
;
|
|
2566
|
+
return;
|
|
2567
|
+
});
|
|
2568
|
+
}
|
|
2569
|
+
function needsPrecedingSemicolon(exp) {
|
|
2570
|
+
let following;
|
|
2571
|
+
if (Array.isArray(exp)) {
|
|
2572
|
+
[, following] = exp;
|
|
2573
|
+
} else {
|
|
2574
|
+
following = exp;
|
|
2575
|
+
}
|
|
2576
|
+
if (!following) {
|
|
2577
|
+
return false;
|
|
2578
|
+
}
|
|
2579
|
+
if (Array.isArray(following)) {
|
|
2580
|
+
return needsPrecedingSemicolon(following[0]);
|
|
2581
|
+
}
|
|
2582
|
+
switch (following.type) {
|
|
2583
|
+
case "ParenthesizedExpression":
|
|
2584
|
+
case "ArrowFunction":
|
|
2585
|
+
case "TemplateLiteral":
|
|
2586
|
+
case "RegularExpressionLiteral": {
|
|
2587
|
+
return true;
|
|
2588
|
+
}
|
|
2589
|
+
case "AssignmentExpression": {
|
|
2590
|
+
return startsWith(following, /^(\[|\()/);
|
|
2591
|
+
}
|
|
2592
|
+
case "Literal": {
|
|
2593
|
+
return following.raw?.startsWith("-") || following.raw?.startsWith("+");
|
|
2594
|
+
}
|
|
2595
|
+
default: {
|
|
2596
|
+
if (following.children) {
|
|
2597
|
+
return needsPrecedingSemicolon(following.children[0]);
|
|
2598
|
+
}
|
|
2599
|
+
;
|
|
2600
|
+
return;
|
|
2601
|
+
}
|
|
2602
|
+
}
|
|
2603
|
+
}
|
|
2507
2604
|
function attachPostfixStatementAsExpression(exp, post) {
|
|
2508
2605
|
switch (post[1].type) {
|
|
2509
2606
|
case "ForStatement":
|
|
@@ -2845,11 +2942,7 @@ var require_lib = __commonJS({
|
|
|
2845
2942
|
}
|
|
2846
2943
|
block.expressions.unshift(...prefix);
|
|
2847
2944
|
const next = [];
|
|
2848
|
-
|
|
2849
|
-
block.children.unshift(" {");
|
|
2850
|
-
block.children.push("}");
|
|
2851
|
-
block.bare = false;
|
|
2852
|
-
}
|
|
2945
|
+
braceBlock(block);
|
|
2853
2946
|
if (i < l - 1)
|
|
2854
2947
|
next.push("\n", "else ");
|
|
2855
2948
|
prev.push(["", {
|
|
@@ -3020,6 +3113,7 @@ var require_lib = __commonJS({
|
|
|
3020
3113
|
} else if (config.autoVar) {
|
|
3021
3114
|
createVarDecs(statements, []);
|
|
3022
3115
|
}
|
|
3116
|
+
processBlocks(statements);
|
|
3023
3117
|
populateRefs(statements);
|
|
3024
3118
|
adjustAtBindings(statements);
|
|
3025
3119
|
}
|
|
@@ -3101,7 +3195,10 @@ var require_lib = __commonJS({
|
|
|
3101
3195
|
if (statements[0][1]?.parent?.root) {
|
|
3102
3196
|
delimiter = ";\n";
|
|
3103
3197
|
}
|
|
3104
|
-
statements.unshift([indent,
|
|
3198
|
+
statements.unshift([indent, {
|
|
3199
|
+
type: "Declaration",
|
|
3200
|
+
children: ["var ", varIds.join(", ")]
|
|
3201
|
+
}, delimiter]);
|
|
3105
3202
|
}
|
|
3106
3203
|
return scopes.pop();
|
|
3107
3204
|
}
|
|
@@ -3171,13 +3268,17 @@ var require_lib = __commonJS({
|
|
|
3171
3268
|
if (gatherNodes(indent, (node) => node.token && node.token.endsWith("\n")).length > 0) {
|
|
3172
3269
|
tail = void 0;
|
|
3173
3270
|
}
|
|
3174
|
-
targetStatements.push([indent,
|
|
3271
|
+
targetStatements.push([indent, {
|
|
3272
|
+
type: "Declaration",
|
|
3273
|
+
children: ["let ", ...undeclaredIdentifiers.join(", ")],
|
|
3274
|
+
names: undeclaredIdentifiers
|
|
3275
|
+
}, tail]);
|
|
3175
3276
|
}
|
|
3176
3277
|
}
|
|
3177
3278
|
targetStatements.push(statement);
|
|
3178
3279
|
}
|
|
3179
3280
|
scopes.pop();
|
|
3180
|
-
statements.splice(0, statements.length, targetStatements);
|
|
3281
|
+
statements.splice(0, statements.length, ...targetStatements);
|
|
3181
3282
|
}
|
|
3182
3283
|
function processReturnValue(func) {
|
|
3183
3284
|
const { block } = func;
|
|
@@ -3185,31 +3286,39 @@ var require_lib = __commonJS({
|
|
|
3185
3286
|
block,
|
|
3186
3287
|
({ type }) => type === "ReturnValue"
|
|
3187
3288
|
);
|
|
3188
|
-
if (!values.length)
|
|
3289
|
+
if (!values.length) {
|
|
3189
3290
|
return false;
|
|
3291
|
+
}
|
|
3190
3292
|
const ref = makeRef("ret");
|
|
3191
|
-
let
|
|
3293
|
+
let declaration;
|
|
3192
3294
|
values.forEach((value) => {
|
|
3193
3295
|
value.children = [ref];
|
|
3194
|
-
const { ancestor } = findAncestor(
|
|
3296
|
+
const { ancestor, child } = findAncestor(
|
|
3195
3297
|
value,
|
|
3196
3298
|
({ type }) => type === "Declaration",
|
|
3197
3299
|
isFunction
|
|
3198
3300
|
);
|
|
3199
|
-
if (ancestor)
|
|
3200
|
-
return
|
|
3301
|
+
if (ancestor) {
|
|
3302
|
+
return declaration ?? (declaration = child);
|
|
3303
|
+
}
|
|
3304
|
+
;
|
|
3201
3305
|
return;
|
|
3202
3306
|
});
|
|
3203
|
-
|
|
3204
|
-
|
|
3205
|
-
|
|
3206
|
-
|
|
3207
|
-
|
|
3208
|
-
|
|
3209
|
-
|
|
3210
|
-
|
|
3211
|
-
}
|
|
3307
|
+
let returnType = func.returnType ?? func.signature?.returnType;
|
|
3308
|
+
if (returnType) {
|
|
3309
|
+
const { t } = returnType;
|
|
3310
|
+
let m1;
|
|
3311
|
+
if (m1 = t.type, m1 === "TypePredicate") {
|
|
3312
|
+
returnType = ": boolean";
|
|
3313
|
+
} else if (m1 === "AssertsType") {
|
|
3314
|
+
returnType = void 0;
|
|
3212
3315
|
}
|
|
3316
|
+
}
|
|
3317
|
+
if (declaration) {
|
|
3318
|
+
if (!(declaration.suffix != null)) {
|
|
3319
|
+
declaration.children[1] = declaration.suffix = returnType;
|
|
3320
|
+
}
|
|
3321
|
+
} else {
|
|
3213
3322
|
block.expressions.unshift([
|
|
3214
3323
|
getIndent(block.expressions[0]),
|
|
3215
3324
|
{
|
|
@@ -3227,7 +3336,7 @@ var require_lib = __commonJS({
|
|
|
3227
3336
|
r.expression = ref;
|
|
3228
3337
|
return r.children.splice(-1, 1, " ", ref);
|
|
3229
3338
|
});
|
|
3230
|
-
if (block.children.at(-2)?.type
|
|
3339
|
+
if (!(block.children.at(-2)?.type === "ReturnStatement")) {
|
|
3231
3340
|
block.expressions.push([
|
|
3232
3341
|
[getIndent(block.expressions.at(-1))],
|
|
3233
3342
|
{
|
|
@@ -3272,15 +3381,18 @@ var require_lib = __commonJS({
|
|
|
3272
3381
|
return exp;
|
|
3273
3382
|
}
|
|
3274
3383
|
if (exp.type === "Literal") {
|
|
3275
|
-
if (pre.length === 1
|
|
3276
|
-
const
|
|
3277
|
-
if (
|
|
3278
|
-
exp.children
|
|
3279
|
-
|
|
3280
|
-
|
|
3281
|
-
|
|
3282
|
-
|
|
3283
|
-
|
|
3384
|
+
if (pre.length === 1) {
|
|
3385
|
+
const { token } = pre[0];
|
|
3386
|
+
if (token === "-" || token === "+") {
|
|
3387
|
+
const children = [pre[0], ...exp.children];
|
|
3388
|
+
if (post)
|
|
3389
|
+
exp.children.push(post);
|
|
3390
|
+
return {
|
|
3391
|
+
type: "Literal",
|
|
3392
|
+
children,
|
|
3393
|
+
raw: `${token}${exp.raw}`
|
|
3394
|
+
};
|
|
3395
|
+
}
|
|
3284
3396
|
}
|
|
3285
3397
|
}
|
|
3286
3398
|
const l = pre.length;
|
|
@@ -3532,7 +3644,6 @@ var require_lib = __commonJS({
|
|
|
3532
3644
|
dedentBlockSubstitutions,
|
|
3533
3645
|
deepCopy,
|
|
3534
3646
|
expressionizeIfClause,
|
|
3535
|
-
expressionizeIteration,
|
|
3536
3647
|
findAncestor,
|
|
3537
3648
|
forRange,
|
|
3538
3649
|
gatherBindingCode,
|
|
@@ -3627,6 +3738,7 @@ var require_parser = __commonJS({
|
|
|
3627
3738
|
NestedNonAssignmentExtendedExpression,
|
|
3628
3739
|
ExpressionizedStatementWithTrailingCallExpressions,
|
|
3629
3740
|
ExpressionizedStatement,
|
|
3741
|
+
_ExpressionizedStatement,
|
|
3630
3742
|
Expression,
|
|
3631
3743
|
Arguments,
|
|
3632
3744
|
ImplicitArguments,
|
|
@@ -3718,6 +3830,7 @@ var require_parser = __commonJS({
|
|
|
3718
3830
|
MemberBracketContent,
|
|
3719
3831
|
SliceParameters,
|
|
3720
3832
|
AccessStart,
|
|
3833
|
+
PropertyAccessModifier,
|
|
3721
3834
|
PropertyAccess,
|
|
3722
3835
|
PropertyGlob,
|
|
3723
3836
|
PropertyBind,
|
|
@@ -3788,12 +3901,14 @@ var require_parser = __commonJS({
|
|
|
3788
3901
|
LiteralContent,
|
|
3789
3902
|
NullLiteral,
|
|
3790
3903
|
BooleanLiteral,
|
|
3904
|
+
_BooleanLiteral,
|
|
3791
3905
|
CoffeeScriptBooleanLiteral,
|
|
3792
3906
|
Identifier,
|
|
3793
3907
|
IdentifierName,
|
|
3794
3908
|
IdentifierReference,
|
|
3795
3909
|
UpcomingAssignment,
|
|
3796
3910
|
ArrayLiteral,
|
|
3911
|
+
_ArrayLiteral,
|
|
3797
3912
|
RangeExpression,
|
|
3798
3913
|
ArrayLiteralContent,
|
|
3799
3914
|
NestedElementList,
|
|
@@ -3834,7 +3949,10 @@ var require_parser = __commonJS({
|
|
|
3834
3949
|
NotDedentedBinaryOp,
|
|
3835
3950
|
IdentifierBinaryOp,
|
|
3836
3951
|
BinaryOp,
|
|
3952
|
+
_BinaryOp,
|
|
3837
3953
|
BinaryOpSymbol,
|
|
3954
|
+
CoffeeOfOp,
|
|
3955
|
+
NotOp,
|
|
3838
3956
|
Xor,
|
|
3839
3957
|
Xnor,
|
|
3840
3958
|
UnaryOp,
|
|
@@ -3845,6 +3963,7 @@ var require_parser = __commonJS({
|
|
|
3845
3963
|
PostfixedExpression,
|
|
3846
3964
|
NonPipelinePostfixedExpression,
|
|
3847
3965
|
PostfixStatement,
|
|
3966
|
+
_PostfixStatement,
|
|
3848
3967
|
Statement,
|
|
3849
3968
|
EmptyStatement,
|
|
3850
3969
|
BlockStatement,
|
|
@@ -3864,6 +3983,7 @@ var require_parser = __commonJS({
|
|
|
3864
3983
|
NestedBlockExpression,
|
|
3865
3984
|
BlockExpressionPart,
|
|
3866
3985
|
IterationStatement,
|
|
3986
|
+
_IterationStatement,
|
|
3867
3987
|
IterationExpression,
|
|
3868
3988
|
LoopStatement,
|
|
3869
3989
|
LoopClause,
|
|
@@ -4000,6 +4120,7 @@ var require_parser = __commonJS({
|
|
|
4000
4120
|
RegExpCharacter,
|
|
4001
4121
|
RegularExpressionFlags,
|
|
4002
4122
|
TemplateLiteral,
|
|
4123
|
+
_TemplateLiteral,
|
|
4003
4124
|
TemplateSubstitution,
|
|
4004
4125
|
TemplateCharacters,
|
|
4005
4126
|
TemplateBlockCharacters,
|
|
@@ -4118,6 +4239,7 @@ var require_parser = __commonJS({
|
|
|
4118
4239
|
Yield,
|
|
4119
4240
|
JSXImplicitFragment,
|
|
4120
4241
|
JSXTag,
|
|
4242
|
+
_JSXTag,
|
|
4121
4243
|
JSXElement,
|
|
4122
4244
|
JSXSelfClosingElement,
|
|
4123
4245
|
PushJSXOpeningElement,
|
|
@@ -4305,8 +4427,8 @@ var require_parser = __commonJS({
|
|
|
4305
4427
|
var $L8 = $L("--");
|
|
4306
4428
|
var $L9 = $L("=>");
|
|
4307
4429
|
var $L10 = $L("\u21D2");
|
|
4308
|
-
var $L11 = $L("
|
|
4309
|
-
var $L12 = $L("
|
|
4430
|
+
var $L11 = $L(":");
|
|
4431
|
+
var $L12 = $L(" ");
|
|
4310
4432
|
var $L13 = $L("implements");
|
|
4311
4433
|
var $L14 = $L("<:");
|
|
4312
4434
|
var $L15 = $L("import");
|
|
@@ -4378,78 +4500,78 @@ var require_parser = __commonJS({
|
|
|
4378
4500
|
var $L81 = $L("\u2A75");
|
|
4379
4501
|
var $L82 = $L("and");
|
|
4380
4502
|
var $L83 = $L("&&");
|
|
4381
|
-
var $L84 = $L("
|
|
4382
|
-
var $L85 = $L("
|
|
4383
|
-
var $L86 = $L("
|
|
4384
|
-
var $L87 = $L("
|
|
4385
|
-
var $L88 = $L("
|
|
4386
|
-
var $L89 = $L("
|
|
4387
|
-
var $L90 = $L("
|
|
4388
|
-
var $L91 = $L("
|
|
4389
|
-
var $L92 = $L("
|
|
4390
|
-
var $L93 = $L("
|
|
4391
|
-
var $L94 = $L("\
|
|
4392
|
-
var $L95 = $L("\
|
|
4393
|
-
var $L96 = $L("\
|
|
4394
|
-
var $L97 = $L("
|
|
4395
|
-
var $L98 = $L("
|
|
4396
|
-
var $L99 = $L("
|
|
4397
|
-
var $L100 = $L("
|
|
4398
|
-
var $L101 = $L("
|
|
4399
|
-
var $L102 = $L("
|
|
4400
|
-
var $L103 = $L("
|
|
4401
|
-
var $L104 = $L("
|
|
4402
|
-
var $L105 = $L("
|
|
4403
|
-
var $L106 = $L("
|
|
4404
|
-
var $L107 = $L("
|
|
4405
|
-
var $L108 = $L("
|
|
4406
|
-
var $L109 = $L("
|
|
4407
|
-
var $L110 = $L("
|
|
4408
|
-
var $L111 = $L("
|
|
4409
|
-
var $L112 = $L("
|
|
4410
|
-
var $L113 = $L("
|
|
4411
|
-
var $L114 = $L("
|
|
4412
|
-
var $L115 = $L("
|
|
4413
|
-
var $L116 = $L("
|
|
4414
|
-
var $L117 = $L("
|
|
4415
|
-
var $L118 = $L("
|
|
4416
|
-
var $L119 = $L("
|
|
4417
|
-
var $L120 = $L("
|
|
4418
|
-
var $L121 = $L("
|
|
4419
|
-
var $L122 = $L("
|
|
4420
|
-
var $L123 = $L("
|
|
4421
|
-
var $L124 = $L("
|
|
4422
|
-
var $L125 = $L("
|
|
4423
|
-
var $L126 = $L("
|
|
4424
|
-
var $L127 = $L("
|
|
4425
|
-
var $L128 = $L("
|
|
4426
|
-
var $L129 = $L("
|
|
4427
|
-
var $L130 = $L("
|
|
4428
|
-
var $L131 = $L("\
|
|
4429
|
-
var $L132 = $L("
|
|
4430
|
-
var $L133 = $L("
|
|
4431
|
-
var $L134 = $L("
|
|
4432
|
-
var $L135 = $L(
|
|
4433
|
-
var $L136 = $L("
|
|
4434
|
-
var $L137 = $L("
|
|
4435
|
-
var $L138 = $L("
|
|
4436
|
-
var $L139 = $L("
|
|
4437
|
-
var $L140 = $L("
|
|
4438
|
-
var $L141 = $L("
|
|
4439
|
-
var $L142 = $L("
|
|
4440
|
-
var $L143 = $L("
|
|
4441
|
-
var $L144 = $L("
|
|
4442
|
-
var $L145 = $L("
|
|
4443
|
-
var $L146 = $L("
|
|
4444
|
-
var $L147 = $L("
|
|
4445
|
-
var $L148 = $L("
|
|
4446
|
-
var $L149 = $L("
|
|
4447
|
-
var $L150 = $L("
|
|
4448
|
-
var $L151 = $L("
|
|
4449
|
-
var $L152 = $L("
|
|
4450
|
-
var $L153 = $L("
|
|
4451
|
-
var $L154 = $L("
|
|
4452
|
-
var $L155 = $L("
|
|
4503
|
+
var $L84 = $L("or");
|
|
4504
|
+
var $L85 = $L("||");
|
|
4505
|
+
var $L86 = $L("\u2016");
|
|
4506
|
+
var $L87 = $L("^^");
|
|
4507
|
+
var $L88 = $L("xor");
|
|
4508
|
+
var $L89 = $L("xnor");
|
|
4509
|
+
var $L90 = $L("??");
|
|
4510
|
+
var $L91 = $L("\u2047");
|
|
4511
|
+
var $L92 = $L("instanceof");
|
|
4512
|
+
var $L93 = $L("\u2208");
|
|
4513
|
+
var $L94 = $L("\u220B");
|
|
4514
|
+
var $L95 = $L("\u220C");
|
|
4515
|
+
var $L96 = $L("\u2209");
|
|
4516
|
+
var $L97 = $L("&");
|
|
4517
|
+
var $L98 = $L("|");
|
|
4518
|
+
var $L99 = $L(";");
|
|
4519
|
+
var $L100 = $L("$:");
|
|
4520
|
+
var $L101 = $L("break");
|
|
4521
|
+
var $L102 = $L("continue");
|
|
4522
|
+
var $L103 = $L("debugger");
|
|
4523
|
+
var $L104 = $L("assert");
|
|
4524
|
+
var $L105 = $L(":=");
|
|
4525
|
+
var $L106 = $L("\u2254");
|
|
4526
|
+
var $L107 = $L(".=");
|
|
4527
|
+
var $L108 = $L("/*");
|
|
4528
|
+
var $L109 = $L("*/");
|
|
4529
|
+
var $L110 = $L("\\");
|
|
4530
|
+
var $L111 = $L(")");
|
|
4531
|
+
var $L112 = $L("abstract");
|
|
4532
|
+
var $L113 = $L("as");
|
|
4533
|
+
var $L114 = $L("@");
|
|
4534
|
+
var $L115 = $L("@@");
|
|
4535
|
+
var $L116 = $L("async");
|
|
4536
|
+
var $L117 = $L("await");
|
|
4537
|
+
var $L118 = $L("`");
|
|
4538
|
+
var $L119 = $L("by");
|
|
4539
|
+
var $L120 = $L("case");
|
|
4540
|
+
var $L121 = $L("catch");
|
|
4541
|
+
var $L122 = $L("class");
|
|
4542
|
+
var $L123 = $L("#{");
|
|
4543
|
+
var $L124 = $L("declare");
|
|
4544
|
+
var $L125 = $L("default");
|
|
4545
|
+
var $L126 = $L("delete");
|
|
4546
|
+
var $L127 = $L("do");
|
|
4547
|
+
var $L128 = $L("..");
|
|
4548
|
+
var $L129 = $L("\u2025");
|
|
4549
|
+
var $L130 = $L("...");
|
|
4550
|
+
var $L131 = $L("\u2026");
|
|
4551
|
+
var $L132 = $L("::");
|
|
4552
|
+
var $L133 = $L('"');
|
|
4553
|
+
var $L134 = $L("each");
|
|
4554
|
+
var $L135 = $L("else");
|
|
4555
|
+
var $L136 = $L("export");
|
|
4556
|
+
var $L137 = $L("extends");
|
|
4557
|
+
var $L138 = $L("finally");
|
|
4558
|
+
var $L139 = $L("for");
|
|
4559
|
+
var $L140 = $L("from");
|
|
4560
|
+
var $L141 = $L("function");
|
|
4561
|
+
var $L142 = $L("get");
|
|
4562
|
+
var $L143 = $L("set");
|
|
4563
|
+
var $L144 = $L("#");
|
|
4564
|
+
var $L145 = $L("if");
|
|
4565
|
+
var $L146 = $L("in");
|
|
4566
|
+
var $L147 = $L("let");
|
|
4567
|
+
var $L148 = $L("const");
|
|
4568
|
+
var $L149 = $L("is");
|
|
4569
|
+
var $L150 = $L("loop");
|
|
4570
|
+
var $L151 = $L("new");
|
|
4571
|
+
var $L152 = $L("not");
|
|
4572
|
+
var $L153 = $L("of");
|
|
4573
|
+
var $L154 = $L("<");
|
|
4574
|
+
var $L155 = $L("[");
|
|
4453
4575
|
var $L156 = $L("operator");
|
|
4454
4576
|
var $L157 = $L("own");
|
|
4455
4577
|
var $L158 = $L("public");
|
|
@@ -4505,77 +4627,94 @@ var require_parser = __commonJS({
|
|
|
4505
4627
|
var $L208 = $L("???");
|
|
4506
4628
|
var $L209 = $L("[]");
|
|
4507
4629
|
var $L210 = $L("civet");
|
|
4508
|
-
var $R0 = $R(new RegExp("(
|
|
4509
|
-
var $R1 = $R(new RegExp("[
|
|
4510
|
-
var $R2 = $R(new RegExp("[
|
|
4511
|
-
var $R3 = $R(new RegExp("[
|
|
4512
|
-
var $R4 = $R(new RegExp("[
|
|
4513
|
-
var $R5 = $R(new RegExp("(
|
|
4514
|
-
var $R6 = $R(new RegExp("[
|
|
4515
|
-
var $R7 = $R(new RegExp("
|
|
4516
|
-
var $R8 = $R(new RegExp("
|
|
4517
|
-
var $R9 = $R(new RegExp("
|
|
4518
|
-
var $R10 = $R(new RegExp(
|
|
4519
|
-
var $R11 = $R(new RegExp(
|
|
4520
|
-
var $R12 = $R(new RegExp("(
|
|
4521
|
-
var $R13 = $R(new RegExp("(
|
|
4522
|
-
var $R14 = $R(new RegExp("(
|
|
4523
|
-
var $R15 = $R(new RegExp("
|
|
4524
|
-
var $R16 = $R(new RegExp("(
|
|
4525
|
-
var $R17 = $R(new RegExp("
|
|
4526
|
-
var $R18 = $R(new RegExp("
|
|
4527
|
-
var $R19 = $R(new RegExp("
|
|
4528
|
-
var $R20 = $R(new RegExp("(
|
|
4529
|
-
var $R21 = $R(new RegExp(
|
|
4530
|
-
var $R22 = $R(new RegExp("(
|
|
4531
|
-
var $R23 = $R(new RegExp('
|
|
4532
|
-
var $R24 = $R(new RegExp("(
|
|
4533
|
-
var $R25 = $R(new RegExp(
|
|
4534
|
-
var $R26 = $R(new RegExp("(
|
|
4535
|
-
var $R27 = $R(new RegExp("(
|
|
4536
|
-
var $R28 = $R(new RegExp("[
|
|
4537
|
-
var $R29 = $R(new RegExp("
|
|
4538
|
-
var $R30 = $R(new RegExp("[
|
|
4539
|
-
var $R31 = $R(new RegExp("[
|
|
4540
|
-
var $R32 = $R(new RegExp("(
|
|
4541
|
-
var $R33 = $R(new RegExp("(
|
|
4542
|
-
var $R34 = $R(new RegExp("(
|
|
4543
|
-
var $R35 = $R(new RegExp(
|
|
4544
|
-
var $R36 = $R(new RegExp("(
|
|
4545
|
-
var $R37 = $R(new RegExp("(
|
|
4546
|
-
var $R38 = $R(new RegExp("(?:
|
|
4547
|
-
var $R39 = $R(new RegExp(
|
|
4548
|
-
var $R40 = $R(new RegExp("(
|
|
4549
|
-
var $R41 = $R(new RegExp("(
|
|
4550
|
-
var $R42 = $R(new RegExp("
|
|
4551
|
-
var $R43 = $R(new RegExp("
|
|
4552
|
-
var $R44 = $R(new RegExp("
|
|
4553
|
-
var $R45 = $R(new RegExp("[
|
|
4554
|
-
var $R46 = $R(new RegExp("
|
|
4555
|
-
var $R47 = $R(new RegExp("
|
|
4556
|
-
var $R48 = $R(new RegExp("(?=[
|
|
4557
|
-
var $R49 = $R(new RegExp("[
|
|
4558
|
-
var $R50 = $R(new RegExp("(?!\\
|
|
4559
|
-
var $R51 = $R(new RegExp("
|
|
4560
|
-
var $R52 = $R(new RegExp("
|
|
4561
|
-
var $R53 = $R(new RegExp("(
|
|
4562
|
-
var $R54 = $R(new RegExp("
|
|
4563
|
-
var $R55 = $R(new RegExp("(?:
|
|
4564
|
-
var $R56 = $R(new RegExp(
|
|
4565
|
-
var $R57 = $R(new RegExp("[
|
|
4566
|
-
var $R58 = $R(new RegExp("
|
|
4567
|
-
var $R59 = $R(new RegExp("(
|
|
4568
|
-
var $R60 = $R(new RegExp("[^
|
|
4569
|
-
var $R61 = $R(new RegExp("
|
|
4570
|
-
var $R62 = $R(new RegExp("[
|
|
4571
|
-
var $R63 = $R(new RegExp("
|
|
4572
|
-
var $R64 = $R(new RegExp("[\\t
|
|
4573
|
-
var $R65 = $R(new RegExp("
|
|
4574
|
-
var $R66 = $R(new RegExp("
|
|
4575
|
-
var $R67 = $R(new RegExp("
|
|
4576
|
-
var $R68 = $R(new RegExp("
|
|
4577
|
-
var $R69 = $R(new RegExp("
|
|
4578
|
-
var $R70 = $R(new RegExp("[
|
|
4630
|
+
var $R0 = $R(new RegExp("(?=debugger|if|unless|do|for|loop|until|while|switch|throw|try)", "suy"));
|
|
4631
|
+
var $R1 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
4632
|
+
var $R2 = $R(new RegExp("[0-9]", "suy"));
|
|
4633
|
+
var $R3 = $R(new RegExp("[ \\t]", "suy"));
|
|
4634
|
+
var $R4 = $R(new RegExp("(?=['\"`])", "suy"));
|
|
4635
|
+
var $R5 = $R(new RegExp("(?=[\\/?])", "suy"));
|
|
4636
|
+
var $R6 = $R(new RegExp("(?=[\\/\\[{?.!@'\u2019:])", "suy"));
|
|
4637
|
+
var $R7 = $R(new RegExp("[)}]", "suy"));
|
|
4638
|
+
var $R8 = $R(new RegExp("[&]", "suy"));
|
|
4639
|
+
var $R9 = $R(new RegExp("[!~+-]+", "suy"));
|
|
4640
|
+
var $R10 = $R(new RegExp(`(?=[0-9.'"tfyno])`, "suy"));
|
|
4641
|
+
var $R11 = $R(new RegExp("(?=true|false|yes|no|on|off)", "suy"));
|
|
4642
|
+
var $R12 = $R(new RegExp("(?=\\p{ID_Start}|[_$])", "suy"));
|
|
4643
|
+
var $R13 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
4644
|
+
var $R14 = $R(new RegExp("(?=\\[)", "suy"));
|
|
4645
|
+
var $R15 = $R(new RegExp("[!+-]", "suy"));
|
|
4646
|
+
var $R16 = $R(new RegExp("(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>+-])", "suy"));
|
|
4647
|
+
var $R17 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
|
|
4648
|
+
var $R18 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
4649
|
+
var $R19 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])", "suy"));
|
|
4650
|
+
var $R20 = $R(new RegExp("(?=for|if|loop|unless|until|while)", "suy"));
|
|
4651
|
+
var $R21 = $R(new RegExp("(?=loop|do|for|until|while)", "suy"));
|
|
4652
|
+
var $R22 = $R(new RegExp("(?=[\\s\\),])", "suy"));
|
|
4653
|
+
var $R23 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
4654
|
+
var $R24 = $R(new RegExp("(?=[0-9.])", "suy"));
|
|
4655
|
+
var $R25 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
4656
|
+
var $R26 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
4657
|
+
var $R27 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
4658
|
+
var $R28 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4659
|
+
var $R29 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
4660
|
+
var $R30 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
4661
|
+
var $R31 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
4662
|
+
var $R32 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
4663
|
+
var $R33 = $R(new RegExp("(?=[0-9])", "suy"));
|
|
4664
|
+
var $R34 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4665
|
+
var $R35 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
4666
|
+
var $R36 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
4667
|
+
var $R37 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
4668
|
+
var $R38 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
4669
|
+
var $R39 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
4670
|
+
var $R40 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
4671
|
+
var $R41 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
4672
|
+
var $R42 = $R(new RegExp("[\\s]+", "suy"));
|
|
4673
|
+
var $R43 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
4674
|
+
var $R44 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
4675
|
+
var $R45 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
4676
|
+
var $R46 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
4677
|
+
var $R47 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
4678
|
+
var $R48 = $R(new RegExp("(?=[`'\"])", "suy"));
|
|
4679
|
+
var $R49 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
4680
|
+
var $R50 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
4681
|
+
var $R51 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
4682
|
+
var $R52 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
4683
|
+
var $R53 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
4684
|
+
var $R54 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
4685
|
+
var $R55 = $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"));
|
|
4686
|
+
var $R56 = $R(new RegExp("(?=\\/|#)", "suy"));
|
|
4687
|
+
var $R57 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
4688
|
+
var $R58 = $R(new RegExp(".", "suy"));
|
|
4689
|
+
var $R59 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
4690
|
+
var $R60 = $R(new RegExp("[^]*?###", "suy"));
|
|
4691
|
+
var $R61 = $R(new RegExp("###(?!#)", "suy"));
|
|
4692
|
+
var $R62 = $R(new RegExp("\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\/", "suy"));
|
|
4693
|
+
var $R63 = $R(new RegExp("(?=[ \\t\\/\\\\])", "suy"));
|
|
4694
|
+
var $R64 = $R(new RegExp("[ \\t]+", "suy"));
|
|
4695
|
+
var $R65 = $R(new RegExp("(?=\\s|\\/|#)", "suy"));
|
|
4696
|
+
var $R66 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
4697
|
+
var $R67 = $R(new RegExp("['\u2019]s", "suy"));
|
|
4698
|
+
var $R68 = $R(new RegExp("\\s", "suy"));
|
|
4699
|
+
var $R69 = $R(new RegExp("(?=[<])", "suy"));
|
|
4700
|
+
var $R70 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
4701
|
+
var $R71 = $R(new RegExp("[\\s>]|\\/>", "suy"));
|
|
4702
|
+
var $R72 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
4703
|
+
var $R73 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
|
|
4704
|
+
var $R74 = $R(new RegExp("[<>]", "suy"));
|
|
4705
|
+
var $R75 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
4706
|
+
var $R76 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
4707
|
+
var $R77 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
4708
|
+
var $R78 = $R(new RegExp("[+-]?", "suy"));
|
|
4709
|
+
var $R79 = $R(new RegExp("[+-]", "suy"));
|
|
4710
|
+
var $R80 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
4711
|
+
var $R81 = $R(new RegExp("[\\t ]*", "suy"));
|
|
4712
|
+
var $R82 = $R(new RegExp("[\\s]*", "suy"));
|
|
4713
|
+
var $R83 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
4714
|
+
var $R84 = $R(new RegExp("\\/\\/\\/[^\\r\\n]*", "suy"));
|
|
4715
|
+
var $R85 = $R(new RegExp("(?=[ \\t\\r\\n\\/#]|$)", "suy"));
|
|
4716
|
+
var $R86 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
4717
|
+
var $R87 = $R(new RegExp("[ \\t]*", "suy"));
|
|
4579
4718
|
var Program$0 = $TS($S(Reset, Init, $E(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
4580
4719
|
var statements = $4;
|
|
4581
4720
|
processProgram({
|
|
@@ -4706,16 +4845,22 @@ var require_parser = __commonJS({
|
|
|
4706
4845
|
function ExpressionizedStatementWithTrailingCallExpressions(ctx, state) {
|
|
4707
4846
|
return $EVENT(ctx, state, "ExpressionizedStatementWithTrailingCallExpressions", ExpressionizedStatementWithTrailingCallExpressions$0);
|
|
4708
4847
|
}
|
|
4709
|
-
var ExpressionizedStatement$0 =
|
|
4710
|
-
|
|
4711
|
-
|
|
4712
|
-
var ExpressionizedStatement$3 = IterationExpression;
|
|
4713
|
-
var ExpressionizedStatement$4 = SwitchExpression;
|
|
4714
|
-
var ExpressionizedStatement$5 = ThrowExpression;
|
|
4715
|
-
var ExpressionizedStatement$6 = TryExpression;
|
|
4716
|
-
var ExpressionizedStatement$$ = [ExpressionizedStatement$0, ExpressionizedStatement$1, ExpressionizedStatement$2, ExpressionizedStatement$3, ExpressionizedStatement$4, ExpressionizedStatement$5, ExpressionizedStatement$6];
|
|
4848
|
+
var ExpressionizedStatement$0 = $T($S($EXPECT($R0, "ExpressionizedStatement /(?=debugger|if|unless|do|for|loop|until|while|switch|throw|try)/"), _ExpressionizedStatement), function(value) {
|
|
4849
|
+
return value[1];
|
|
4850
|
+
});
|
|
4717
4851
|
function ExpressionizedStatement(ctx, state) {
|
|
4718
|
-
return $
|
|
4852
|
+
return $EVENT(ctx, state, "ExpressionizedStatement", ExpressionizedStatement$0);
|
|
4853
|
+
}
|
|
4854
|
+
var _ExpressionizedStatement$0 = DebuggerExpression;
|
|
4855
|
+
var _ExpressionizedStatement$1 = IfExpression;
|
|
4856
|
+
var _ExpressionizedStatement$2 = UnlessExpression;
|
|
4857
|
+
var _ExpressionizedStatement$3 = IterationExpression;
|
|
4858
|
+
var _ExpressionizedStatement$4 = SwitchExpression;
|
|
4859
|
+
var _ExpressionizedStatement$5 = ThrowExpression;
|
|
4860
|
+
var _ExpressionizedStatement$6 = TryExpression;
|
|
4861
|
+
var _ExpressionizedStatement$$ = [_ExpressionizedStatement$0, _ExpressionizedStatement$1, _ExpressionizedStatement$2, _ExpressionizedStatement$3, _ExpressionizedStatement$4, _ExpressionizedStatement$5, _ExpressionizedStatement$6];
|
|
4862
|
+
function _ExpressionizedStatement(ctx, state) {
|
|
4863
|
+
return $EVENT_C(ctx, state, "_ExpressionizedStatement", _ExpressionizedStatement$$);
|
|
4719
4864
|
}
|
|
4720
4865
|
var Expression$0 = $TS($S(AssignmentExpression, $Q($S(CommaDelimiter, AssignmentExpression))), function($skip, $loc, $0, $1, $2) {
|
|
4721
4866
|
if ($2.length == 0)
|
|
@@ -4736,7 +4881,7 @@ var require_parser = __commonJS({
|
|
|
4736
4881
|
function Arguments(ctx, state) {
|
|
4737
4882
|
return $EVENT_C(ctx, state, "Arguments", Arguments$$);
|
|
4738
4883
|
}
|
|
4739
|
-
var ImplicitArguments$0 = $TS($S($E($S(TypeArguments, $N(ImplementsToken))), ApplicationStart, InsertOpenParen, $
|
|
4884
|
+
var ImplicitArguments$0 = $TS($S($E($S(TypeArguments, $N(ImplementsToken))), ApplicationStart, InsertOpenParen, $E(_), NonPipelineArgumentList, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
4740
4885
|
var ta = $1;
|
|
4741
4886
|
var open = $3;
|
|
4742
4887
|
var ws = $4;
|
|
@@ -4760,7 +4905,7 @@ var require_parser = __commonJS({
|
|
|
4760
4905
|
function ApplicationStart(ctx, state) {
|
|
4761
4906
|
return $EVENT_C(ctx, state, "ApplicationStart", ApplicationStart$$);
|
|
4762
4907
|
}
|
|
4763
|
-
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($
|
|
4908
|
+
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R1, "ForbiddenImplicitCalls /(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
4764
4909
|
var ForbiddenImplicitCalls$1 = $EXPECT($L2, 'ForbiddenImplicitCalls "/ "');
|
|
4765
4910
|
var ForbiddenImplicitCalls$2 = $S(ClassImplicitCallForbidden, $C(Class, AtAt));
|
|
4766
4911
|
var ForbiddenImplicitCalls$3 = $S(Identifier, $EXPECT($L3, 'ForbiddenImplicitCalls "="'), Whitespace);
|
|
@@ -4792,7 +4937,7 @@ var require_parser = __commonJS({
|
|
|
4792
4937
|
function ArgumentsWithTrailingMemberExpressions(ctx, state) {
|
|
4793
4938
|
return $EVENT(ctx, state, "ArgumentsWithTrailingMemberExpressions", ArgumentsWithTrailingMemberExpressions$0);
|
|
4794
4939
|
}
|
|
4795
|
-
var TrailingMemberExpressions$0 = $TS($S($Q(MemberExpressionRest), $Q($S(IndentedAtLeast, $Y($S($E($EXPECT($L5, 'TrailingMemberExpressions "?"')), $EXPECT($L6, 'TrailingMemberExpressions "."'), $N($EXPECT($
|
|
4940
|
+
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) {
|
|
4796
4941
|
return $1.concat($2);
|
|
4797
4942
|
});
|
|
4798
4943
|
function TrailingMemberExpressions(ctx, state) {
|
|
@@ -4806,7 +4951,7 @@ var require_parser = __commonJS({
|
|
|
4806
4951
|
function AllowedTrailingMemberExpressions(ctx, state) {
|
|
4807
4952
|
return $EVENT_C(ctx, state, "AllowedTrailingMemberExpressions", AllowedTrailingMemberExpressions$$);
|
|
4808
4953
|
}
|
|
4809
|
-
var TrailingCallExpressions$0 = $P($S(IndentedAtLeast, $Y($S($E($EXPECT($L5, 'TrailingCallExpressions "?"')), $EXPECT($L6, 'TrailingCallExpressions "."'), $N($R$0($EXPECT($
|
|
4954
|
+
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)));
|
|
4810
4955
|
function TrailingCallExpressions(ctx, state) {
|
|
4811
4956
|
return $EVENT(ctx, state, "TrailingCallExpressions", TrailingCallExpressions$0);
|
|
4812
4957
|
}
|
|
@@ -5124,7 +5269,7 @@ var require_parser = __commonJS({
|
|
|
5124
5269
|
function FatArrow(ctx, state) {
|
|
5125
5270
|
return $EVENT(ctx, state, "FatArrow", FatArrow$0);
|
|
5126
5271
|
}
|
|
5127
|
-
var TrailingDeclaration$0 = $S($
|
|
5272
|
+
var TrailingDeclaration$0 = $S($E(_), $C(ConstAssignment, LetAssignment));
|
|
5128
5273
|
function TrailingDeclaration(ctx, state) {
|
|
5129
5274
|
return $EVENT(ctx, state, "TrailingDeclaration", TrailingDeclaration$0);
|
|
5130
5275
|
}
|
|
@@ -5147,7 +5292,7 @@ var require_parser = __commonJS({
|
|
|
5147
5292
|
return $EVENT(ctx, state, "ConditionalExpression", ConditionalExpression$0);
|
|
5148
5293
|
}
|
|
5149
5294
|
var TernaryRest$0 = NestedTernaryRest;
|
|
5150
|
-
var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($
|
|
5295
|
+
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) {
|
|
5151
5296
|
return $0.slice(2);
|
|
5152
5297
|
});
|
|
5153
5298
|
var TernaryRest$$ = [TernaryRest$0, TernaryRest$1];
|
|
@@ -5176,6 +5321,18 @@ var require_parser = __commonJS({
|
|
|
5176
5321
|
type: "PipelineExpression",
|
|
5177
5322
|
children: [ws, ref, body]
|
|
5178
5323
|
};
|
|
5324
|
+
const parameters = {
|
|
5325
|
+
type: "Parameters",
|
|
5326
|
+
children: [ref],
|
|
5327
|
+
names: []
|
|
5328
|
+
};
|
|
5329
|
+
const expressions = [arrowBody];
|
|
5330
|
+
const block = {
|
|
5331
|
+
bare: true,
|
|
5332
|
+
expressions,
|
|
5333
|
+
children: [expressions]
|
|
5334
|
+
};
|
|
5335
|
+
const children = [parameters, " => ", block];
|
|
5179
5336
|
return {
|
|
5180
5337
|
type: "ArrowFunction",
|
|
5181
5338
|
signature: {
|
|
@@ -5183,10 +5340,12 @@ var require_parser = __commonJS({
|
|
|
5183
5340
|
children: []
|
|
5184
5341
|
}
|
|
5185
5342
|
},
|
|
5186
|
-
children
|
|
5343
|
+
children,
|
|
5187
5344
|
ref,
|
|
5188
5345
|
body: [arrowBody],
|
|
5189
|
-
ampersandBlock: true
|
|
5346
|
+
ampersandBlock: true,
|
|
5347
|
+
parameters,
|
|
5348
|
+
block
|
|
5190
5349
|
};
|
|
5191
5350
|
}
|
|
5192
5351
|
return {
|
|
@@ -5261,7 +5420,7 @@ var require_parser = __commonJS({
|
|
|
5261
5420
|
function ClassDeclaration(ctx, state) {
|
|
5262
5421
|
return $EVENT(ctx, state, "ClassDeclaration", ClassDeclaration$0);
|
|
5263
5422
|
}
|
|
5264
|
-
var ClassExpression$0 = $S($E(Decorators), $E($S(Abstract, __)), Class, $N($EXPECT($
|
|
5423
|
+
var ClassExpression$0 = $S($E(Decorators), $E($S(Abstract, __)), Class, $N($EXPECT($L11, 'ClassExpression ":"')), $E(ClassBinding), $E(ClassHeritage), ClassBody);
|
|
5265
5424
|
function ClassExpression(ctx, state) {
|
|
5266
5425
|
return $EVENT(ctx, state, "ClassExpression", ClassExpression$0);
|
|
5267
5426
|
}
|
|
@@ -5281,7 +5440,7 @@ var require_parser = __commonJS({
|
|
|
5281
5440
|
function ExtendsClause(ctx, state) {
|
|
5282
5441
|
return $EVENT(ctx, state, "ExtendsClause", ExtendsClause$0);
|
|
5283
5442
|
}
|
|
5284
|
-
var ExtendsToken$0 = $TS($S(Loc, __, OpenAngleBracket, $E($EXPECT($
|
|
5443
|
+
var ExtendsToken$0 = $TS($S(Loc, __, OpenAngleBracket, $E($EXPECT($L12, 'ExtendsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5285
5444
|
var l = $1;
|
|
5286
5445
|
var ws = $2;
|
|
5287
5446
|
var lt = $3;
|
|
@@ -5319,7 +5478,7 @@ var require_parser = __commonJS({
|
|
|
5319
5478
|
function ImplementsClause(ctx, state) {
|
|
5320
5479
|
return $EVENT(ctx, state, "ImplementsClause", ImplementsClause$0);
|
|
5321
5480
|
}
|
|
5322
|
-
var ImplementsToken$0 = $TS($S(Loc, __, ImplementsShorthand, $E($EXPECT($
|
|
5481
|
+
var ImplementsToken$0 = $TS($S(Loc, __, ImplementsShorthand, $E($EXPECT($L12, 'ImplementsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5323
5482
|
var l = $1;
|
|
5324
5483
|
var ws = $2;
|
|
5325
5484
|
var token = $3;
|
|
@@ -5549,7 +5708,7 @@ var require_parser = __commonJS({
|
|
|
5549
5708
|
function AtThis(ctx, state) {
|
|
5550
5709
|
return $EVENT(ctx, state, "AtThis", AtThis$0);
|
|
5551
5710
|
}
|
|
5552
|
-
var LeftHandSideExpression$0 = $S($P($S(New, $N($C($EXPECT($L6, 'LeftHandSideExpression "."'), $EXPECT($
|
|
5711
|
+
var LeftHandSideExpression$0 = $S($P($S(New, $N($C($EXPECT($L6, 'LeftHandSideExpression "."'), $EXPECT($L11, 'LeftHandSideExpression ":"'))), __)), CallExpression, $E(TypeArguments));
|
|
5553
5712
|
var LeftHandSideExpression$1 = CallExpression;
|
|
5554
5713
|
var LeftHandSideExpression$$ = [LeftHandSideExpression$0, LeftHandSideExpression$1];
|
|
5555
5714
|
function LeftHandSideExpression(ctx, state) {
|
|
@@ -5587,13 +5746,14 @@ var require_parser = __commonJS({
|
|
|
5587
5746
|
return $EVENT_C(ctx, state, "CallExpression", CallExpression$$);
|
|
5588
5747
|
}
|
|
5589
5748
|
var CallExpressionRest$0 = MemberExpressionRest;
|
|
5590
|
-
var CallExpressionRest$1 = $
|
|
5591
|
-
|
|
5592
|
-
|
|
5749
|
+
var CallExpressionRest$1 = $TS($S($EXPECT($R4, "CallExpressionRest /(?=['\"`])/"), $C(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2) {
|
|
5750
|
+
var literal = $2;
|
|
5751
|
+
if (literal.type === "StringLiteral") {
|
|
5752
|
+
return "`" + literal.token.slice(1, -1).replace(/(`|\$\{)/g, "\\$1") + "`";
|
|
5593
5753
|
}
|
|
5594
|
-
return
|
|
5754
|
+
return literal;
|
|
5595
5755
|
});
|
|
5596
|
-
var CallExpressionRest$2 = $TS($S($E(
|
|
5756
|
+
var CallExpressionRest$2 = $TS($S($E(OptionalShorthand), ArgumentsWithTrailingMemberExpressions), function($skip, $loc, $0, $1, $2) {
|
|
5597
5757
|
if (!$1)
|
|
5598
5758
|
return $2;
|
|
5599
5759
|
return [$1, ...$2];
|
|
@@ -5602,17 +5762,19 @@ var require_parser = __commonJS({
|
|
|
5602
5762
|
function CallExpressionRest(ctx, state) {
|
|
5603
5763
|
return $EVENT_C(ctx, state, "CallExpressionRest", CallExpressionRest$$);
|
|
5604
5764
|
}
|
|
5605
|
-
var OptionalShorthand$0 = $TS($S($Q(InlineComment), QuestionMark, OptionalDot), function($skip, $loc, $0, $1, $2, $3) {
|
|
5765
|
+
var OptionalShorthand$0 = $TS($S($EXPECT($R5, "OptionalShorthand /(?=[\\/?])/"), $Q(InlineComment), QuestionMark, OptionalDot), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5606
5766
|
return {
|
|
5607
5767
|
type: "Optional",
|
|
5608
5768
|
children: $0
|
|
5609
5769
|
};
|
|
5610
5770
|
});
|
|
5771
|
+
var OptionalShorthand$1 = NonNullAssertion;
|
|
5772
|
+
var OptionalShorthand$$ = [OptionalShorthand$0, OptionalShorthand$1];
|
|
5611
5773
|
function OptionalShorthand(ctx, state) {
|
|
5612
|
-
return $
|
|
5774
|
+
return $EVENT_C(ctx, state, "OptionalShorthand", OptionalShorthand$$);
|
|
5613
5775
|
}
|
|
5614
5776
|
var OptionalDot$0 = $S($Q(InlineComment), Dot);
|
|
5615
|
-
var OptionalDot$1 =
|
|
5777
|
+
var OptionalDot$1 = InsertDot;
|
|
5616
5778
|
var OptionalDot$$ = [OptionalDot$0, OptionalDot$1];
|
|
5617
5779
|
function OptionalDot(ctx, state) {
|
|
5618
5780
|
return $EVENT_C(ctx, state, "OptionalDot", OptionalDot$$);
|
|
@@ -5643,9 +5805,9 @@ var require_parser = __commonJS({
|
|
|
5643
5805
|
function MemberBase(ctx, state) {
|
|
5644
5806
|
return $EVENT_C(ctx, state, "MemberBase", MemberBase$$);
|
|
5645
5807
|
}
|
|
5646
|
-
var MemberExpressionRest$0 = $TS($S($Q(InlineComment), MemberExpressionRestBody), function($skip, $loc, $0, $1, $2) {
|
|
5647
|
-
var comments = $
|
|
5648
|
-
var body = $
|
|
5808
|
+
var MemberExpressionRest$0 = $TS($S($EXPECT($R6, "MemberExpressionRest /(?=[\\/\\[{?.!@'\u2019:])/"), $Q(InlineComment), MemberExpressionRestBody), function($skip, $loc, $0, $1, $2, $3) {
|
|
5809
|
+
var comments = $2;
|
|
5810
|
+
var body = $3;
|
|
5649
5811
|
if (Array.isArray(body))
|
|
5650
5812
|
return [...comments, ...body];
|
|
5651
5813
|
return {
|
|
@@ -5656,7 +5818,7 @@ var require_parser = __commonJS({
|
|
|
5656
5818
|
function MemberExpressionRest(ctx, state) {
|
|
5657
5819
|
return $EVENT(ctx, state, "MemberExpressionRest", MemberExpressionRest$0);
|
|
5658
5820
|
}
|
|
5659
|
-
var MemberExpressionRestBody$0 = $TS($S($E(
|
|
5821
|
+
var MemberExpressionRestBody$0 = $TS($S($E(OptionalShorthand), $Q(InlineComment), MemberBracketContent), function($skip, $loc, $0, $1, $2, $3) {
|
|
5660
5822
|
var dot = $1;
|
|
5661
5823
|
var comments = $2;
|
|
5662
5824
|
var content = $3;
|
|
@@ -5700,35 +5862,21 @@ var require_parser = __commonJS({
|
|
|
5700
5862
|
expression
|
|
5701
5863
|
};
|
|
5702
5864
|
});
|
|
5703
|
-
var MemberBracketContent$1 = $TS($S(Dot, $C(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2) {
|
|
5704
|
-
var dot = $1;
|
|
5705
|
-
var str = $2;
|
|
5706
|
-
if (Array.isArray(dot))
|
|
5707
|
-
dot = dot[0];
|
|
5708
|
-
return {
|
|
5709
|
-
type: "Index",
|
|
5710
|
-
children: [
|
|
5711
|
-
{ token: "[", $loc: dot.$loc },
|
|
5712
|
-
str,
|
|
5713
|
-
"]"
|
|
5714
|
-
]
|
|
5715
|
-
};
|
|
5716
|
-
});
|
|
5717
|
-
var MemberBracketContent$2 = $TS($S(Dot, IntegerLiteral), function($skip, $loc, $0, $1, $2) {
|
|
5865
|
+
var MemberBracketContent$1 = $TS($S(Dot, $C(TemplateLiteral, StringLiteral, IntegerLiteral)), function($skip, $loc, $0, $1, $2) {
|
|
5718
5866
|
var dot = $1;
|
|
5719
|
-
var
|
|
5867
|
+
var literal = $2;
|
|
5720
5868
|
if (Array.isArray(dot))
|
|
5721
5869
|
dot = dot[0];
|
|
5722
5870
|
return {
|
|
5723
5871
|
type: "Index",
|
|
5724
5872
|
children: [
|
|
5725
5873
|
{ token: "[", $loc: dot.$loc },
|
|
5726
|
-
|
|
5874
|
+
literal,
|
|
5727
5875
|
"]"
|
|
5728
5876
|
]
|
|
5729
5877
|
};
|
|
5730
5878
|
});
|
|
5731
|
-
var MemberBracketContent$
|
|
5879
|
+
var MemberBracketContent$2 = $TS($S(Dot, $EXPECT($L18, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
5732
5880
|
var dot = $1;
|
|
5733
5881
|
var neg = $2;
|
|
5734
5882
|
var num = $3;
|
|
@@ -5738,7 +5886,7 @@ var require_parser = __commonJS({
|
|
|
5738
5886
|
{ type: "Call", children: ["(", neg, num, ")"] }
|
|
5739
5887
|
];
|
|
5740
5888
|
});
|
|
5741
|
-
var MemberBracketContent$$ = [MemberBracketContent$0, MemberBracketContent$1, MemberBracketContent$2
|
|
5889
|
+
var MemberBracketContent$$ = [MemberBracketContent$0, MemberBracketContent$1, MemberBracketContent$2];
|
|
5742
5890
|
function MemberBracketContent(ctx, state) {
|
|
5743
5891
|
return $EVENT_C(ctx, state, "MemberBracketContent", MemberBracketContent$$);
|
|
5744
5892
|
}
|
|
@@ -5806,7 +5954,7 @@ var require_parser = __commonJS({
|
|
|
5806
5954
|
function SliceParameters(ctx, state) {
|
|
5807
5955
|
return $EVENT_C(ctx, state, "SliceParameters", SliceParameters$$);
|
|
5808
5956
|
}
|
|
5809
|
-
var AccessStart$0 = $TS($S($E(
|
|
5957
|
+
var AccessStart$0 = $TS($S($E(PropertyAccessModifier), Dot, $N(Dot)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5810
5958
|
if ($1)
|
|
5811
5959
|
return [$1, $2];
|
|
5812
5960
|
return $2;
|
|
@@ -5814,6 +5962,12 @@ var require_parser = __commonJS({
|
|
|
5814
5962
|
function AccessStart(ctx, state) {
|
|
5815
5963
|
return $EVENT(ctx, state, "AccessStart", AccessStart$0);
|
|
5816
5964
|
}
|
|
5965
|
+
var PropertyAccessModifier$0 = QuestionMark;
|
|
5966
|
+
var PropertyAccessModifier$1 = NonNullAssertion;
|
|
5967
|
+
var PropertyAccessModifier$$ = [PropertyAccessModifier$0, PropertyAccessModifier$1];
|
|
5968
|
+
function PropertyAccessModifier(ctx, state) {
|
|
5969
|
+
return $EVENT_C(ctx, state, "PropertyAccessModifier", PropertyAccessModifier$$);
|
|
5970
|
+
}
|
|
5817
5971
|
var PropertyAccess$0 = $TS($S(AccessStart, $Q(InlineComment), $C(IdentifierName, PrivateIdentifier)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5818
5972
|
var access = $1;
|
|
5819
5973
|
var comments = $2;
|
|
@@ -5846,7 +6000,7 @@ var require_parser = __commonJS({
|
|
|
5846
6000
|
function PropertyAccess(ctx, state) {
|
|
5847
6001
|
return $EVENT_C(ctx, state, "PropertyAccess", PropertyAccess$$);
|
|
5848
6002
|
}
|
|
5849
|
-
var PropertyGlob$0 = $TS($S($S($E(
|
|
6003
|
+
var PropertyGlob$0 = $TS($S($S($E(PropertyAccessModifier), OptionalDot), $Q(InlineComment), BracedObjectLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
5850
6004
|
var dot = $1;
|
|
5851
6005
|
var object = $3;
|
|
5852
6006
|
return {
|
|
@@ -5859,7 +6013,7 @@ var require_parser = __commonJS({
|
|
|
5859
6013
|
function PropertyGlob(ctx, state) {
|
|
5860
6014
|
return $EVENT(ctx, state, "PropertyGlob", PropertyGlob$0);
|
|
5861
6015
|
}
|
|
5862
|
-
var PropertyBind$0 = $TS($S($E(
|
|
6016
|
+
var PropertyBind$0 = $TS($S($E(PropertyAccessModifier), At, OptionalDot, $C(IdentifierName, PrivateIdentifier)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5863
6017
|
var modifier = $1;
|
|
5864
6018
|
var dot = $3;
|
|
5865
6019
|
var id = $4;
|
|
@@ -5874,7 +6028,7 @@ var require_parser = __commonJS({
|
|
|
5874
6028
|
return $EVENT(ctx, state, "PropertyBind", PropertyBind$0);
|
|
5875
6029
|
}
|
|
5876
6030
|
var SuperProperty$0 = $S(Super, MemberBracketContent);
|
|
5877
|
-
var SuperProperty$1 = $S(Super, $N(
|
|
6031
|
+
var SuperProperty$1 = $S(Super, $N(PropertyAccessModifier), PropertyAccess);
|
|
5878
6032
|
var SuperProperty$$ = [SuperProperty$0, SuperProperty$1];
|
|
5879
6033
|
function SuperProperty(ctx, state) {
|
|
5880
6034
|
return $EVENT_C(ctx, state, "SuperProperty", SuperProperty$$);
|
|
@@ -6005,8 +6159,8 @@ var require_parser = __commonJS({
|
|
|
6005
6159
|
function ParameterElement(ctx, state) {
|
|
6006
6160
|
return $EVENT(ctx, state, "ParameterElement", ParameterElement$0);
|
|
6007
6161
|
}
|
|
6008
|
-
var ParameterElementDelimiter$0 = $S($
|
|
6009
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $R$0($EXPECT($
|
|
6162
|
+
var ParameterElementDelimiter$0 = $S($E(_), Comma);
|
|
6163
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $R$0($EXPECT($R7, "ParameterElementDelimiter /[)}]/"))));
|
|
6010
6164
|
var ParameterElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6011
6165
|
return value[1];
|
|
6012
6166
|
});
|
|
@@ -6080,10 +6234,14 @@ var require_parser = __commonJS({
|
|
|
6080
6234
|
return $EVENT_C(ctx, state, "BindingPattern", BindingPattern$$);
|
|
6081
6235
|
}
|
|
6082
6236
|
var ObjectBindingPattern$0 = $TS($S($E(_), OpenBrace, ObjectBindingPatternContent, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
6237
|
+
var ws1 = $1;
|
|
6238
|
+
var open = $2;
|
|
6083
6239
|
var c = $3;
|
|
6240
|
+
var ws2 = $4;
|
|
6241
|
+
var close = $5;
|
|
6084
6242
|
return {
|
|
6085
6243
|
type: "ObjectBindingPattern",
|
|
6086
|
-
children: [
|
|
6244
|
+
children: [ws1, open, c.children, ws2, close],
|
|
6087
6245
|
names: c.names,
|
|
6088
6246
|
properties: c.children
|
|
6089
6247
|
};
|
|
@@ -6116,13 +6274,17 @@ var require_parser = __commonJS({
|
|
|
6116
6274
|
return $EVENT(ctx, state, "BindingPropertyList", BindingPropertyList$0);
|
|
6117
6275
|
}
|
|
6118
6276
|
var ArrayBindingPattern$0 = $TS($S($E(_), OpenBracket, ArrayBindingPatternContent, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
6277
|
+
var ws1 = $1;
|
|
6278
|
+
var open = $2;
|
|
6119
6279
|
var c = $3;
|
|
6280
|
+
var ws2 = $4;
|
|
6281
|
+
var close = $5;
|
|
6120
6282
|
return {
|
|
6121
6283
|
...c,
|
|
6122
6284
|
// names, blockPrefix, length
|
|
6123
6285
|
type: "ArrayBindingPattern",
|
|
6124
6286
|
elements: c.children,
|
|
6125
|
-
children: [
|
|
6287
|
+
children: [ws1, open, c.children, ws2, close]
|
|
6126
6288
|
};
|
|
6127
6289
|
});
|
|
6128
6290
|
function ArrayBindingPattern(ctx, state) {
|
|
@@ -6424,6 +6586,14 @@ var require_parser = __commonJS({
|
|
|
6424
6586
|
});
|
|
6425
6587
|
var FunctionExpression$1 = $TV($EXPECT($L22, 'FunctionExpression "(&)"'), function($skip, $loc, $0, $1) {
|
|
6426
6588
|
const ref = makeRef("$"), body = [ref];
|
|
6589
|
+
const parameters = {
|
|
6590
|
+
type: "Parameters",
|
|
6591
|
+
children: [ref],
|
|
6592
|
+
names: []
|
|
6593
|
+
};
|
|
6594
|
+
const block = {
|
|
6595
|
+
expressions: [ref]
|
|
6596
|
+
};
|
|
6427
6597
|
return {
|
|
6428
6598
|
type: "ArrowFunction",
|
|
6429
6599
|
signature: {
|
|
@@ -6432,7 +6602,9 @@ var require_parser = __commonJS({
|
|
|
6432
6602
|
children: [ref, " => ", body],
|
|
6433
6603
|
ref,
|
|
6434
6604
|
body,
|
|
6435
|
-
ampersandBlock: true
|
|
6605
|
+
ampersandBlock: true,
|
|
6606
|
+
block,
|
|
6607
|
+
parameters
|
|
6436
6608
|
};
|
|
6437
6609
|
});
|
|
6438
6610
|
var FunctionExpression$2 = AmpersandFunctionExpression;
|
|
@@ -6475,7 +6647,18 @@ var require_parser = __commonJS({
|
|
|
6475
6647
|
children: [prefix, body, void 0]
|
|
6476
6648
|
};
|
|
6477
6649
|
}
|
|
6478
|
-
const
|
|
6650
|
+
const parameters = {
|
|
6651
|
+
type: "Parameters",
|
|
6652
|
+
children: [ref],
|
|
6653
|
+
names: []
|
|
6654
|
+
};
|
|
6655
|
+
const expressions = [body];
|
|
6656
|
+
const block = {
|
|
6657
|
+
bare: true,
|
|
6658
|
+
expressions,
|
|
6659
|
+
children: [expressions]
|
|
6660
|
+
};
|
|
6661
|
+
const children = [parameters, " => ", block];
|
|
6479
6662
|
const async = hasAwait(body);
|
|
6480
6663
|
if (async) {
|
|
6481
6664
|
children.unshift("async ");
|
|
@@ -6490,7 +6673,9 @@ var require_parser = __commonJS({
|
|
|
6490
6673
|
children,
|
|
6491
6674
|
ref,
|
|
6492
6675
|
body,
|
|
6493
|
-
ampersandBlock: true
|
|
6676
|
+
ampersandBlock: true,
|
|
6677
|
+
block,
|
|
6678
|
+
parameters
|
|
6494
6679
|
};
|
|
6495
6680
|
});
|
|
6496
6681
|
function AmpersandFunctionExpression(ctx, state) {
|
|
@@ -6564,7 +6749,7 @@ var require_parser = __commonJS({
|
|
|
6564
6749
|
function AmpersandBlockRHS(ctx, state) {
|
|
6565
6750
|
return $EVENT(ctx, state, "AmpersandBlockRHS", AmpersandBlockRHS$0);
|
|
6566
6751
|
}
|
|
6567
|
-
var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S($N($EXPECT($
|
|
6752
|
+
var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S($N($EXPECT($R8, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2, $3) {
|
|
6568
6753
|
var callExpRest = $1;
|
|
6569
6754
|
var unaryPostfix = $2;
|
|
6570
6755
|
var binopRHS = $3;
|
|
@@ -6594,7 +6779,7 @@ var require_parser = __commonJS({
|
|
|
6594
6779
|
function AmpersandBlockRHSBody(ctx, state) {
|
|
6595
6780
|
return $EVENT(ctx, state, "AmpersandBlockRHSBody", AmpersandBlockRHSBody$0);
|
|
6596
6781
|
}
|
|
6597
|
-
var AmpersandUnaryPrefix$0 = $R$0($EXPECT($
|
|
6782
|
+
var AmpersandUnaryPrefix$0 = $R$0($EXPECT($R9, "AmpersandUnaryPrefix /[!~+-]+/"));
|
|
6598
6783
|
function AmpersandUnaryPrefix(ctx, state) {
|
|
6599
6784
|
return $EVENT(ctx, state, "AmpersandUnaryPrefix", AmpersandUnaryPrefix$0);
|
|
6600
6785
|
}
|
|
@@ -6928,12 +7113,13 @@ var require_parser = __commonJS({
|
|
|
6928
7113
|
function BlockStatementPart(ctx, state) {
|
|
6929
7114
|
return $EVENT(ctx, state, "BlockStatementPart", BlockStatementPart$0);
|
|
6930
7115
|
}
|
|
6931
|
-
var Literal$0 = $TS($S(LiteralContent), function($skip, $loc, $0, $1) {
|
|
7116
|
+
var Literal$0 = $TS($S($EXPECT($R10, `Literal /(?=[0-9.'"tfyno])/`), LiteralContent), function($skip, $loc, $0, $1, $2) {
|
|
7117
|
+
var literal = $2;
|
|
6932
7118
|
return {
|
|
6933
7119
|
type: "Literal",
|
|
6934
|
-
subtype:
|
|
6935
|
-
children:
|
|
6936
|
-
raw:
|
|
7120
|
+
subtype: literal.type,
|
|
7121
|
+
children: [literal],
|
|
7122
|
+
raw: literal.token
|
|
6937
7123
|
};
|
|
6938
7124
|
});
|
|
6939
7125
|
function Literal(ctx, state) {
|
|
@@ -6953,15 +7139,21 @@ var require_parser = __commonJS({
|
|
|
6953
7139
|
function NullLiteral(ctx, state) {
|
|
6954
7140
|
return $EVENT(ctx, state, "NullLiteral", NullLiteral$0);
|
|
6955
7141
|
}
|
|
6956
|
-
var BooleanLiteral$0 = $T($S(
|
|
7142
|
+
var BooleanLiteral$0 = $T($S($EXPECT($R11, "BooleanLiteral /(?=true|false|yes|no|on|off)/"), _BooleanLiteral), function(value) {
|
|
7143
|
+
return value[1];
|
|
7144
|
+
});
|
|
7145
|
+
function BooleanLiteral(ctx, state) {
|
|
7146
|
+
return $EVENT(ctx, state, "BooleanLiteral", BooleanLiteral$0);
|
|
7147
|
+
}
|
|
7148
|
+
var _BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
6957
7149
|
return value[1];
|
|
6958
7150
|
});
|
|
6959
|
-
var
|
|
7151
|
+
var _BooleanLiteral$1 = $TS($S($C($EXPECT($L27, '_BooleanLiteral "true"'), $EXPECT($L28, '_BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6960
7152
|
return { $loc, token: $1 };
|
|
6961
7153
|
});
|
|
6962
|
-
var
|
|
6963
|
-
function
|
|
6964
|
-
return $EVENT_C(ctx, state, "
|
|
7154
|
+
var _BooleanLiteral$$ = [_BooleanLiteral$0, _BooleanLiteral$1];
|
|
7155
|
+
function _BooleanLiteral(ctx, state) {
|
|
7156
|
+
return $EVENT_C(ctx, state, "_BooleanLiteral", _BooleanLiteral$$);
|
|
6965
7157
|
}
|
|
6966
7158
|
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L29, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L30, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6967
7159
|
return { $loc, token: "true" };
|
|
@@ -6973,13 +7165,14 @@ var require_parser = __commonJS({
|
|
|
6973
7165
|
function CoffeeScriptBooleanLiteral(ctx, state) {
|
|
6974
7166
|
return $EVENT_C(ctx, state, "CoffeeScriptBooleanLiteral", CoffeeScriptBooleanLiteral$$);
|
|
6975
7167
|
}
|
|
6976
|
-
var Identifier$0 = $T($S($N(ReservedWord), IdentifierName), function(value) {
|
|
6977
|
-
|
|
7168
|
+
var Identifier$0 = $T($S($EXPECT($R12, "Identifier /(?=\\p{ID_Start}|[_$])/"), $N(ReservedWord), IdentifierName), function(value) {
|
|
7169
|
+
var id = value[2];
|
|
7170
|
+
return id;
|
|
6978
7171
|
});
|
|
6979
7172
|
function Identifier(ctx, state) {
|
|
6980
7173
|
return $EVENT(ctx, state, "Identifier", Identifier$0);
|
|
6981
7174
|
}
|
|
6982
|
-
var IdentifierName$0 = $TR($EXPECT($
|
|
7175
|
+
var IdentifierName$0 = $TR($EXPECT($R13, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
6983
7176
|
return {
|
|
6984
7177
|
type: "Identifier",
|
|
6985
7178
|
name: $0,
|
|
@@ -7001,10 +7194,16 @@ var require_parser = __commonJS({
|
|
|
7001
7194
|
function UpcomingAssignment(ctx, state) {
|
|
7002
7195
|
return $EVENT(ctx, state, "UpcomingAssignment", UpcomingAssignment$0);
|
|
7003
7196
|
}
|
|
7004
|
-
var ArrayLiteral$0 = $T($S(
|
|
7197
|
+
var ArrayLiteral$0 = $T($S($EXPECT($R14, "ArrayLiteral /(?=\\[)/"), _ArrayLiteral), function(value) {
|
|
7198
|
+
return value[1];
|
|
7199
|
+
});
|
|
7200
|
+
function ArrayLiteral(ctx, state) {
|
|
7201
|
+
return $EVENT(ctx, state, "ArrayLiteral", ArrayLiteral$0);
|
|
7202
|
+
}
|
|
7203
|
+
var _ArrayLiteral$0 = $T($S(ArrayBindingPattern, UpcomingAssignment), function(value) {
|
|
7005
7204
|
return value[0];
|
|
7006
7205
|
});
|
|
7007
|
-
var
|
|
7206
|
+
var _ArrayLiteral$1 = $TS($S(OpenBracket, AllowAll, $E($S(ArrayLiteralContent, __, CloseBracket)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7008
7207
|
var open = $1;
|
|
7009
7208
|
if (!$3)
|
|
7010
7209
|
return $skip;
|
|
@@ -7028,9 +7227,9 @@ var require_parser = __commonJS({
|
|
|
7028
7227
|
names
|
|
7029
7228
|
};
|
|
7030
7229
|
});
|
|
7031
|
-
var
|
|
7032
|
-
function
|
|
7033
|
-
return $EVENT_C(ctx, state, "
|
|
7230
|
+
var _ArrayLiteral$$ = [_ArrayLiteral$0, _ArrayLiteral$1];
|
|
7231
|
+
function _ArrayLiteral(ctx, state) {
|
|
7232
|
+
return $EVENT_C(ctx, state, "_ArrayLiteral", _ArrayLiteral$$);
|
|
7034
7233
|
}
|
|
7035
7234
|
var RangeExpression$0 = $TS($S(ExtendedExpression, __, $C(DotDotDot, DotDot), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7036
7235
|
var s = $1;
|
|
@@ -7395,7 +7594,7 @@ var require_parser = __commonJS({
|
|
|
7395
7594
|
children: [ws, ...prop.children]
|
|
7396
7595
|
};
|
|
7397
7596
|
});
|
|
7398
|
-
var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($
|
|
7597
|
+
var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($R15, "PropertyDefinition /[!+-]/")), PropertyName), function($skip, $loc, $0, $1, $2, $3) {
|
|
7399
7598
|
var ws = $1;
|
|
7400
7599
|
var toggle = $2;
|
|
7401
7600
|
var id = $3;
|
|
@@ -7918,12 +8117,19 @@ var require_parser = __commonJS({
|
|
|
7918
8117
|
function IdentifierBinaryOp(ctx, state) {
|
|
7919
8118
|
return $EVENT(ctx, state, "IdentifierBinaryOp", IdentifierBinaryOp$0);
|
|
7920
8119
|
}
|
|
7921
|
-
var BinaryOp$0 = $
|
|
8120
|
+
var BinaryOp$0 = $T($S($EXPECT($R16, "BinaryOp /(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>+-])/"), _BinaryOp), function(value) {
|
|
8121
|
+
var op = value[1];
|
|
8122
|
+
return op;
|
|
8123
|
+
});
|
|
8124
|
+
function BinaryOp(ctx, state) {
|
|
8125
|
+
return $EVENT(ctx, state, "BinaryOp", BinaryOp$0);
|
|
8126
|
+
}
|
|
8127
|
+
var _BinaryOp$0 = $TS($S(BinaryOpSymbol), function($skip, $loc, $0, $1) {
|
|
7922
8128
|
if (typeof $1 === "string")
|
|
7923
8129
|
return { $loc, token: $1 };
|
|
7924
8130
|
return $1;
|
|
7925
8131
|
});
|
|
7926
|
-
var
|
|
8132
|
+
var _BinaryOp$1 = $TV(Identifier, function($skip, $loc, $0, $1) {
|
|
7927
8133
|
var id = $0;
|
|
7928
8134
|
if (!module.operators.has(id.name))
|
|
7929
8135
|
return $skip;
|
|
@@ -7932,7 +8138,7 @@ var require_parser = __commonJS({
|
|
|
7932
8138
|
special: true
|
|
7933
8139
|
};
|
|
7934
8140
|
});
|
|
7935
|
-
var
|
|
8141
|
+
var _BinaryOp$2 = $TS($S(Not, __, Identifier), function($skip, $loc, $0, $1, $2, $3) {
|
|
7936
8142
|
var id = $3;
|
|
7937
8143
|
if (!module.operators.has(id.name))
|
|
7938
8144
|
return $skip;
|
|
@@ -7942,9 +8148,9 @@ var require_parser = __commonJS({
|
|
|
7942
8148
|
negated: true
|
|
7943
8149
|
};
|
|
7944
8150
|
});
|
|
7945
|
-
var
|
|
7946
|
-
function
|
|
7947
|
-
return $EVENT_C(ctx, state, "
|
|
8151
|
+
var _BinaryOp$$ = [_BinaryOp$0, _BinaryOp$1, _BinaryOp$2];
|
|
8152
|
+
function _BinaryOp(ctx, state) {
|
|
8153
|
+
return $EVENT_C(ctx, state, "_BinaryOp", _BinaryOp$$);
|
|
7948
8154
|
}
|
|
7949
8155
|
var BinaryOpSymbol$0 = $EXPECT($L53, 'BinaryOpSymbol "**"');
|
|
7950
8156
|
var BinaryOpSymbol$1 = $EXPECT($L54, 'BinaryOpSymbol "*"');
|
|
@@ -7987,7 +8193,7 @@ var require_parser = __commonJS({
|
|
|
7987
8193
|
var BinaryOpSymbol$14 = $T($EXPECT($L66, 'BinaryOpSymbol "\xAB"'), function(value) {
|
|
7988
8194
|
return "<<";
|
|
7989
8195
|
});
|
|
7990
|
-
var BinaryOpSymbol$15 = $TR($EXPECT($
|
|
8196
|
+
var BinaryOpSymbol$15 = $TR($EXPECT($R17, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7991
8197
|
return "<";
|
|
7992
8198
|
});
|
|
7993
8199
|
var BinaryOpSymbol$16 = $EXPECT($L67, 'BinaryOpSymbol ">>>"');
|
|
@@ -8026,36 +8232,33 @@ var require_parser = __commonJS({
|
|
|
8026
8232
|
return "&&";
|
|
8027
8233
|
});
|
|
8028
8234
|
var BinaryOpSymbol$29 = $EXPECT($L83, 'BinaryOpSymbol "&&"');
|
|
8029
|
-
var BinaryOpSymbol$30 = $T($S(
|
|
8030
|
-
return "in";
|
|
8031
|
-
});
|
|
8032
|
-
var BinaryOpSymbol$31 = $T($S($EXPECT($L85, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
8235
|
+
var BinaryOpSymbol$30 = $T($S($EXPECT($L84, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
8033
8236
|
return "||";
|
|
8034
8237
|
});
|
|
8035
|
-
var BinaryOpSymbol$
|
|
8036
|
-
var BinaryOpSymbol$
|
|
8238
|
+
var BinaryOpSymbol$31 = $EXPECT($L85, 'BinaryOpSymbol "||"');
|
|
8239
|
+
var BinaryOpSymbol$32 = $T($EXPECT($L86, 'BinaryOpSymbol "\u2016"'), function(value) {
|
|
8037
8240
|
return "||";
|
|
8038
8241
|
});
|
|
8039
|
-
var BinaryOpSymbol$
|
|
8242
|
+
var BinaryOpSymbol$33 = $TV($C($EXPECT($L87, 'BinaryOpSymbol "^^"'), $S($EXPECT($L88, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8040
8243
|
return {
|
|
8041
8244
|
call: module.getRef("xor"),
|
|
8042
8245
|
special: true
|
|
8043
8246
|
};
|
|
8044
8247
|
});
|
|
8045
|
-
var BinaryOpSymbol$
|
|
8248
|
+
var BinaryOpSymbol$34 = $TV($C($EXPECT($R18, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L89, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8046
8249
|
return {
|
|
8047
8250
|
call: module.getRef("xnor"),
|
|
8048
8251
|
special: true
|
|
8049
8252
|
};
|
|
8050
8253
|
});
|
|
8051
|
-
var BinaryOpSymbol$
|
|
8052
|
-
var BinaryOpSymbol$
|
|
8254
|
+
var BinaryOpSymbol$35 = $EXPECT($L90, 'BinaryOpSymbol "??"');
|
|
8255
|
+
var BinaryOpSymbol$36 = $T($EXPECT($L91, 'BinaryOpSymbol "\u2047"'), function(value) {
|
|
8053
8256
|
return "??";
|
|
8054
8257
|
});
|
|
8055
|
-
var BinaryOpSymbol$
|
|
8258
|
+
var BinaryOpSymbol$37 = $T($S($EXPECT($L5, 'BinaryOpSymbol "?"'), CoffeeBinaryExistentialEnabled), function(value) {
|
|
8056
8259
|
return "??";
|
|
8057
8260
|
});
|
|
8058
|
-
var BinaryOpSymbol$
|
|
8261
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L92, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8059
8262
|
return {
|
|
8060
8263
|
$loc,
|
|
8061
8264
|
token: $1,
|
|
@@ -8064,24 +8267,15 @@ var require_parser = __commonJS({
|
|
|
8064
8267
|
// for typeof shorthand
|
|
8065
8268
|
};
|
|
8066
8269
|
});
|
|
8067
|
-
var BinaryOpSymbol$
|
|
8068
|
-
|
|
8069
|
-
|
|
8070
|
-
token: "instanceof",
|
|
8071
|
-
relational: true,
|
|
8072
|
-
special: true,
|
|
8073
|
-
negated: true
|
|
8074
|
-
};
|
|
8270
|
+
var BinaryOpSymbol$39 = $T($S(CoffeeOfEnabled, CoffeeOfOp), function(value) {
|
|
8271
|
+
var op = value[1];
|
|
8272
|
+
return op;
|
|
8075
8273
|
});
|
|
8076
|
-
var BinaryOpSymbol$
|
|
8077
|
-
|
|
8078
|
-
|
|
8079
|
-
token: "in",
|
|
8080
|
-
special: true,
|
|
8081
|
-
negated: true
|
|
8082
|
-
};
|
|
8274
|
+
var BinaryOpSymbol$40 = $TS($S(Not, __, NotOp), function($skip, $loc, $0, $1, $2, $3) {
|
|
8275
|
+
var op = $3;
|
|
8276
|
+
return { ...op, $loc };
|
|
8083
8277
|
});
|
|
8084
|
-
var BinaryOpSymbol$
|
|
8278
|
+
var BinaryOpSymbol$41 = $TV($C($S(Is, __, In), $EXPECT($L93, 'BinaryOpSymbol "\u2208"')), function($skip, $loc, $0, $1) {
|
|
8085
8279
|
return {
|
|
8086
8280
|
method: "includes",
|
|
8087
8281
|
relational: true,
|
|
@@ -8089,14 +8283,14 @@ var require_parser = __commonJS({
|
|
|
8089
8283
|
special: true
|
|
8090
8284
|
};
|
|
8091
8285
|
});
|
|
8092
|
-
var BinaryOpSymbol$
|
|
8286
|
+
var BinaryOpSymbol$42 = $TV($EXPECT($L94, 'BinaryOpSymbol "\u220B"'), function($skip, $loc, $0, $1) {
|
|
8093
8287
|
return {
|
|
8094
8288
|
method: "includes",
|
|
8095
8289
|
relational: true,
|
|
8096
8290
|
special: true
|
|
8097
8291
|
};
|
|
8098
8292
|
});
|
|
8099
|
-
var BinaryOpSymbol$
|
|
8293
|
+
var BinaryOpSymbol$43 = $TV($EXPECT($L95, 'BinaryOpSymbol "\u220C"'), function($skip, $loc, $0, $1) {
|
|
8100
8294
|
return {
|
|
8101
8295
|
method: "includes",
|
|
8102
8296
|
relational: true,
|
|
@@ -8104,16 +8298,7 @@ var require_parser = __commonJS({
|
|
|
8104
8298
|
negated: true
|
|
8105
8299
|
};
|
|
8106
8300
|
});
|
|
8107
|
-
var BinaryOpSymbol$
|
|
8108
|
-
return {
|
|
8109
|
-
call: [module.getRef("indexOf"), ".call"],
|
|
8110
|
-
relational: true,
|
|
8111
|
-
reversed: true,
|
|
8112
|
-
suffix: " >= 0",
|
|
8113
|
-
special: true
|
|
8114
|
-
};
|
|
8115
|
-
});
|
|
8116
|
-
var BinaryOpSymbol$46 = $TV($C($S(Is, __, Not, __, In), $EXPECT($L97, 'BinaryOpSymbol "\u2209"')), function($skip, $loc, $0, $1) {
|
|
8301
|
+
var BinaryOpSymbol$44 = $TV($C($S(Is, __, Not, __, In), $EXPECT($L96, 'BinaryOpSymbol "\u2209"')), function($skip, $loc, $0, $1) {
|
|
8117
8302
|
return {
|
|
8118
8303
|
method: "includes",
|
|
8119
8304
|
relational: true,
|
|
@@ -8122,16 +8307,7 @@ var require_parser = __commonJS({
|
|
|
8122
8307
|
negated: true
|
|
8123
8308
|
};
|
|
8124
8309
|
});
|
|
8125
|
-
var BinaryOpSymbol$
|
|
8126
|
-
return {
|
|
8127
|
-
call: [module.getRef("indexOf"), ".call"],
|
|
8128
|
-
relational: true,
|
|
8129
|
-
reversed: true,
|
|
8130
|
-
suffix: " < 0",
|
|
8131
|
-
special: true
|
|
8132
|
-
};
|
|
8133
|
-
});
|
|
8134
|
-
var BinaryOpSymbol$48 = $TS($S($N(CoffeeNotEnabled), Is, __, Not), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8310
|
+
var BinaryOpSymbol$45 = $TS($S($N(CoffeeNotEnabled), Is, __, Not), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8135
8311
|
if (module.config.objectIs) {
|
|
8136
8312
|
return {
|
|
8137
8313
|
call: module.getRef("is"),
|
|
@@ -8143,7 +8319,7 @@ var require_parser = __commonJS({
|
|
|
8143
8319
|
}
|
|
8144
8320
|
return "!==";
|
|
8145
8321
|
});
|
|
8146
|
-
var BinaryOpSymbol$
|
|
8322
|
+
var BinaryOpSymbol$46 = $TS($S(Is), function($skip, $loc, $0, $1) {
|
|
8147
8323
|
if (module.config.objectIs) {
|
|
8148
8324
|
return {
|
|
8149
8325
|
call: module.getRef("is"),
|
|
@@ -8154,34 +8330,86 @@ var require_parser = __commonJS({
|
|
|
8154
8330
|
}
|
|
8155
8331
|
return "===";
|
|
8156
8332
|
});
|
|
8157
|
-
var BinaryOpSymbol$
|
|
8158
|
-
|
|
8159
|
-
|
|
8160
|
-
var BinaryOpSymbol$
|
|
8161
|
-
var BinaryOpSymbol
|
|
8162
|
-
var BinaryOpSymbol$53 = $EXPECT($L99, 'BinaryOpSymbol "|"');
|
|
8163
|
-
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];
|
|
8333
|
+
var BinaryOpSymbol$47 = In;
|
|
8334
|
+
var BinaryOpSymbol$48 = $EXPECT($L97, 'BinaryOpSymbol "&"');
|
|
8335
|
+
var BinaryOpSymbol$49 = $EXPECT($L17, 'BinaryOpSymbol "^"');
|
|
8336
|
+
var BinaryOpSymbol$50 = $EXPECT($L98, 'BinaryOpSymbol "|"');
|
|
8337
|
+
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];
|
|
8164
8338
|
function BinaryOpSymbol(ctx, state) {
|
|
8165
8339
|
return $EVENT_C(ctx, state, "BinaryOpSymbol", BinaryOpSymbol$$);
|
|
8166
8340
|
}
|
|
8167
|
-
var
|
|
8168
|
-
|
|
8341
|
+
var CoffeeOfOp$0 = $T($S(Of), function(value) {
|
|
8342
|
+
return "in";
|
|
8343
|
+
});
|
|
8344
|
+
var CoffeeOfOp$1 = $TS($S(In), function($skip, $loc, $0, $1) {
|
|
8345
|
+
return {
|
|
8346
|
+
call: [module.getRef("indexOf"), ".call"],
|
|
8347
|
+
relational: true,
|
|
8348
|
+
reversed: true,
|
|
8349
|
+
suffix: " >= 0",
|
|
8350
|
+
special: true
|
|
8351
|
+
};
|
|
8352
|
+
});
|
|
8353
|
+
var CoffeeOfOp$2 = $TS($S(Not, __, Of, NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8354
|
+
return {
|
|
8355
|
+
$loc,
|
|
8356
|
+
token: "in",
|
|
8357
|
+
special: true,
|
|
8358
|
+
negated: true
|
|
8359
|
+
};
|
|
8360
|
+
});
|
|
8361
|
+
var CoffeeOfOp$3 = $TS($S(Not, __, In), function($skip, $loc, $0, $1, $2, $3) {
|
|
8362
|
+
return {
|
|
8363
|
+
call: [module.getRef("indexOf"), ".call"],
|
|
8364
|
+
relational: true,
|
|
8365
|
+
reversed: true,
|
|
8366
|
+
suffix: " < 0",
|
|
8367
|
+
special: true
|
|
8368
|
+
};
|
|
8369
|
+
});
|
|
8370
|
+
var CoffeeOfOp$$ = [CoffeeOfOp$0, CoffeeOfOp$1, CoffeeOfOp$2, CoffeeOfOp$3];
|
|
8371
|
+
function CoffeeOfOp(ctx, state) {
|
|
8372
|
+
return $EVENT_C(ctx, state, "CoffeeOfOp", CoffeeOfOp$$);
|
|
8373
|
+
}
|
|
8374
|
+
var NotOp$0 = $TS($S($EXPECT($L92, 'NotOp "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8375
|
+
return {
|
|
8376
|
+
$loc,
|
|
8377
|
+
token: "instanceof",
|
|
8378
|
+
relational: true,
|
|
8379
|
+
special: true,
|
|
8380
|
+
negated: true
|
|
8381
|
+
};
|
|
8382
|
+
});
|
|
8383
|
+
var NotOp$1 = $TS($S(In), function($skip, $loc, $0, $1) {
|
|
8384
|
+
return {
|
|
8385
|
+
$loc,
|
|
8386
|
+
token: "in",
|
|
8387
|
+
special: true,
|
|
8388
|
+
negated: true
|
|
8389
|
+
};
|
|
8390
|
+
});
|
|
8391
|
+
var NotOp$$ = [NotOp$0, NotOp$1];
|
|
8392
|
+
function NotOp(ctx, state) {
|
|
8393
|
+
return $EVENT_C(ctx, state, "NotOp", NotOp$$);
|
|
8394
|
+
}
|
|
8395
|
+
var Xor$0 = $EXPECT($L87, 'Xor "^^"');
|
|
8396
|
+
var Xor$1 = $S($EXPECT($L88, 'Xor "xor"'), NonIdContinue);
|
|
8169
8397
|
var Xor$$ = [Xor$0, Xor$1];
|
|
8170
8398
|
function Xor(ctx, state) {
|
|
8171
8399
|
return $EVENT_C(ctx, state, "Xor", Xor$$);
|
|
8172
8400
|
}
|
|
8173
|
-
var Xnor$0 = $R$0($EXPECT($
|
|
8174
|
-
var Xnor$1 = $EXPECT($
|
|
8401
|
+
var Xnor$0 = $R$0($EXPECT($R18, "Xnor /!\\^\\^?/"));
|
|
8402
|
+
var Xnor$1 = $EXPECT($L89, 'Xnor "xnor"');
|
|
8175
8403
|
var Xnor$$ = [Xnor$0, Xnor$1];
|
|
8176
8404
|
function Xnor(ctx, state) {
|
|
8177
8405
|
return $EVENT_C(ctx, state, "Xnor", Xnor$$);
|
|
8178
8406
|
}
|
|
8179
|
-
var UnaryOp$0 = $TR($EXPECT($
|
|
8407
|
+
var UnaryOp$0 = $TR($EXPECT($R19, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8180
8408
|
return { $loc, token: $0 };
|
|
8181
8409
|
});
|
|
8182
8410
|
var UnaryOp$1 = AwaitOp;
|
|
8183
|
-
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($EXPECT($
|
|
8184
|
-
var UnaryOp$3 = $T($S(Not, $E($EXPECT($
|
|
8411
|
+
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($EXPECT($L11, 'UnaryOp ":"')), $E(_));
|
|
8412
|
+
var UnaryOp$3 = $T($S(Not, $E($EXPECT($L12, 'UnaryOp " "')), $E(_)), function(value) {
|
|
8185
8413
|
return [value[0], value[2]];
|
|
8186
8414
|
});
|
|
8187
8415
|
var UnaryOp$$ = [UnaryOp$0, UnaryOp$1, UnaryOp$2, UnaryOp$3];
|
|
@@ -8247,14 +8475,20 @@ var require_parser = __commonJS({
|
|
|
8247
8475
|
function NonPipelinePostfixedExpression(ctx, state) {
|
|
8248
8476
|
return $EVENT(ctx, state, "NonPipelinePostfixedExpression", NonPipelinePostfixedExpression$0);
|
|
8249
8477
|
}
|
|
8250
|
-
var PostfixStatement$0 =
|
|
8251
|
-
|
|
8252
|
-
|
|
8253
|
-
var PostfixStatement$3 = UnlessClause;
|
|
8254
|
-
var PostfixStatement$4 = WhileClause;
|
|
8255
|
-
var PostfixStatement$$ = [PostfixStatement$0, PostfixStatement$1, PostfixStatement$2, PostfixStatement$3, PostfixStatement$4];
|
|
8478
|
+
var PostfixStatement$0 = $T($S($EXPECT($R20, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
|
|
8479
|
+
return value[1];
|
|
8480
|
+
});
|
|
8256
8481
|
function PostfixStatement(ctx, state) {
|
|
8257
|
-
return $
|
|
8482
|
+
return $EVENT(ctx, state, "PostfixStatement", PostfixStatement$0);
|
|
8483
|
+
}
|
|
8484
|
+
var _PostfixStatement$0 = ForClause;
|
|
8485
|
+
var _PostfixStatement$1 = IfClause;
|
|
8486
|
+
var _PostfixStatement$2 = LoopClause;
|
|
8487
|
+
var _PostfixStatement$3 = UnlessClause;
|
|
8488
|
+
var _PostfixStatement$4 = WhileClause;
|
|
8489
|
+
var _PostfixStatement$$ = [_PostfixStatement$0, _PostfixStatement$1, _PostfixStatement$2, _PostfixStatement$3, _PostfixStatement$4];
|
|
8490
|
+
function _PostfixStatement(ctx, state) {
|
|
8491
|
+
return $EVENT_C(ctx, state, "_PostfixStatement", _PostfixStatement$$);
|
|
8258
8492
|
}
|
|
8259
8493
|
var Statement$0 = KeywordStatement;
|
|
8260
8494
|
var Statement$1 = VariableStatement;
|
|
@@ -8275,7 +8509,7 @@ var require_parser = __commonJS({
|
|
|
8275
8509
|
function Statement(ctx, state) {
|
|
8276
8510
|
return $EVENT_C(ctx, state, "Statement", Statement$$);
|
|
8277
8511
|
}
|
|
8278
|
-
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($
|
|
8512
|
+
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L99, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
|
|
8279
8513
|
return { type: "EmptyStatement", children: $1 || [] };
|
|
8280
8514
|
});
|
|
8281
8515
|
function EmptyStatement(ctx, state) {
|
|
@@ -8297,7 +8531,7 @@ var require_parser = __commonJS({
|
|
|
8297
8531
|
var w = $3;
|
|
8298
8532
|
return [id, colon, w];
|
|
8299
8533
|
});
|
|
8300
|
-
var Label$1 = $S($EXPECT($
|
|
8534
|
+
var Label$1 = $S($EXPECT($L100, 'Label "$:"'), Whitespace);
|
|
8301
8535
|
var Label$$ = [Label$0, Label$1];
|
|
8302
8536
|
function Label(ctx, state) {
|
|
8303
8537
|
return $EVENT_C(ctx, state, "Label", Label$$);
|
|
@@ -8470,18 +8704,24 @@ var require_parser = __commonJS({
|
|
|
8470
8704
|
function BlockExpressionPart(ctx, state) {
|
|
8471
8705
|
return $EVENT(ctx, state, "BlockExpressionPart", BlockExpressionPart$0);
|
|
8472
8706
|
}
|
|
8473
|
-
var IterationStatement$0 =
|
|
8474
|
-
var IterationStatement$1 = $T($S($N(CoffeeDoEnabled), DoWhileStatement), function(value) {
|
|
8707
|
+
var IterationStatement$0 = $T($S($EXPECT($R21, "IterationStatement /(?=loop|do|for|until|while)/"), _IterationStatement), function(value) {
|
|
8475
8708
|
return value[1];
|
|
8476
8709
|
});
|
|
8477
|
-
|
|
8710
|
+
function IterationStatement(ctx, state) {
|
|
8711
|
+
return $EVENT(ctx, state, "IterationStatement", IterationStatement$0);
|
|
8712
|
+
}
|
|
8713
|
+
var _IterationStatement$0 = LoopStatement;
|
|
8714
|
+
var _IterationStatement$1 = $T($S($N(CoffeeDoEnabled), DoWhileStatement), function(value) {
|
|
8478
8715
|
return value[1];
|
|
8479
8716
|
});
|
|
8480
|
-
var
|
|
8481
|
-
|
|
8482
|
-
|
|
8483
|
-
|
|
8484
|
-
|
|
8717
|
+
var _IterationStatement$2 = $T($S($N(CoffeeDoEnabled), DoStatement), function(value) {
|
|
8718
|
+
return value[1];
|
|
8719
|
+
});
|
|
8720
|
+
var _IterationStatement$3 = WhileStatement;
|
|
8721
|
+
var _IterationStatement$4 = ForStatement;
|
|
8722
|
+
var _IterationStatement$$ = [_IterationStatement$0, _IterationStatement$1, _IterationStatement$2, _IterationStatement$3, _IterationStatement$4];
|
|
8723
|
+
function _IterationStatement(ctx, state) {
|
|
8724
|
+
return $EVENT_C(ctx, state, "_IterationStatement", _IterationStatement$$);
|
|
8485
8725
|
}
|
|
8486
8726
|
var IterationExpression$0 = $TS($S($E($S(Async, __)), IterationStatement), function($skip, $loc, $0, $1, $2) {
|
|
8487
8727
|
var async = $1;
|
|
@@ -8596,8 +8836,9 @@ var require_parser = __commonJS({
|
|
|
8596
8836
|
return value[1];
|
|
8597
8837
|
});
|
|
8598
8838
|
var ForStatementControl$1 = $TS($S(CoffeeForLoopsEnabled, CoffeeForStatementParameters, $E(WhenCondition)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8599
|
-
|
|
8600
|
-
|
|
8839
|
+
var condition = $3;
|
|
8840
|
+
if (condition) {
|
|
8841
|
+
const block = "continue";
|
|
8601
8842
|
$2 = {
|
|
8602
8843
|
...$2,
|
|
8603
8844
|
blockPrefix: [
|
|
@@ -8605,8 +8846,8 @@ var require_parser = __commonJS({
|
|
|
8605
8846
|
["", {
|
|
8606
8847
|
type: "IfStatement",
|
|
8607
8848
|
then: block,
|
|
8608
|
-
children: ["if (!(", insertTrimmingSpace(
|
|
8609
|
-
}]
|
|
8849
|
+
children: ["if (!(", insertTrimmingSpace(condition, ""), ")) ", block]
|
|
8850
|
+
}, ";"]
|
|
8610
8851
|
]
|
|
8611
8852
|
};
|
|
8612
8853
|
}
|
|
@@ -8645,7 +8886,7 @@ var require_parser = __commonJS({
|
|
|
8645
8886
|
}
|
|
8646
8887
|
if (declaration.own) {
|
|
8647
8888
|
const hasPropRef = module.getRef("hasProp");
|
|
8648
|
-
blockPrefix.push(["", "if (!", hasPropRef, "(", exp, ", ", declaration, ")) continue", ";"]);
|
|
8889
|
+
blockPrefix.push(["", ["if (!", hasPropRef, "(", exp, ", ", declaration, ")) continue"], ";"]);
|
|
8649
8890
|
}
|
|
8650
8891
|
if (index) {
|
|
8651
8892
|
blockPrefix.push(["", {
|
|
@@ -8816,7 +9057,7 @@ var require_parser = __commonJS({
|
|
|
8816
9057
|
names: binding.names
|
|
8817
9058
|
};
|
|
8818
9059
|
});
|
|
8819
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
9060
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R22, "ForDeclaration /(?=[\\s\\),])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
8820
9061
|
var c = $1;
|
|
8821
9062
|
var binding = $2;
|
|
8822
9063
|
return {
|
|
@@ -9042,7 +9283,7 @@ var require_parser = __commonJS({
|
|
|
9042
9283
|
function IgnoreColon(ctx, state) {
|
|
9043
9284
|
return $EVENT(ctx, state, "IgnoreColon", IgnoreColon$0);
|
|
9044
9285
|
}
|
|
9045
|
-
var TryStatement$0 = $TS($S(Try, $N($EXPECT($
|
|
9286
|
+
var TryStatement$0 = $TS($S(Try, $N($EXPECT($L11, 'TryStatement ":"')), NoPostfixBracedOrEmptyBlock, $E(CatchClause), $E(FinallyClause)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
9046
9287
|
var t = $1;
|
|
9047
9288
|
var b = $3;
|
|
9048
9289
|
var c = $4;
|
|
@@ -9350,7 +9591,7 @@ var require_parser = __commonJS({
|
|
|
9350
9591
|
};
|
|
9351
9592
|
});
|
|
9352
9593
|
var KeywordStatement$2 = DebuggerStatement;
|
|
9353
|
-
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($
|
|
9594
|
+
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L11, 'KeywordStatement ":"'), $EXPECT($L6, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
|
|
9354
9595
|
var expression = value[2];
|
|
9355
9596
|
return { "type": "ReturnStatement", "expression": expression, "children": value };
|
|
9356
9597
|
});
|
|
@@ -9371,19 +9612,19 @@ var require_parser = __commonJS({
|
|
|
9371
9612
|
function ThrowStatement(ctx, state) {
|
|
9372
9613
|
return $EVENT(ctx, state, "ThrowStatement", ThrowStatement$0);
|
|
9373
9614
|
}
|
|
9374
|
-
var Break$0 = $TS($S($EXPECT($
|
|
9615
|
+
var Break$0 = $TS($S($EXPECT($L101, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9375
9616
|
return { $loc, token: $1 };
|
|
9376
9617
|
});
|
|
9377
9618
|
function Break(ctx, state) {
|
|
9378
9619
|
return $EVENT(ctx, state, "Break", Break$0);
|
|
9379
9620
|
}
|
|
9380
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
9621
|
+
var Continue$0 = $TS($S($EXPECT($L102, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9381
9622
|
return { $loc, token: $1 };
|
|
9382
9623
|
});
|
|
9383
9624
|
function Continue(ctx, state) {
|
|
9384
9625
|
return $EVENT(ctx, state, "Continue", Continue$0);
|
|
9385
9626
|
}
|
|
9386
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
9627
|
+
var Debugger$0 = $TS($S($EXPECT($L103, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9387
9628
|
return { $loc, token: $1 };
|
|
9388
9629
|
});
|
|
9389
9630
|
function Debugger(ctx, state) {
|
|
@@ -9504,7 +9745,7 @@ var require_parser = __commonJS({
|
|
|
9504
9745
|
function FromClause(ctx, state) {
|
|
9505
9746
|
return $EVENT(ctx, state, "FromClause", FromClause$0);
|
|
9506
9747
|
}
|
|
9507
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
9748
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L104, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
9508
9749
|
function ImportAssertion(ctx, state) {
|
|
9509
9750
|
return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
|
|
9510
9751
|
}
|
|
@@ -9552,7 +9793,7 @@ var require_parser = __commonJS({
|
|
|
9552
9793
|
return $EVENT_C(ctx, state, "ImportSpecifier", ImportSpecifier$$);
|
|
9553
9794
|
}
|
|
9554
9795
|
var ImportAsToken$0 = $S(__, As);
|
|
9555
|
-
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($
|
|
9796
|
+
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($L12, 'ImportAsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
9556
9797
|
var l = $1;
|
|
9557
9798
|
var ws = $2;
|
|
9558
9799
|
var c = $3;
|
|
@@ -9592,7 +9833,7 @@ var require_parser = __commonJS({
|
|
|
9592
9833
|
function UnprocessedModuleSpecifier(ctx, state) {
|
|
9593
9834
|
return $EVENT_C(ctx, state, "UnprocessedModuleSpecifier", UnprocessedModuleSpecifier$$);
|
|
9594
9835
|
}
|
|
9595
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
9836
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R23, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
9596
9837
|
var spec = $0;
|
|
9597
9838
|
return { $loc, token: `"${spec}"` };
|
|
9598
9839
|
});
|
|
@@ -9724,13 +9965,13 @@ var require_parser = __commonJS({
|
|
|
9724
9965
|
function LexicalDeclaration(ctx, state) {
|
|
9725
9966
|
return $EVENT_C(ctx, state, "LexicalDeclaration", LexicalDeclaration$$);
|
|
9726
9967
|
}
|
|
9727
|
-
var ConstAssignment$0 = $TV($C($EXPECT($
|
|
9968
|
+
var ConstAssignment$0 = $TV($C($EXPECT($L105, 'ConstAssignment ":="'), $EXPECT($L106, 'ConstAssignment "\u2254"')), function($skip, $loc, $0, $1) {
|
|
9728
9969
|
return { $loc, token: "=" };
|
|
9729
9970
|
});
|
|
9730
9971
|
function ConstAssignment(ctx, state) {
|
|
9731
9972
|
return $EVENT(ctx, state, "ConstAssignment", ConstAssignment$0);
|
|
9732
9973
|
}
|
|
9733
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
9974
|
+
var LetAssignment$0 = $TV($EXPECT($L107, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
9734
9975
|
return { $loc, token: "=" };
|
|
9735
9976
|
});
|
|
9736
9977
|
function LetAssignment(ctx, state) {
|
|
@@ -9798,8 +10039,9 @@ var require_parser = __commonJS({
|
|
|
9798
10039
|
function VariableDeclarationList(ctx, state) {
|
|
9799
10040
|
return $EVENT(ctx, state, "VariableDeclarationList", VariableDeclarationList$0);
|
|
9800
10041
|
}
|
|
9801
|
-
var NumericLiteral$0 = $TS($S(NumericLiteralKind), function($skip, $loc, $0, $1) {
|
|
9802
|
-
|
|
10042
|
+
var NumericLiteral$0 = $TS($S($EXPECT($R24, "NumericLiteral /(?=[0-9.])/"), NumericLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
10043
|
+
var token = $2;
|
|
10044
|
+
return { type: "NumericLiteral", $loc, token };
|
|
9803
10045
|
});
|
|
9804
10046
|
function NumericLiteral(ctx, state) {
|
|
9805
10047
|
return $EVENT(ctx, state, "NumericLiteral", NumericLiteral$0);
|
|
@@ -9813,37 +10055,38 @@ var require_parser = __commonJS({
|
|
|
9813
10055
|
function NumericLiteralKind(ctx, state) {
|
|
9814
10056
|
return $EVENT_C(ctx, state, "NumericLiteralKind", NumericLiteralKind$$);
|
|
9815
10057
|
}
|
|
9816
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
10058
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R25, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
9817
10059
|
function DecimalBigIntegerLiteral(ctx, state) {
|
|
9818
10060
|
return $EVENT(ctx, state, "DecimalBigIntegerLiteral", DecimalBigIntegerLiteral$0);
|
|
9819
10061
|
}
|
|
9820
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
10062
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R26, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
9821
10063
|
return $1 + ".";
|
|
9822
10064
|
});
|
|
9823
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
9824
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
10065
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R27, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
10066
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R28, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
9825
10067
|
var DecimalLiteral$$ = [DecimalLiteral$0, DecimalLiteral$1, DecimalLiteral$2];
|
|
9826
10068
|
function DecimalLiteral(ctx, state) {
|
|
9827
10069
|
return $EVENT_C(ctx, state, "DecimalLiteral", DecimalLiteral$$);
|
|
9828
10070
|
}
|
|
9829
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
10071
|
+
var ExponentPart$0 = $R$0($EXPECT($R29, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
9830
10072
|
function ExponentPart(ctx, state) {
|
|
9831
10073
|
return $EVENT(ctx, state, "ExponentPart", ExponentPart$0);
|
|
9832
10074
|
}
|
|
9833
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
10075
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R30, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
9834
10076
|
function BinaryIntegerLiteral(ctx, state) {
|
|
9835
10077
|
return $EVENT(ctx, state, "BinaryIntegerLiteral", BinaryIntegerLiteral$0);
|
|
9836
10078
|
}
|
|
9837
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
10079
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R31, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
9838
10080
|
function OctalIntegerLiteral(ctx, state) {
|
|
9839
10081
|
return $EVENT(ctx, state, "OctalIntegerLiteral", OctalIntegerLiteral$0);
|
|
9840
10082
|
}
|
|
9841
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
10083
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R32, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
9842
10084
|
function HexIntegerLiteral(ctx, state) {
|
|
9843
10085
|
return $EVENT(ctx, state, "HexIntegerLiteral", HexIntegerLiteral$0);
|
|
9844
10086
|
}
|
|
9845
|
-
var IntegerLiteral$0 = $TS($S(IntegerLiteralKind), function($skip, $loc, $0, $1) {
|
|
9846
|
-
|
|
10087
|
+
var IntegerLiteral$0 = $TS($S($EXPECT($R33, "IntegerLiteral /(?=[0-9])/"), IntegerLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
10088
|
+
var token = $2;
|
|
10089
|
+
return { $loc, token };
|
|
9847
10090
|
});
|
|
9848
10091
|
function IntegerLiteral(ctx, state) {
|
|
9849
10092
|
return $EVENT(ctx, state, "IntegerLiteral", IntegerLiteral$0);
|
|
@@ -9857,7 +10100,7 @@ var require_parser = __commonJS({
|
|
|
9857
10100
|
function IntegerLiteralKind(ctx, state) {
|
|
9858
10101
|
return $EVENT_C(ctx, state, "IntegerLiteralKind", IntegerLiteralKind$$);
|
|
9859
10102
|
}
|
|
9860
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
10103
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R34, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
9861
10104
|
function DecimalIntegerLiteral(ctx, state) {
|
|
9862
10105
|
return $EVENT(ctx, state, "DecimalIntegerLiteral", DecimalIntegerLiteral$0);
|
|
9863
10106
|
}
|
|
@@ -9881,25 +10124,25 @@ var require_parser = __commonJS({
|
|
|
9881
10124
|
function StringLiteral(ctx, state) {
|
|
9882
10125
|
return $EVENT_C(ctx, state, "StringLiteral", StringLiteral$$);
|
|
9883
10126
|
}
|
|
9884
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
10127
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R35, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9885
10128
|
return { $loc, token: $0 };
|
|
9886
10129
|
});
|
|
9887
10130
|
function DoubleStringCharacters(ctx, state) {
|
|
9888
10131
|
return $EVENT(ctx, state, "DoubleStringCharacters", DoubleStringCharacters$0);
|
|
9889
10132
|
}
|
|
9890
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
10133
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R36, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9891
10134
|
return { $loc, token: $0 };
|
|
9892
10135
|
});
|
|
9893
10136
|
function SingleStringCharacters(ctx, state) {
|
|
9894
10137
|
return $EVENT(ctx, state, "SingleStringCharacters", SingleStringCharacters$0);
|
|
9895
10138
|
}
|
|
9896
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
10139
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R37, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9897
10140
|
return { $loc, token: $0 };
|
|
9898
10141
|
});
|
|
9899
10142
|
function TripleDoubleStringCharacters(ctx, state) {
|
|
9900
10143
|
return $EVENT(ctx, state, "TripleDoubleStringCharacters", TripleDoubleStringCharacters$0);
|
|
9901
10144
|
}
|
|
9902
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
10145
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R38, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9903
10146
|
return { $loc, token: $0 };
|
|
9904
10147
|
});
|
|
9905
10148
|
function TripleSingleStringCharacters(ctx, state) {
|
|
@@ -9918,7 +10161,7 @@ var require_parser = __commonJS({
|
|
|
9918
10161
|
function CoffeeInterpolatedDoubleQuotedString(ctx, state) {
|
|
9919
10162
|
return $EVENT(ctx, state, "CoffeeInterpolatedDoubleQuotedString", CoffeeInterpolatedDoubleQuotedString$0);
|
|
9920
10163
|
}
|
|
9921
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
10164
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R39, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9922
10165
|
return { $loc, token: $0 };
|
|
9923
10166
|
});
|
|
9924
10167
|
function CoffeeDoubleQuotedStringCharacters(ctx, state) {
|
|
@@ -9938,7 +10181,7 @@ var require_parser = __commonJS({
|
|
|
9938
10181
|
function RegularExpressionClass(ctx, state) {
|
|
9939
10182
|
return $EVENT(ctx, state, "RegularExpressionClass", RegularExpressionClass$0);
|
|
9940
10183
|
}
|
|
9941
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
10184
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R40, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9942
10185
|
return { $loc, token: $0 };
|
|
9943
10186
|
});
|
|
9944
10187
|
function RegularExpressionClassCharacters(ctx, state) {
|
|
@@ -9992,7 +10235,7 @@ var require_parser = __commonJS({
|
|
|
9992
10235
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
9993
10236
|
return { "type": "Substitution", "children": value[0] };
|
|
9994
10237
|
});
|
|
9995
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
10238
|
+
var HeregexPart$3 = $TR($EXPECT($R41, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9996
10239
|
let token = $0;
|
|
9997
10240
|
switch ($0[1]) {
|
|
9998
10241
|
case "\n":
|
|
@@ -10010,13 +10253,13 @@ var require_parser = __commonJS({
|
|
|
10010
10253
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
10011
10254
|
return { $loc, token: "" };
|
|
10012
10255
|
});
|
|
10013
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
10256
|
+
var HeregexPart$5 = $TR($EXPECT($R42, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10014
10257
|
return { $loc, token: "" };
|
|
10015
10258
|
});
|
|
10016
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
10259
|
+
var HeregexPart$6 = $TR($EXPECT($R43, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10017
10260
|
return { $loc, token: "\\/" };
|
|
10018
10261
|
});
|
|
10019
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
10262
|
+
var HeregexPart$7 = $TR($EXPECT($R44, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10020
10263
|
return { $loc, token: $0 };
|
|
10021
10264
|
});
|
|
10022
10265
|
var HeregexPart$$ = [HeregexPart$0, HeregexPart$1, HeregexPart$2, HeregexPart$3, HeregexPart$4, HeregexPart$5, HeregexPart$6, HeregexPart$7];
|
|
@@ -10029,7 +10272,7 @@ var require_parser = __commonJS({
|
|
|
10029
10272
|
function HeregexComment(ctx, state) {
|
|
10030
10273
|
return $EVENT_C(ctx, state, "HeregexComment", HeregexComment$$);
|
|
10031
10274
|
}
|
|
10032
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
10275
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R45, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
10033
10276
|
function RegularExpressionBody(ctx, state) {
|
|
10034
10277
|
return $EVENT(ctx, state, "RegularExpressionBody", RegularExpressionBody$0);
|
|
10035
10278
|
}
|
|
@@ -10039,27 +10282,33 @@ var require_parser = __commonJS({
|
|
|
10039
10282
|
function RegExpPart(ctx, state) {
|
|
10040
10283
|
return $EVENT_C(ctx, state, "RegExpPart", RegExpPart$$);
|
|
10041
10284
|
}
|
|
10042
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
10285
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R46, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
10043
10286
|
function RegExpCharacter(ctx, state) {
|
|
10044
10287
|
return $EVENT(ctx, state, "RegExpCharacter", RegExpCharacter$0);
|
|
10045
10288
|
}
|
|
10046
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
10289
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R47, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
10047
10290
|
function RegularExpressionFlags(ctx, state) {
|
|
10048
10291
|
return $EVENT(ctx, state, "RegularExpressionFlags", RegularExpressionFlags$0);
|
|
10049
10292
|
}
|
|
10050
|
-
var TemplateLiteral$0 = $
|
|
10293
|
+
var TemplateLiteral$0 = $T($S($EXPECT($R48, "TemplateLiteral /(?=[`'\"])/"), _TemplateLiteral), function(value) {
|
|
10294
|
+
return value[1];
|
|
10295
|
+
});
|
|
10296
|
+
function TemplateLiteral(ctx, state) {
|
|
10297
|
+
return $EVENT(ctx, state, "TemplateLiteral", TemplateLiteral$0);
|
|
10298
|
+
}
|
|
10299
|
+
var _TemplateLiteral$0 = $TS($S(TripleTick, $Q($C(TemplateBlockCharacters, TemplateSubstitution)), TripleTick), function($skip, $loc, $0, $1, $2, $3) {
|
|
10051
10300
|
return dedentBlockSubstitutions($0, module.config.tab);
|
|
10052
10301
|
});
|
|
10053
|
-
var
|
|
10302
|
+
var _TemplateLiteral$1 = $TS($S(Backtick, $Q($C(TemplateCharacters, TemplateSubstitution)), Backtick), function($skip, $loc, $0, $1, $2, $3) {
|
|
10054
10303
|
return {
|
|
10055
10304
|
type: "TemplateLiteral",
|
|
10056
10305
|
children: $0
|
|
10057
10306
|
};
|
|
10058
10307
|
});
|
|
10059
|
-
var
|
|
10308
|
+
var _TemplateLiteral$2 = $TS($S(TripleDoubleQuote, $Q($C(TripleDoubleStringCharacters, CoffeeStringSubstitution)), TripleDoubleQuote), function($skip, $loc, $0, $1, $2, $3) {
|
|
10060
10309
|
return dedentBlockSubstitutions($0, module.config.tab);
|
|
10061
10310
|
});
|
|
10062
|
-
var
|
|
10311
|
+
var _TemplateLiteral$3 = $TS($S(TripleSingleQuote, TripleSingleStringCharacters, TripleSingleQuote), function($skip, $loc, $0, $1, $2, $3) {
|
|
10063
10312
|
var s = $1;
|
|
10064
10313
|
var str = $2;
|
|
10065
10314
|
var e = $3;
|
|
@@ -10068,37 +10317,37 @@ var require_parser = __commonJS({
|
|
|
10068
10317
|
children: [s, dedentBlockString(str, module.config.tab), e]
|
|
10069
10318
|
};
|
|
10070
10319
|
});
|
|
10071
|
-
var
|
|
10072
|
-
var
|
|
10073
|
-
function
|
|
10074
|
-
return $EVENT_C(ctx, state, "
|
|
10320
|
+
var _TemplateLiteral$4 = CoffeeInterpolatedDoubleQuotedString;
|
|
10321
|
+
var _TemplateLiteral$$ = [_TemplateLiteral$0, _TemplateLiteral$1, _TemplateLiteral$2, _TemplateLiteral$3, _TemplateLiteral$4];
|
|
10322
|
+
function _TemplateLiteral(ctx, state) {
|
|
10323
|
+
return $EVENT_C(ctx, state, "_TemplateLiteral", _TemplateLiteral$$);
|
|
10075
10324
|
}
|
|
10076
10325
|
var TemplateSubstitution$0 = $S(SubstitutionStart, PostfixedExpression, __, CloseBrace);
|
|
10077
10326
|
function TemplateSubstitution(ctx, state) {
|
|
10078
10327
|
return $EVENT(ctx, state, "TemplateSubstitution", TemplateSubstitution$0);
|
|
10079
10328
|
}
|
|
10080
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
10329
|
+
var TemplateCharacters$0 = $TR($EXPECT($R49, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10081
10330
|
return { $loc, token: $0 };
|
|
10082
10331
|
});
|
|
10083
10332
|
function TemplateCharacters(ctx, state) {
|
|
10084
10333
|
return $EVENT(ctx, state, "TemplateCharacters", TemplateCharacters$0);
|
|
10085
10334
|
}
|
|
10086
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
10335
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R50, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10087
10336
|
return { $loc, token: $0 };
|
|
10088
10337
|
});
|
|
10089
10338
|
function TemplateBlockCharacters(ctx, state) {
|
|
10090
10339
|
return $EVENT(ctx, state, "TemplateBlockCharacters", TemplateBlockCharacters$0);
|
|
10091
10340
|
}
|
|
10092
|
-
var ReservedWord$0 = $S(
|
|
10093
|
-
var ReservedWord$1 = $S(
|
|
10094
|
-
var ReservedWord$2 = $S(
|
|
10095
|
-
var ReservedWord$3 = $S(
|
|
10096
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
10341
|
+
var ReservedWord$0 = $S($R$0($EXPECT($R51, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")), CoffeeBooleansEnabled);
|
|
10342
|
+
var ReservedWord$1 = $S($R$0($EXPECT($R52, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")), CoffeeIsntEnabled);
|
|
10343
|
+
var ReservedWord$2 = $S($R$0($EXPECT($R53, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")), CoffeeForLoopsEnabled);
|
|
10344
|
+
var ReservedWord$3 = $S($R$0($EXPECT($R54, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")), CoffeeOfEnabled);
|
|
10345
|
+
var ReservedWord$4 = $R$0($EXPECT($R55, "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})/"));
|
|
10097
10346
|
var ReservedWord$$ = [ReservedWord$0, ReservedWord$1, ReservedWord$2, ReservedWord$3, ReservedWord$4];
|
|
10098
10347
|
function ReservedWord(ctx, state) {
|
|
10099
10348
|
return $EVENT_C(ctx, state, "ReservedWord", ReservedWord$$);
|
|
10100
10349
|
}
|
|
10101
|
-
var Comment$0 = $T($S($EXPECT($
|
|
10350
|
+
var Comment$0 = $T($S($EXPECT($R56, "Comment /(?=\\/|#)/"), _Comment), function(value) {
|
|
10102
10351
|
return value[1];
|
|
10103
10352
|
});
|
|
10104
10353
|
function Comment(ctx, state) {
|
|
@@ -10116,7 +10365,7 @@ var require_parser = __commonJS({
|
|
|
10116
10365
|
function SingleLineComment(ctx, state) {
|
|
10117
10366
|
return $EVENT_C(ctx, state, "SingleLineComment", SingleLineComment$$);
|
|
10118
10367
|
}
|
|
10119
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
10368
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R57, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10120
10369
|
return { type: "Comment", $loc, token: $0 };
|
|
10121
10370
|
});
|
|
10122
10371
|
function JSSingleLineComment(ctx, state) {
|
|
@@ -10128,30 +10377,30 @@ var require_parser = __commonJS({
|
|
|
10128
10377
|
function MultiLineComment(ctx, state) {
|
|
10129
10378
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
10130
10379
|
}
|
|
10131
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
10380
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L108, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L109, 'JSMultiLineComment "*/"')), $EXPECT($R58, "JSMultiLineComment /./"))), $EXPECT($L109, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
10132
10381
|
return { type: "Comment", $loc, token: $1 };
|
|
10133
10382
|
});
|
|
10134
10383
|
function JSMultiLineComment(ctx, state) {
|
|
10135
10384
|
return $EVENT(ctx, state, "JSMultiLineComment", JSMultiLineComment$0);
|
|
10136
10385
|
}
|
|
10137
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
10386
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R59, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10138
10387
|
return { type: "Comment", $loc, token: `//${$1}` };
|
|
10139
10388
|
});
|
|
10140
10389
|
function CoffeeSingleLineComment(ctx, state) {
|
|
10141
10390
|
return $EVENT(ctx, state, "CoffeeSingleLineComment", CoffeeSingleLineComment$0);
|
|
10142
10391
|
}
|
|
10143
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
10392
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R60, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
10144
10393
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
10145
10394
|
return { type: "Comment", $loc, token: `/*${$2}*/` };
|
|
10146
10395
|
});
|
|
10147
10396
|
function CoffeeMultiLineComment(ctx, state) {
|
|
10148
10397
|
return $EVENT(ctx, state, "CoffeeMultiLineComment", CoffeeMultiLineComment$0);
|
|
10149
10398
|
}
|
|
10150
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
10399
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R61, "CoffeeHereCommentStart /###(?!#)/"));
|
|
10151
10400
|
function CoffeeHereCommentStart(ctx, state) {
|
|
10152
10401
|
return $EVENT(ctx, state, "CoffeeHereCommentStart", CoffeeHereCommentStart$0);
|
|
10153
10402
|
}
|
|
10154
|
-
var InlineComment$0 = $TR($EXPECT($
|
|
10403
|
+
var InlineComment$0 = $TR($EXPECT($R62, "InlineComment /\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\//"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10155
10404
|
return { $loc, token: $0 };
|
|
10156
10405
|
});
|
|
10157
10406
|
function InlineComment(ctx, state) {
|
|
@@ -10165,34 +10414,38 @@ var require_parser = __commonJS({
|
|
|
10165
10414
|
function TrailingComment(ctx, state) {
|
|
10166
10415
|
return $EVENT(ctx, state, "TrailingComment", TrailingComment$0);
|
|
10167
10416
|
}
|
|
10168
|
-
var _$0 = $T($S($EXPECT($
|
|
10417
|
+
var _$0 = $T($S($EXPECT($R63, "_ /(?=[ \\t\\/\\\\])/"), $P($C(NonNewlineWhitespace, InlineComment))), function(value) {
|
|
10169
10418
|
return value[1];
|
|
10170
10419
|
});
|
|
10171
10420
|
function _(ctx, state) {
|
|
10172
10421
|
return $EVENT(ctx, state, "_", _$0);
|
|
10173
10422
|
}
|
|
10174
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
10423
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R64, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10175
10424
|
return { $loc, token: $0 };
|
|
10176
10425
|
});
|
|
10177
|
-
var NonNewlineWhitespace$1 = $T($S(
|
|
10178
|
-
return "";
|
|
10426
|
+
var NonNewlineWhitespace$1 = $T($S($EXPECT($L110, 'NonNewlineWhitespace "\\\\\\\\"'), CoffeeLineContinuationEnabled, EOL), function(value) {
|
|
10427
|
+
return " ";
|
|
10179
10428
|
});
|
|
10180
10429
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
10181
10430
|
function NonNewlineWhitespace(ctx, state) {
|
|
10182
10431
|
return $EVENT_C(ctx, state, "NonNewlineWhitespace", NonNewlineWhitespace$$);
|
|
10183
10432
|
}
|
|
10184
|
-
var Trimmed_$0 = $TV($
|
|
10433
|
+
var Trimmed_$0 = $TV($E(_), function($skip, $loc, $0, $1) {
|
|
10185
10434
|
var ws = $0;
|
|
10186
10435
|
return insertTrimmingSpace(ws, "");
|
|
10187
10436
|
});
|
|
10188
10437
|
function Trimmed_(ctx, state) {
|
|
10189
10438
|
return $EVENT(ctx, state, "Trimmed_", Trimmed_$0);
|
|
10190
10439
|
}
|
|
10191
|
-
var __$0 = $Q($C(Whitespace, Comment))
|
|
10440
|
+
var __$0 = $T($S($EXPECT($R65, "__ /(?=\\s|\\/|#)/"), $Q($C(Whitespace, Comment))), function(value) {
|
|
10441
|
+
return value[1];
|
|
10442
|
+
});
|
|
10443
|
+
var __$1 = $EXPECT($L0, '__ ""');
|
|
10444
|
+
var __$$ = [__$0, __$1];
|
|
10192
10445
|
function __(ctx, state) {
|
|
10193
|
-
return $
|
|
10446
|
+
return $EVENT_C(ctx, state, "__", __$$);
|
|
10194
10447
|
}
|
|
10195
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
10448
|
+
var Whitespace$0 = $TR($EXPECT($R42, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10196
10449
|
return { $loc, token: $0 };
|
|
10197
10450
|
});
|
|
10198
10451
|
function Whitespace(ctx, state) {
|
|
@@ -10208,17 +10461,16 @@ var require_parser = __commonJS({
|
|
|
10208
10461
|
function ExpressionDelimiter(ctx, state) {
|
|
10209
10462
|
return $EVENT_C(ctx, state, "ExpressionDelimiter", ExpressionDelimiter$$);
|
|
10210
10463
|
}
|
|
10211
|
-
var SimpleStatementDelimiter$0 =
|
|
10212
|
-
var SimpleStatementDelimiter$1 =
|
|
10464
|
+
var SimpleStatementDelimiter$0 = $Y(EOS);
|
|
10465
|
+
var SimpleStatementDelimiter$1 = SemicolonDelimiter;
|
|
10213
10466
|
var SimpleStatementDelimiter$$ = [SimpleStatementDelimiter$0, SimpleStatementDelimiter$1];
|
|
10214
10467
|
function SimpleStatementDelimiter(ctx, state) {
|
|
10215
10468
|
return $EVENT_C(ctx, state, "SimpleStatementDelimiter", SimpleStatementDelimiter$$);
|
|
10216
10469
|
}
|
|
10217
|
-
var StatementDelimiter$0 =
|
|
10218
|
-
var StatementDelimiter$1 =
|
|
10219
|
-
var StatementDelimiter$2 = $Y(
|
|
10220
|
-
var StatementDelimiter
|
|
10221
|
-
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2, StatementDelimiter$3];
|
|
10470
|
+
var StatementDelimiter$0 = $Y(EOS);
|
|
10471
|
+
var StatementDelimiter$1 = SemicolonDelimiter;
|
|
10472
|
+
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L25, 'StatementDelimiter "}"'), $EXPECT($L111, 'StatementDelimiter ")"'), $EXPECT($L34, 'StatementDelimiter "]"'))));
|
|
10473
|
+
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2];
|
|
10222
10474
|
function StatementDelimiter(ctx, state) {
|
|
10223
10475
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
10224
10476
|
}
|
|
@@ -10231,7 +10483,7 @@ var require_parser = __commonJS({
|
|
|
10231
10483
|
function SemicolonDelimiter(ctx, state) {
|
|
10232
10484
|
return $EVENT(ctx, state, "SemicolonDelimiter", SemicolonDelimiter$0);
|
|
10233
10485
|
}
|
|
10234
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
10486
|
+
var NonIdContinue$0 = $R$0($EXPECT($R66, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
10235
10487
|
function NonIdContinue(ctx, state) {
|
|
10236
10488
|
return $EVENT(ctx, state, "NonIdContinue", NonIdContinue$0);
|
|
10237
10489
|
}
|
|
@@ -10241,73 +10493,73 @@ var require_parser = __commonJS({
|
|
|
10241
10493
|
function Loc(ctx, state) {
|
|
10242
10494
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
10243
10495
|
}
|
|
10244
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
10496
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L112, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L12, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
10245
10497
|
return { $loc, token: $1, ts: true };
|
|
10246
10498
|
});
|
|
10247
10499
|
function Abstract(ctx, state) {
|
|
10248
10500
|
return $EVENT(ctx, state, "Abstract", Abstract$0);
|
|
10249
10501
|
}
|
|
10250
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
10502
|
+
var Ampersand$0 = $TV($EXPECT($L97, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
10251
10503
|
return { $loc, token: $1 };
|
|
10252
10504
|
});
|
|
10253
10505
|
function Ampersand(ctx, state) {
|
|
10254
10506
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
10255
10507
|
}
|
|
10256
|
-
var As$0 = $TS($S($EXPECT($
|
|
10508
|
+
var As$0 = $TS($S($EXPECT($L113, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10257
10509
|
return { $loc, token: $1 };
|
|
10258
10510
|
});
|
|
10259
10511
|
function As(ctx, state) {
|
|
10260
10512
|
return $EVENT(ctx, state, "As", As$0);
|
|
10261
10513
|
}
|
|
10262
|
-
var At$0 = $TV($EXPECT($
|
|
10514
|
+
var At$0 = $TV($EXPECT($L114, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
10263
10515
|
return { $loc, token: $1 };
|
|
10264
10516
|
});
|
|
10265
10517
|
function At(ctx, state) {
|
|
10266
10518
|
return $EVENT(ctx, state, "At", At$0);
|
|
10267
10519
|
}
|
|
10268
|
-
var AtAt$0 = $TV($EXPECT($
|
|
10520
|
+
var AtAt$0 = $TV($EXPECT($L115, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
10269
10521
|
return { $loc, token: "@" };
|
|
10270
10522
|
});
|
|
10271
10523
|
function AtAt(ctx, state) {
|
|
10272
10524
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
10273
10525
|
}
|
|
10274
|
-
var Async$0 = $TS($S($EXPECT($
|
|
10526
|
+
var Async$0 = $TS($S($EXPECT($L116, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10275
10527
|
return { $loc, token: $1, type: "Async" };
|
|
10276
10528
|
});
|
|
10277
10529
|
function Async(ctx, state) {
|
|
10278
10530
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
10279
10531
|
}
|
|
10280
|
-
var Await$0 = $TS($S($EXPECT($
|
|
10532
|
+
var Await$0 = $TS($S($EXPECT($L117, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10281
10533
|
return { $loc, token: $1, type: "Await" };
|
|
10282
10534
|
});
|
|
10283
10535
|
function Await(ctx, state) {
|
|
10284
10536
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
10285
10537
|
}
|
|
10286
|
-
var Backtick$0 = $TV($EXPECT($
|
|
10538
|
+
var Backtick$0 = $TV($EXPECT($L118, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
10287
10539
|
return { $loc, token: $1 };
|
|
10288
10540
|
});
|
|
10289
10541
|
function Backtick(ctx, state) {
|
|
10290
10542
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
10291
10543
|
}
|
|
10292
|
-
var By$0 = $TS($S($EXPECT($
|
|
10544
|
+
var By$0 = $TS($S($EXPECT($L119, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10293
10545
|
return { $loc, token: $1 };
|
|
10294
10546
|
});
|
|
10295
10547
|
function By(ctx, state) {
|
|
10296
10548
|
return $EVENT(ctx, state, "By", By$0);
|
|
10297
10549
|
}
|
|
10298
|
-
var Case$0 = $TS($S($EXPECT($
|
|
10550
|
+
var Case$0 = $TS($S($EXPECT($L120, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10299
10551
|
return { $loc, token: $1 };
|
|
10300
10552
|
});
|
|
10301
10553
|
function Case(ctx, state) {
|
|
10302
10554
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
10303
10555
|
}
|
|
10304
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
10556
|
+
var Catch$0 = $TS($S($EXPECT($L121, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10305
10557
|
return { $loc, token: $1 };
|
|
10306
10558
|
});
|
|
10307
10559
|
function Catch(ctx, state) {
|
|
10308
10560
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
10309
10561
|
}
|
|
10310
|
-
var Class$0 = $TS($S($EXPECT($
|
|
10562
|
+
var Class$0 = $TS($S($EXPECT($L122, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10311
10563
|
return { $loc, token: $1 };
|
|
10312
10564
|
});
|
|
10313
10565
|
function Class(ctx, state) {
|
|
@@ -10325,19 +10577,19 @@ var require_parser = __commonJS({
|
|
|
10325
10577
|
function CloseBracket(ctx, state) {
|
|
10326
10578
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
10327
10579
|
}
|
|
10328
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
10580
|
+
var CloseParen$0 = $TV($EXPECT($L111, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
10329
10581
|
return { $loc, token: $1 };
|
|
10330
10582
|
});
|
|
10331
10583
|
function CloseParen(ctx, state) {
|
|
10332
10584
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
10333
10585
|
}
|
|
10334
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
10586
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L123, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
10335
10587
|
return { $loc, token: "${" };
|
|
10336
10588
|
});
|
|
10337
10589
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
10338
10590
|
return $EVENT(ctx, state, "CoffeeSubstitutionStart", CoffeeSubstitutionStart$0);
|
|
10339
10591
|
}
|
|
10340
|
-
var Colon$0 = $TS($S($EXPECT($
|
|
10592
|
+
var Colon$0 = $TS($S($EXPECT($L11, 'Colon ":"'), $N($EXPECT($L3, 'Colon "="'))), function($skip, $loc, $0, $1, $2) {
|
|
10341
10593
|
return { $loc, token: $1 };
|
|
10342
10594
|
});
|
|
10343
10595
|
function Colon(ctx, state) {
|
|
@@ -10349,31 +10601,31 @@ var require_parser = __commonJS({
|
|
|
10349
10601
|
function Comma(ctx, state) {
|
|
10350
10602
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
10351
10603
|
}
|
|
10352
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
10604
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L114, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
10353
10605
|
return { $loc, token: "constructor" };
|
|
10354
10606
|
});
|
|
10355
10607
|
function ConstructorShorthand(ctx, state) {
|
|
10356
10608
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
10357
10609
|
}
|
|
10358
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
10610
|
+
var Declare$0 = $TS($S($EXPECT($L124, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10359
10611
|
return { $loc, token: $1 };
|
|
10360
10612
|
});
|
|
10361
10613
|
function Declare(ctx, state) {
|
|
10362
10614
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
10363
10615
|
}
|
|
10364
|
-
var Default$0 = $TS($S($EXPECT($
|
|
10616
|
+
var Default$0 = $TS($S($EXPECT($L125, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10365
10617
|
return { $loc, token: $1 };
|
|
10366
10618
|
});
|
|
10367
10619
|
function Default(ctx, state) {
|
|
10368
10620
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
10369
10621
|
}
|
|
10370
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
10622
|
+
var Delete$0 = $TS($S($EXPECT($L126, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10371
10623
|
return { $loc, token: $1 };
|
|
10372
10624
|
});
|
|
10373
10625
|
function Delete(ctx, state) {
|
|
10374
10626
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
10375
10627
|
}
|
|
10376
|
-
var Do$0 = $TS($S($EXPECT($
|
|
10628
|
+
var Do$0 = $TS($S($EXPECT($L127, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10377
10629
|
return { $loc, token: $1 };
|
|
10378
10630
|
});
|
|
10379
10631
|
function Do(ctx, state) {
|
|
@@ -10382,7 +10634,7 @@ var require_parser = __commonJS({
|
|
|
10382
10634
|
var Dot$0 = $TV($EXPECT($L6, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
10383
10635
|
return { $loc, token: $1 };
|
|
10384
10636
|
});
|
|
10385
|
-
var Dot$1 = $TS($S($EXPECT($
|
|
10637
|
+
var Dot$1 = $TS($S($EXPECT($R67, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
|
|
10386
10638
|
var ws = $2;
|
|
10387
10639
|
return [
|
|
10388
10640
|
{ $loc, token: "." },
|
|
@@ -10393,45 +10645,45 @@ var require_parser = __commonJS({
|
|
|
10393
10645
|
function Dot(ctx, state) {
|
|
10394
10646
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
10395
10647
|
}
|
|
10396
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
10648
|
+
var DotDot$0 = $TS($S($EXPECT($L128, 'DotDot ".."'), $N($EXPECT($L6, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
10397
10649
|
return { $loc, token: $1 };
|
|
10398
10650
|
});
|
|
10399
|
-
var DotDot$1 = $TV($EXPECT($
|
|
10651
|
+
var DotDot$1 = $TV($EXPECT($L129, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
10400
10652
|
return { $loc, token: ".." };
|
|
10401
10653
|
});
|
|
10402
10654
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
10403
10655
|
function DotDot(ctx, state) {
|
|
10404
10656
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
10405
10657
|
}
|
|
10406
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
10658
|
+
var DotDotDot$0 = $TV($EXPECT($L130, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
10407
10659
|
return { $loc, token: $1 };
|
|
10408
10660
|
});
|
|
10409
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
10661
|
+
var DotDotDot$1 = $TV($EXPECT($L131, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
10410
10662
|
return { $loc, token: "..." };
|
|
10411
10663
|
});
|
|
10412
10664
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
10413
10665
|
function DotDotDot(ctx, state) {
|
|
10414
10666
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
10415
10667
|
}
|
|
10416
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
10668
|
+
var DoubleColon$0 = $TV($EXPECT($L132, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
10417
10669
|
return { $loc, token: $1 };
|
|
10418
10670
|
});
|
|
10419
10671
|
function DoubleColon(ctx, state) {
|
|
10420
10672
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
10421
10673
|
}
|
|
10422
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
10674
|
+
var DoubleQuote$0 = $TV($EXPECT($L133, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
10423
10675
|
return { $loc, token: $1 };
|
|
10424
10676
|
});
|
|
10425
10677
|
function DoubleQuote(ctx, state) {
|
|
10426
10678
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
10427
10679
|
}
|
|
10428
|
-
var Each$0 = $TS($S($EXPECT($
|
|
10680
|
+
var Each$0 = $TS($S($EXPECT($L134, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10429
10681
|
return { $loc, token: $1 };
|
|
10430
10682
|
});
|
|
10431
10683
|
function Each(ctx, state) {
|
|
10432
10684
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
10433
10685
|
}
|
|
10434
|
-
var Else$0 = $TS($S($EXPECT($
|
|
10686
|
+
var Else$0 = $TS($S($EXPECT($L135, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10435
10687
|
return { $loc, token: $1 };
|
|
10436
10688
|
});
|
|
10437
10689
|
function Else(ctx, state) {
|
|
@@ -10443,85 +10695,85 @@ var require_parser = __commonJS({
|
|
|
10443
10695
|
function Equals(ctx, state) {
|
|
10444
10696
|
return $EVENT(ctx, state, "Equals", Equals$0);
|
|
10445
10697
|
}
|
|
10446
|
-
var Export$0 = $TS($S($EXPECT($
|
|
10698
|
+
var Export$0 = $TS($S($EXPECT($L136, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10447
10699
|
return { $loc, token: $1 };
|
|
10448
10700
|
});
|
|
10449
10701
|
function Export(ctx, state) {
|
|
10450
10702
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
10451
10703
|
}
|
|
10452
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
10704
|
+
var Extends$0 = $TS($S($EXPECT($L137, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10453
10705
|
return { $loc, token: $1 };
|
|
10454
10706
|
});
|
|
10455
10707
|
function Extends(ctx, state) {
|
|
10456
10708
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
10457
10709
|
}
|
|
10458
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
10710
|
+
var Finally$0 = $TS($S($EXPECT($L138, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10459
10711
|
return { $loc, token: $1 };
|
|
10460
10712
|
});
|
|
10461
10713
|
function Finally(ctx, state) {
|
|
10462
10714
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
10463
10715
|
}
|
|
10464
|
-
var For$0 = $TS($S($EXPECT($
|
|
10716
|
+
var For$0 = $TS($S($EXPECT($L139, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10465
10717
|
return { $loc, token: $1 };
|
|
10466
10718
|
});
|
|
10467
10719
|
function For(ctx, state) {
|
|
10468
10720
|
return $EVENT(ctx, state, "For", For$0);
|
|
10469
10721
|
}
|
|
10470
|
-
var From$0 = $TS($S($EXPECT($
|
|
10722
|
+
var From$0 = $TS($S($EXPECT($L140, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10471
10723
|
return { $loc, token: $1 };
|
|
10472
10724
|
});
|
|
10473
10725
|
function From(ctx, state) {
|
|
10474
10726
|
return $EVENT(ctx, state, "From", From$0);
|
|
10475
10727
|
}
|
|
10476
|
-
var Function$0 = $TS($S($EXPECT($
|
|
10728
|
+
var Function$0 = $TS($S($EXPECT($L141, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10477
10729
|
return { $loc, token: $1 };
|
|
10478
10730
|
});
|
|
10479
10731
|
function Function(ctx, state) {
|
|
10480
10732
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
10481
10733
|
}
|
|
10482
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
10734
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L142, 'GetOrSet "get"'), $EXPECT($L143, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10483
10735
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
10484
10736
|
});
|
|
10485
10737
|
function GetOrSet(ctx, state) {
|
|
10486
10738
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
10487
10739
|
}
|
|
10488
|
-
var Hash$0 = $TV($EXPECT($
|
|
10740
|
+
var Hash$0 = $TV($EXPECT($L144, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
10489
10741
|
return { $loc, token: $1 };
|
|
10490
10742
|
});
|
|
10491
10743
|
function Hash(ctx, state) {
|
|
10492
10744
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
10493
10745
|
}
|
|
10494
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
10746
|
+
var If$0 = $TV($TEXT($S($EXPECT($L145, 'If "if"'), NonIdContinue, $E($EXPECT($L12, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
10495
10747
|
return { $loc, token: $1 };
|
|
10496
10748
|
});
|
|
10497
10749
|
function If(ctx, state) {
|
|
10498
10750
|
return $EVENT(ctx, state, "If", If$0);
|
|
10499
10751
|
}
|
|
10500
|
-
var Import$0 = $TS($S($EXPECT($L15, 'Import "import"'), $Y($EXPECT($
|
|
10752
|
+
var Import$0 = $TS($S($EXPECT($L15, 'Import "import"'), $Y($EXPECT($R68, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
10501
10753
|
return { $loc, token: $1 };
|
|
10502
10754
|
});
|
|
10503
10755
|
function Import(ctx, state) {
|
|
10504
10756
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
10505
10757
|
}
|
|
10506
|
-
var In$0 = $TS($S($EXPECT($
|
|
10758
|
+
var In$0 = $TS($S($EXPECT($L146, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10507
10759
|
return { $loc, token: $1 };
|
|
10508
10760
|
});
|
|
10509
10761
|
function In(ctx, state) {
|
|
10510
10762
|
return $EVENT(ctx, state, "In", In$0);
|
|
10511
10763
|
}
|
|
10512
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
10764
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L147, 'LetOrConst "let"'), $EXPECT($L148, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10513
10765
|
return { $loc, token: $1 };
|
|
10514
10766
|
});
|
|
10515
10767
|
function LetOrConst(ctx, state) {
|
|
10516
10768
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
10517
10769
|
}
|
|
10518
|
-
var Const$0 = $TS($S($EXPECT($
|
|
10770
|
+
var Const$0 = $TS($S($EXPECT($L148, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10519
10771
|
return { $loc, token: $1 };
|
|
10520
10772
|
});
|
|
10521
10773
|
function Const(ctx, state) {
|
|
10522
10774
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
10523
10775
|
}
|
|
10524
|
-
var Is$0 = $TS($S($EXPECT($
|
|
10776
|
+
var Is$0 = $TS($S($EXPECT($L149, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10525
10777
|
return { $loc, token: $1 };
|
|
10526
10778
|
});
|
|
10527
10779
|
function Is(ctx, state) {
|
|
@@ -10533,31 +10785,31 @@ var require_parser = __commonJS({
|
|
|
10533
10785
|
function LetOrConstOrVar(ctx, state) {
|
|
10534
10786
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
10535
10787
|
}
|
|
10536
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
10788
|
+
var Loop$0 = $TS($S($EXPECT($L150, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10537
10789
|
return { $loc, token: "while(true)" };
|
|
10538
10790
|
});
|
|
10539
10791
|
function Loop(ctx, state) {
|
|
10540
10792
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
10541
10793
|
}
|
|
10542
|
-
var New$0 = $TS($S($EXPECT($
|
|
10794
|
+
var New$0 = $TS($S($EXPECT($L151, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10543
10795
|
return { $loc, token: $1 };
|
|
10544
10796
|
});
|
|
10545
10797
|
function New(ctx, state) {
|
|
10546
10798
|
return $EVENT(ctx, state, "New", New$0);
|
|
10547
10799
|
}
|
|
10548
|
-
var Not$0 = $TS($S($EXPECT($
|
|
10800
|
+
var Not$0 = $TS($S($EXPECT($L152, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L11, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
10549
10801
|
return { $loc, token: "!" };
|
|
10550
10802
|
});
|
|
10551
10803
|
function Not(ctx, state) {
|
|
10552
10804
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
10553
10805
|
}
|
|
10554
|
-
var Of$0 = $TS($S($EXPECT($
|
|
10806
|
+
var Of$0 = $TS($S($EXPECT($L153, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10555
10807
|
return { $loc, token: $1 };
|
|
10556
10808
|
});
|
|
10557
10809
|
function Of(ctx, state) {
|
|
10558
10810
|
return $EVENT(ctx, state, "Of", Of$0);
|
|
10559
10811
|
}
|
|
10560
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
10812
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L154, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
10561
10813
|
return { $loc, token: $1 };
|
|
10562
10814
|
});
|
|
10563
10815
|
function OpenAngleBracket(ctx, state) {
|
|
@@ -10569,7 +10821,7 @@ var require_parser = __commonJS({
|
|
|
10569
10821
|
function OpenBrace(ctx, state) {
|
|
10570
10822
|
return $EVENT(ctx, state, "OpenBrace", OpenBrace$0);
|
|
10571
10823
|
}
|
|
10572
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
10824
|
+
var OpenBracket$0 = $TV($EXPECT($L155, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
10573
10825
|
return { $loc, token: $1 };
|
|
10574
10826
|
});
|
|
10575
10827
|
function OpenBracket(ctx, state) {
|
|
@@ -10648,7 +10900,7 @@ var require_parser = __commonJS({
|
|
|
10648
10900
|
function Satisfies(ctx, state) {
|
|
10649
10901
|
return $EVENT(ctx, state, "Satisfies", Satisfies$0);
|
|
10650
10902
|
}
|
|
10651
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
10903
|
+
var Semicolon$0 = $TV($EXPECT($L99, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
10652
10904
|
return { $loc, token: $1 };
|
|
10653
10905
|
});
|
|
10654
10906
|
function Semicolon(ctx, state) {
|
|
@@ -10669,7 +10921,7 @@ var require_parser = __commonJS({
|
|
|
10669
10921
|
var Static$0 = $TS($S($EXPECT($L171, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10670
10922
|
return { $loc, token: $1 };
|
|
10671
10923
|
});
|
|
10672
|
-
var Static$1 = $TS($S($EXPECT($
|
|
10924
|
+
var Static$1 = $TS($S($EXPECT($L114, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L114, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
10673
10925
|
return { $loc, token: "static " };
|
|
10674
10926
|
});
|
|
10675
10927
|
var Static$$ = [Static$0, Static$1];
|
|
@@ -10825,12 +11077,18 @@ var require_parser = __commonJS({
|
|
|
10825
11077
|
function JSXImplicitFragment(ctx, state) {
|
|
10826
11078
|
return $EVENT(ctx, state, "JSXImplicitFragment", JSXImplicitFragment$0);
|
|
10827
11079
|
}
|
|
10828
|
-
var JSXTag$0 =
|
|
10829
|
-
|
|
10830
|
-
|
|
10831
|
-
var JSXTag$$ = [JSXTag$0, JSXTag$1, JSXTag$2];
|
|
11080
|
+
var JSXTag$0 = $T($S($EXPECT($R69, "JSXTag /(?=[<])/"), _JSXTag), function(value) {
|
|
11081
|
+
return value[1];
|
|
11082
|
+
});
|
|
10832
11083
|
function JSXTag(ctx, state) {
|
|
10833
|
-
return $
|
|
11084
|
+
return $EVENT(ctx, state, "JSXTag", JSXTag$0);
|
|
11085
|
+
}
|
|
11086
|
+
var _JSXTag$0 = JSXElement;
|
|
11087
|
+
var _JSXTag$1 = JSXFragment;
|
|
11088
|
+
var _JSXTag$2 = JSXComment;
|
|
11089
|
+
var _JSXTag$$ = [_JSXTag$0, _JSXTag$1, _JSXTag$2];
|
|
11090
|
+
function _JSXTag(ctx, state) {
|
|
11091
|
+
return $EVENT_C(ctx, state, "_JSXTag", _JSXTag$$);
|
|
10834
11092
|
}
|
|
10835
11093
|
var JSXElement$0 = JSXSelfClosingElement;
|
|
10836
11094
|
var JSXElement$1 = $TS($S($N(CoffeeJSXEnabled), PushJSXOpeningElement, $E(JSXMixedChildren), JSXOptionalClosingElement, PopJSXStack), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
@@ -10869,7 +11127,7 @@ var require_parser = __commonJS({
|
|
|
10869
11127
|
function JSXElement(ctx, state) {
|
|
10870
11128
|
return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
|
|
10871
11129
|
}
|
|
10872
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
11130
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L154, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L193, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
10873
11131
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
10874
11132
|
});
|
|
10875
11133
|
function JSXSelfClosingElement(ctx, state) {
|
|
@@ -10888,7 +11146,7 @@ var require_parser = __commonJS({
|
|
|
10888
11146
|
function PopJSXStack(ctx, state) {
|
|
10889
11147
|
return $EVENT(ctx, state, "PopJSXStack", PopJSXStack$0);
|
|
10890
11148
|
}
|
|
10891
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
11149
|
+
var JSXOpeningElement$0 = $S($EXPECT($L154, 'JSXOpeningElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L33, 'JSXOpeningElement ">"'));
|
|
10892
11150
|
function JSXOpeningElement(ctx, state) {
|
|
10893
11151
|
return $EVENT(ctx, state, "JSXOpeningElement", JSXOpeningElement$0);
|
|
10894
11152
|
}
|
|
@@ -10958,7 +11216,7 @@ var require_parser = __commonJS({
|
|
|
10958
11216
|
function JSXClosingFragment(ctx, state) {
|
|
10959
11217
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
10960
11218
|
}
|
|
10961
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
11219
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L144, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
10962
11220
|
return module.config.defaultElement;
|
|
10963
11221
|
});
|
|
10964
11222
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -10966,7 +11224,7 @@ var require_parser = __commonJS({
|
|
|
10966
11224
|
function JSXElementName(ctx, state) {
|
|
10967
11225
|
return $EVENT_C(ctx, state, "JSXElementName", JSXElementName$$);
|
|
10968
11226
|
}
|
|
10969
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
11227
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R70, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
10970
11228
|
function JSXIdentifierName(ctx, state) {
|
|
10971
11229
|
return $EVENT(ctx, state, "JSXIdentifierName", JSXIdentifierName$0);
|
|
10972
11230
|
}
|
|
@@ -11130,7 +11388,7 @@ var require_parser = __commonJS({
|
|
|
11130
11388
|
}
|
|
11131
11389
|
return $skip;
|
|
11132
11390
|
});
|
|
11133
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
11391
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L144, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
11134
11392
|
return [" ", "id=", $2];
|
|
11135
11393
|
});
|
|
11136
11394
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -11139,7 +11397,7 @@ var require_parser = __commonJS({
|
|
|
11139
11397
|
class: $2
|
|
11140
11398
|
};
|
|
11141
11399
|
});
|
|
11142
|
-
var JSXAttribute$7 = $TS($S($TEXT($EXPECT($
|
|
11400
|
+
var JSXAttribute$7 = $TS($S($TEXT($EXPECT($R15, "JSXAttribute /[!+-]/")), JSXAttributeName, $Y(JSXAttributeSpace)), function($skip, $loc, $0, $1, $2, $3) {
|
|
11143
11401
|
var toggle = $1;
|
|
11144
11402
|
var id = $2;
|
|
11145
11403
|
const value = toggle === "+" ? "true" : "false";
|
|
@@ -11149,11 +11407,11 @@ var require_parser = __commonJS({
|
|
|
11149
11407
|
function JSXAttribute(ctx, state) {
|
|
11150
11408
|
return $EVENT_C(ctx, state, "JSXAttribute", JSXAttribute$$);
|
|
11151
11409
|
}
|
|
11152
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
11410
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R71, "JSXAttributeSpace /[\\s>]|\\/>/"));
|
|
11153
11411
|
function JSXAttributeSpace(ctx, state) {
|
|
11154
11412
|
return $EVENT(ctx, state, "JSXAttributeSpace", JSXAttributeSpace$0);
|
|
11155
11413
|
}
|
|
11156
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
11414
|
+
var JSXShorthandString$0 = $TR($EXPECT($R72, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11157
11415
|
return quoteString($0);
|
|
11158
11416
|
});
|
|
11159
11417
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -11187,7 +11445,7 @@ var require_parser = __commonJS({
|
|
|
11187
11445
|
}
|
|
11188
11446
|
return [open, value, close];
|
|
11189
11447
|
});
|
|
11190
|
-
var JSXAttributeValue$4 = $R$0($EXPECT($
|
|
11448
|
+
var JSXAttributeValue$4 = $R$0($EXPECT($R73, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
|
|
11191
11449
|
var JSXAttributeValue$$ = [JSXAttributeValue$0, JSXAttributeValue$1, JSXAttributeValue$2, JSXAttributeValue$3, JSXAttributeValue$4];
|
|
11192
11450
|
function JSXAttributeValue(ctx, state) {
|
|
11193
11451
|
return $EVENT_C(ctx, state, "JSXAttributeValue", JSXAttributeValue$$);
|
|
@@ -11200,7 +11458,7 @@ var require_parser = __commonJS({
|
|
|
11200
11458
|
function InlineJSXAttributeValue(ctx, state) {
|
|
11201
11459
|
return $EVENT(ctx, state, "InlineJSXAttributeValue", InlineJSXAttributeValue$0);
|
|
11202
11460
|
}
|
|
11203
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
11461
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R74, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
11204
11462
|
var op = $2;
|
|
11205
11463
|
var rhs = $3;
|
|
11206
11464
|
return [[], op, [], rhs];
|
|
@@ -11217,7 +11475,7 @@ var require_parser = __commonJS({
|
|
|
11217
11475
|
function InlineJSXUnaryExpression(ctx, state) {
|
|
11218
11476
|
return $EVENT(ctx, state, "InlineJSXUnaryExpression", InlineJSXUnaryExpression$0);
|
|
11219
11477
|
}
|
|
11220
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
11478
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R75, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11221
11479
|
return { $loc, token: $0 };
|
|
11222
11480
|
});
|
|
11223
11481
|
function InlineJSXUnaryOp(ctx, state) {
|
|
@@ -11284,7 +11542,7 @@ var require_parser = __commonJS({
|
|
|
11284
11542
|
}
|
|
11285
11543
|
return $1;
|
|
11286
11544
|
});
|
|
11287
|
-
var InlineJSXCallExpressionRest$2 = $TS($S($E(
|
|
11545
|
+
var InlineJSXCallExpressionRest$2 = $TS($S($E(OptionalShorthand), ExplicitArguments), function($skip, $loc, $0, $1, $2) {
|
|
11288
11546
|
var args = $2;
|
|
11289
11547
|
args = { type: "Call", children: args };
|
|
11290
11548
|
if (!$1)
|
|
@@ -11308,7 +11566,7 @@ var require_parser = __commonJS({
|
|
|
11308
11566
|
function InlineJSXMemberExpression(ctx, state) {
|
|
11309
11567
|
return $EVENT(ctx, state, "InlineJSXMemberExpression", InlineJSXMemberExpression$0);
|
|
11310
11568
|
}
|
|
11311
|
-
var InlineJSXMemberExpressionRest$0 = $TS($S($E(
|
|
11569
|
+
var InlineJSXMemberExpressionRest$0 = $TS($S($E(OptionalShorthand), MemberBracketContent), function($skip, $loc, $0, $1, $2) {
|
|
11312
11570
|
if ($1) {
|
|
11313
11571
|
if ($1.type === "Optional" && $2.type === "SliceExpression") {
|
|
11314
11572
|
return [$1.children[0], $2];
|
|
@@ -11429,13 +11687,13 @@ var require_parser = __commonJS({
|
|
|
11429
11687
|
function JSXComment(ctx, state) {
|
|
11430
11688
|
return $EVENT(ctx, state, "JSXComment", JSXComment$0);
|
|
11431
11689
|
}
|
|
11432
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
11690
|
+
var JSXCommentContent$0 = $TR($EXPECT($R76, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11433
11691
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
11434
11692
|
});
|
|
11435
11693
|
function JSXCommentContent(ctx, state) {
|
|
11436
11694
|
return $EVENT(ctx, state, "JSXCommentContent", JSXCommentContent$0);
|
|
11437
11695
|
}
|
|
11438
|
-
var JSXText$0 = $TR($EXPECT($
|
|
11696
|
+
var JSXText$0 = $TR($EXPECT($R77, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11439
11697
|
return {
|
|
11440
11698
|
type: "JSXText",
|
|
11441
11699
|
token: $0,
|
|
@@ -11800,7 +12058,7 @@ var require_parser = __commonJS({
|
|
|
11800
12058
|
function TypeProperty(ctx, state) {
|
|
11801
12059
|
return $EVENT(ctx, state, "TypeProperty", TypeProperty$0);
|
|
11802
12060
|
}
|
|
11803
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
12061
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R78, "TypeIndexSignature /[+-]?/")), Readonly, NotDedented)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R79, "TypeIndexSignature /[+-]/")), $Y($S($E(_), QuestionMark)))));
|
|
11804
12062
|
function TypeIndexSignature(ctx, state) {
|
|
11805
12063
|
return $EVENT(ctx, state, "TypeIndexSignature", TypeIndexSignature$0);
|
|
11806
12064
|
}
|
|
@@ -11851,7 +12109,7 @@ var require_parser = __commonJS({
|
|
|
11851
12109
|
function ReturnType(ctx, state) {
|
|
11852
12110
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
11853
12111
|
}
|
|
11854
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
12112
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L149, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
11855
12113
|
var lhs = $1;
|
|
11856
12114
|
var rhs = $2;
|
|
11857
12115
|
if (!rhs)
|
|
@@ -12013,7 +12271,7 @@ var require_parser = __commonJS({
|
|
|
12013
12271
|
function NestedType(ctx, state) {
|
|
12014
12272
|
return $EVENT(ctx, state, "NestedType", NestedType$0);
|
|
12015
12273
|
}
|
|
12016
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
12274
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L137, 'TypeConditional "extends"'), NonIdContinue, Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
12017
12275
|
if ($2)
|
|
12018
12276
|
return $0;
|
|
12019
12277
|
return $1;
|
|
@@ -12073,16 +12331,16 @@ var require_parser = __commonJS({
|
|
|
12073
12331
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
12074
12332
|
return value[1];
|
|
12075
12333
|
});
|
|
12076
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
12334
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L111, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L34, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L25, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
12077
12335
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
12078
12336
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
12079
12337
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
12080
12338
|
return $EVENT_C(ctx, state, "InlineInterfacePropertyDelimiter", InlineInterfacePropertyDelimiter$$);
|
|
12081
12339
|
}
|
|
12082
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
12340
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L98, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
12083
12341
|
return { $loc, token: "|" };
|
|
12084
12342
|
});
|
|
12085
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
12343
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L97, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
12086
12344
|
return { $loc, token: "&" };
|
|
12087
12345
|
});
|
|
12088
12346
|
var TypeBinaryOp$$ = [TypeBinaryOp$0, TypeBinaryOp$1];
|
|
@@ -12105,7 +12363,7 @@ var require_parser = __commonJS({
|
|
|
12105
12363
|
function TypeArrowFunction(ctx, state) {
|
|
12106
12364
|
return $EVENT(ctx, state, "TypeArrowFunction", TypeArrowFunction$0);
|
|
12107
12365
|
}
|
|
12108
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
12366
|
+
var TypeArguments$0 = $TS($S($EXPECT($L154, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L33, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
12109
12367
|
var args = $2;
|
|
12110
12368
|
return { ts: true, types: args.map(([, t]) => t), children: $0 };
|
|
12111
12369
|
});
|
|
@@ -12120,7 +12378,7 @@ var require_parser = __commonJS({
|
|
|
12120
12378
|
function TypeArgumentDelimiter(ctx, state) {
|
|
12121
12379
|
return $EVENT(ctx, state, "TypeArgumentDelimiter", TypeArgumentDelimiter$0);
|
|
12122
12380
|
}
|
|
12123
|
-
var TypeParameters$0 = $TS($S($E(_), $EXPECT($
|
|
12381
|
+
var TypeParameters$0 = $TS($S($E(_), $EXPECT($L154, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L33, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
12124
12382
|
var parameters = $3;
|
|
12125
12383
|
return {
|
|
12126
12384
|
type: "TypeParameters",
|
|
@@ -12132,11 +12390,11 @@ var require_parser = __commonJS({
|
|
|
12132
12390
|
function TypeParameters(ctx, state) {
|
|
12133
12391
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
12134
12392
|
}
|
|
12135
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
12393
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L148, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
12136
12394
|
function TypeParameter(ctx, state) {
|
|
12137
12395
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
12138
12396
|
}
|
|
12139
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
12397
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L137, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
12140
12398
|
function TypeConstraint(ctx, state) {
|
|
12141
12399
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
12142
12400
|
}
|
|
@@ -12144,7 +12402,7 @@ var require_parser = __commonJS({
|
|
|
12144
12402
|
function TypeInitializer(ctx, state) {
|
|
12145
12403
|
return $EVENT(ctx, state, "TypeInitializer", TypeInitializer$0);
|
|
12146
12404
|
}
|
|
12147
|
-
var TypeParameterDelimiter$0 = $S($
|
|
12405
|
+
var TypeParameterDelimiter$0 = $S($E(_), Comma);
|
|
12148
12406
|
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L33, 'TypeParameterDelimiter ">"')));
|
|
12149
12407
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
12150
12408
|
return value[1];
|
|
@@ -12159,15 +12417,15 @@ var require_parser = __commonJS({
|
|
|
12159
12417
|
function ThisType(ctx, state) {
|
|
12160
12418
|
return $EVENT(ctx, state, "ThisType", ThisType$0);
|
|
12161
12419
|
}
|
|
12162
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
12420
|
+
var Shebang$0 = $S($R$0($EXPECT($R80, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
12163
12421
|
function Shebang(ctx, state) {
|
|
12164
12422
|
return $EVENT(ctx, state, "Shebang", Shebang$0);
|
|
12165
12423
|
}
|
|
12166
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
12424
|
+
var CivetPrologue$0 = $T($S($EXPECT($R81, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, SimpleStatementDelimiter, $E(EOS)), function(value) {
|
|
12167
12425
|
var content = value[2];
|
|
12168
12426
|
return content;
|
|
12169
12427
|
});
|
|
12170
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
12428
|
+
var CivetPrologue$1 = $T($S($EXPECT($R81, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, SimpleStatementDelimiter, $E(EOS)), function(value) {
|
|
12171
12429
|
var content = value[2];
|
|
12172
12430
|
return content;
|
|
12173
12431
|
});
|
|
@@ -12175,7 +12433,7 @@ var require_parser = __commonJS({
|
|
|
12175
12433
|
function CivetPrologue(ctx, state) {
|
|
12176
12434
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
12177
12435
|
}
|
|
12178
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($
|
|
12436
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R82, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
12179
12437
|
var options = $3;
|
|
12180
12438
|
return {
|
|
12181
12439
|
type: "CivetPrologue",
|
|
@@ -12186,7 +12444,7 @@ var require_parser = __commonJS({
|
|
|
12186
12444
|
function CivetPrologueContent(ctx, state) {
|
|
12187
12445
|
return $EVENT(ctx, state, "CivetPrologueContent", CivetPrologueContent$0);
|
|
12188
12446
|
}
|
|
12189
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
12447
|
+
var CivetOption$0 = $TR($EXPECT($R83, "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) {
|
|
12190
12448
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
12191
12449
|
if (l)
|
|
12192
12450
|
return l.toUpperCase();
|
|
@@ -12203,11 +12461,11 @@ var require_parser = __commonJS({
|
|
|
12203
12461
|
function CivetOption(ctx, state) {
|
|
12204
12462
|
return $EVENT(ctx, state, "CivetOption", CivetOption$0);
|
|
12205
12463
|
}
|
|
12206
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
12464
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R81, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
12207
12465
|
function UnknownPrologue(ctx, state) {
|
|
12208
12466
|
return $EVENT(ctx, state, "UnknownPrologue", UnknownPrologue$0);
|
|
12209
12467
|
}
|
|
12210
|
-
var TripleSlashDirective$0 = $S($R$0($EXPECT($
|
|
12468
|
+
var TripleSlashDirective$0 = $S($R$0($EXPECT($R84, "TripleSlashDirective /\\/\\/\\/[^\\r\\n]*/")), $E(EOS));
|
|
12211
12469
|
function TripleSlashDirective(ctx, state) {
|
|
12212
12470
|
return $EVENT(ctx, state, "TripleSlashDirective", TripleSlashDirective$0);
|
|
12213
12471
|
}
|
|
@@ -12221,13 +12479,13 @@ var require_parser = __commonJS({
|
|
|
12221
12479
|
function PrologueString(ctx, state) {
|
|
12222
12480
|
return $EVENT_C(ctx, state, "PrologueString", PrologueString$$);
|
|
12223
12481
|
}
|
|
12224
|
-
var EOS$0 = $T($S($EXPECT($
|
|
12482
|
+
var EOS$0 = $T($S($EXPECT($R85, "EOS /(?=[ \\t\\r\\n\\/#]|$)/"), $P(RestOfLine)), function(value) {
|
|
12225
12483
|
return value[1];
|
|
12226
12484
|
});
|
|
12227
12485
|
function EOS(ctx, state) {
|
|
12228
12486
|
return $EVENT(ctx, state, "EOS", EOS$0);
|
|
12229
12487
|
}
|
|
12230
|
-
var EOL$0 = $TR($EXPECT($
|
|
12488
|
+
var EOL$0 = $TR($EXPECT($R86, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12231
12489
|
return { $loc, token: $0 };
|
|
12232
12490
|
});
|
|
12233
12491
|
function EOL(ctx, state) {
|
|
@@ -12721,7 +12979,7 @@ var require_parser = __commonJS({
|
|
|
12721
12979
|
function Init(ctx, state) {
|
|
12722
12980
|
return $EVENT(ctx, state, "Init", Init$0);
|
|
12723
12981
|
}
|
|
12724
|
-
var Indent$0 = $TR($EXPECT($
|
|
12982
|
+
var Indent$0 = $TR($EXPECT($R87, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12725
12983
|
const level = getIndentLevel($0, module.config.tab);
|
|
12726
12984
|
return {
|
|
12727
12985
|
$loc,
|
|
@@ -12843,6 +13101,7 @@ var require_parser = __commonJS({
|
|
|
12843
13101
|
exports.NestedNonAssignmentExtendedExpression = NestedNonAssignmentExtendedExpression;
|
|
12844
13102
|
exports.ExpressionizedStatementWithTrailingCallExpressions = ExpressionizedStatementWithTrailingCallExpressions;
|
|
12845
13103
|
exports.ExpressionizedStatement = ExpressionizedStatement;
|
|
13104
|
+
exports._ExpressionizedStatement = _ExpressionizedStatement;
|
|
12846
13105
|
exports.Expression = Expression;
|
|
12847
13106
|
exports.Arguments = Arguments;
|
|
12848
13107
|
exports.ImplicitArguments = ImplicitArguments;
|
|
@@ -12934,6 +13193,7 @@ var require_parser = __commonJS({
|
|
|
12934
13193
|
exports.MemberBracketContent = MemberBracketContent;
|
|
12935
13194
|
exports.SliceParameters = SliceParameters;
|
|
12936
13195
|
exports.AccessStart = AccessStart;
|
|
13196
|
+
exports.PropertyAccessModifier = PropertyAccessModifier;
|
|
12937
13197
|
exports.PropertyAccess = PropertyAccess;
|
|
12938
13198
|
exports.PropertyGlob = PropertyGlob;
|
|
12939
13199
|
exports.PropertyBind = PropertyBind;
|
|
@@ -13004,12 +13264,14 @@ var require_parser = __commonJS({
|
|
|
13004
13264
|
exports.LiteralContent = LiteralContent;
|
|
13005
13265
|
exports.NullLiteral = NullLiteral;
|
|
13006
13266
|
exports.BooleanLiteral = BooleanLiteral;
|
|
13267
|
+
exports._BooleanLiteral = _BooleanLiteral;
|
|
13007
13268
|
exports.CoffeeScriptBooleanLiteral = CoffeeScriptBooleanLiteral;
|
|
13008
13269
|
exports.Identifier = Identifier;
|
|
13009
13270
|
exports.IdentifierName = IdentifierName;
|
|
13010
13271
|
exports.IdentifierReference = IdentifierReference;
|
|
13011
13272
|
exports.UpcomingAssignment = UpcomingAssignment;
|
|
13012
13273
|
exports.ArrayLiteral = ArrayLiteral;
|
|
13274
|
+
exports._ArrayLiteral = _ArrayLiteral;
|
|
13013
13275
|
exports.RangeExpression = RangeExpression;
|
|
13014
13276
|
exports.ArrayLiteralContent = ArrayLiteralContent;
|
|
13015
13277
|
exports.NestedElementList = NestedElementList;
|
|
@@ -13050,7 +13312,10 @@ var require_parser = __commonJS({
|
|
|
13050
13312
|
exports.NotDedentedBinaryOp = NotDedentedBinaryOp;
|
|
13051
13313
|
exports.IdentifierBinaryOp = IdentifierBinaryOp;
|
|
13052
13314
|
exports.BinaryOp = BinaryOp;
|
|
13315
|
+
exports._BinaryOp = _BinaryOp;
|
|
13053
13316
|
exports.BinaryOpSymbol = BinaryOpSymbol;
|
|
13317
|
+
exports.CoffeeOfOp = CoffeeOfOp;
|
|
13318
|
+
exports.NotOp = NotOp;
|
|
13054
13319
|
exports.Xor = Xor;
|
|
13055
13320
|
exports.Xnor = Xnor;
|
|
13056
13321
|
exports.UnaryOp = UnaryOp;
|
|
@@ -13061,6 +13326,7 @@ var require_parser = __commonJS({
|
|
|
13061
13326
|
exports.PostfixedExpression = PostfixedExpression;
|
|
13062
13327
|
exports.NonPipelinePostfixedExpression = NonPipelinePostfixedExpression;
|
|
13063
13328
|
exports.PostfixStatement = PostfixStatement;
|
|
13329
|
+
exports._PostfixStatement = _PostfixStatement;
|
|
13064
13330
|
exports.Statement = Statement;
|
|
13065
13331
|
exports.EmptyStatement = EmptyStatement;
|
|
13066
13332
|
exports.BlockStatement = BlockStatement;
|
|
@@ -13080,6 +13346,7 @@ var require_parser = __commonJS({
|
|
|
13080
13346
|
exports.NestedBlockExpression = NestedBlockExpression;
|
|
13081
13347
|
exports.BlockExpressionPart = BlockExpressionPart;
|
|
13082
13348
|
exports.IterationStatement = IterationStatement;
|
|
13349
|
+
exports._IterationStatement = _IterationStatement;
|
|
13083
13350
|
exports.IterationExpression = IterationExpression;
|
|
13084
13351
|
exports.LoopStatement = LoopStatement;
|
|
13085
13352
|
exports.LoopClause = LoopClause;
|
|
@@ -13216,6 +13483,7 @@ var require_parser = __commonJS({
|
|
|
13216
13483
|
exports.RegExpCharacter = RegExpCharacter;
|
|
13217
13484
|
exports.RegularExpressionFlags = RegularExpressionFlags;
|
|
13218
13485
|
exports.TemplateLiteral = TemplateLiteral;
|
|
13486
|
+
exports._TemplateLiteral = _TemplateLiteral;
|
|
13219
13487
|
exports.TemplateSubstitution = TemplateSubstitution;
|
|
13220
13488
|
exports.TemplateCharacters = TemplateCharacters;
|
|
13221
13489
|
exports.TemplateBlockCharacters = TemplateBlockCharacters;
|
|
@@ -13334,6 +13602,7 @@ var require_parser = __commonJS({
|
|
|
13334
13602
|
exports.Yield = Yield;
|
|
13335
13603
|
exports.JSXImplicitFragment = JSXImplicitFragment;
|
|
13336
13604
|
exports.JSXTag = JSXTag;
|
|
13605
|
+
exports._JSXTag = _JSXTag;
|
|
13337
13606
|
exports.JSXElement = JSXElement;
|
|
13338
13607
|
exports.JSXSelfClosingElement = JSXSelfClosingElement;
|
|
13339
13608
|
exports.PushJSXOpeningElement = PushJSXOpeningElement;
|
|
@@ -14162,7 +14431,8 @@ function makeCache({ hits, trace } = {}) {
|
|
|
14162
14431
|
return;
|
|
14163
14432
|
}
|
|
14164
14433
|
;
|
|
14165
|
-
const
|
|
14434
|
+
const [stateKey, tagKey] = getStateKey();
|
|
14435
|
+
const key = [tagKey, stateKey, state.pos, ruleName];
|
|
14166
14436
|
if (stateCache.has(key)) {
|
|
14167
14437
|
if (trace) {
|
|
14168
14438
|
logs.push("".padStart(stack.length * 2, " ") + ruleName + ":" + state.pos + "\u{1F4B0}");
|
|
@@ -14183,12 +14453,9 @@ function makeCache({ hits, trace } = {}) {
|
|
|
14183
14453
|
({ getStateKey } = result.value);
|
|
14184
14454
|
}
|
|
14185
14455
|
if (!uncacheable.has(ruleName)) {
|
|
14186
|
-
const
|
|
14187
|
-
|
|
14188
|
-
|
|
14189
|
-
} else {
|
|
14190
|
-
stateCache.set(key, result);
|
|
14191
|
-
}
|
|
14456
|
+
const [stateKey, tagKey] = getStateKey();
|
|
14457
|
+
const key = [tagKey, stateKey, state.pos, ruleName];
|
|
14458
|
+
stateCache.set(key, result);
|
|
14192
14459
|
}
|
|
14193
14460
|
if (parse.config.verbose && result) {
|
|
14194
14461
|
console.log(`Parsed ${JSON.stringify(state.input.slice(state.pos, result.pos))} [pos ${state.pos}-${result.pos}] as ${ruleName}`);
|