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