@danielx/civet 0.6.43 → 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 +505 -337
- package/dist/main.js +505 -337
- package/dist/main.mjs +505 -337
- package/package.json +2 -2
package/dist/browser.js
CHANGED
|
@@ -902,18 +902,18 @@ ${input.slice(result.pos)}
|
|
|
902
902
|
}
|
|
903
903
|
if (subtype === "DoStatement") {
|
|
904
904
|
insertReturn(block);
|
|
905
|
-
children.splice(i, 1, ...wrapIIFE(statement, async));
|
|
905
|
+
children.splice(i, 1, ...wrapIIFE(["", statement, void 0], async));
|
|
906
906
|
return;
|
|
907
907
|
}
|
|
908
908
|
const resultsRef = makeRef("results");
|
|
909
909
|
insertPush(block, resultsRef);
|
|
910
|
+
braceBlock(block);
|
|
910
911
|
children.splice(
|
|
911
912
|
i,
|
|
912
913
|
1,
|
|
913
914
|
...wrapIIFE([
|
|
914
915
|
["", ["const ", resultsRef, "=[]"], ";"],
|
|
915
|
-
...children,
|
|
916
|
-
["", "; "],
|
|
916
|
+
...children.map((c) => ["", c, void 0]),
|
|
917
917
|
["", wrapWithReturn(resultsRef)]
|
|
918
918
|
], async)
|
|
919
919
|
);
|
|
@@ -1317,6 +1317,7 @@ ${input.slice(result.pos)}
|
|
|
1317
1317
|
};
|
|
1318
1318
|
const prefix = splices.map((s) => ["let ", s]).concat(thisAssignments).map(
|
|
1319
1319
|
(s) => s.type ? {
|
|
1320
|
+
// TODO: figure out how to get JS only statement tuples
|
|
1320
1321
|
...s,
|
|
1321
1322
|
children: [indent, ...s.children, delimiter]
|
|
1322
1323
|
} : [indent, s, delimiter]
|
|
@@ -1715,6 +1716,31 @@ ${input.slice(result.pos)}
|
|
|
1715
1716
|
return target.token.match(/^ ?/)[0];
|
|
1716
1717
|
return;
|
|
1717
1718
|
}
|
|
1719
|
+
function startsWith(target, value) {
|
|
1720
|
+
if (!target)
|
|
1721
|
+
return;
|
|
1722
|
+
if (Array.isArray(target)) {
|
|
1723
|
+
let i = 0;
|
|
1724
|
+
let l = target.length;
|
|
1725
|
+
while (i < l) {
|
|
1726
|
+
const t = target[i];
|
|
1727
|
+
if (t && (t.length || t.token || t.children)) {
|
|
1728
|
+
break;
|
|
1729
|
+
}
|
|
1730
|
+
i++;
|
|
1731
|
+
}
|
|
1732
|
+
if (i < l) {
|
|
1733
|
+
return startsWith(target[i], value);
|
|
1734
|
+
}
|
|
1735
|
+
}
|
|
1736
|
+
if (target.children)
|
|
1737
|
+
return startsWith(target.children, value);
|
|
1738
|
+
if (target.token)
|
|
1739
|
+
return value.test(target.token);
|
|
1740
|
+
if (typeof target === "string")
|
|
1741
|
+
return value.test(target);
|
|
1742
|
+
return;
|
|
1743
|
+
}
|
|
1718
1744
|
function processForInOf($0, getRef) {
|
|
1719
1745
|
let [awaits, eachOwn, open, declaration, declaration2, ws, inOf, exp, step, close] = $0;
|
|
1720
1746
|
if (exp.type === "RangeExpression" && inOf.token === "of" && !declaration2) {
|
|
@@ -1827,7 +1853,7 @@ ${input.slice(result.pos)}
|
|
|
1827
1853
|
}
|
|
1828
1854
|
if (own) {
|
|
1829
1855
|
const hasPropRef = getRef("hasProp");
|
|
1830
|
-
blockPrefix.push(["", "if (!", hasPropRef, "(", insertTrimmingSpace(expRef2, ""), ", ", insertTrimmingSpace(binding, ""), ")) continue", ";"]);
|
|
1856
|
+
blockPrefix.push(["", ["if (!", hasPropRef, "(", insertTrimmingSpace(expRef2, ""), ", ", insertTrimmingSpace(binding, ""), ")) continue"], ";"]);
|
|
1831
1857
|
}
|
|
1832
1858
|
if (decl2) {
|
|
1833
1859
|
blockPrefix.push(["", {
|
|
@@ -1986,6 +2012,15 @@ ${input.slice(result.pos)}
|
|
|
1986
2012
|
empty: true
|
|
1987
2013
|
};
|
|
1988
2014
|
}
|
|
2015
|
+
function braceBlock(block) {
|
|
2016
|
+
if (block.bare) {
|
|
2017
|
+
block.children.unshift(" {");
|
|
2018
|
+
block.children.push("}");
|
|
2019
|
+
return block.bare = false;
|
|
2020
|
+
}
|
|
2021
|
+
;
|
|
2022
|
+
return;
|
|
2023
|
+
}
|
|
1989
2024
|
function makeLeftHandSideExpression(expression) {
|
|
1990
2025
|
switch (expression.type) {
|
|
1991
2026
|
case "Ref":
|
|
@@ -2514,6 +2549,68 @@ ${input.slice(result.pos)}
|
|
|
2514
2549
|
return exp.children.splice(index + 1, 0, ...tail);
|
|
2515
2550
|
});
|
|
2516
2551
|
}
|
|
2552
|
+
function processBlocks(statements) {
|
|
2553
|
+
insertSemicolon(statements);
|
|
2554
|
+
gatherRecursive(statements, ($) => $.type === "BlockStatement").forEach(function({ expressions }) {
|
|
2555
|
+
return processBlocks(expressions);
|
|
2556
|
+
});
|
|
2557
|
+
}
|
|
2558
|
+
function insertSemicolon(statements) {
|
|
2559
|
+
const l = statements.length;
|
|
2560
|
+
statements.forEach(function(s, i) {
|
|
2561
|
+
if (i < l - 1) {
|
|
2562
|
+
if (needsPrecedingSemicolon(statements[i + 1])) {
|
|
2563
|
+
const delim = s[2];
|
|
2564
|
+
if (!delim) {
|
|
2565
|
+
return s[2] = ";";
|
|
2566
|
+
} else if (typeof delim === "string" && !delim.match(/;/)) {
|
|
2567
|
+
return s[2] = `;${delim}`;
|
|
2568
|
+
}
|
|
2569
|
+
;
|
|
2570
|
+
return;
|
|
2571
|
+
}
|
|
2572
|
+
;
|
|
2573
|
+
return;
|
|
2574
|
+
}
|
|
2575
|
+
;
|
|
2576
|
+
return;
|
|
2577
|
+
});
|
|
2578
|
+
}
|
|
2579
|
+
function needsPrecedingSemicolon(exp) {
|
|
2580
|
+
let following;
|
|
2581
|
+
if (Array.isArray(exp)) {
|
|
2582
|
+
[, following] = exp;
|
|
2583
|
+
} else {
|
|
2584
|
+
following = exp;
|
|
2585
|
+
}
|
|
2586
|
+
if (!following) {
|
|
2587
|
+
return false;
|
|
2588
|
+
}
|
|
2589
|
+
if (Array.isArray(following)) {
|
|
2590
|
+
return needsPrecedingSemicolon(following[0]);
|
|
2591
|
+
}
|
|
2592
|
+
switch (following.type) {
|
|
2593
|
+
case "ParenthesizedExpression":
|
|
2594
|
+
case "ArrowFunction":
|
|
2595
|
+
case "TemplateLiteral":
|
|
2596
|
+
case "RegularExpressionLiteral": {
|
|
2597
|
+
return true;
|
|
2598
|
+
}
|
|
2599
|
+
case "AssignmentExpression": {
|
|
2600
|
+
return startsWith(following, /^(\[|\()/);
|
|
2601
|
+
}
|
|
2602
|
+
case "Literal": {
|
|
2603
|
+
return following.raw?.startsWith("-") || following.raw?.startsWith("+");
|
|
2604
|
+
}
|
|
2605
|
+
default: {
|
|
2606
|
+
if (following.children) {
|
|
2607
|
+
return needsPrecedingSemicolon(following.children[0]);
|
|
2608
|
+
}
|
|
2609
|
+
;
|
|
2610
|
+
return;
|
|
2611
|
+
}
|
|
2612
|
+
}
|
|
2613
|
+
}
|
|
2517
2614
|
function attachPostfixStatementAsExpression(exp, post) {
|
|
2518
2615
|
switch (post[1].type) {
|
|
2519
2616
|
case "ForStatement":
|
|
@@ -2855,11 +2952,7 @@ ${input.slice(result.pos)}
|
|
|
2855
2952
|
}
|
|
2856
2953
|
block.expressions.unshift(...prefix);
|
|
2857
2954
|
const next = [];
|
|
2858
|
-
|
|
2859
|
-
block.children.unshift(" {");
|
|
2860
|
-
block.children.push("}");
|
|
2861
|
-
block.bare = false;
|
|
2862
|
-
}
|
|
2955
|
+
braceBlock(block);
|
|
2863
2956
|
if (i < l - 1)
|
|
2864
2957
|
next.push("\n", "else ");
|
|
2865
2958
|
prev.push(["", {
|
|
@@ -3030,6 +3123,7 @@ ${input.slice(result.pos)}
|
|
|
3030
3123
|
} else if (config.autoVar) {
|
|
3031
3124
|
createVarDecs(statements, []);
|
|
3032
3125
|
}
|
|
3126
|
+
processBlocks(statements);
|
|
3033
3127
|
populateRefs(statements);
|
|
3034
3128
|
adjustAtBindings(statements);
|
|
3035
3129
|
}
|
|
@@ -3111,7 +3205,10 @@ ${input.slice(result.pos)}
|
|
|
3111
3205
|
if (statements[0][1]?.parent?.root) {
|
|
3112
3206
|
delimiter = ";\n";
|
|
3113
3207
|
}
|
|
3114
|
-
statements.unshift([indent,
|
|
3208
|
+
statements.unshift([indent, {
|
|
3209
|
+
type: "Declaration",
|
|
3210
|
+
children: ["var ", varIds.join(", ")]
|
|
3211
|
+
}, delimiter]);
|
|
3115
3212
|
}
|
|
3116
3213
|
return scopes.pop();
|
|
3117
3214
|
}
|
|
@@ -3181,13 +3278,17 @@ ${input.slice(result.pos)}
|
|
|
3181
3278
|
if (gatherNodes(indent, (node) => node.token && node.token.endsWith("\n")).length > 0) {
|
|
3182
3279
|
tail = void 0;
|
|
3183
3280
|
}
|
|
3184
|
-
targetStatements.push([indent,
|
|
3281
|
+
targetStatements.push([indent, {
|
|
3282
|
+
type: "Declaration",
|
|
3283
|
+
children: ["let ", ...undeclaredIdentifiers.join(", ")],
|
|
3284
|
+
names: undeclaredIdentifiers
|
|
3285
|
+
}, tail]);
|
|
3185
3286
|
}
|
|
3186
3287
|
}
|
|
3187
3288
|
targetStatements.push(statement);
|
|
3188
3289
|
}
|
|
3189
3290
|
scopes.pop();
|
|
3190
|
-
statements.splice(0, statements.length, targetStatements);
|
|
3291
|
+
statements.splice(0, statements.length, ...targetStatements);
|
|
3191
3292
|
}
|
|
3192
3293
|
function processReturnValue(func) {
|
|
3193
3294
|
const { block } = func;
|
|
@@ -3195,31 +3296,39 @@ ${input.slice(result.pos)}
|
|
|
3195
3296
|
block,
|
|
3196
3297
|
({ type }) => type === "ReturnValue"
|
|
3197
3298
|
);
|
|
3198
|
-
if (!values.length)
|
|
3299
|
+
if (!values.length) {
|
|
3199
3300
|
return false;
|
|
3301
|
+
}
|
|
3200
3302
|
const ref = makeRef("ret");
|
|
3201
|
-
let
|
|
3303
|
+
let declaration;
|
|
3202
3304
|
values.forEach((value) => {
|
|
3203
3305
|
value.children = [ref];
|
|
3204
|
-
const { ancestor } = findAncestor(
|
|
3306
|
+
const { ancestor, child } = findAncestor(
|
|
3205
3307
|
value,
|
|
3206
3308
|
({ type }) => type === "Declaration",
|
|
3207
3309
|
isFunction
|
|
3208
3310
|
);
|
|
3209
|
-
if (ancestor)
|
|
3210
|
-
return
|
|
3311
|
+
if (ancestor) {
|
|
3312
|
+
return declaration ?? (declaration = child);
|
|
3313
|
+
}
|
|
3314
|
+
;
|
|
3211
3315
|
return;
|
|
3212
3316
|
});
|
|
3213
|
-
|
|
3214
|
-
|
|
3215
|
-
|
|
3216
|
-
|
|
3217
|
-
|
|
3218
|
-
|
|
3219
|
-
|
|
3220
|
-
|
|
3221
|
-
|
|
3317
|
+
let returnType = func.returnType ?? func.signature?.returnType;
|
|
3318
|
+
if (returnType) {
|
|
3319
|
+
const { t } = returnType;
|
|
3320
|
+
let m1;
|
|
3321
|
+
if (m1 = t.type, m1 === "TypePredicate") {
|
|
3322
|
+
returnType = ": boolean";
|
|
3323
|
+
} else if (m1 === "AssertsType") {
|
|
3324
|
+
returnType = void 0;
|
|
3325
|
+
}
|
|
3326
|
+
}
|
|
3327
|
+
if (declaration) {
|
|
3328
|
+
if (!(declaration.suffix != null)) {
|
|
3329
|
+
declaration.children[1] = declaration.suffix = returnType;
|
|
3222
3330
|
}
|
|
3331
|
+
} else {
|
|
3223
3332
|
block.expressions.unshift([
|
|
3224
3333
|
getIndent(block.expressions[0]),
|
|
3225
3334
|
{
|
|
@@ -3237,7 +3346,7 @@ ${input.slice(result.pos)}
|
|
|
3237
3346
|
r.expression = ref;
|
|
3238
3347
|
return r.children.splice(-1, 1, " ", ref);
|
|
3239
3348
|
});
|
|
3240
|
-
if (block.children.at(-2)?.type
|
|
3349
|
+
if (!(block.children.at(-2)?.type === "ReturnStatement")) {
|
|
3241
3350
|
block.expressions.push([
|
|
3242
3351
|
[getIndent(block.expressions.at(-1))],
|
|
3243
3352
|
{
|
|
@@ -3282,15 +3391,18 @@ ${input.slice(result.pos)}
|
|
|
3282
3391
|
return exp;
|
|
3283
3392
|
}
|
|
3284
3393
|
if (exp.type === "Literal") {
|
|
3285
|
-
if (pre.length === 1
|
|
3286
|
-
const
|
|
3287
|
-
if (
|
|
3288
|
-
exp.children
|
|
3289
|
-
|
|
3290
|
-
|
|
3291
|
-
|
|
3292
|
-
|
|
3293
|
-
|
|
3394
|
+
if (pre.length === 1) {
|
|
3395
|
+
const { token } = pre[0];
|
|
3396
|
+
if (token === "-" || token === "+") {
|
|
3397
|
+
const children = [pre[0], ...exp.children];
|
|
3398
|
+
if (post)
|
|
3399
|
+
exp.children.push(post);
|
|
3400
|
+
return {
|
|
3401
|
+
type: "Literal",
|
|
3402
|
+
children,
|
|
3403
|
+
raw: `${token}${exp.raw}`
|
|
3404
|
+
};
|
|
3405
|
+
}
|
|
3294
3406
|
}
|
|
3295
3407
|
}
|
|
3296
3408
|
const l = pre.length;
|
|
@@ -3542,7 +3654,6 @@ ${input.slice(result.pos)}
|
|
|
3542
3654
|
dedentBlockSubstitutions,
|
|
3543
3655
|
deepCopy,
|
|
3544
3656
|
expressionizeIfClause,
|
|
3545
|
-
expressionizeIteration,
|
|
3546
3657
|
findAncestor,
|
|
3547
3658
|
forRange,
|
|
3548
3659
|
gatherBindingCode,
|
|
@@ -3848,6 +3959,7 @@ ${input.slice(result.pos)}
|
|
|
3848
3959
|
NotDedentedBinaryOp,
|
|
3849
3960
|
IdentifierBinaryOp,
|
|
3850
3961
|
BinaryOp,
|
|
3962
|
+
_BinaryOp,
|
|
3851
3963
|
BinaryOpSymbol,
|
|
3852
3964
|
CoffeeOfOp,
|
|
3853
3965
|
NotOp,
|
|
@@ -4137,6 +4249,7 @@ ${input.slice(result.pos)}
|
|
|
4137
4249
|
Yield,
|
|
4138
4250
|
JSXImplicitFragment,
|
|
4139
4251
|
JSXTag,
|
|
4252
|
+
_JSXTag,
|
|
4140
4253
|
JSXElement,
|
|
4141
4254
|
JSXSelfClosingElement,
|
|
4142
4255
|
PushJSXOpeningElement,
|
|
@@ -4424,51 +4537,51 @@ ${input.slice(result.pos)}
|
|
|
4424
4537
|
var $L108 = $L("/*");
|
|
4425
4538
|
var $L109 = $L("*/");
|
|
4426
4539
|
var $L110 = $L("\\");
|
|
4427
|
-
var $L111 = $L("
|
|
4428
|
-
var $L112 = $L("
|
|
4429
|
-
var $L113 = $L("
|
|
4430
|
-
var $L114 = $L("
|
|
4431
|
-
var $L115 = $L("
|
|
4432
|
-
var $L116 = $L("
|
|
4433
|
-
var $L117 = $L("
|
|
4434
|
-
var $L118 = $L("
|
|
4435
|
-
var $L119 = $L("
|
|
4436
|
-
var $L120 = $L("
|
|
4437
|
-
var $L121 = $L("
|
|
4438
|
-
var $L122 = $L("
|
|
4439
|
-
var $L123 = $L("
|
|
4440
|
-
var $L124 = $L("
|
|
4441
|
-
var $L125 = $L("
|
|
4442
|
-
var $L126 = $L("
|
|
4443
|
-
var $L127 = $L("
|
|
4444
|
-
var $L128 = $L("
|
|
4445
|
-
var $L129 = $L("
|
|
4446
|
-
var $L130 = $L("
|
|
4447
|
-
var $L131 = $L("
|
|
4448
|
-
var $L132 = $L("
|
|
4449
|
-
var $L133 = $L("
|
|
4450
|
-
var $L134 = $L(
|
|
4451
|
-
var $L135 = $L("
|
|
4452
|
-
var $L136 = $L("
|
|
4453
|
-
var $L137 = $L("
|
|
4454
|
-
var $L138 = $L("
|
|
4455
|
-
var $L139 = $L("
|
|
4456
|
-
var $L140 = $L("
|
|
4457
|
-
var $L141 = $L("
|
|
4458
|
-
var $L142 = $L("
|
|
4459
|
-
var $L143 = $L("
|
|
4460
|
-
var $L144 = $L("
|
|
4461
|
-
var $L145 = $L("
|
|
4462
|
-
var $L146 = $L("
|
|
4463
|
-
var $L147 = $L("
|
|
4464
|
-
var $L148 = $L("
|
|
4465
|
-
var $L149 = $L("
|
|
4466
|
-
var $L150 = $L("
|
|
4467
|
-
var $L151 = $L("
|
|
4468
|
-
var $L152 = $L("
|
|
4469
|
-
var $L153 = $L("
|
|
4470
|
-
var $L154 = $L("
|
|
4471
|
-
var $L155 = $L("
|
|
4540
|
+
var $L111 = $L(")");
|
|
4541
|
+
var $L112 = $L("abstract");
|
|
4542
|
+
var $L113 = $L("as");
|
|
4543
|
+
var $L114 = $L("@");
|
|
4544
|
+
var $L115 = $L("@@");
|
|
4545
|
+
var $L116 = $L("async");
|
|
4546
|
+
var $L117 = $L("await");
|
|
4547
|
+
var $L118 = $L("`");
|
|
4548
|
+
var $L119 = $L("by");
|
|
4549
|
+
var $L120 = $L("case");
|
|
4550
|
+
var $L121 = $L("catch");
|
|
4551
|
+
var $L122 = $L("class");
|
|
4552
|
+
var $L123 = $L("#{");
|
|
4553
|
+
var $L124 = $L("declare");
|
|
4554
|
+
var $L125 = $L("default");
|
|
4555
|
+
var $L126 = $L("delete");
|
|
4556
|
+
var $L127 = $L("do");
|
|
4557
|
+
var $L128 = $L("..");
|
|
4558
|
+
var $L129 = $L("\u2025");
|
|
4559
|
+
var $L130 = $L("...");
|
|
4560
|
+
var $L131 = $L("\u2026");
|
|
4561
|
+
var $L132 = $L("::");
|
|
4562
|
+
var $L133 = $L('"');
|
|
4563
|
+
var $L134 = $L("each");
|
|
4564
|
+
var $L135 = $L("else");
|
|
4565
|
+
var $L136 = $L("export");
|
|
4566
|
+
var $L137 = $L("extends");
|
|
4567
|
+
var $L138 = $L("finally");
|
|
4568
|
+
var $L139 = $L("for");
|
|
4569
|
+
var $L140 = $L("from");
|
|
4570
|
+
var $L141 = $L("function");
|
|
4571
|
+
var $L142 = $L("get");
|
|
4572
|
+
var $L143 = $L("set");
|
|
4573
|
+
var $L144 = $L("#");
|
|
4574
|
+
var $L145 = $L("if");
|
|
4575
|
+
var $L146 = $L("in");
|
|
4576
|
+
var $L147 = $L("let");
|
|
4577
|
+
var $L148 = $L("const");
|
|
4578
|
+
var $L149 = $L("is");
|
|
4579
|
+
var $L150 = $L("loop");
|
|
4580
|
+
var $L151 = $L("new");
|
|
4581
|
+
var $L152 = $L("not");
|
|
4582
|
+
var $L153 = $L("of");
|
|
4583
|
+
var $L154 = $L("<");
|
|
4584
|
+
var $L155 = $L("[");
|
|
4472
4585
|
var $L156 = $L("operator");
|
|
4473
4586
|
var $L157 = $L("own");
|
|
4474
4587
|
var $L158 = $L("public");
|
|
@@ -4530,85 +4643,88 @@ ${input.slice(result.pos)}
|
|
|
4530
4643
|
var $R3 = $R(new RegExp("[ \\t]", "suy"));
|
|
4531
4644
|
var $R4 = $R(new RegExp("(?=['\"`])", "suy"));
|
|
4532
4645
|
var $R5 = $R(new RegExp("(?=[\\/?])", "suy"));
|
|
4533
|
-
var $R6 = $R(new RegExp("[)
|
|
4534
|
-
var $R7 = $R(new RegExp("[
|
|
4535
|
-
var $R8 = $R(new RegExp("[
|
|
4536
|
-
var $R9 = $R(new RegExp(
|
|
4537
|
-
var $R10 = $R(new RegExp(
|
|
4538
|
-
var $R11 = $R(new RegExp("(
|
|
4539
|
-
var $R12 = $R(new RegExp("(
|
|
4540
|
-
var $R13 = $R(new RegExp("(
|
|
4541
|
-
var $R14 = $R(new RegExp("[
|
|
4542
|
-
var $R15 = $R(new RegExp("
|
|
4543
|
-
var $R16 = $R(new RegExp("
|
|
4544
|
-
var $R17 = $R(new RegExp("(
|
|
4545
|
-
var $R18 = $R(new RegExp("
|
|
4546
|
-
var $R19 = $R(new RegExp("(
|
|
4547
|
-
var $R20 = $R(new RegExp("(?=
|
|
4548
|
-
var $R21 = $R(new RegExp(
|
|
4549
|
-
var $R22 = $R(new RegExp("(?=[
|
|
4550
|
-
var $R23 = $R(new RegExp("
|
|
4551
|
-
var $R24 = $R(new RegExp("(
|
|
4552
|
-
var $R25 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)
|
|
4553
|
-
var $R26 = $R(new RegExp("(
|
|
4554
|
-
var $R27 = $R(new RegExp("(?:[
|
|
4555
|
-
var $R28 = $R(new RegExp("0
|
|
4556
|
-
var $R29 = $R(new RegExp("
|
|
4557
|
-
var $R30 = $R(new RegExp("0[
|
|
4558
|
-
var $R31 = $R(new RegExp("(
|
|
4559
|
-
var $R32 = $R(new RegExp("
|
|
4560
|
-
var $R33 = $R(new RegExp(
|
|
4561
|
-
var $R34 = $R(new RegExp("(
|
|
4562
|
-
var $R35 = $R(new RegExp('(
|
|
4563
|
-
var $R36 = $R(new RegExp("(
|
|
4564
|
-
var $R37 = $R(new RegExp('(
|
|
4565
|
-
var $R38 = $R(new RegExp("(
|
|
4566
|
-
var $R39 = $R(new RegExp(
|
|
4567
|
-
var $R40 = $R(new RegExp("[
|
|
4568
|
-
var $R41 = $R(new RegExp("
|
|
4569
|
-
var $R42 = $R(new RegExp("[
|
|
4570
|
-
var $R43 = $R(new RegExp("
|
|
4571
|
-
var $R44 = $R(new RegExp("
|
|
4572
|
-
var $R45 = $R(new RegExp("
|
|
4573
|
-
var $R46 = $R(new RegExp("(
|
|
4574
|
-
var $R47 = $R(new RegExp("(
|
|
4575
|
-
var $R48 = $R(new RegExp("(
|
|
4576
|
-
var $R49 = $R(new RegExp("(
|
|
4577
|
-
var $R50 = $R(new RegExp("(
|
|
4578
|
-
var $R51 = $R(new RegExp("(?:
|
|
4579
|
-
var $R52 = $R(new RegExp("(?:
|
|
4580
|
-
var $R53 = $R(new RegExp("(?:
|
|
4581
|
-
var $R54 = $R(new RegExp("(
|
|
4582
|
-
var $R55 = $R(new RegExp("
|
|
4583
|
-
var $R56 = $R(new RegExp("
|
|
4584
|
-
var $R57 = $R(new RegExp("
|
|
4585
|
-
var $R58 = $R(new RegExp("
|
|
4586
|
-
var $R59 = $R(new RegExp("
|
|
4587
|
-
var $R60 = $R(new RegExp("
|
|
4588
|
-
var $R61 = $R(new RegExp("(
|
|
4589
|
-
var $R62 = $R(new RegExp("[
|
|
4590
|
-
var $R63 = $R(new RegExp("(
|
|
4591
|
-
var $R64 = $R(new RegExp("
|
|
4592
|
-
var $R65 = $R(new RegExp("
|
|
4593
|
-
var $R66 = $R(new RegExp("
|
|
4594
|
-
var $R67 = $R(new RegExp("
|
|
4595
|
-
var $R68 = $R(new RegExp("
|
|
4596
|
-
var $R69 = $R(new RegExp("(
|
|
4597
|
-
var $R70 = $R(new RegExp(
|
|
4598
|
-
var $R71 = $R(new RegExp("[
|
|
4599
|
-
var $R72 = $R(new RegExp("[
|
|
4600
|
-
var $R73 = $R(new RegExp("
|
|
4601
|
-
var $R74 = $R(new RegExp("[
|
|
4602
|
-
var $R75 = $R(new RegExp("[
|
|
4603
|
-
var $R76 = $R(new RegExp("[
|
|
4604
|
-
var $R77 = $R(new RegExp("
|
|
4605
|
-
var $R78 = $R(new RegExp("[
|
|
4606
|
-
var $R79 = $R(new RegExp("[
|
|
4607
|
-
var $R80 = $R(new RegExp("
|
|
4608
|
-
var $R81 = $R(new RegExp("
|
|
4609
|
-
var $R82 = $R(new RegExp("
|
|
4610
|
-
var $R83 = $R(new RegExp("\\
|
|
4611
|
-
var $R84 = $R(new RegExp("[
|
|
4646
|
+
var $R6 = $R(new RegExp("(?=[\\/\\[{?.!@'\u2019:])", "suy"));
|
|
4647
|
+
var $R7 = $R(new RegExp("[)}]", "suy"));
|
|
4648
|
+
var $R8 = $R(new RegExp("[&]", "suy"));
|
|
4649
|
+
var $R9 = $R(new RegExp("[!~+-]+", "suy"));
|
|
4650
|
+
var $R10 = $R(new RegExp(`(?=[0-9.'"tfyno])`, "suy"));
|
|
4651
|
+
var $R11 = $R(new RegExp("(?=true|false|yes|no|on|off)", "suy"));
|
|
4652
|
+
var $R12 = $R(new RegExp("(?=\\p{ID_Start}|[_$])", "suy"));
|
|
4653
|
+
var $R13 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
4654
|
+
var $R14 = $R(new RegExp("(?=\\[)", "suy"));
|
|
4655
|
+
var $R15 = $R(new RegExp("[!+-]", "suy"));
|
|
4656
|
+
var $R16 = $R(new RegExp("(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>+-])", "suy"));
|
|
4657
|
+
var $R17 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
|
|
4658
|
+
var $R18 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
4659
|
+
var $R19 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])", "suy"));
|
|
4660
|
+
var $R20 = $R(new RegExp("(?=for|if|loop|unless|until|while)", "suy"));
|
|
4661
|
+
var $R21 = $R(new RegExp("(?=loop|do|for|until|while)", "suy"));
|
|
4662
|
+
var $R22 = $R(new RegExp("(?=[\\s\\),])", "suy"));
|
|
4663
|
+
var $R23 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
4664
|
+
var $R24 = $R(new RegExp("(?=[0-9.])", "suy"));
|
|
4665
|
+
var $R25 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
4666
|
+
var $R26 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
4667
|
+
var $R27 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
4668
|
+
var $R28 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4669
|
+
var $R29 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
4670
|
+
var $R30 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
4671
|
+
var $R31 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
4672
|
+
var $R32 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
4673
|
+
var $R33 = $R(new RegExp("(?=[0-9])", "suy"));
|
|
4674
|
+
var $R34 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4675
|
+
var $R35 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
4676
|
+
var $R36 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
4677
|
+
var $R37 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
4678
|
+
var $R38 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
4679
|
+
var $R39 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
4680
|
+
var $R40 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
4681
|
+
var $R41 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
4682
|
+
var $R42 = $R(new RegExp("[\\s]+", "suy"));
|
|
4683
|
+
var $R43 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
4684
|
+
var $R44 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
4685
|
+
var $R45 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
4686
|
+
var $R46 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
4687
|
+
var $R47 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
4688
|
+
var $R48 = $R(new RegExp("(?=[`'\"])", "suy"));
|
|
4689
|
+
var $R49 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
4690
|
+
var $R50 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
4691
|
+
var $R51 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
4692
|
+
var $R52 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
4693
|
+
var $R53 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
4694
|
+
var $R54 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
4695
|
+
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"));
|
|
4696
|
+
var $R56 = $R(new RegExp("(?=\\/|#)", "suy"));
|
|
4697
|
+
var $R57 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
4698
|
+
var $R58 = $R(new RegExp(".", "suy"));
|
|
4699
|
+
var $R59 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
4700
|
+
var $R60 = $R(new RegExp("[^]*?###", "suy"));
|
|
4701
|
+
var $R61 = $R(new RegExp("###(?!#)", "suy"));
|
|
4702
|
+
var $R62 = $R(new RegExp("\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\/", "suy"));
|
|
4703
|
+
var $R63 = $R(new RegExp("(?=[ \\t\\/\\\\])", "suy"));
|
|
4704
|
+
var $R64 = $R(new RegExp("[ \\t]+", "suy"));
|
|
4705
|
+
var $R65 = $R(new RegExp("(?=\\s|\\/|#)", "suy"));
|
|
4706
|
+
var $R66 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
4707
|
+
var $R67 = $R(new RegExp("['\u2019]s", "suy"));
|
|
4708
|
+
var $R68 = $R(new RegExp("\\s", "suy"));
|
|
4709
|
+
var $R69 = $R(new RegExp("(?=[<])", "suy"));
|
|
4710
|
+
var $R70 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
4711
|
+
var $R71 = $R(new RegExp("[\\s>]|\\/>", "suy"));
|
|
4712
|
+
var $R72 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
4713
|
+
var $R73 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
|
|
4714
|
+
var $R74 = $R(new RegExp("[<>]", "suy"));
|
|
4715
|
+
var $R75 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
4716
|
+
var $R76 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
4717
|
+
var $R77 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
4718
|
+
var $R78 = $R(new RegExp("[+-]?", "suy"));
|
|
4719
|
+
var $R79 = $R(new RegExp("[+-]", "suy"));
|
|
4720
|
+
var $R80 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
4721
|
+
var $R81 = $R(new RegExp("[\\t ]*", "suy"));
|
|
4722
|
+
var $R82 = $R(new RegExp("[\\s]*", "suy"));
|
|
4723
|
+
var $R83 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
4724
|
+
var $R84 = $R(new RegExp("\\/\\/\\/[^\\r\\n]*", "suy"));
|
|
4725
|
+
var $R85 = $R(new RegExp("(?=[ \\t\\r\\n\\/#]|$)", "suy"));
|
|
4726
|
+
var $R86 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
4727
|
+
var $R87 = $R(new RegExp("[ \\t]*", "suy"));
|
|
4612
4728
|
var Program$0 = $TS($S(Reset, Init, $E(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
4613
4729
|
var statements = $4;
|
|
4614
4730
|
processProgram({
|
|
@@ -4775,7 +4891,7 @@ ${input.slice(result.pos)}
|
|
|
4775
4891
|
function Arguments(ctx, state) {
|
|
4776
4892
|
return $EVENT_C(ctx, state, "Arguments", Arguments$$);
|
|
4777
4893
|
}
|
|
4778
|
-
var ImplicitArguments$0 = $TS($S($E($S(TypeArguments, $N(ImplementsToken))), ApplicationStart, InsertOpenParen, $
|
|
4894
|
+
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) {
|
|
4779
4895
|
var ta = $1;
|
|
4780
4896
|
var open = $3;
|
|
4781
4897
|
var ws = $4;
|
|
@@ -5215,6 +5331,18 @@ ${input.slice(result.pos)}
|
|
|
5215
5331
|
type: "PipelineExpression",
|
|
5216
5332
|
children: [ws, ref, body]
|
|
5217
5333
|
};
|
|
5334
|
+
const parameters = {
|
|
5335
|
+
type: "Parameters",
|
|
5336
|
+
children: [ref],
|
|
5337
|
+
names: []
|
|
5338
|
+
};
|
|
5339
|
+
const expressions = [arrowBody];
|
|
5340
|
+
const block = {
|
|
5341
|
+
bare: true,
|
|
5342
|
+
expressions,
|
|
5343
|
+
children: [expressions]
|
|
5344
|
+
};
|
|
5345
|
+
const children = [parameters, " => ", block];
|
|
5218
5346
|
return {
|
|
5219
5347
|
type: "ArrowFunction",
|
|
5220
5348
|
signature: {
|
|
@@ -5222,10 +5350,12 @@ ${input.slice(result.pos)}
|
|
|
5222
5350
|
children: []
|
|
5223
5351
|
}
|
|
5224
5352
|
},
|
|
5225
|
-
children
|
|
5353
|
+
children,
|
|
5226
5354
|
ref,
|
|
5227
5355
|
body: [arrowBody],
|
|
5228
|
-
ampersandBlock: true
|
|
5356
|
+
ampersandBlock: true,
|
|
5357
|
+
parameters,
|
|
5358
|
+
block
|
|
5229
5359
|
};
|
|
5230
5360
|
}
|
|
5231
5361
|
return {
|
|
@@ -5685,9 +5815,9 @@ ${input.slice(result.pos)}
|
|
|
5685
5815
|
function MemberBase(ctx, state) {
|
|
5686
5816
|
return $EVENT_C(ctx, state, "MemberBase", MemberBase$$);
|
|
5687
5817
|
}
|
|
5688
|
-
var MemberExpressionRest$0 = $TS($S($Q(InlineComment), MemberExpressionRestBody), function($skip, $loc, $0, $1, $2) {
|
|
5689
|
-
var comments = $
|
|
5690
|
-
var body = $
|
|
5818
|
+
var MemberExpressionRest$0 = $TS($S($EXPECT($R6, "MemberExpressionRest /(?=[\\/\\[{?.!@'\u2019:])/"), $Q(InlineComment), MemberExpressionRestBody), function($skip, $loc, $0, $1, $2, $3) {
|
|
5819
|
+
var comments = $2;
|
|
5820
|
+
var body = $3;
|
|
5691
5821
|
if (Array.isArray(body))
|
|
5692
5822
|
return [...comments, ...body];
|
|
5693
5823
|
return {
|
|
@@ -6039,8 +6169,8 @@ ${input.slice(result.pos)}
|
|
|
6039
6169
|
function ParameterElement(ctx, state) {
|
|
6040
6170
|
return $EVENT(ctx, state, "ParameterElement", ParameterElement$0);
|
|
6041
6171
|
}
|
|
6042
|
-
var ParameterElementDelimiter$0 = $S($
|
|
6043
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $R$0($EXPECT($
|
|
6172
|
+
var ParameterElementDelimiter$0 = $S($E(_), Comma);
|
|
6173
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $R$0($EXPECT($R7, "ParameterElementDelimiter /[)}]/"))));
|
|
6044
6174
|
var ParameterElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6045
6175
|
return value[1];
|
|
6046
6176
|
});
|
|
@@ -6466,6 +6596,14 @@ ${input.slice(result.pos)}
|
|
|
6466
6596
|
});
|
|
6467
6597
|
var FunctionExpression$1 = $TV($EXPECT($L22, 'FunctionExpression "(&)"'), function($skip, $loc, $0, $1) {
|
|
6468
6598
|
const ref = makeRef("$"), body = [ref];
|
|
6599
|
+
const parameters = {
|
|
6600
|
+
type: "Parameters",
|
|
6601
|
+
children: [ref],
|
|
6602
|
+
names: []
|
|
6603
|
+
};
|
|
6604
|
+
const block = {
|
|
6605
|
+
expressions: [ref]
|
|
6606
|
+
};
|
|
6469
6607
|
return {
|
|
6470
6608
|
type: "ArrowFunction",
|
|
6471
6609
|
signature: {
|
|
@@ -6474,7 +6612,9 @@ ${input.slice(result.pos)}
|
|
|
6474
6612
|
children: [ref, " => ", body],
|
|
6475
6613
|
ref,
|
|
6476
6614
|
body,
|
|
6477
|
-
ampersandBlock: true
|
|
6615
|
+
ampersandBlock: true,
|
|
6616
|
+
block,
|
|
6617
|
+
parameters
|
|
6478
6618
|
};
|
|
6479
6619
|
});
|
|
6480
6620
|
var FunctionExpression$2 = AmpersandFunctionExpression;
|
|
@@ -6517,7 +6657,18 @@ ${input.slice(result.pos)}
|
|
|
6517
6657
|
children: [prefix, body, void 0]
|
|
6518
6658
|
};
|
|
6519
6659
|
}
|
|
6520
|
-
const
|
|
6660
|
+
const parameters = {
|
|
6661
|
+
type: "Parameters",
|
|
6662
|
+
children: [ref],
|
|
6663
|
+
names: []
|
|
6664
|
+
};
|
|
6665
|
+
const expressions = [body];
|
|
6666
|
+
const block = {
|
|
6667
|
+
bare: true,
|
|
6668
|
+
expressions,
|
|
6669
|
+
children: [expressions]
|
|
6670
|
+
};
|
|
6671
|
+
const children = [parameters, " => ", block];
|
|
6521
6672
|
const async = hasAwait(body);
|
|
6522
6673
|
if (async) {
|
|
6523
6674
|
children.unshift("async ");
|
|
@@ -6532,7 +6683,9 @@ ${input.slice(result.pos)}
|
|
|
6532
6683
|
children,
|
|
6533
6684
|
ref,
|
|
6534
6685
|
body,
|
|
6535
|
-
ampersandBlock: true
|
|
6686
|
+
ampersandBlock: true,
|
|
6687
|
+
block,
|
|
6688
|
+
parameters
|
|
6536
6689
|
};
|
|
6537
6690
|
});
|
|
6538
6691
|
function AmpersandFunctionExpression(ctx, state) {
|
|
@@ -6606,7 +6759,7 @@ ${input.slice(result.pos)}
|
|
|
6606
6759
|
function AmpersandBlockRHS(ctx, state) {
|
|
6607
6760
|
return $EVENT(ctx, state, "AmpersandBlockRHS", AmpersandBlockRHS$0);
|
|
6608
6761
|
}
|
|
6609
|
-
var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S($N($EXPECT($
|
|
6762
|
+
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) {
|
|
6610
6763
|
var callExpRest = $1;
|
|
6611
6764
|
var unaryPostfix = $2;
|
|
6612
6765
|
var binopRHS = $3;
|
|
@@ -6636,7 +6789,7 @@ ${input.slice(result.pos)}
|
|
|
6636
6789
|
function AmpersandBlockRHSBody(ctx, state) {
|
|
6637
6790
|
return $EVENT(ctx, state, "AmpersandBlockRHSBody", AmpersandBlockRHSBody$0);
|
|
6638
6791
|
}
|
|
6639
|
-
var AmpersandUnaryPrefix$0 = $R$0($EXPECT($
|
|
6792
|
+
var AmpersandUnaryPrefix$0 = $R$0($EXPECT($R9, "AmpersandUnaryPrefix /[!~+-]+/"));
|
|
6640
6793
|
function AmpersandUnaryPrefix(ctx, state) {
|
|
6641
6794
|
return $EVENT(ctx, state, "AmpersandUnaryPrefix", AmpersandUnaryPrefix$0);
|
|
6642
6795
|
}
|
|
@@ -6970,7 +7123,7 @@ ${input.slice(result.pos)}
|
|
|
6970
7123
|
function BlockStatementPart(ctx, state) {
|
|
6971
7124
|
return $EVENT(ctx, state, "BlockStatementPart", BlockStatementPart$0);
|
|
6972
7125
|
}
|
|
6973
|
-
var Literal$0 = $TS($S($EXPECT($
|
|
7126
|
+
var Literal$0 = $TS($S($EXPECT($R10, `Literal /(?=[0-9.'"tfyno])/`), LiteralContent), function($skip, $loc, $0, $1, $2) {
|
|
6974
7127
|
var literal = $2;
|
|
6975
7128
|
return {
|
|
6976
7129
|
type: "Literal",
|
|
@@ -6996,7 +7149,7 @@ ${input.slice(result.pos)}
|
|
|
6996
7149
|
function NullLiteral(ctx, state) {
|
|
6997
7150
|
return $EVENT(ctx, state, "NullLiteral", NullLiteral$0);
|
|
6998
7151
|
}
|
|
6999
|
-
var BooleanLiteral$0 = $T($S($EXPECT($
|
|
7152
|
+
var BooleanLiteral$0 = $T($S($EXPECT($R11, "BooleanLiteral /(?=true|false|yes|no|on|off)/"), _BooleanLiteral), function(value) {
|
|
7000
7153
|
return value[1];
|
|
7001
7154
|
});
|
|
7002
7155
|
function BooleanLiteral(ctx, state) {
|
|
@@ -7022,14 +7175,14 @@ ${input.slice(result.pos)}
|
|
|
7022
7175
|
function CoffeeScriptBooleanLiteral(ctx, state) {
|
|
7023
7176
|
return $EVENT_C(ctx, state, "CoffeeScriptBooleanLiteral", CoffeeScriptBooleanLiteral$$);
|
|
7024
7177
|
}
|
|
7025
|
-
var Identifier$0 = $T($S($EXPECT($
|
|
7178
|
+
var Identifier$0 = $T($S($EXPECT($R12, "Identifier /(?=\\p{ID_Start}|[_$])/"), $N(ReservedWord), IdentifierName), function(value) {
|
|
7026
7179
|
var id = value[2];
|
|
7027
7180
|
return id;
|
|
7028
7181
|
});
|
|
7029
7182
|
function Identifier(ctx, state) {
|
|
7030
7183
|
return $EVENT(ctx, state, "Identifier", Identifier$0);
|
|
7031
7184
|
}
|
|
7032
|
-
var IdentifierName$0 = $TR($EXPECT($
|
|
7185
|
+
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) {
|
|
7033
7186
|
return {
|
|
7034
7187
|
type: "Identifier",
|
|
7035
7188
|
name: $0,
|
|
@@ -7051,7 +7204,7 @@ ${input.slice(result.pos)}
|
|
|
7051
7204
|
function UpcomingAssignment(ctx, state) {
|
|
7052
7205
|
return $EVENT(ctx, state, "UpcomingAssignment", UpcomingAssignment$0);
|
|
7053
7206
|
}
|
|
7054
|
-
var ArrayLiteral$0 = $T($S($EXPECT($
|
|
7207
|
+
var ArrayLiteral$0 = $T($S($EXPECT($R14, "ArrayLiteral /(?=\\[)/"), _ArrayLiteral), function(value) {
|
|
7055
7208
|
return value[1];
|
|
7056
7209
|
});
|
|
7057
7210
|
function ArrayLiteral(ctx, state) {
|
|
@@ -7451,7 +7604,7 @@ ${input.slice(result.pos)}
|
|
|
7451
7604
|
children: [ws, ...prop.children]
|
|
7452
7605
|
};
|
|
7453
7606
|
});
|
|
7454
|
-
var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($
|
|
7607
|
+
var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($R15, "PropertyDefinition /[!+-]/")), PropertyName), function($skip, $loc, $0, $1, $2, $3) {
|
|
7455
7608
|
var ws = $1;
|
|
7456
7609
|
var toggle = $2;
|
|
7457
7610
|
var id = $3;
|
|
@@ -7974,12 +8127,19 @@ ${input.slice(result.pos)}
|
|
|
7974
8127
|
function IdentifierBinaryOp(ctx, state) {
|
|
7975
8128
|
return $EVENT(ctx, state, "IdentifierBinaryOp", IdentifierBinaryOp$0);
|
|
7976
8129
|
}
|
|
7977
|
-
var BinaryOp$0 = $
|
|
8130
|
+
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) {
|
|
8131
|
+
var op = value[1];
|
|
8132
|
+
return op;
|
|
8133
|
+
});
|
|
8134
|
+
function BinaryOp(ctx, state) {
|
|
8135
|
+
return $EVENT(ctx, state, "BinaryOp", BinaryOp$0);
|
|
8136
|
+
}
|
|
8137
|
+
var _BinaryOp$0 = $TS($S(BinaryOpSymbol), function($skip, $loc, $0, $1) {
|
|
7978
8138
|
if (typeof $1 === "string")
|
|
7979
8139
|
return { $loc, token: $1 };
|
|
7980
8140
|
return $1;
|
|
7981
8141
|
});
|
|
7982
|
-
var
|
|
8142
|
+
var _BinaryOp$1 = $TV(Identifier, function($skip, $loc, $0, $1) {
|
|
7983
8143
|
var id = $0;
|
|
7984
8144
|
if (!module.operators.has(id.name))
|
|
7985
8145
|
return $skip;
|
|
@@ -7988,7 +8148,7 @@ ${input.slice(result.pos)}
|
|
|
7988
8148
|
special: true
|
|
7989
8149
|
};
|
|
7990
8150
|
});
|
|
7991
|
-
var
|
|
8151
|
+
var _BinaryOp$2 = $TS($S(Not, __, Identifier), function($skip, $loc, $0, $1, $2, $3) {
|
|
7992
8152
|
var id = $3;
|
|
7993
8153
|
if (!module.operators.has(id.name))
|
|
7994
8154
|
return $skip;
|
|
@@ -7998,9 +8158,9 @@ ${input.slice(result.pos)}
|
|
|
7998
8158
|
negated: true
|
|
7999
8159
|
};
|
|
8000
8160
|
});
|
|
8001
|
-
var
|
|
8002
|
-
function
|
|
8003
|
-
return $EVENT_C(ctx, state, "
|
|
8161
|
+
var _BinaryOp$$ = [_BinaryOp$0, _BinaryOp$1, _BinaryOp$2];
|
|
8162
|
+
function _BinaryOp(ctx, state) {
|
|
8163
|
+
return $EVENT_C(ctx, state, "_BinaryOp", _BinaryOp$$);
|
|
8004
8164
|
}
|
|
8005
8165
|
var BinaryOpSymbol$0 = $EXPECT($L53, 'BinaryOpSymbol "**"');
|
|
8006
8166
|
var BinaryOpSymbol$1 = $EXPECT($L54, 'BinaryOpSymbol "*"');
|
|
@@ -8043,7 +8203,7 @@ ${input.slice(result.pos)}
|
|
|
8043
8203
|
var BinaryOpSymbol$14 = $T($EXPECT($L66, 'BinaryOpSymbol "\xAB"'), function(value) {
|
|
8044
8204
|
return "<<";
|
|
8045
8205
|
});
|
|
8046
|
-
var BinaryOpSymbol$15 = $TR($EXPECT($
|
|
8206
|
+
var BinaryOpSymbol$15 = $TR($EXPECT($R17, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8047
8207
|
return "<";
|
|
8048
8208
|
});
|
|
8049
8209
|
var BinaryOpSymbol$16 = $EXPECT($L67, 'BinaryOpSymbol ">>>"');
|
|
@@ -8095,7 +8255,7 @@ ${input.slice(result.pos)}
|
|
|
8095
8255
|
special: true
|
|
8096
8256
|
};
|
|
8097
8257
|
});
|
|
8098
|
-
var BinaryOpSymbol$34 = $TV($C($EXPECT($
|
|
8258
|
+
var BinaryOpSymbol$34 = $TV($C($EXPECT($R18, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L89, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8099
8259
|
return {
|
|
8100
8260
|
call: module.getRef("xnor"),
|
|
8101
8261
|
special: true
|
|
@@ -8248,13 +8408,13 @@ ${input.slice(result.pos)}
|
|
|
8248
8408
|
function Xor(ctx, state) {
|
|
8249
8409
|
return $EVENT_C(ctx, state, "Xor", Xor$$);
|
|
8250
8410
|
}
|
|
8251
|
-
var Xnor$0 = $R$0($EXPECT($
|
|
8411
|
+
var Xnor$0 = $R$0($EXPECT($R18, "Xnor /!\\^\\^?/"));
|
|
8252
8412
|
var Xnor$1 = $EXPECT($L89, 'Xnor "xnor"');
|
|
8253
8413
|
var Xnor$$ = [Xnor$0, Xnor$1];
|
|
8254
8414
|
function Xnor(ctx, state) {
|
|
8255
8415
|
return $EVENT_C(ctx, state, "Xnor", Xnor$$);
|
|
8256
8416
|
}
|
|
8257
|
-
var UnaryOp$0 = $TR($EXPECT($
|
|
8417
|
+
var UnaryOp$0 = $TR($EXPECT($R19, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8258
8418
|
return { $loc, token: $0 };
|
|
8259
8419
|
});
|
|
8260
8420
|
var UnaryOp$1 = AwaitOp;
|
|
@@ -8325,7 +8485,7 @@ ${input.slice(result.pos)}
|
|
|
8325
8485
|
function NonPipelinePostfixedExpression(ctx, state) {
|
|
8326
8486
|
return $EVENT(ctx, state, "NonPipelinePostfixedExpression", NonPipelinePostfixedExpression$0);
|
|
8327
8487
|
}
|
|
8328
|
-
var PostfixStatement$0 = $T($S($EXPECT($
|
|
8488
|
+
var PostfixStatement$0 = $T($S($EXPECT($R20, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
|
|
8329
8489
|
return value[1];
|
|
8330
8490
|
});
|
|
8331
8491
|
function PostfixStatement(ctx, state) {
|
|
@@ -8554,7 +8714,7 @@ ${input.slice(result.pos)}
|
|
|
8554
8714
|
function BlockExpressionPart(ctx, state) {
|
|
8555
8715
|
return $EVENT(ctx, state, "BlockExpressionPart", BlockExpressionPart$0);
|
|
8556
8716
|
}
|
|
8557
|
-
var IterationStatement$0 = $T($S($EXPECT($
|
|
8717
|
+
var IterationStatement$0 = $T($S($EXPECT($R21, "IterationStatement /(?=loop|do|for|until|while)/"), _IterationStatement), function(value) {
|
|
8558
8718
|
return value[1];
|
|
8559
8719
|
});
|
|
8560
8720
|
function IterationStatement(ctx, state) {
|
|
@@ -8686,8 +8846,9 @@ ${input.slice(result.pos)}
|
|
|
8686
8846
|
return value[1];
|
|
8687
8847
|
});
|
|
8688
8848
|
var ForStatementControl$1 = $TS($S(CoffeeForLoopsEnabled, CoffeeForStatementParameters, $E(WhenCondition)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8689
|
-
|
|
8690
|
-
|
|
8849
|
+
var condition = $3;
|
|
8850
|
+
if (condition) {
|
|
8851
|
+
const block = "continue";
|
|
8691
8852
|
$2 = {
|
|
8692
8853
|
...$2,
|
|
8693
8854
|
blockPrefix: [
|
|
@@ -8695,8 +8856,8 @@ ${input.slice(result.pos)}
|
|
|
8695
8856
|
["", {
|
|
8696
8857
|
type: "IfStatement",
|
|
8697
8858
|
then: block,
|
|
8698
|
-
children: ["if (!(", insertTrimmingSpace(
|
|
8699
|
-
}]
|
|
8859
|
+
children: ["if (!(", insertTrimmingSpace(condition, ""), ")) ", block]
|
|
8860
|
+
}, ";"]
|
|
8700
8861
|
]
|
|
8701
8862
|
};
|
|
8702
8863
|
}
|
|
@@ -8735,7 +8896,7 @@ ${input.slice(result.pos)}
|
|
|
8735
8896
|
}
|
|
8736
8897
|
if (declaration.own) {
|
|
8737
8898
|
const hasPropRef = module.getRef("hasProp");
|
|
8738
|
-
blockPrefix.push(["", "if (!", hasPropRef, "(", exp, ", ", declaration, ")) continue", ";"]);
|
|
8899
|
+
blockPrefix.push(["", ["if (!", hasPropRef, "(", exp, ", ", declaration, ")) continue"], ";"]);
|
|
8739
8900
|
}
|
|
8740
8901
|
if (index) {
|
|
8741
8902
|
blockPrefix.push(["", {
|
|
@@ -8906,7 +9067,7 @@ ${input.slice(result.pos)}
|
|
|
8906
9067
|
names: binding.names
|
|
8907
9068
|
};
|
|
8908
9069
|
});
|
|
8909
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
9070
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R22, "ForDeclaration /(?=[\\s\\),])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
8910
9071
|
var c = $1;
|
|
8911
9072
|
var binding = $2;
|
|
8912
9073
|
return {
|
|
@@ -9682,7 +9843,7 @@ ${input.slice(result.pos)}
|
|
|
9682
9843
|
function UnprocessedModuleSpecifier(ctx, state) {
|
|
9683
9844
|
return $EVENT_C(ctx, state, "UnprocessedModuleSpecifier", UnprocessedModuleSpecifier$$);
|
|
9684
9845
|
}
|
|
9685
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
9846
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R23, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
9686
9847
|
var spec = $0;
|
|
9687
9848
|
return { $loc, token: `"${spec}"` };
|
|
9688
9849
|
});
|
|
@@ -9888,7 +10049,7 @@ ${input.slice(result.pos)}
|
|
|
9888
10049
|
function VariableDeclarationList(ctx, state) {
|
|
9889
10050
|
return $EVENT(ctx, state, "VariableDeclarationList", VariableDeclarationList$0);
|
|
9890
10051
|
}
|
|
9891
|
-
var NumericLiteral$0 = $TS($S($EXPECT($
|
|
10052
|
+
var NumericLiteral$0 = $TS($S($EXPECT($R24, "NumericLiteral /(?=[0-9.])/"), NumericLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
9892
10053
|
var token = $2;
|
|
9893
10054
|
return { type: "NumericLiteral", $loc, token };
|
|
9894
10055
|
});
|
|
@@ -9904,36 +10065,36 @@ ${input.slice(result.pos)}
|
|
|
9904
10065
|
function NumericLiteralKind(ctx, state) {
|
|
9905
10066
|
return $EVENT_C(ctx, state, "NumericLiteralKind", NumericLiteralKind$$);
|
|
9906
10067
|
}
|
|
9907
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
10068
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R25, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
9908
10069
|
function DecimalBigIntegerLiteral(ctx, state) {
|
|
9909
10070
|
return $EVENT(ctx, state, "DecimalBigIntegerLiteral", DecimalBigIntegerLiteral$0);
|
|
9910
10071
|
}
|
|
9911
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
10072
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R26, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
9912
10073
|
return $1 + ".";
|
|
9913
10074
|
});
|
|
9914
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
9915
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
10075
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R27, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
10076
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R28, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
9916
10077
|
var DecimalLiteral$$ = [DecimalLiteral$0, DecimalLiteral$1, DecimalLiteral$2];
|
|
9917
10078
|
function DecimalLiteral(ctx, state) {
|
|
9918
10079
|
return $EVENT_C(ctx, state, "DecimalLiteral", DecimalLiteral$$);
|
|
9919
10080
|
}
|
|
9920
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
10081
|
+
var ExponentPart$0 = $R$0($EXPECT($R29, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
9921
10082
|
function ExponentPart(ctx, state) {
|
|
9922
10083
|
return $EVENT(ctx, state, "ExponentPart", ExponentPart$0);
|
|
9923
10084
|
}
|
|
9924
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
10085
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R30, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
9925
10086
|
function BinaryIntegerLiteral(ctx, state) {
|
|
9926
10087
|
return $EVENT(ctx, state, "BinaryIntegerLiteral", BinaryIntegerLiteral$0);
|
|
9927
10088
|
}
|
|
9928
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
10089
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R31, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
9929
10090
|
function OctalIntegerLiteral(ctx, state) {
|
|
9930
10091
|
return $EVENT(ctx, state, "OctalIntegerLiteral", OctalIntegerLiteral$0);
|
|
9931
10092
|
}
|
|
9932
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
10093
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R32, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
9933
10094
|
function HexIntegerLiteral(ctx, state) {
|
|
9934
10095
|
return $EVENT(ctx, state, "HexIntegerLiteral", HexIntegerLiteral$0);
|
|
9935
10096
|
}
|
|
9936
|
-
var IntegerLiteral$0 = $TS($S($EXPECT($
|
|
10097
|
+
var IntegerLiteral$0 = $TS($S($EXPECT($R33, "IntegerLiteral /(?=[0-9])/"), IntegerLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
9937
10098
|
var token = $2;
|
|
9938
10099
|
return { $loc, token };
|
|
9939
10100
|
});
|
|
@@ -9949,7 +10110,7 @@ ${input.slice(result.pos)}
|
|
|
9949
10110
|
function IntegerLiteralKind(ctx, state) {
|
|
9950
10111
|
return $EVENT_C(ctx, state, "IntegerLiteralKind", IntegerLiteralKind$$);
|
|
9951
10112
|
}
|
|
9952
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
10113
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R34, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
9953
10114
|
function DecimalIntegerLiteral(ctx, state) {
|
|
9954
10115
|
return $EVENT(ctx, state, "DecimalIntegerLiteral", DecimalIntegerLiteral$0);
|
|
9955
10116
|
}
|
|
@@ -9973,25 +10134,25 @@ ${input.slice(result.pos)}
|
|
|
9973
10134
|
function StringLiteral(ctx, state) {
|
|
9974
10135
|
return $EVENT_C(ctx, state, "StringLiteral", StringLiteral$$);
|
|
9975
10136
|
}
|
|
9976
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
10137
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R35, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9977
10138
|
return { $loc, token: $0 };
|
|
9978
10139
|
});
|
|
9979
10140
|
function DoubleStringCharacters(ctx, state) {
|
|
9980
10141
|
return $EVENT(ctx, state, "DoubleStringCharacters", DoubleStringCharacters$0);
|
|
9981
10142
|
}
|
|
9982
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
10143
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R36, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9983
10144
|
return { $loc, token: $0 };
|
|
9984
10145
|
});
|
|
9985
10146
|
function SingleStringCharacters(ctx, state) {
|
|
9986
10147
|
return $EVENT(ctx, state, "SingleStringCharacters", SingleStringCharacters$0);
|
|
9987
10148
|
}
|
|
9988
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
10149
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R37, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9989
10150
|
return { $loc, token: $0 };
|
|
9990
10151
|
});
|
|
9991
10152
|
function TripleDoubleStringCharacters(ctx, state) {
|
|
9992
10153
|
return $EVENT(ctx, state, "TripleDoubleStringCharacters", TripleDoubleStringCharacters$0);
|
|
9993
10154
|
}
|
|
9994
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
10155
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R38, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9995
10156
|
return { $loc, token: $0 };
|
|
9996
10157
|
});
|
|
9997
10158
|
function TripleSingleStringCharacters(ctx, state) {
|
|
@@ -10010,7 +10171,7 @@ ${input.slice(result.pos)}
|
|
|
10010
10171
|
function CoffeeInterpolatedDoubleQuotedString(ctx, state) {
|
|
10011
10172
|
return $EVENT(ctx, state, "CoffeeInterpolatedDoubleQuotedString", CoffeeInterpolatedDoubleQuotedString$0);
|
|
10012
10173
|
}
|
|
10013
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
10174
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R39, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10014
10175
|
return { $loc, token: $0 };
|
|
10015
10176
|
});
|
|
10016
10177
|
function CoffeeDoubleQuotedStringCharacters(ctx, state) {
|
|
@@ -10030,7 +10191,7 @@ ${input.slice(result.pos)}
|
|
|
10030
10191
|
function RegularExpressionClass(ctx, state) {
|
|
10031
10192
|
return $EVENT(ctx, state, "RegularExpressionClass", RegularExpressionClass$0);
|
|
10032
10193
|
}
|
|
10033
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
10194
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R40, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10034
10195
|
return { $loc, token: $0 };
|
|
10035
10196
|
});
|
|
10036
10197
|
function RegularExpressionClassCharacters(ctx, state) {
|
|
@@ -10084,7 +10245,7 @@ ${input.slice(result.pos)}
|
|
|
10084
10245
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
10085
10246
|
return { "type": "Substitution", "children": value[0] };
|
|
10086
10247
|
});
|
|
10087
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
10248
|
+
var HeregexPart$3 = $TR($EXPECT($R41, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10088
10249
|
let token = $0;
|
|
10089
10250
|
switch ($0[1]) {
|
|
10090
10251
|
case "\n":
|
|
@@ -10102,13 +10263,13 @@ ${input.slice(result.pos)}
|
|
|
10102
10263
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
10103
10264
|
return { $loc, token: "" };
|
|
10104
10265
|
});
|
|
10105
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
10266
|
+
var HeregexPart$5 = $TR($EXPECT($R42, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10106
10267
|
return { $loc, token: "" };
|
|
10107
10268
|
});
|
|
10108
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
10269
|
+
var HeregexPart$6 = $TR($EXPECT($R43, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10109
10270
|
return { $loc, token: "\\/" };
|
|
10110
10271
|
});
|
|
10111
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
10272
|
+
var HeregexPart$7 = $TR($EXPECT($R44, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10112
10273
|
return { $loc, token: $0 };
|
|
10113
10274
|
});
|
|
10114
10275
|
var HeregexPart$$ = [HeregexPart$0, HeregexPart$1, HeregexPart$2, HeregexPart$3, HeregexPart$4, HeregexPart$5, HeregexPart$6, HeregexPart$7];
|
|
@@ -10121,7 +10282,7 @@ ${input.slice(result.pos)}
|
|
|
10121
10282
|
function HeregexComment(ctx, state) {
|
|
10122
10283
|
return $EVENT_C(ctx, state, "HeregexComment", HeregexComment$$);
|
|
10123
10284
|
}
|
|
10124
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
10285
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R45, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
10125
10286
|
function RegularExpressionBody(ctx, state) {
|
|
10126
10287
|
return $EVENT(ctx, state, "RegularExpressionBody", RegularExpressionBody$0);
|
|
10127
10288
|
}
|
|
@@ -10131,15 +10292,15 @@ ${input.slice(result.pos)}
|
|
|
10131
10292
|
function RegExpPart(ctx, state) {
|
|
10132
10293
|
return $EVENT_C(ctx, state, "RegExpPart", RegExpPart$$);
|
|
10133
10294
|
}
|
|
10134
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
10295
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R46, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
10135
10296
|
function RegExpCharacter(ctx, state) {
|
|
10136
10297
|
return $EVENT(ctx, state, "RegExpCharacter", RegExpCharacter$0);
|
|
10137
10298
|
}
|
|
10138
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
10299
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R47, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
10139
10300
|
function RegularExpressionFlags(ctx, state) {
|
|
10140
10301
|
return $EVENT(ctx, state, "RegularExpressionFlags", RegularExpressionFlags$0);
|
|
10141
10302
|
}
|
|
10142
|
-
var TemplateLiteral$0 = $T($S($EXPECT($
|
|
10303
|
+
var TemplateLiteral$0 = $T($S($EXPECT($R48, "TemplateLiteral /(?=[`'\"])/"), _TemplateLiteral), function(value) {
|
|
10143
10304
|
return value[1];
|
|
10144
10305
|
});
|
|
10145
10306
|
function TemplateLiteral(ctx, state) {
|
|
@@ -10175,28 +10336,28 @@ ${input.slice(result.pos)}
|
|
|
10175
10336
|
function TemplateSubstitution(ctx, state) {
|
|
10176
10337
|
return $EVENT(ctx, state, "TemplateSubstitution", TemplateSubstitution$0);
|
|
10177
10338
|
}
|
|
10178
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
10339
|
+
var TemplateCharacters$0 = $TR($EXPECT($R49, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10179
10340
|
return { $loc, token: $0 };
|
|
10180
10341
|
});
|
|
10181
10342
|
function TemplateCharacters(ctx, state) {
|
|
10182
10343
|
return $EVENT(ctx, state, "TemplateCharacters", TemplateCharacters$0);
|
|
10183
10344
|
}
|
|
10184
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
10345
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R50, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10185
10346
|
return { $loc, token: $0 };
|
|
10186
10347
|
});
|
|
10187
10348
|
function TemplateBlockCharacters(ctx, state) {
|
|
10188
10349
|
return $EVENT(ctx, state, "TemplateBlockCharacters", TemplateBlockCharacters$0);
|
|
10189
10350
|
}
|
|
10190
|
-
var ReservedWord$0 = $S($R$0($EXPECT($
|
|
10191
|
-
var ReservedWord$1 = $S($R$0($EXPECT($
|
|
10192
|
-
var ReservedWord$2 = $S($R$0($EXPECT($
|
|
10193
|
-
var ReservedWord$3 = $S($R$0($EXPECT($
|
|
10194
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
10351
|
+
var ReservedWord$0 = $S($R$0($EXPECT($R51, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")), CoffeeBooleansEnabled);
|
|
10352
|
+
var ReservedWord$1 = $S($R$0($EXPECT($R52, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")), CoffeeIsntEnabled);
|
|
10353
|
+
var ReservedWord$2 = $S($R$0($EXPECT($R53, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")), CoffeeForLoopsEnabled);
|
|
10354
|
+
var ReservedWord$3 = $S($R$0($EXPECT($R54, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")), CoffeeOfEnabled);
|
|
10355
|
+
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})/"));
|
|
10195
10356
|
var ReservedWord$$ = [ReservedWord$0, ReservedWord$1, ReservedWord$2, ReservedWord$3, ReservedWord$4];
|
|
10196
10357
|
function ReservedWord(ctx, state) {
|
|
10197
10358
|
return $EVENT_C(ctx, state, "ReservedWord", ReservedWord$$);
|
|
10198
10359
|
}
|
|
10199
|
-
var Comment$0 = $T($S($EXPECT($
|
|
10360
|
+
var Comment$0 = $T($S($EXPECT($R56, "Comment /(?=\\/|#)/"), _Comment), function(value) {
|
|
10200
10361
|
return value[1];
|
|
10201
10362
|
});
|
|
10202
10363
|
function Comment(ctx, state) {
|
|
@@ -10214,7 +10375,7 @@ ${input.slice(result.pos)}
|
|
|
10214
10375
|
function SingleLineComment(ctx, state) {
|
|
10215
10376
|
return $EVENT_C(ctx, state, "SingleLineComment", SingleLineComment$$);
|
|
10216
10377
|
}
|
|
10217
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
10378
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R57, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10218
10379
|
return { type: "Comment", $loc, token: $0 };
|
|
10219
10380
|
});
|
|
10220
10381
|
function JSSingleLineComment(ctx, state) {
|
|
@@ -10226,30 +10387,30 @@ ${input.slice(result.pos)}
|
|
|
10226
10387
|
function MultiLineComment(ctx, state) {
|
|
10227
10388
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
10228
10389
|
}
|
|
10229
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L108, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L109, 'JSMultiLineComment "*/"')), $EXPECT($
|
|
10390
|
+
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) {
|
|
10230
10391
|
return { type: "Comment", $loc, token: $1 };
|
|
10231
10392
|
});
|
|
10232
10393
|
function JSMultiLineComment(ctx, state) {
|
|
10233
10394
|
return $EVENT(ctx, state, "JSMultiLineComment", JSMultiLineComment$0);
|
|
10234
10395
|
}
|
|
10235
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
10396
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R59, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10236
10397
|
return { type: "Comment", $loc, token: `//${$1}` };
|
|
10237
10398
|
});
|
|
10238
10399
|
function CoffeeSingleLineComment(ctx, state) {
|
|
10239
10400
|
return $EVENT(ctx, state, "CoffeeSingleLineComment", CoffeeSingleLineComment$0);
|
|
10240
10401
|
}
|
|
10241
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
10402
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R60, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
10242
10403
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
10243
10404
|
return { type: "Comment", $loc, token: `/*${$2}*/` };
|
|
10244
10405
|
});
|
|
10245
10406
|
function CoffeeMultiLineComment(ctx, state) {
|
|
10246
10407
|
return $EVENT(ctx, state, "CoffeeMultiLineComment", CoffeeMultiLineComment$0);
|
|
10247
10408
|
}
|
|
10248
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
10409
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R61, "CoffeeHereCommentStart /###(?!#)/"));
|
|
10249
10410
|
function CoffeeHereCommentStart(ctx, state) {
|
|
10250
10411
|
return $EVENT(ctx, state, "CoffeeHereCommentStart", CoffeeHereCommentStart$0);
|
|
10251
10412
|
}
|
|
10252
|
-
var InlineComment$0 = $TR($EXPECT($
|
|
10413
|
+
var InlineComment$0 = $TR($EXPECT($R62, "InlineComment /\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\//"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10253
10414
|
return { $loc, token: $0 };
|
|
10254
10415
|
});
|
|
10255
10416
|
function InlineComment(ctx, state) {
|
|
@@ -10263,30 +10424,30 @@ ${input.slice(result.pos)}
|
|
|
10263
10424
|
function TrailingComment(ctx, state) {
|
|
10264
10425
|
return $EVENT(ctx, state, "TrailingComment", TrailingComment$0);
|
|
10265
10426
|
}
|
|
10266
|
-
var _$0 = $T($S($EXPECT($
|
|
10427
|
+
var _$0 = $T($S($EXPECT($R63, "_ /(?=[ \\t\\/\\\\])/"), $P($C(NonNewlineWhitespace, InlineComment))), function(value) {
|
|
10267
10428
|
return value[1];
|
|
10268
10429
|
});
|
|
10269
10430
|
function _(ctx, state) {
|
|
10270
10431
|
return $EVENT(ctx, state, "_", _$0);
|
|
10271
10432
|
}
|
|
10272
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
10433
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R64, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10273
10434
|
return { $loc, token: $0 };
|
|
10274
10435
|
});
|
|
10275
|
-
var NonNewlineWhitespace$1 = $T($S(
|
|
10436
|
+
var NonNewlineWhitespace$1 = $T($S($EXPECT($L110, 'NonNewlineWhitespace "\\\\\\\\"'), CoffeeLineContinuationEnabled, EOL), function(value) {
|
|
10276
10437
|
return " ";
|
|
10277
10438
|
});
|
|
10278
10439
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
10279
10440
|
function NonNewlineWhitespace(ctx, state) {
|
|
10280
10441
|
return $EVENT_C(ctx, state, "NonNewlineWhitespace", NonNewlineWhitespace$$);
|
|
10281
10442
|
}
|
|
10282
|
-
var Trimmed_$0 = $TV($
|
|
10443
|
+
var Trimmed_$0 = $TV($E(_), function($skip, $loc, $0, $1) {
|
|
10283
10444
|
var ws = $0;
|
|
10284
10445
|
return insertTrimmingSpace(ws, "");
|
|
10285
10446
|
});
|
|
10286
10447
|
function Trimmed_(ctx, state) {
|
|
10287
10448
|
return $EVENT(ctx, state, "Trimmed_", Trimmed_$0);
|
|
10288
10449
|
}
|
|
10289
|
-
var __$0 = $T($S($EXPECT($
|
|
10450
|
+
var __$0 = $T($S($EXPECT($R65, "__ /(?=\\s|\\/|#)/"), $Q($C(Whitespace, Comment))), function(value) {
|
|
10290
10451
|
return value[1];
|
|
10291
10452
|
});
|
|
10292
10453
|
var __$1 = $EXPECT($L0, '__ ""');
|
|
@@ -10294,7 +10455,7 @@ ${input.slice(result.pos)}
|
|
|
10294
10455
|
function __(ctx, state) {
|
|
10295
10456
|
return $EVENT_C(ctx, state, "__", __$$);
|
|
10296
10457
|
}
|
|
10297
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
10458
|
+
var Whitespace$0 = $TR($EXPECT($R42, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10298
10459
|
return { $loc, token: $0 };
|
|
10299
10460
|
});
|
|
10300
10461
|
function Whitespace(ctx, state) {
|
|
@@ -10310,17 +10471,16 @@ ${input.slice(result.pos)}
|
|
|
10310
10471
|
function ExpressionDelimiter(ctx, state) {
|
|
10311
10472
|
return $EVENT_C(ctx, state, "ExpressionDelimiter", ExpressionDelimiter$$);
|
|
10312
10473
|
}
|
|
10313
|
-
var SimpleStatementDelimiter$0 =
|
|
10314
|
-
var SimpleStatementDelimiter$1 =
|
|
10474
|
+
var SimpleStatementDelimiter$0 = $Y(EOS);
|
|
10475
|
+
var SimpleStatementDelimiter$1 = SemicolonDelimiter;
|
|
10315
10476
|
var SimpleStatementDelimiter$$ = [SimpleStatementDelimiter$0, SimpleStatementDelimiter$1];
|
|
10316
10477
|
function SimpleStatementDelimiter(ctx, state) {
|
|
10317
10478
|
return $EVENT_C(ctx, state, "SimpleStatementDelimiter", SimpleStatementDelimiter$$);
|
|
10318
10479
|
}
|
|
10319
|
-
var StatementDelimiter$0 =
|
|
10320
|
-
var StatementDelimiter$1 =
|
|
10321
|
-
var StatementDelimiter$2 = $Y(
|
|
10322
|
-
var StatementDelimiter
|
|
10323
|
-
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2, StatementDelimiter$3];
|
|
10480
|
+
var StatementDelimiter$0 = $Y(EOS);
|
|
10481
|
+
var StatementDelimiter$1 = SemicolonDelimiter;
|
|
10482
|
+
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L25, 'StatementDelimiter "}"'), $EXPECT($L111, 'StatementDelimiter ")"'), $EXPECT($L34, 'StatementDelimiter "]"'))));
|
|
10483
|
+
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2];
|
|
10324
10484
|
function StatementDelimiter(ctx, state) {
|
|
10325
10485
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
10326
10486
|
}
|
|
@@ -10333,7 +10493,7 @@ ${input.slice(result.pos)}
|
|
|
10333
10493
|
function SemicolonDelimiter(ctx, state) {
|
|
10334
10494
|
return $EVENT(ctx, state, "SemicolonDelimiter", SemicolonDelimiter$0);
|
|
10335
10495
|
}
|
|
10336
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
10496
|
+
var NonIdContinue$0 = $R$0($EXPECT($R66, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
10337
10497
|
function NonIdContinue(ctx, state) {
|
|
10338
10498
|
return $EVENT(ctx, state, "NonIdContinue", NonIdContinue$0);
|
|
10339
10499
|
}
|
|
@@ -10343,7 +10503,7 @@ ${input.slice(result.pos)}
|
|
|
10343
10503
|
function Loc(ctx, state) {
|
|
10344
10504
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
10345
10505
|
}
|
|
10346
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
10506
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L112, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L12, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
10347
10507
|
return { $loc, token: $1, ts: true };
|
|
10348
10508
|
});
|
|
10349
10509
|
function Abstract(ctx, state) {
|
|
@@ -10355,61 +10515,61 @@ ${input.slice(result.pos)}
|
|
|
10355
10515
|
function Ampersand(ctx, state) {
|
|
10356
10516
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
10357
10517
|
}
|
|
10358
|
-
var As$0 = $TS($S($EXPECT($
|
|
10518
|
+
var As$0 = $TS($S($EXPECT($L113, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10359
10519
|
return { $loc, token: $1 };
|
|
10360
10520
|
});
|
|
10361
10521
|
function As(ctx, state) {
|
|
10362
10522
|
return $EVENT(ctx, state, "As", As$0);
|
|
10363
10523
|
}
|
|
10364
|
-
var At$0 = $TV($EXPECT($
|
|
10524
|
+
var At$0 = $TV($EXPECT($L114, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
10365
10525
|
return { $loc, token: $1 };
|
|
10366
10526
|
});
|
|
10367
10527
|
function At(ctx, state) {
|
|
10368
10528
|
return $EVENT(ctx, state, "At", At$0);
|
|
10369
10529
|
}
|
|
10370
|
-
var AtAt$0 = $TV($EXPECT($
|
|
10530
|
+
var AtAt$0 = $TV($EXPECT($L115, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
10371
10531
|
return { $loc, token: "@" };
|
|
10372
10532
|
});
|
|
10373
10533
|
function AtAt(ctx, state) {
|
|
10374
10534
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
10375
10535
|
}
|
|
10376
|
-
var Async$0 = $TS($S($EXPECT($
|
|
10536
|
+
var Async$0 = $TS($S($EXPECT($L116, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10377
10537
|
return { $loc, token: $1, type: "Async" };
|
|
10378
10538
|
});
|
|
10379
10539
|
function Async(ctx, state) {
|
|
10380
10540
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
10381
10541
|
}
|
|
10382
|
-
var Await$0 = $TS($S($EXPECT($
|
|
10542
|
+
var Await$0 = $TS($S($EXPECT($L117, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10383
10543
|
return { $loc, token: $1, type: "Await" };
|
|
10384
10544
|
});
|
|
10385
10545
|
function Await(ctx, state) {
|
|
10386
10546
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
10387
10547
|
}
|
|
10388
|
-
var Backtick$0 = $TV($EXPECT($
|
|
10548
|
+
var Backtick$0 = $TV($EXPECT($L118, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
10389
10549
|
return { $loc, token: $1 };
|
|
10390
10550
|
});
|
|
10391
10551
|
function Backtick(ctx, state) {
|
|
10392
10552
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
10393
10553
|
}
|
|
10394
|
-
var By$0 = $TS($S($EXPECT($
|
|
10554
|
+
var By$0 = $TS($S($EXPECT($L119, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10395
10555
|
return { $loc, token: $1 };
|
|
10396
10556
|
});
|
|
10397
10557
|
function By(ctx, state) {
|
|
10398
10558
|
return $EVENT(ctx, state, "By", By$0);
|
|
10399
10559
|
}
|
|
10400
|
-
var Case$0 = $TS($S($EXPECT($
|
|
10560
|
+
var Case$0 = $TS($S($EXPECT($L120, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10401
10561
|
return { $loc, token: $1 };
|
|
10402
10562
|
});
|
|
10403
10563
|
function Case(ctx, state) {
|
|
10404
10564
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
10405
10565
|
}
|
|
10406
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
10566
|
+
var Catch$0 = $TS($S($EXPECT($L121, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10407
10567
|
return { $loc, token: $1 };
|
|
10408
10568
|
});
|
|
10409
10569
|
function Catch(ctx, state) {
|
|
10410
10570
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
10411
10571
|
}
|
|
10412
|
-
var Class$0 = $TS($S($EXPECT($
|
|
10572
|
+
var Class$0 = $TS($S($EXPECT($L122, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10413
10573
|
return { $loc, token: $1 };
|
|
10414
10574
|
});
|
|
10415
10575
|
function Class(ctx, state) {
|
|
@@ -10427,13 +10587,13 @@ ${input.slice(result.pos)}
|
|
|
10427
10587
|
function CloseBracket(ctx, state) {
|
|
10428
10588
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
10429
10589
|
}
|
|
10430
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
10590
|
+
var CloseParen$0 = $TV($EXPECT($L111, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
10431
10591
|
return { $loc, token: $1 };
|
|
10432
10592
|
});
|
|
10433
10593
|
function CloseParen(ctx, state) {
|
|
10434
10594
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
10435
10595
|
}
|
|
10436
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
10596
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L123, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
10437
10597
|
return { $loc, token: "${" };
|
|
10438
10598
|
});
|
|
10439
10599
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
@@ -10451,31 +10611,31 @@ ${input.slice(result.pos)}
|
|
|
10451
10611
|
function Comma(ctx, state) {
|
|
10452
10612
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
10453
10613
|
}
|
|
10454
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
10614
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L114, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
10455
10615
|
return { $loc, token: "constructor" };
|
|
10456
10616
|
});
|
|
10457
10617
|
function ConstructorShorthand(ctx, state) {
|
|
10458
10618
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
10459
10619
|
}
|
|
10460
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
10620
|
+
var Declare$0 = $TS($S($EXPECT($L124, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10461
10621
|
return { $loc, token: $1 };
|
|
10462
10622
|
});
|
|
10463
10623
|
function Declare(ctx, state) {
|
|
10464
10624
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
10465
10625
|
}
|
|
10466
|
-
var Default$0 = $TS($S($EXPECT($
|
|
10626
|
+
var Default$0 = $TS($S($EXPECT($L125, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10467
10627
|
return { $loc, token: $1 };
|
|
10468
10628
|
});
|
|
10469
10629
|
function Default(ctx, state) {
|
|
10470
10630
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
10471
10631
|
}
|
|
10472
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
10632
|
+
var Delete$0 = $TS($S($EXPECT($L126, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10473
10633
|
return { $loc, token: $1 };
|
|
10474
10634
|
});
|
|
10475
10635
|
function Delete(ctx, state) {
|
|
10476
10636
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
10477
10637
|
}
|
|
10478
|
-
var Do$0 = $TS($S($EXPECT($
|
|
10638
|
+
var Do$0 = $TS($S($EXPECT($L127, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10479
10639
|
return { $loc, token: $1 };
|
|
10480
10640
|
});
|
|
10481
10641
|
function Do(ctx, state) {
|
|
@@ -10484,7 +10644,7 @@ ${input.slice(result.pos)}
|
|
|
10484
10644
|
var Dot$0 = $TV($EXPECT($L6, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
10485
10645
|
return { $loc, token: $1 };
|
|
10486
10646
|
});
|
|
10487
|
-
var Dot$1 = $TS($S($EXPECT($
|
|
10647
|
+
var Dot$1 = $TS($S($EXPECT($R67, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
|
|
10488
10648
|
var ws = $2;
|
|
10489
10649
|
return [
|
|
10490
10650
|
{ $loc, token: "." },
|
|
@@ -10495,45 +10655,45 @@ ${input.slice(result.pos)}
|
|
|
10495
10655
|
function Dot(ctx, state) {
|
|
10496
10656
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
10497
10657
|
}
|
|
10498
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
10658
|
+
var DotDot$0 = $TS($S($EXPECT($L128, 'DotDot ".."'), $N($EXPECT($L6, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
10499
10659
|
return { $loc, token: $1 };
|
|
10500
10660
|
});
|
|
10501
|
-
var DotDot$1 = $TV($EXPECT($
|
|
10661
|
+
var DotDot$1 = $TV($EXPECT($L129, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
10502
10662
|
return { $loc, token: ".." };
|
|
10503
10663
|
});
|
|
10504
10664
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
10505
10665
|
function DotDot(ctx, state) {
|
|
10506
10666
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
10507
10667
|
}
|
|
10508
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
10668
|
+
var DotDotDot$0 = $TV($EXPECT($L130, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
10509
10669
|
return { $loc, token: $1 };
|
|
10510
10670
|
});
|
|
10511
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
10671
|
+
var DotDotDot$1 = $TV($EXPECT($L131, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
10512
10672
|
return { $loc, token: "..." };
|
|
10513
10673
|
});
|
|
10514
10674
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
10515
10675
|
function DotDotDot(ctx, state) {
|
|
10516
10676
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
10517
10677
|
}
|
|
10518
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
10678
|
+
var DoubleColon$0 = $TV($EXPECT($L132, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
10519
10679
|
return { $loc, token: $1 };
|
|
10520
10680
|
});
|
|
10521
10681
|
function DoubleColon(ctx, state) {
|
|
10522
10682
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
10523
10683
|
}
|
|
10524
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
10684
|
+
var DoubleQuote$0 = $TV($EXPECT($L133, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
10525
10685
|
return { $loc, token: $1 };
|
|
10526
10686
|
});
|
|
10527
10687
|
function DoubleQuote(ctx, state) {
|
|
10528
10688
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
10529
10689
|
}
|
|
10530
|
-
var Each$0 = $TS($S($EXPECT($
|
|
10690
|
+
var Each$0 = $TS($S($EXPECT($L134, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10531
10691
|
return { $loc, token: $1 };
|
|
10532
10692
|
});
|
|
10533
10693
|
function Each(ctx, state) {
|
|
10534
10694
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
10535
10695
|
}
|
|
10536
|
-
var Else$0 = $TS($S($EXPECT($
|
|
10696
|
+
var Else$0 = $TS($S($EXPECT($L135, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10537
10697
|
return { $loc, token: $1 };
|
|
10538
10698
|
});
|
|
10539
10699
|
function Else(ctx, state) {
|
|
@@ -10545,85 +10705,85 @@ ${input.slice(result.pos)}
|
|
|
10545
10705
|
function Equals(ctx, state) {
|
|
10546
10706
|
return $EVENT(ctx, state, "Equals", Equals$0);
|
|
10547
10707
|
}
|
|
10548
|
-
var Export$0 = $TS($S($EXPECT($
|
|
10708
|
+
var Export$0 = $TS($S($EXPECT($L136, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10549
10709
|
return { $loc, token: $1 };
|
|
10550
10710
|
});
|
|
10551
10711
|
function Export(ctx, state) {
|
|
10552
10712
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
10553
10713
|
}
|
|
10554
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
10714
|
+
var Extends$0 = $TS($S($EXPECT($L137, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10555
10715
|
return { $loc, token: $1 };
|
|
10556
10716
|
});
|
|
10557
10717
|
function Extends(ctx, state) {
|
|
10558
10718
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
10559
10719
|
}
|
|
10560
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
10720
|
+
var Finally$0 = $TS($S($EXPECT($L138, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10561
10721
|
return { $loc, token: $1 };
|
|
10562
10722
|
});
|
|
10563
10723
|
function Finally(ctx, state) {
|
|
10564
10724
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
10565
10725
|
}
|
|
10566
|
-
var For$0 = $TS($S($EXPECT($
|
|
10726
|
+
var For$0 = $TS($S($EXPECT($L139, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10567
10727
|
return { $loc, token: $1 };
|
|
10568
10728
|
});
|
|
10569
10729
|
function For(ctx, state) {
|
|
10570
10730
|
return $EVENT(ctx, state, "For", For$0);
|
|
10571
10731
|
}
|
|
10572
|
-
var From$0 = $TS($S($EXPECT($
|
|
10732
|
+
var From$0 = $TS($S($EXPECT($L140, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10573
10733
|
return { $loc, token: $1 };
|
|
10574
10734
|
});
|
|
10575
10735
|
function From(ctx, state) {
|
|
10576
10736
|
return $EVENT(ctx, state, "From", From$0);
|
|
10577
10737
|
}
|
|
10578
|
-
var Function$0 = $TS($S($EXPECT($
|
|
10738
|
+
var Function$0 = $TS($S($EXPECT($L141, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10579
10739
|
return { $loc, token: $1 };
|
|
10580
10740
|
});
|
|
10581
10741
|
function Function(ctx, state) {
|
|
10582
10742
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
10583
10743
|
}
|
|
10584
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
10744
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L142, 'GetOrSet "get"'), $EXPECT($L143, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10585
10745
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
10586
10746
|
});
|
|
10587
10747
|
function GetOrSet(ctx, state) {
|
|
10588
10748
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
10589
10749
|
}
|
|
10590
|
-
var Hash$0 = $TV($EXPECT($
|
|
10750
|
+
var Hash$0 = $TV($EXPECT($L144, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
10591
10751
|
return { $loc, token: $1 };
|
|
10592
10752
|
});
|
|
10593
10753
|
function Hash(ctx, state) {
|
|
10594
10754
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
10595
10755
|
}
|
|
10596
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
10756
|
+
var If$0 = $TV($TEXT($S($EXPECT($L145, 'If "if"'), NonIdContinue, $E($EXPECT($L12, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
10597
10757
|
return { $loc, token: $1 };
|
|
10598
10758
|
});
|
|
10599
10759
|
function If(ctx, state) {
|
|
10600
10760
|
return $EVENT(ctx, state, "If", If$0);
|
|
10601
10761
|
}
|
|
10602
|
-
var Import$0 = $TS($S($EXPECT($L15, 'Import "import"'), $Y($EXPECT($
|
|
10762
|
+
var Import$0 = $TS($S($EXPECT($L15, 'Import "import"'), $Y($EXPECT($R68, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
10603
10763
|
return { $loc, token: $1 };
|
|
10604
10764
|
});
|
|
10605
10765
|
function Import(ctx, state) {
|
|
10606
10766
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
10607
10767
|
}
|
|
10608
|
-
var In$0 = $TS($S($EXPECT($
|
|
10768
|
+
var In$0 = $TS($S($EXPECT($L146, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10609
10769
|
return { $loc, token: $1 };
|
|
10610
10770
|
});
|
|
10611
10771
|
function In(ctx, state) {
|
|
10612
10772
|
return $EVENT(ctx, state, "In", In$0);
|
|
10613
10773
|
}
|
|
10614
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
10774
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L147, 'LetOrConst "let"'), $EXPECT($L148, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10615
10775
|
return { $loc, token: $1 };
|
|
10616
10776
|
});
|
|
10617
10777
|
function LetOrConst(ctx, state) {
|
|
10618
10778
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
10619
10779
|
}
|
|
10620
|
-
var Const$0 = $TS($S($EXPECT($
|
|
10780
|
+
var Const$0 = $TS($S($EXPECT($L148, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10621
10781
|
return { $loc, token: $1 };
|
|
10622
10782
|
});
|
|
10623
10783
|
function Const(ctx, state) {
|
|
10624
10784
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
10625
10785
|
}
|
|
10626
|
-
var Is$0 = $TS($S($EXPECT($
|
|
10786
|
+
var Is$0 = $TS($S($EXPECT($L149, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10627
10787
|
return { $loc, token: $1 };
|
|
10628
10788
|
});
|
|
10629
10789
|
function Is(ctx, state) {
|
|
@@ -10635,31 +10795,31 @@ ${input.slice(result.pos)}
|
|
|
10635
10795
|
function LetOrConstOrVar(ctx, state) {
|
|
10636
10796
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
10637
10797
|
}
|
|
10638
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
10798
|
+
var Loop$0 = $TS($S($EXPECT($L150, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10639
10799
|
return { $loc, token: "while(true)" };
|
|
10640
10800
|
});
|
|
10641
10801
|
function Loop(ctx, state) {
|
|
10642
10802
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
10643
10803
|
}
|
|
10644
|
-
var New$0 = $TS($S($EXPECT($
|
|
10804
|
+
var New$0 = $TS($S($EXPECT($L151, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10645
10805
|
return { $loc, token: $1 };
|
|
10646
10806
|
});
|
|
10647
10807
|
function New(ctx, state) {
|
|
10648
10808
|
return $EVENT(ctx, state, "New", New$0);
|
|
10649
10809
|
}
|
|
10650
|
-
var Not$0 = $TS($S($EXPECT($
|
|
10810
|
+
var Not$0 = $TS($S($EXPECT($L152, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L11, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
10651
10811
|
return { $loc, token: "!" };
|
|
10652
10812
|
});
|
|
10653
10813
|
function Not(ctx, state) {
|
|
10654
10814
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
10655
10815
|
}
|
|
10656
|
-
var Of$0 = $TS($S($EXPECT($
|
|
10816
|
+
var Of$0 = $TS($S($EXPECT($L153, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10657
10817
|
return { $loc, token: $1 };
|
|
10658
10818
|
});
|
|
10659
10819
|
function Of(ctx, state) {
|
|
10660
10820
|
return $EVENT(ctx, state, "Of", Of$0);
|
|
10661
10821
|
}
|
|
10662
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
10822
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L154, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
10663
10823
|
return { $loc, token: $1 };
|
|
10664
10824
|
});
|
|
10665
10825
|
function OpenAngleBracket(ctx, state) {
|
|
@@ -10671,7 +10831,7 @@ ${input.slice(result.pos)}
|
|
|
10671
10831
|
function OpenBrace(ctx, state) {
|
|
10672
10832
|
return $EVENT(ctx, state, "OpenBrace", OpenBrace$0);
|
|
10673
10833
|
}
|
|
10674
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
10834
|
+
var OpenBracket$0 = $TV($EXPECT($L155, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
10675
10835
|
return { $loc, token: $1 };
|
|
10676
10836
|
});
|
|
10677
10837
|
function OpenBracket(ctx, state) {
|
|
@@ -10771,7 +10931,7 @@ ${input.slice(result.pos)}
|
|
|
10771
10931
|
var Static$0 = $TS($S($EXPECT($L171, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10772
10932
|
return { $loc, token: $1 };
|
|
10773
10933
|
});
|
|
10774
|
-
var Static$1 = $TS($S($EXPECT($
|
|
10934
|
+
var Static$1 = $TS($S($EXPECT($L114, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L114, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
10775
10935
|
return { $loc, token: "static " };
|
|
10776
10936
|
});
|
|
10777
10937
|
var Static$$ = [Static$0, Static$1];
|
|
@@ -10927,12 +11087,18 @@ ${input.slice(result.pos)}
|
|
|
10927
11087
|
function JSXImplicitFragment(ctx, state) {
|
|
10928
11088
|
return $EVENT(ctx, state, "JSXImplicitFragment", JSXImplicitFragment$0);
|
|
10929
11089
|
}
|
|
10930
|
-
var JSXTag$0 =
|
|
10931
|
-
|
|
10932
|
-
|
|
10933
|
-
var JSXTag$$ = [JSXTag$0, JSXTag$1, JSXTag$2];
|
|
11090
|
+
var JSXTag$0 = $T($S($EXPECT($R69, "JSXTag /(?=[<])/"), _JSXTag), function(value) {
|
|
11091
|
+
return value[1];
|
|
11092
|
+
});
|
|
10934
11093
|
function JSXTag(ctx, state) {
|
|
10935
|
-
return $
|
|
11094
|
+
return $EVENT(ctx, state, "JSXTag", JSXTag$0);
|
|
11095
|
+
}
|
|
11096
|
+
var _JSXTag$0 = JSXElement;
|
|
11097
|
+
var _JSXTag$1 = JSXFragment;
|
|
11098
|
+
var _JSXTag$2 = JSXComment;
|
|
11099
|
+
var _JSXTag$$ = [_JSXTag$0, _JSXTag$1, _JSXTag$2];
|
|
11100
|
+
function _JSXTag(ctx, state) {
|
|
11101
|
+
return $EVENT_C(ctx, state, "_JSXTag", _JSXTag$$);
|
|
10936
11102
|
}
|
|
10937
11103
|
var JSXElement$0 = JSXSelfClosingElement;
|
|
10938
11104
|
var JSXElement$1 = $TS($S($N(CoffeeJSXEnabled), PushJSXOpeningElement, $E(JSXMixedChildren), JSXOptionalClosingElement, PopJSXStack), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
@@ -10971,7 +11137,7 @@ ${input.slice(result.pos)}
|
|
|
10971
11137
|
function JSXElement(ctx, state) {
|
|
10972
11138
|
return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
|
|
10973
11139
|
}
|
|
10974
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
11140
|
+
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) {
|
|
10975
11141
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
10976
11142
|
});
|
|
10977
11143
|
function JSXSelfClosingElement(ctx, state) {
|
|
@@ -10990,7 +11156,7 @@ ${input.slice(result.pos)}
|
|
|
10990
11156
|
function PopJSXStack(ctx, state) {
|
|
10991
11157
|
return $EVENT(ctx, state, "PopJSXStack", PopJSXStack$0);
|
|
10992
11158
|
}
|
|
10993
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
11159
|
+
var JSXOpeningElement$0 = $S($EXPECT($L154, 'JSXOpeningElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L33, 'JSXOpeningElement ">"'));
|
|
10994
11160
|
function JSXOpeningElement(ctx, state) {
|
|
10995
11161
|
return $EVENT(ctx, state, "JSXOpeningElement", JSXOpeningElement$0);
|
|
10996
11162
|
}
|
|
@@ -11060,7 +11226,7 @@ ${input.slice(result.pos)}
|
|
|
11060
11226
|
function JSXClosingFragment(ctx, state) {
|
|
11061
11227
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
11062
11228
|
}
|
|
11063
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
11229
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L144, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
11064
11230
|
return module.config.defaultElement;
|
|
11065
11231
|
});
|
|
11066
11232
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -11068,7 +11234,7 @@ ${input.slice(result.pos)}
|
|
|
11068
11234
|
function JSXElementName(ctx, state) {
|
|
11069
11235
|
return $EVENT_C(ctx, state, "JSXElementName", JSXElementName$$);
|
|
11070
11236
|
}
|
|
11071
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
11237
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R70, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
11072
11238
|
function JSXIdentifierName(ctx, state) {
|
|
11073
11239
|
return $EVENT(ctx, state, "JSXIdentifierName", JSXIdentifierName$0);
|
|
11074
11240
|
}
|
|
@@ -11232,7 +11398,7 @@ ${input.slice(result.pos)}
|
|
|
11232
11398
|
}
|
|
11233
11399
|
return $skip;
|
|
11234
11400
|
});
|
|
11235
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
11401
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L144, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
11236
11402
|
return [" ", "id=", $2];
|
|
11237
11403
|
});
|
|
11238
11404
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -11241,7 +11407,7 @@ ${input.slice(result.pos)}
|
|
|
11241
11407
|
class: $2
|
|
11242
11408
|
};
|
|
11243
11409
|
});
|
|
11244
|
-
var JSXAttribute$7 = $TS($S($TEXT($EXPECT($
|
|
11410
|
+
var JSXAttribute$7 = $TS($S($TEXT($EXPECT($R15, "JSXAttribute /[!+-]/")), JSXAttributeName, $Y(JSXAttributeSpace)), function($skip, $loc, $0, $1, $2, $3) {
|
|
11245
11411
|
var toggle = $1;
|
|
11246
11412
|
var id = $2;
|
|
11247
11413
|
const value = toggle === "+" ? "true" : "false";
|
|
@@ -11251,11 +11417,11 @@ ${input.slice(result.pos)}
|
|
|
11251
11417
|
function JSXAttribute(ctx, state) {
|
|
11252
11418
|
return $EVENT_C(ctx, state, "JSXAttribute", JSXAttribute$$);
|
|
11253
11419
|
}
|
|
11254
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
11420
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R71, "JSXAttributeSpace /[\\s>]|\\/>/"));
|
|
11255
11421
|
function JSXAttributeSpace(ctx, state) {
|
|
11256
11422
|
return $EVENT(ctx, state, "JSXAttributeSpace", JSXAttributeSpace$0);
|
|
11257
11423
|
}
|
|
11258
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
11424
|
+
var JSXShorthandString$0 = $TR($EXPECT($R72, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11259
11425
|
return quoteString($0);
|
|
11260
11426
|
});
|
|
11261
11427
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -11289,7 +11455,7 @@ ${input.slice(result.pos)}
|
|
|
11289
11455
|
}
|
|
11290
11456
|
return [open, value, close];
|
|
11291
11457
|
});
|
|
11292
|
-
var JSXAttributeValue$4 = $R$0($EXPECT($
|
|
11458
|
+
var JSXAttributeValue$4 = $R$0($EXPECT($R73, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
|
|
11293
11459
|
var JSXAttributeValue$$ = [JSXAttributeValue$0, JSXAttributeValue$1, JSXAttributeValue$2, JSXAttributeValue$3, JSXAttributeValue$4];
|
|
11294
11460
|
function JSXAttributeValue(ctx, state) {
|
|
11295
11461
|
return $EVENT_C(ctx, state, "JSXAttributeValue", JSXAttributeValue$$);
|
|
@@ -11302,7 +11468,7 @@ ${input.slice(result.pos)}
|
|
|
11302
11468
|
function InlineJSXAttributeValue(ctx, state) {
|
|
11303
11469
|
return $EVENT(ctx, state, "InlineJSXAttributeValue", InlineJSXAttributeValue$0);
|
|
11304
11470
|
}
|
|
11305
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
11471
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R74, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
11306
11472
|
var op = $2;
|
|
11307
11473
|
var rhs = $3;
|
|
11308
11474
|
return [[], op, [], rhs];
|
|
@@ -11319,7 +11485,7 @@ ${input.slice(result.pos)}
|
|
|
11319
11485
|
function InlineJSXUnaryExpression(ctx, state) {
|
|
11320
11486
|
return $EVENT(ctx, state, "InlineJSXUnaryExpression", InlineJSXUnaryExpression$0);
|
|
11321
11487
|
}
|
|
11322
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
11488
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R75, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11323
11489
|
return { $loc, token: $0 };
|
|
11324
11490
|
});
|
|
11325
11491
|
function InlineJSXUnaryOp(ctx, state) {
|
|
@@ -11531,13 +11697,13 @@ ${input.slice(result.pos)}
|
|
|
11531
11697
|
function JSXComment(ctx, state) {
|
|
11532
11698
|
return $EVENT(ctx, state, "JSXComment", JSXComment$0);
|
|
11533
11699
|
}
|
|
11534
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
11700
|
+
var JSXCommentContent$0 = $TR($EXPECT($R76, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11535
11701
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
11536
11702
|
});
|
|
11537
11703
|
function JSXCommentContent(ctx, state) {
|
|
11538
11704
|
return $EVENT(ctx, state, "JSXCommentContent", JSXCommentContent$0);
|
|
11539
11705
|
}
|
|
11540
|
-
var JSXText$0 = $TR($EXPECT($
|
|
11706
|
+
var JSXText$0 = $TR($EXPECT($R77, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11541
11707
|
return {
|
|
11542
11708
|
type: "JSXText",
|
|
11543
11709
|
token: $0,
|
|
@@ -11902,7 +12068,7 @@ ${input.slice(result.pos)}
|
|
|
11902
12068
|
function TypeProperty(ctx, state) {
|
|
11903
12069
|
return $EVENT(ctx, state, "TypeProperty", TypeProperty$0);
|
|
11904
12070
|
}
|
|
11905
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
12071
|
+
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)))));
|
|
11906
12072
|
function TypeIndexSignature(ctx, state) {
|
|
11907
12073
|
return $EVENT(ctx, state, "TypeIndexSignature", TypeIndexSignature$0);
|
|
11908
12074
|
}
|
|
@@ -11953,7 +12119,7 @@ ${input.slice(result.pos)}
|
|
|
11953
12119
|
function ReturnType(ctx, state) {
|
|
11954
12120
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
11955
12121
|
}
|
|
11956
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
12122
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L149, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
11957
12123
|
var lhs = $1;
|
|
11958
12124
|
var rhs = $2;
|
|
11959
12125
|
if (!rhs)
|
|
@@ -12115,7 +12281,7 @@ ${input.slice(result.pos)}
|
|
|
12115
12281
|
function NestedType(ctx, state) {
|
|
12116
12282
|
return $EVENT(ctx, state, "NestedType", NestedType$0);
|
|
12117
12283
|
}
|
|
12118
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
12284
|
+
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) {
|
|
12119
12285
|
if ($2)
|
|
12120
12286
|
return $0;
|
|
12121
12287
|
return $1;
|
|
@@ -12175,7 +12341,7 @@ ${input.slice(result.pos)}
|
|
|
12175
12341
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
12176
12342
|
return value[1];
|
|
12177
12343
|
});
|
|
12178
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($
|
|
12344
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L111, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L34, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L25, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
12179
12345
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
12180
12346
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
12181
12347
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
@@ -12207,7 +12373,7 @@ ${input.slice(result.pos)}
|
|
|
12207
12373
|
function TypeArrowFunction(ctx, state) {
|
|
12208
12374
|
return $EVENT(ctx, state, "TypeArrowFunction", TypeArrowFunction$0);
|
|
12209
12375
|
}
|
|
12210
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
12376
|
+
var TypeArguments$0 = $TS($S($EXPECT($L154, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L33, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
12211
12377
|
var args = $2;
|
|
12212
12378
|
return { ts: true, types: args.map(([, t]) => t), children: $0 };
|
|
12213
12379
|
});
|
|
@@ -12222,7 +12388,7 @@ ${input.slice(result.pos)}
|
|
|
12222
12388
|
function TypeArgumentDelimiter(ctx, state) {
|
|
12223
12389
|
return $EVENT(ctx, state, "TypeArgumentDelimiter", TypeArgumentDelimiter$0);
|
|
12224
12390
|
}
|
|
12225
|
-
var TypeParameters$0 = $TS($S($E(_), $EXPECT($
|
|
12391
|
+
var TypeParameters$0 = $TS($S($E(_), $EXPECT($L154, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L33, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
12226
12392
|
var parameters = $3;
|
|
12227
12393
|
return {
|
|
12228
12394
|
type: "TypeParameters",
|
|
@@ -12234,11 +12400,11 @@ ${input.slice(result.pos)}
|
|
|
12234
12400
|
function TypeParameters(ctx, state) {
|
|
12235
12401
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
12236
12402
|
}
|
|
12237
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
12403
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L148, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
12238
12404
|
function TypeParameter(ctx, state) {
|
|
12239
12405
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
12240
12406
|
}
|
|
12241
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
12407
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L137, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
12242
12408
|
function TypeConstraint(ctx, state) {
|
|
12243
12409
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
12244
12410
|
}
|
|
@@ -12246,7 +12412,7 @@ ${input.slice(result.pos)}
|
|
|
12246
12412
|
function TypeInitializer(ctx, state) {
|
|
12247
12413
|
return $EVENT(ctx, state, "TypeInitializer", TypeInitializer$0);
|
|
12248
12414
|
}
|
|
12249
|
-
var TypeParameterDelimiter$0 = $S($
|
|
12415
|
+
var TypeParameterDelimiter$0 = $S($E(_), Comma);
|
|
12250
12416
|
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L33, 'TypeParameterDelimiter ">"')));
|
|
12251
12417
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
12252
12418
|
return value[1];
|
|
@@ -12261,15 +12427,15 @@ ${input.slice(result.pos)}
|
|
|
12261
12427
|
function ThisType(ctx, state) {
|
|
12262
12428
|
return $EVENT(ctx, state, "ThisType", ThisType$0);
|
|
12263
12429
|
}
|
|
12264
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
12430
|
+
var Shebang$0 = $S($R$0($EXPECT($R80, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
12265
12431
|
function Shebang(ctx, state) {
|
|
12266
12432
|
return $EVENT(ctx, state, "Shebang", Shebang$0);
|
|
12267
12433
|
}
|
|
12268
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
12434
|
+
var CivetPrologue$0 = $T($S($EXPECT($R81, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, SimpleStatementDelimiter, $E(EOS)), function(value) {
|
|
12269
12435
|
var content = value[2];
|
|
12270
12436
|
return content;
|
|
12271
12437
|
});
|
|
12272
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
12438
|
+
var CivetPrologue$1 = $T($S($EXPECT($R81, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, SimpleStatementDelimiter, $E(EOS)), function(value) {
|
|
12273
12439
|
var content = value[2];
|
|
12274
12440
|
return content;
|
|
12275
12441
|
});
|
|
@@ -12277,7 +12443,7 @@ ${input.slice(result.pos)}
|
|
|
12277
12443
|
function CivetPrologue(ctx, state) {
|
|
12278
12444
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
12279
12445
|
}
|
|
12280
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($
|
|
12446
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R82, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
12281
12447
|
var options = $3;
|
|
12282
12448
|
return {
|
|
12283
12449
|
type: "CivetPrologue",
|
|
@@ -12288,7 +12454,7 @@ ${input.slice(result.pos)}
|
|
|
12288
12454
|
function CivetPrologueContent(ctx, state) {
|
|
12289
12455
|
return $EVENT(ctx, state, "CivetPrologueContent", CivetPrologueContent$0);
|
|
12290
12456
|
}
|
|
12291
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
12457
|
+
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) {
|
|
12292
12458
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
12293
12459
|
if (l)
|
|
12294
12460
|
return l.toUpperCase();
|
|
@@ -12305,11 +12471,11 @@ ${input.slice(result.pos)}
|
|
|
12305
12471
|
function CivetOption(ctx, state) {
|
|
12306
12472
|
return $EVENT(ctx, state, "CivetOption", CivetOption$0);
|
|
12307
12473
|
}
|
|
12308
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
12474
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R81, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
12309
12475
|
function UnknownPrologue(ctx, state) {
|
|
12310
12476
|
return $EVENT(ctx, state, "UnknownPrologue", UnknownPrologue$0);
|
|
12311
12477
|
}
|
|
12312
|
-
var TripleSlashDirective$0 = $S($R$0($EXPECT($
|
|
12478
|
+
var TripleSlashDirective$0 = $S($R$0($EXPECT($R84, "TripleSlashDirective /\\/\\/\\/[^\\r\\n]*/")), $E(EOS));
|
|
12313
12479
|
function TripleSlashDirective(ctx, state) {
|
|
12314
12480
|
return $EVENT(ctx, state, "TripleSlashDirective", TripleSlashDirective$0);
|
|
12315
12481
|
}
|
|
@@ -12323,13 +12489,13 @@ ${input.slice(result.pos)}
|
|
|
12323
12489
|
function PrologueString(ctx, state) {
|
|
12324
12490
|
return $EVENT_C(ctx, state, "PrologueString", PrologueString$$);
|
|
12325
12491
|
}
|
|
12326
|
-
var EOS$0 = $T($S($EXPECT($
|
|
12492
|
+
var EOS$0 = $T($S($EXPECT($R85, "EOS /(?=[ \\t\\r\\n\\/#]|$)/"), $P(RestOfLine)), function(value) {
|
|
12327
12493
|
return value[1];
|
|
12328
12494
|
});
|
|
12329
12495
|
function EOS(ctx, state) {
|
|
12330
12496
|
return $EVENT(ctx, state, "EOS", EOS$0);
|
|
12331
12497
|
}
|
|
12332
|
-
var EOL$0 = $TR($EXPECT($
|
|
12498
|
+
var EOL$0 = $TR($EXPECT($R86, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12333
12499
|
return { $loc, token: $0 };
|
|
12334
12500
|
});
|
|
12335
12501
|
function EOL(ctx, state) {
|
|
@@ -12823,7 +12989,7 @@ ${input.slice(result.pos)}
|
|
|
12823
12989
|
function Init(ctx, state) {
|
|
12824
12990
|
return $EVENT(ctx, state, "Init", Init$0);
|
|
12825
12991
|
}
|
|
12826
|
-
var Indent$0 = $TR($EXPECT($
|
|
12992
|
+
var Indent$0 = $TR($EXPECT($R87, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12827
12993
|
const level = getIndentLevel($0, module.config.tab);
|
|
12828
12994
|
return {
|
|
12829
12995
|
$loc,
|
|
@@ -13156,6 +13322,7 @@ ${input.slice(result.pos)}
|
|
|
13156
13322
|
exports.NotDedentedBinaryOp = NotDedentedBinaryOp;
|
|
13157
13323
|
exports.IdentifierBinaryOp = IdentifierBinaryOp;
|
|
13158
13324
|
exports.BinaryOp = BinaryOp;
|
|
13325
|
+
exports._BinaryOp = _BinaryOp;
|
|
13159
13326
|
exports.BinaryOpSymbol = BinaryOpSymbol;
|
|
13160
13327
|
exports.CoffeeOfOp = CoffeeOfOp;
|
|
13161
13328
|
exports.NotOp = NotOp;
|
|
@@ -13445,6 +13612,7 @@ ${input.slice(result.pos)}
|
|
|
13445
13612
|
exports.Yield = Yield;
|
|
13446
13613
|
exports.JSXImplicitFragment = JSXImplicitFragment;
|
|
13447
13614
|
exports.JSXTag = JSXTag;
|
|
13615
|
+
exports._JSXTag = _JSXTag;
|
|
13448
13616
|
exports.JSXElement = JSXElement;
|
|
13449
13617
|
exports.JSXSelfClosingElement = JSXSelfClosingElement;
|
|
13450
13618
|
exports.PushJSXOpeningElement = PushJSXOpeningElement;
|