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