@danielx/civet 0.5.79 → 0.5.81
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 +608 -301
- package/dist/civet +2 -1
- package/dist/main.js +608 -301
- package/dist/main.mjs +608 -301
- package/package.json +1 -1
package/dist/main.mjs
CHANGED
|
@@ -24,6 +24,106 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
|
|
|
24
24
|
mod
|
|
25
25
|
));
|
|
26
26
|
|
|
27
|
+
// source/lib.js
|
|
28
|
+
var require_lib = __commonJS({
|
|
29
|
+
"source/lib.js"(exports, module) {
|
|
30
|
+
"use strict";
|
|
31
|
+
function clone(node) {
|
|
32
|
+
removeParentPointers(node);
|
|
33
|
+
return deepCopy(node);
|
|
34
|
+
}
|
|
35
|
+
function deepCopy(node) {
|
|
36
|
+
if (node == null)
|
|
37
|
+
return node;
|
|
38
|
+
if (typeof node !== "object")
|
|
39
|
+
return node;
|
|
40
|
+
if (Array.isArray(node)) {
|
|
41
|
+
return node.map(deepCopy);
|
|
42
|
+
}
|
|
43
|
+
return Object.fromEntries(
|
|
44
|
+
Object.entries(node).map(([key, value]) => {
|
|
45
|
+
return [key, deepCopy(value)];
|
|
46
|
+
})
|
|
47
|
+
);
|
|
48
|
+
}
|
|
49
|
+
function removeParentPointers(node) {
|
|
50
|
+
if (node == null)
|
|
51
|
+
return;
|
|
52
|
+
if (typeof node !== "object")
|
|
53
|
+
return;
|
|
54
|
+
if (Array.isArray(node)) {
|
|
55
|
+
for (const child of node) {
|
|
56
|
+
removeParentPointers(child);
|
|
57
|
+
}
|
|
58
|
+
return;
|
|
59
|
+
}
|
|
60
|
+
node.parent = null;
|
|
61
|
+
if (node.children) {
|
|
62
|
+
for (const child of node.children) {
|
|
63
|
+
removeParentPointers(child);
|
|
64
|
+
}
|
|
65
|
+
}
|
|
66
|
+
}
|
|
67
|
+
function gatherNodes(node, predicate) {
|
|
68
|
+
if (node == null)
|
|
69
|
+
return [];
|
|
70
|
+
if (Array.isArray(node)) {
|
|
71
|
+
return node.flatMap((n) => gatherNodes(n, predicate));
|
|
72
|
+
}
|
|
73
|
+
if (predicate(node)) {
|
|
74
|
+
return [node];
|
|
75
|
+
}
|
|
76
|
+
switch (node.type) {
|
|
77
|
+
case "BlockStatement":
|
|
78
|
+
return [];
|
|
79
|
+
case "ForStatement":
|
|
80
|
+
const isDec = node.declaration?.type === "Declaration";
|
|
81
|
+
return node.children.flatMap((n) => {
|
|
82
|
+
if (isDec && n === node.declaration)
|
|
83
|
+
return [];
|
|
84
|
+
return gatherNodes(n, predicate);
|
|
85
|
+
});
|
|
86
|
+
default:
|
|
87
|
+
return gatherNodes(node.children, predicate);
|
|
88
|
+
}
|
|
89
|
+
return [];
|
|
90
|
+
}
|
|
91
|
+
function gatherRecursive(node, predicate, skipPredicate) {
|
|
92
|
+
if (node == null)
|
|
93
|
+
return [];
|
|
94
|
+
if (Array.isArray(node)) {
|
|
95
|
+
return node.flatMap((n) => gatherRecursive(n, predicate, skipPredicate));
|
|
96
|
+
}
|
|
97
|
+
if (skipPredicate?.(node))
|
|
98
|
+
return [];
|
|
99
|
+
if (predicate(node)) {
|
|
100
|
+
return [node];
|
|
101
|
+
}
|
|
102
|
+
return gatherRecursive(node.children, predicate, skipPredicate);
|
|
103
|
+
}
|
|
104
|
+
function gatherRecursiveAll(node, predicate) {
|
|
105
|
+
if (node == null)
|
|
106
|
+
return [];
|
|
107
|
+
if (Array.isArray(node)) {
|
|
108
|
+
return node.flatMap((n) => gatherRecursiveAll(n, predicate));
|
|
109
|
+
}
|
|
110
|
+
const nodes = gatherRecursiveAll(node.children, predicate);
|
|
111
|
+
if (predicate(node)) {
|
|
112
|
+
nodes.push(node);
|
|
113
|
+
}
|
|
114
|
+
return nodes;
|
|
115
|
+
}
|
|
116
|
+
module.exports = {
|
|
117
|
+
clone,
|
|
118
|
+
deepCopy,
|
|
119
|
+
gatherNodes,
|
|
120
|
+
gatherRecursive,
|
|
121
|
+
gatherRecursiveAll,
|
|
122
|
+
removeParentPointers
|
|
123
|
+
};
|
|
124
|
+
}
|
|
125
|
+
});
|
|
126
|
+
|
|
27
127
|
// source/parser.hera
|
|
28
128
|
var require_parser = __commonJS({
|
|
29
129
|
"source/parser.hera"(exports, module) {
|
|
@@ -424,6 +524,9 @@ ${input.slice(result.pos)}
|
|
|
424
524
|
exports.parserState = parserState;
|
|
425
525
|
var { parse: parse2 } = parserState({
|
|
426
526
|
Program,
|
|
527
|
+
TopLevelStatements,
|
|
528
|
+
NestedTopLevelStatements,
|
|
529
|
+
TopLevelSingleLineStatements,
|
|
427
530
|
TopLevelStatement,
|
|
428
531
|
ExtendedExpression,
|
|
429
532
|
SingleLineExtendedExpression,
|
|
@@ -560,6 +663,7 @@ ${input.slice(result.pos)}
|
|
|
560
663
|
FunctionDeclaration,
|
|
561
664
|
FunctionSignature,
|
|
562
665
|
FunctionExpression,
|
|
666
|
+
AmpersandFunctionExpression,
|
|
563
667
|
OperatorDeclaration,
|
|
564
668
|
OperatorSignature,
|
|
565
669
|
AmpersandBlockRHS,
|
|
@@ -695,6 +799,9 @@ ${input.slice(result.pos)}
|
|
|
695
799
|
CatchParameter,
|
|
696
800
|
Condition,
|
|
697
801
|
ExpressionWithIndentedApplicationForbidden,
|
|
802
|
+
ForbidClassImplicitCall,
|
|
803
|
+
AllowClassImplicitCall,
|
|
804
|
+
RestoreClassImplicitCall,
|
|
698
805
|
ForbidIndentedApplication,
|
|
699
806
|
AllowIndentedApplication,
|
|
700
807
|
RestoreIndentedApplication,
|
|
@@ -1050,26 +1157,26 @@ ${input.slice(result.pos)}
|
|
|
1050
1157
|
PopIndent,
|
|
1051
1158
|
Nested
|
|
1052
1159
|
});
|
|
1053
|
-
var $L0 = $L("
|
|
1054
|
-
var $L1 = $L("
|
|
1055
|
-
var $L2 = $L("
|
|
1056
|
-
var $L3 = $L("
|
|
1057
|
-
var $L4 = $L("
|
|
1058
|
-
var $L5 = $L("
|
|
1059
|
-
var $L6 = $L("
|
|
1060
|
-
var $L7 = $L("
|
|
1061
|
-
var $L8 = $L("
|
|
1062
|
-
var $L9 = $L("
|
|
1063
|
-
var $L10 = $L("
|
|
1064
|
-
var $L11 = $L("
|
|
1065
|
-
var $L12 = $L("
|
|
1066
|
-
var $L13 = $L("
|
|
1067
|
-
var $L14 = $L("
|
|
1068
|
-
var $L15 = $L("
|
|
1069
|
-
var $L16 = $L("
|
|
1070
|
-
var $L17 = $L("
|
|
1071
|
-
var $L18 = $L("
|
|
1072
|
-
var $L19 = $L("");
|
|
1160
|
+
var $L0 = $L("");
|
|
1161
|
+
var $L1 = $L("/ ");
|
|
1162
|
+
var $L2 = $L("=");
|
|
1163
|
+
var $L3 = $L("(");
|
|
1164
|
+
var $L4 = $L("?");
|
|
1165
|
+
var $L5 = $L(".");
|
|
1166
|
+
var $L6 = $L("++");
|
|
1167
|
+
var $L7 = $L("--");
|
|
1168
|
+
var $L8 = $L("=>");
|
|
1169
|
+
var $L9 = $L(" ");
|
|
1170
|
+
var $L10 = $L("implements");
|
|
1171
|
+
var $L11 = $L("<:");
|
|
1172
|
+
var $L12 = $L("#");
|
|
1173
|
+
var $L13 = $L("super");
|
|
1174
|
+
var $L14 = $L("import");
|
|
1175
|
+
var $L15 = $L("return.value");
|
|
1176
|
+
var $L16 = $L("!");
|
|
1177
|
+
var $L17 = $L("^");
|
|
1178
|
+
var $L18 = $L("-");
|
|
1179
|
+
var $L19 = $L("import.meta");
|
|
1073
1180
|
var $L20 = $L(",");
|
|
1074
1181
|
var $L21 = $L("->");
|
|
1075
1182
|
var $L22 = $L("}");
|
|
@@ -1298,7 +1405,7 @@ ${input.slice(result.pos)}
|
|
|
1298
1405
|
var $R63 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
1299
1406
|
var $R64 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
1300
1407
|
var $R65 = $R(new RegExp("[ \\t]*", "suy"));
|
|
1301
|
-
var Program$0 = $TS($S(Reset, Init,
|
|
1408
|
+
var Program$0 = $TS($S(Reset, Init, $E(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1302
1409
|
var statements = $4;
|
|
1303
1410
|
module.processProgram(statements);
|
|
1304
1411
|
return $0;
|
|
@@ -1325,7 +1432,117 @@ ${input.slice(result.pos)}
|
|
|
1325
1432
|
return result;
|
|
1326
1433
|
}
|
|
1327
1434
|
}
|
|
1328
|
-
var
|
|
1435
|
+
var TopLevelStatements$0 = $TS($S(TrackIndented, TopLevelSingleLineStatements, $Q(NestedTopLevelStatements), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1436
|
+
var indent = $1;
|
|
1437
|
+
var first = $2;
|
|
1438
|
+
var rest = $3;
|
|
1439
|
+
return [
|
|
1440
|
+
[indent, ...first[0]],
|
|
1441
|
+
...first.slice(1).map((s) => ["", ...s]),
|
|
1442
|
+
...rest.flat()
|
|
1443
|
+
];
|
|
1444
|
+
});
|
|
1445
|
+
var TopLevelStatements$1 = $TS($S(TopLevelSingleLineStatements, $Q(NestedTopLevelStatements)), function($skip, $loc, $0, $1, $2) {
|
|
1446
|
+
var first = $1;
|
|
1447
|
+
var rest = $2;
|
|
1448
|
+
return [
|
|
1449
|
+
...first.map((s) => ["", ...s]),
|
|
1450
|
+
...rest.flat()
|
|
1451
|
+
];
|
|
1452
|
+
});
|
|
1453
|
+
var TopLevelStatements$2 = $T($EXPECT($L0, fail, 'TopLevelStatements ""'), function(value) {
|
|
1454
|
+
return [];
|
|
1455
|
+
});
|
|
1456
|
+
function TopLevelStatements(state) {
|
|
1457
|
+
let eventData;
|
|
1458
|
+
if (state.events) {
|
|
1459
|
+
const result = state.events.enter?.("TopLevelStatements", state);
|
|
1460
|
+
if (result) {
|
|
1461
|
+
if (result.cache)
|
|
1462
|
+
return result.cache;
|
|
1463
|
+
eventData = result.data;
|
|
1464
|
+
}
|
|
1465
|
+
}
|
|
1466
|
+
if (state.tokenize) {
|
|
1467
|
+
const result = $TOKEN("TopLevelStatements", state, TopLevelStatements$0(state) || TopLevelStatements$1(state) || TopLevelStatements$2(state));
|
|
1468
|
+
if (state.events)
|
|
1469
|
+
state.events.exit?.("TopLevelStatements", state, result, eventData);
|
|
1470
|
+
return result;
|
|
1471
|
+
} else {
|
|
1472
|
+
const result = TopLevelStatements$0(state) || TopLevelStatements$1(state) || TopLevelStatements$2(state);
|
|
1473
|
+
if (state.events)
|
|
1474
|
+
state.events.exit?.("TopLevelStatements", state, result, eventData);
|
|
1475
|
+
return result;
|
|
1476
|
+
}
|
|
1477
|
+
}
|
|
1478
|
+
var NestedTopLevelStatements$0 = $TS($S(Nested, TopLevelSingleLineStatements), function($skip, $loc, $0, $1, $2) {
|
|
1479
|
+
var nested = $1;
|
|
1480
|
+
var statements = $2;
|
|
1481
|
+
return [
|
|
1482
|
+
[nested, ...statements[0]],
|
|
1483
|
+
...statements.slice(1).map((s) => ["", ...s])
|
|
1484
|
+
];
|
|
1485
|
+
});
|
|
1486
|
+
function NestedTopLevelStatements(state) {
|
|
1487
|
+
let eventData;
|
|
1488
|
+
if (state.events) {
|
|
1489
|
+
const result = state.events.enter?.("NestedTopLevelStatements", state);
|
|
1490
|
+
if (result) {
|
|
1491
|
+
if (result.cache)
|
|
1492
|
+
return result.cache;
|
|
1493
|
+
eventData = result.data;
|
|
1494
|
+
}
|
|
1495
|
+
}
|
|
1496
|
+
if (state.tokenize) {
|
|
1497
|
+
const result = $TOKEN("NestedTopLevelStatements", state, NestedTopLevelStatements$0(state));
|
|
1498
|
+
if (state.events)
|
|
1499
|
+
state.events.exit?.("NestedTopLevelStatements", state, result, eventData);
|
|
1500
|
+
return result;
|
|
1501
|
+
} else {
|
|
1502
|
+
const result = NestedTopLevelStatements$0(state);
|
|
1503
|
+
if (state.events)
|
|
1504
|
+
state.events.exit?.("NestedTopLevelStatements", state, result, eventData);
|
|
1505
|
+
return result;
|
|
1506
|
+
}
|
|
1507
|
+
}
|
|
1508
|
+
var TopLevelSingleLineStatements$0 = $TV($P($S($N(EOS), TopLevelStatement)), function($skip, $loc, $0, $1) {
|
|
1509
|
+
var statements = $0;
|
|
1510
|
+
return statements.map(([, statement]) => statement);
|
|
1511
|
+
});
|
|
1512
|
+
function TopLevelSingleLineStatements(state) {
|
|
1513
|
+
let eventData;
|
|
1514
|
+
if (state.events) {
|
|
1515
|
+
const result = state.events.enter?.("TopLevelSingleLineStatements", state);
|
|
1516
|
+
if (result) {
|
|
1517
|
+
if (result.cache)
|
|
1518
|
+
return result.cache;
|
|
1519
|
+
eventData = result.data;
|
|
1520
|
+
}
|
|
1521
|
+
}
|
|
1522
|
+
if (state.tokenize) {
|
|
1523
|
+
const result = $TOKEN("TopLevelSingleLineStatements", state, TopLevelSingleLineStatements$0(state));
|
|
1524
|
+
if (state.events)
|
|
1525
|
+
state.events.exit?.("TopLevelSingleLineStatements", state, result, eventData);
|
|
1526
|
+
return result;
|
|
1527
|
+
} else {
|
|
1528
|
+
const result = TopLevelSingleLineStatements$0(state);
|
|
1529
|
+
if (state.events)
|
|
1530
|
+
state.events.exit?.("TopLevelSingleLineStatements", state, result, eventData);
|
|
1531
|
+
return result;
|
|
1532
|
+
}
|
|
1533
|
+
}
|
|
1534
|
+
var TopLevelStatement$0 = $TS($S($E(_), ModuleItem, StatementDelimiter), function($skip, $loc, $0, $1, $2, $3) {
|
|
1535
|
+
var ws = $1;
|
|
1536
|
+
var statement = $2;
|
|
1537
|
+
var delimiter = $3;
|
|
1538
|
+
if (ws) {
|
|
1539
|
+
statement = {
|
|
1540
|
+
...statement,
|
|
1541
|
+
children: [ws, ...statement.children]
|
|
1542
|
+
};
|
|
1543
|
+
}
|
|
1544
|
+
return [statement, delimiter];
|
|
1545
|
+
});
|
|
1329
1546
|
function TopLevelStatement(state) {
|
|
1330
1547
|
let eventData;
|
|
1331
1548
|
if (state.events) {
|
|
@@ -1620,10 +1837,11 @@ ${input.slice(result.pos)}
|
|
|
1620
1837
|
}
|
|
1621
1838
|
}
|
|
1622
1839
|
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R0, fail, "ForbiddenImplicitCalls /(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
1623
|
-
var ForbiddenImplicitCalls$1 = $EXPECT($
|
|
1624
|
-
var ForbiddenImplicitCalls$2 =
|
|
1625
|
-
var ForbiddenImplicitCalls$3 =
|
|
1626
|
-
var ForbiddenImplicitCalls$4 = $
|
|
1840
|
+
var ForbiddenImplicitCalls$1 = $EXPECT($L1, fail, 'ForbiddenImplicitCalls "/ "');
|
|
1841
|
+
var ForbiddenImplicitCalls$2 = $S(ForbidClassImplicitCall, Class);
|
|
1842
|
+
var ForbiddenImplicitCalls$3 = AtAt;
|
|
1843
|
+
var ForbiddenImplicitCalls$4 = $S(Identifier, $EXPECT($L2, fail, 'ForbiddenImplicitCalls "="'), Whitespace);
|
|
1844
|
+
var ForbiddenImplicitCalls$5 = $TS($S(Identifier, $N($EXPECT($L3, fail, 'ForbiddenImplicitCalls "("'))), function($skip, $loc, $0, $1, $2) {
|
|
1627
1845
|
if (module.operators.has($1.name))
|
|
1628
1846
|
return $1;
|
|
1629
1847
|
return $skip;
|
|
@@ -1639,12 +1857,12 @@ ${input.slice(result.pos)}
|
|
|
1639
1857
|
}
|
|
1640
1858
|
}
|
|
1641
1859
|
if (state.tokenize) {
|
|
1642
|
-
const result = $TOKEN("ForbiddenImplicitCalls", state, ForbiddenImplicitCalls$0(state) || ForbiddenImplicitCalls$1(state) || ForbiddenImplicitCalls$2(state) || ForbiddenImplicitCalls$3(state) || ForbiddenImplicitCalls$4(state));
|
|
1860
|
+
const result = $TOKEN("ForbiddenImplicitCalls", state, ForbiddenImplicitCalls$0(state) || ForbiddenImplicitCalls$1(state) || ForbiddenImplicitCalls$2(state) || ForbiddenImplicitCalls$3(state) || ForbiddenImplicitCalls$4(state) || ForbiddenImplicitCalls$5(state));
|
|
1643
1861
|
if (state.events)
|
|
1644
1862
|
state.events.exit?.("ForbiddenImplicitCalls", state, result, eventData);
|
|
1645
1863
|
return result;
|
|
1646
1864
|
} else {
|
|
1647
|
-
const result = ForbiddenImplicitCalls$0(state) || ForbiddenImplicitCalls$1(state) || ForbiddenImplicitCalls$2(state) || ForbiddenImplicitCalls$3(state) || ForbiddenImplicitCalls$4(state);
|
|
1865
|
+
const result = ForbiddenImplicitCalls$0(state) || ForbiddenImplicitCalls$1(state) || ForbiddenImplicitCalls$2(state) || ForbiddenImplicitCalls$3(state) || ForbiddenImplicitCalls$4(state) || ForbiddenImplicitCalls$5(state);
|
|
1648
1866
|
if (state.events)
|
|
1649
1867
|
state.events.exit?.("ForbiddenImplicitCalls", state, result, eventData);
|
|
1650
1868
|
return result;
|
|
@@ -1681,7 +1899,7 @@ ${input.slice(result.pos)}
|
|
|
1681
1899
|
return result;
|
|
1682
1900
|
}
|
|
1683
1901
|
}
|
|
1684
|
-
var TrailingMemberExpressions$0 = $TS($S($Q(MemberExpressionRest), $Q($S($C(Samedent, IndentedFurther), $Y($S($E($EXPECT($
|
|
1902
|
+
var TrailingMemberExpressions$0 = $TS($S($Q(MemberExpressionRest), $Q($S($C(Samedent, IndentedFurther), $Y($S($E($EXPECT($L4, fail, 'TrailingMemberExpressions "?"')), $EXPECT($L5, fail, 'TrailingMemberExpressions "."'), $N($EXPECT($R1, fail, "TrailingMemberExpressions /[0-9]/")))), MemberExpressionRest))), function($skip, $loc, $0, $1, $2) {
|
|
1685
1903
|
return $1.concat($2);
|
|
1686
1904
|
});
|
|
1687
1905
|
function TrailingMemberExpressions(state) {
|
|
@@ -1760,8 +1978,8 @@ ${input.slice(result.pos)}
|
|
|
1760
1978
|
return module.insertTrimmingSpace($1, "");
|
|
1761
1979
|
});
|
|
1762
1980
|
var ArgumentList$2 = NestedArgumentList;
|
|
1763
|
-
var ArgumentList$3 = $TS($S($
|
|
1764
|
-
return [...$1, $2, ...$3];
|
|
1981
|
+
var ArgumentList$3 = $TS($S($E(_), ArgumentPart, $Q($S(CommaDelimiter, $E(_), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
|
|
1982
|
+
return [...$1 || [], $2, ...$3];
|
|
1765
1983
|
});
|
|
1766
1984
|
function ArgumentList(state) {
|
|
1767
1985
|
let eventData;
|
|
@@ -1790,8 +2008,8 @@ ${input.slice(result.pos)}
|
|
|
1790
2008
|
return module.insertTrimmingSpace($1, "");
|
|
1791
2009
|
});
|
|
1792
2010
|
var NonPipelineArgumentList$2 = NestedArgumentList;
|
|
1793
|
-
var NonPipelineArgumentList$3 = $TS($S($
|
|
1794
|
-
return [...$1, $2, ...$3];
|
|
2011
|
+
var NonPipelineArgumentList$3 = $TS($S($E(_), NonPipelineArgumentPart, $Q($S(CommaDelimiter, $E(_), NonPipelineArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
|
|
2012
|
+
return [...$1 || [], $2, ...$3];
|
|
1795
2013
|
});
|
|
1796
2014
|
function NonPipelineArgumentList(state) {
|
|
1797
2015
|
let eventData;
|
|
@@ -1866,7 +2084,7 @@ ${input.slice(result.pos)}
|
|
|
1866
2084
|
return result;
|
|
1867
2085
|
}
|
|
1868
2086
|
}
|
|
1869
|
-
var SingleLineArgumentExpressions$0 = $S($
|
|
2087
|
+
var SingleLineArgumentExpressions$0 = $S($E(_), ArgumentPart, $Q($S($E(_), Comma, $E(_), ArgumentPart)));
|
|
1870
2088
|
function SingleLineArgumentExpressions(state) {
|
|
1871
2089
|
let eventData;
|
|
1872
2090
|
if (state.events) {
|
|
@@ -2151,7 +2369,7 @@ ${input.slice(result.pos)}
|
|
|
2151
2369
|
return result;
|
|
2152
2370
|
}
|
|
2153
2371
|
}
|
|
2154
|
-
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($
|
|
2372
|
+
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L6, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L7, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
|
|
2155
2373
|
return { $loc, token: $1 };
|
|
2156
2374
|
});
|
|
2157
2375
|
function UpdateExpressionSymbol(state) {
|
|
@@ -2225,10 +2443,10 @@ ${input.slice(result.pos)}
|
|
|
2225
2443
|
return result;
|
|
2226
2444
|
}
|
|
2227
2445
|
}
|
|
2228
|
-
var SingleLineAssignmentExpression$0 = $TS($S($
|
|
2446
|
+
var SingleLineAssignmentExpression$0 = $TS($S($E(_), AssignmentExpressionTail), function($skip, $loc, $0, $1, $2) {
|
|
2229
2447
|
var ws = $1;
|
|
2230
2448
|
var tail = $2;
|
|
2231
|
-
if (ws
|
|
2449
|
+
if (ws?.length) {
|
|
2232
2450
|
if (tail.children && tail.type !== "IterationExpression") {
|
|
2233
2451
|
return {
|
|
2234
2452
|
...tail,
|
|
@@ -2345,7 +2563,7 @@ ${input.slice(result.pos)}
|
|
|
2345
2563
|
}
|
|
2346
2564
|
}
|
|
2347
2565
|
var YieldTail$0 = $Y(EOS);
|
|
2348
|
-
var YieldTail$1 = $S($E($S($
|
|
2566
|
+
var YieldTail$1 = $S($E($S($E(_), Star)), AssignmentExpression);
|
|
2349
2567
|
function YieldTail(state) {
|
|
2350
2568
|
let eventData;
|
|
2351
2569
|
if (state.events) {
|
|
@@ -2433,7 +2651,7 @@ ${input.slice(result.pos)}
|
|
|
2433
2651
|
return result;
|
|
2434
2652
|
}
|
|
2435
2653
|
}
|
|
2436
|
-
var FatArrow$0 = $TS($S(__, $EXPECT($
|
|
2654
|
+
var FatArrow$0 = $TS($S(__, $EXPECT($L8, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
|
|
2437
2655
|
var ws = $1;
|
|
2438
2656
|
if (!ws.length)
|
|
2439
2657
|
return " =>";
|
|
@@ -2517,7 +2735,7 @@ ${input.slice(result.pos)}
|
|
|
2517
2735
|
}
|
|
2518
2736
|
}
|
|
2519
2737
|
var TernaryRest$0 = NestedTernaryRest;
|
|
2520
|
-
var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($
|
|
2738
|
+
var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($L9, fail, 'TernaryRest " "')), $E(_), QuestionMark, ExtendedExpression, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
2521
2739
|
return $0.slice(2);
|
|
2522
2740
|
});
|
|
2523
2741
|
function TernaryRest(state) {
|
|
@@ -2596,6 +2814,23 @@ ${input.slice(result.pos)}
|
|
|
2596
2814
|
var ws = $1;
|
|
2597
2815
|
var head = $2;
|
|
2598
2816
|
var body = $3;
|
|
2817
|
+
if (head.token === "&") {
|
|
2818
|
+
const ref = {
|
|
2819
|
+
type: "Ref",
|
|
2820
|
+
base: "$"
|
|
2821
|
+
};
|
|
2822
|
+
const arrowBody = {
|
|
2823
|
+
type: "PipelineExpression",
|
|
2824
|
+
children: [ws, ref, body]
|
|
2825
|
+
};
|
|
2826
|
+
return {
|
|
2827
|
+
type: "ArrowFunction",
|
|
2828
|
+
children: [ref, " => ", arrowBody],
|
|
2829
|
+
ref,
|
|
2830
|
+
body: [arrowBody],
|
|
2831
|
+
ampersandBlock: true
|
|
2832
|
+
};
|
|
2833
|
+
}
|
|
2599
2834
|
return {
|
|
2600
2835
|
type: "PipelineExpression",
|
|
2601
2836
|
children: [ws, head, body]
|
|
@@ -2625,6 +2860,7 @@ ${input.slice(result.pos)}
|
|
|
2625
2860
|
}
|
|
2626
2861
|
var PipelineHeadItem$0 = NonPipelineExtendedExpression;
|
|
2627
2862
|
var PipelineHeadItem$1 = ParenthesizedExpression;
|
|
2863
|
+
var PipelineHeadItem$2 = Ampersand;
|
|
2628
2864
|
function PipelineHeadItem(state) {
|
|
2629
2865
|
let eventData;
|
|
2630
2866
|
if (state.events) {
|
|
@@ -2636,12 +2872,12 @@ ${input.slice(result.pos)}
|
|
|
2636
2872
|
}
|
|
2637
2873
|
}
|
|
2638
2874
|
if (state.tokenize) {
|
|
2639
|
-
const result = $TOKEN("PipelineHeadItem", state, PipelineHeadItem$0(state) || PipelineHeadItem$1(state));
|
|
2875
|
+
const result = $TOKEN("PipelineHeadItem", state, PipelineHeadItem$0(state) || PipelineHeadItem$1(state) || PipelineHeadItem$2(state));
|
|
2640
2876
|
if (state.events)
|
|
2641
2877
|
state.events.exit?.("PipelineHeadItem", state, result, eventData);
|
|
2642
2878
|
return result;
|
|
2643
2879
|
} else {
|
|
2644
|
-
const result = PipelineHeadItem$0(state) || PipelineHeadItem$1(state);
|
|
2880
|
+
const result = PipelineHeadItem$0(state) || PipelineHeadItem$1(state) || PipelineHeadItem$2(state);
|
|
2645
2881
|
if (state.events)
|
|
2646
2882
|
state.events.exit?.("PipelineHeadItem", state, result, eventData);
|
|
2647
2883
|
return result;
|
|
@@ -2650,7 +2886,10 @@ ${input.slice(result.pos)}
|
|
|
2650
2886
|
var PipelineTailItem$0 = Await;
|
|
2651
2887
|
var PipelineTailItem$1 = Yield;
|
|
2652
2888
|
var PipelineTailItem$2 = Return;
|
|
2653
|
-
var PipelineTailItem$3 =
|
|
2889
|
+
var PipelineTailItem$3 = AmpersandFunctionExpression;
|
|
2890
|
+
var PipelineTailItem$4 = $T($S($N(Ampersand), PipelineHeadItem), function(value) {
|
|
2891
|
+
return value[1];
|
|
2892
|
+
});
|
|
2654
2893
|
function PipelineTailItem(state) {
|
|
2655
2894
|
let eventData;
|
|
2656
2895
|
if (state.events) {
|
|
@@ -2662,12 +2901,12 @@ ${input.slice(result.pos)}
|
|
|
2662
2901
|
}
|
|
2663
2902
|
}
|
|
2664
2903
|
if (state.tokenize) {
|
|
2665
|
-
const result = $TOKEN("PipelineTailItem", state, PipelineTailItem$0(state) || PipelineTailItem$1(state) || PipelineTailItem$2(state) || PipelineTailItem$3(state));
|
|
2904
|
+
const result = $TOKEN("PipelineTailItem", state, PipelineTailItem$0(state) || PipelineTailItem$1(state) || PipelineTailItem$2(state) || PipelineTailItem$3(state) || PipelineTailItem$4(state));
|
|
2666
2905
|
if (state.events)
|
|
2667
2906
|
state.events.exit?.("PipelineTailItem", state, result, eventData);
|
|
2668
2907
|
return result;
|
|
2669
2908
|
} else {
|
|
2670
|
-
const result = PipelineTailItem$0(state) || PipelineTailItem$1(state) || PipelineTailItem$2(state) || PipelineTailItem$3(state);
|
|
2909
|
+
const result = PipelineTailItem$0(state) || PipelineTailItem$1(state) || PipelineTailItem$2(state) || PipelineTailItem$3(state) || PipelineTailItem$4(state);
|
|
2671
2910
|
if (state.events)
|
|
2672
2911
|
state.events.exit?.("PipelineTailItem", state, result, eventData);
|
|
2673
2912
|
return result;
|
|
@@ -2861,7 +3100,7 @@ ${input.slice(result.pos)}
|
|
|
2861
3100
|
return result;
|
|
2862
3101
|
}
|
|
2863
3102
|
}
|
|
2864
|
-
var ExtendsToken$0 = $TS($S(Loc, __, OpenAngleBracket, $E($EXPECT($
|
|
3103
|
+
var ExtendsToken$0 = $TS($S(Loc, __, OpenAngleBracket, $E($EXPECT($L9, fail, 'ExtendsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2865
3104
|
var l = $1;
|
|
2866
3105
|
var ws = $2;
|
|
2867
3106
|
var lt = $3;
|
|
@@ -2955,7 +3194,7 @@ ${input.slice(result.pos)}
|
|
|
2955
3194
|
return result;
|
|
2956
3195
|
}
|
|
2957
3196
|
}
|
|
2958
|
-
var ImplementsToken$0 = $TS($S(Loc, __, ImplementsShorthand, $E($EXPECT($
|
|
3197
|
+
var ImplementsToken$0 = $TS($S(Loc, __, ImplementsShorthand, $E($EXPECT($L9, fail, 'ImplementsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2959
3198
|
var l = $1;
|
|
2960
3199
|
var ws = $2;
|
|
2961
3200
|
var token = $3;
|
|
@@ -2965,7 +3204,7 @@ ${input.slice(result.pos)}
|
|
|
2965
3204
|
}
|
|
2966
3205
|
return { children };
|
|
2967
3206
|
});
|
|
2968
|
-
var ImplementsToken$1 = $TS($S(__, $EXPECT($
|
|
3207
|
+
var ImplementsToken$1 = $TS($S(__, $EXPECT($L10, fail, 'ImplementsToken "implements"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
2969
3208
|
$2 = { $loc, token: $2 };
|
|
2970
3209
|
return [$1, $2];
|
|
2971
3210
|
});
|
|
@@ -2991,7 +3230,7 @@ ${input.slice(result.pos)}
|
|
|
2991
3230
|
return result;
|
|
2992
3231
|
}
|
|
2993
3232
|
}
|
|
2994
|
-
var ImplementsShorthand$0 = $TV($EXPECT($
|
|
3233
|
+
var ImplementsShorthand$0 = $TV($EXPECT($L11, fail, 'ImplementsShorthand "<:"'), function($skip, $loc, $0, $1) {
|
|
2995
3234
|
return { $loc, token: "implements " };
|
|
2996
3235
|
});
|
|
2997
3236
|
function ImplementsShorthand(state) {
|
|
@@ -3114,7 +3353,7 @@ ${input.slice(result.pos)}
|
|
|
3114
3353
|
return result;
|
|
3115
3354
|
}
|
|
3116
3355
|
}
|
|
3117
|
-
var ClassElement$0 = $S($E(Decorators), $E(AccessModifier), $E($S(Static, $
|
|
3356
|
+
var ClassElement$0 = $S($E(Decorators), $E(AccessModifier), $E($S(Static, $E(_))), ClassElementDefinition);
|
|
3118
3357
|
var ClassElement$1 = $S(Static, BracedBlock);
|
|
3119
3358
|
function ClassElement(state) {
|
|
3120
3359
|
let eventData;
|
|
@@ -3260,7 +3499,7 @@ ${input.slice(result.pos)}
|
|
|
3260
3499
|
return result;
|
|
3261
3500
|
}
|
|
3262
3501
|
}
|
|
3263
|
-
var ClassSignatureElement$0 = $S($E(Decorators), $E(AccessModifier), $E($S(Static, $
|
|
3502
|
+
var ClassSignatureElement$0 = $S($E(Decorators), $E(AccessModifier), $E($S(Static, $E(_))), $C(MethodSignature, FieldDefinition));
|
|
3264
3503
|
var ClassSignatureElement$1 = $S(Static, ClassSignatureBody);
|
|
3265
3504
|
function ClassSignatureElement(state) {
|
|
3266
3505
|
let eventData;
|
|
@@ -3336,7 +3575,7 @@ ${input.slice(result.pos)}
|
|
|
3336
3575
|
};
|
|
3337
3576
|
return $0;
|
|
3338
3577
|
});
|
|
3339
|
-
var FieldDefinition$2 = $TS($S($E($S(Abstract, $
|
|
3578
|
+
var FieldDefinition$2 = $TS($S($E($S(Abstract, $E(_))), $E($S(Readonly, $E(_))), ClassElementName, $E(TypeSuffix), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
3340
3579
|
if ($1)
|
|
3341
3580
|
return { children: $0, ts: true };
|
|
3342
3581
|
return $0;
|
|
@@ -3364,7 +3603,7 @@ ${input.slice(result.pos)}
|
|
|
3364
3603
|
}
|
|
3365
3604
|
}
|
|
3366
3605
|
var ThisLiteral$0 = This;
|
|
3367
|
-
var ThisLiteral$1 = $TS($S(AtThis, $TEXT($S($E($EXPECT($
|
|
3606
|
+
var ThisLiteral$1 = $TS($S(AtThis, $TEXT($S($E($EXPECT($L12, fail, 'ThisLiteral "#"')), IdentifierName))), function($skip, $loc, $0, $1, $2) {
|
|
3368
3607
|
var at = $1;
|
|
3369
3608
|
var id = $2;
|
|
3370
3609
|
return [at, ".", id];
|
|
@@ -3418,7 +3657,7 @@ ${input.slice(result.pos)}
|
|
|
3418
3657
|
return result;
|
|
3419
3658
|
}
|
|
3420
3659
|
}
|
|
3421
|
-
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($
|
|
3660
|
+
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($L5, fail, 'LeftHandSideExpression "."')), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
3422
3661
|
if ($1.length)
|
|
3423
3662
|
return $0;
|
|
3424
3663
|
return $2;
|
|
@@ -3445,14 +3684,14 @@ ${input.slice(result.pos)}
|
|
|
3445
3684
|
return result;
|
|
3446
3685
|
}
|
|
3447
3686
|
}
|
|
3448
|
-
var CallExpression$0 = $TS($S($EXPECT($
|
|
3687
|
+
var CallExpression$0 = $TS($S($EXPECT($L13, fail, 'CallExpression "super"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
3449
3688
|
var rest = $3;
|
|
3450
3689
|
return module.processGlob({
|
|
3451
3690
|
type: "CallExpression",
|
|
3452
3691
|
children: [$1, ...$2, ...rest.flat()]
|
|
3453
3692
|
});
|
|
3454
3693
|
});
|
|
3455
|
-
var CallExpression$1 = $TS($S($EXPECT($
|
|
3694
|
+
var CallExpression$1 = $TS($S($EXPECT($L14, fail, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
3456
3695
|
var rest = $3;
|
|
3457
3696
|
return module.processGlob({
|
|
3458
3697
|
type: "CallExpression",
|
|
@@ -3495,7 +3734,7 @@ ${input.slice(result.pos)}
|
|
|
3495
3734
|
return result;
|
|
3496
3735
|
}
|
|
3497
3736
|
}
|
|
3498
|
-
var ReturnValue$0 = $TV($C($S($EXPECT($
|
|
3737
|
+
var ReturnValue$0 = $TV($C($S($EXPECT($L15, fail, 'ReturnValue "return.value"'), NonIdContinue), $S(Return, $Y(AfterReturnShorthand))), function($skip, $loc, $0, $1) {
|
|
3499
3738
|
return { type: "ReturnValue", children: [$1[0]] };
|
|
3500
3739
|
});
|
|
3501
3740
|
function ReturnValue(state) {
|
|
@@ -3633,7 +3872,7 @@ ${input.slice(result.pos)}
|
|
|
3633
3872
|
return result;
|
|
3634
3873
|
}
|
|
3635
3874
|
}
|
|
3636
|
-
var NonNullAssertion$0 = $T($S($EXPECT($
|
|
3875
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L16, fail, 'NonNullAssertion "!"'), $N($EXPECT($L17, fail, 'NonNullAssertion "^"'))), function(value) {
|
|
3637
3876
|
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
3638
3877
|
});
|
|
3639
3878
|
function NonNullAssertion(state) {
|
|
@@ -3771,7 +4010,7 @@ ${input.slice(result.pos)}
|
|
|
3771
4010
|
]
|
|
3772
4011
|
};
|
|
3773
4012
|
});
|
|
3774
|
-
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($
|
|
4013
|
+
var MemberBracketContent$3 = $TS($S(Dot, $EXPECT($L18, fail, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
3775
4014
|
var dot = $1;
|
|
3776
4015
|
var neg = $2;
|
|
3777
4016
|
var num = $3;
|
|
@@ -3957,8 +4196,8 @@ ${input.slice(result.pos)}
|
|
|
3957
4196
|
return result;
|
|
3958
4197
|
}
|
|
3959
4198
|
}
|
|
3960
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
3961
|
-
var SuperProperty$1 = $S($EXPECT($
|
|
4199
|
+
var SuperProperty$0 = $S($EXPECT($L13, fail, 'SuperProperty "super"'), MemberBracketContent);
|
|
4200
|
+
var SuperProperty$1 = $S($EXPECT($L13, fail, 'SuperProperty "super"'), $N($C(QuestionMark, NonNullAssertion)), PropertyAccess);
|
|
3962
4201
|
function SuperProperty(state) {
|
|
3963
4202
|
let eventData;
|
|
3964
4203
|
if (state.events) {
|
|
@@ -3982,7 +4221,7 @@ ${input.slice(result.pos)}
|
|
|
3982
4221
|
}
|
|
3983
4222
|
}
|
|
3984
4223
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
3985
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
4224
|
+
var MetaProperty$1 = $TS($S($EXPECT($L19, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3986
4225
|
return { $loc, token: $1 };
|
|
3987
4226
|
});
|
|
3988
4227
|
function MetaProperty(state) {
|
|
@@ -4008,7 +4247,7 @@ ${input.slice(result.pos)}
|
|
|
4008
4247
|
}
|
|
4009
4248
|
}
|
|
4010
4249
|
var Parameters$0 = NonEmptyParameters;
|
|
4011
|
-
var Parameters$1 = $TV($EXPECT($
|
|
4250
|
+
var Parameters$1 = $TV($EXPECT($L0, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
4012
4251
|
return {
|
|
4013
4252
|
type: "Parameters",
|
|
4014
4253
|
children: [{ $loc, token: "()" }],
|
|
@@ -4865,7 +5104,7 @@ ${input.slice(result.pos)}
|
|
|
4865
5104
|
return result;
|
|
4866
5105
|
}
|
|
4867
5106
|
}
|
|
4868
|
-
var EmptyBindingPattern$0 = $TV($EXPECT($
|
|
5107
|
+
var EmptyBindingPattern$0 = $TV($EXPECT($L0, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
|
|
4869
5108
|
const ref = {
|
|
4870
5109
|
type: "Ref",
|
|
4871
5110
|
base: "ref",
|
|
@@ -5476,7 +5715,30 @@ ${input.slice(result.pos)}
|
|
|
5476
5715
|
block
|
|
5477
5716
|
};
|
|
5478
5717
|
});
|
|
5479
|
-
var FunctionExpression$1 =
|
|
5718
|
+
var FunctionExpression$1 = AmpersandFunctionExpression;
|
|
5719
|
+
function FunctionExpression(state) {
|
|
5720
|
+
let eventData;
|
|
5721
|
+
if (state.events) {
|
|
5722
|
+
const result = state.events.enter?.("FunctionExpression", state);
|
|
5723
|
+
if (result) {
|
|
5724
|
+
if (result.cache)
|
|
5725
|
+
return result.cache;
|
|
5726
|
+
eventData = result.data;
|
|
5727
|
+
}
|
|
5728
|
+
}
|
|
5729
|
+
if (state.tokenize) {
|
|
5730
|
+
const result = $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
|
|
5731
|
+
if (state.events)
|
|
5732
|
+
state.events.exit?.("FunctionExpression", state, result, eventData);
|
|
5733
|
+
return result;
|
|
5734
|
+
} else {
|
|
5735
|
+
const result = FunctionExpression$0(state) || FunctionExpression$1(state);
|
|
5736
|
+
if (state.events)
|
|
5737
|
+
state.events.exit?.("FunctionExpression", state, result, eventData);
|
|
5738
|
+
return result;
|
|
5739
|
+
}
|
|
5740
|
+
}
|
|
5741
|
+
var AmpersandFunctionExpression$0 = $TS($S($E(AmpersandUnaryPrefix), $C(Ampersand, $S($N(NumericLiteral), $Y($S($E(QuestionMark), Dot)))), $E(AmpersandBlockRHS)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5480
5742
|
var prefix = $1;
|
|
5481
5743
|
var rhs = $3;
|
|
5482
5744
|
if (!prefix && !rhs)
|
|
@@ -5505,10 +5767,10 @@ ${input.slice(result.pos)}
|
|
|
5505
5767
|
ampersandBlock: true
|
|
5506
5768
|
};
|
|
5507
5769
|
});
|
|
5508
|
-
function
|
|
5770
|
+
function AmpersandFunctionExpression(state) {
|
|
5509
5771
|
let eventData;
|
|
5510
5772
|
if (state.events) {
|
|
5511
|
-
const result = state.events.enter?.("
|
|
5773
|
+
const result = state.events.enter?.("AmpersandFunctionExpression", state);
|
|
5512
5774
|
if (result) {
|
|
5513
5775
|
if (result.cache)
|
|
5514
5776
|
return result.cache;
|
|
@@ -5516,14 +5778,14 @@ ${input.slice(result.pos)}
|
|
|
5516
5778
|
}
|
|
5517
5779
|
}
|
|
5518
5780
|
if (state.tokenize) {
|
|
5519
|
-
const result = $TOKEN("
|
|
5781
|
+
const result = $TOKEN("AmpersandFunctionExpression", state, AmpersandFunctionExpression$0(state));
|
|
5520
5782
|
if (state.events)
|
|
5521
|
-
state.events.exit?.("
|
|
5783
|
+
state.events.exit?.("AmpersandFunctionExpression", state, result, eventData);
|
|
5522
5784
|
return result;
|
|
5523
5785
|
} else {
|
|
5524
|
-
const result =
|
|
5786
|
+
const result = AmpersandFunctionExpression$0(state);
|
|
5525
5787
|
if (state.events)
|
|
5526
|
-
state.events.exit?.("
|
|
5788
|
+
state.events.exit?.("AmpersandFunctionExpression", state, result, eventData);
|
|
5527
5789
|
return result;
|
|
5528
5790
|
}
|
|
5529
5791
|
}
|
|
@@ -5773,10 +6035,11 @@ ${input.slice(result.pos)}
|
|
|
5773
6035
|
});
|
|
5774
6036
|
var ExplicitBlock$1 = $TS($S(__, OpenBrace, NestedBlockStatements, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
5775
6037
|
var block = $3;
|
|
5776
|
-
return
|
|
6038
|
+
return {
|
|
6039
|
+
...block,
|
|
5777
6040
|
children: [$1, $2, ...block.children, $4, $5],
|
|
5778
6041
|
bare: false
|
|
5779
|
-
}
|
|
6042
|
+
};
|
|
5780
6043
|
});
|
|
5781
6044
|
function ExplicitBlock(state) {
|
|
5782
6045
|
let eventData;
|
|
@@ -5836,7 +6099,7 @@ ${input.slice(result.pos)}
|
|
|
5836
6099
|
var Block$0 = ExplicitBlock;
|
|
5837
6100
|
var Block$1 = ImplicitNestedBlock;
|
|
5838
6101
|
var Block$2 = ThenClause;
|
|
5839
|
-
var Block$3 = $TS($S($
|
|
6102
|
+
var Block$3 = $TS($S($E(_), $N(EOS), Statement), function($skip, $loc, $0, $1, $2, $3) {
|
|
5840
6103
|
var ws = $1;
|
|
5841
6104
|
var s = $3;
|
|
5842
6105
|
const expressions = [[ws, s]];
|
|
@@ -5974,7 +6237,7 @@ ${input.slice(result.pos)}
|
|
|
5974
6237
|
return result;
|
|
5975
6238
|
}
|
|
5976
6239
|
}
|
|
5977
|
-
var EmptyBareBlock$0 = $TV($EXPECT($
|
|
6240
|
+
var EmptyBareBlock$0 = $TV($EXPECT($L0, fail, 'EmptyBareBlock ""'), function($skip, $loc, $0, $1) {
|
|
5978
6241
|
const expressions = [];
|
|
5979
6242
|
return {
|
|
5980
6243
|
type: "BlockStatement",
|
|
@@ -6077,7 +6340,7 @@ ${input.slice(result.pos)}
|
|
|
6077
6340
|
return result;
|
|
6078
6341
|
}
|
|
6079
6342
|
}
|
|
6080
|
-
var NonSingleBracedBlock$0 = $TS($S($
|
|
6343
|
+
var NonSingleBracedBlock$0 = $TS($S($E(_), OpenBrace, AllowAll, $E($S(BracedContent, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
6081
6344
|
var ws1 = $1;
|
|
6082
6345
|
var open = $2;
|
|
6083
6346
|
if (!$4)
|
|
@@ -6193,7 +6456,7 @@ ${input.slice(result.pos)}
|
|
|
6193
6456
|
}
|
|
6194
6457
|
}
|
|
6195
6458
|
var BracedContent$0 = NestedBlockStatements;
|
|
6196
|
-
var BracedContent$1 = $TS($S($
|
|
6459
|
+
var BracedContent$1 = $TS($S($E(_), Statement), function($skip, $loc, $0, $1, $2) {
|
|
6197
6460
|
const expressions = [["", $2]];
|
|
6198
6461
|
return {
|
|
6199
6462
|
type: "BlockStatement",
|
|
@@ -6237,8 +6500,11 @@ ${input.slice(result.pos)}
|
|
|
6237
6500
|
return $skip;
|
|
6238
6501
|
const first = statements[0];
|
|
6239
6502
|
const ws = first[0];
|
|
6240
|
-
const
|
|
6241
|
-
|
|
6503
|
+
const indent = ws.at(-1);
|
|
6504
|
+
statements = [
|
|
6505
|
+
[indent, ...first.slice(1)],
|
|
6506
|
+
...statements.slice(1)
|
|
6507
|
+
];
|
|
6242
6508
|
return {
|
|
6243
6509
|
type: "BlockStatement",
|
|
6244
6510
|
expressions: statements,
|
|
@@ -6268,7 +6534,16 @@ ${input.slice(result.pos)}
|
|
|
6268
6534
|
return result;
|
|
6269
6535
|
}
|
|
6270
6536
|
}
|
|
6271
|
-
var NestedBlockStatement$0 = $S(Nested, StatementListItem, StatementDelimiter)
|
|
6537
|
+
var NestedBlockStatement$0 = $TS($S(Nested, $E(_), StatementListItem, StatementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6538
|
+
var nested = $1;
|
|
6539
|
+
var ws = $2;
|
|
6540
|
+
var statement = $3;
|
|
6541
|
+
var delimiter = $4;
|
|
6542
|
+
if (ws) {
|
|
6543
|
+
statement = { ...statement, children: [ws, ...statement.children] };
|
|
6544
|
+
}
|
|
6545
|
+
return [nested, statement, delimiter];
|
|
6546
|
+
});
|
|
6272
6547
|
function NestedBlockStatement(state) {
|
|
6273
6548
|
let eventData;
|
|
6274
6549
|
if (state.events) {
|
|
@@ -6509,7 +6784,7 @@ ${input.slice(result.pos)}
|
|
|
6509
6784
|
return result;
|
|
6510
6785
|
}
|
|
6511
6786
|
}
|
|
6512
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($
|
|
6787
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L2, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L2, fail, 'UpcomingAssignment "="'), $EXPECT($L30, fail, 'UpcomingAssignment ">"')))));
|
|
6513
6788
|
function UpcomingAssignment(state) {
|
|
6514
6789
|
let eventData;
|
|
6515
6790
|
if (state.events) {
|
|
@@ -7225,7 +7500,7 @@ ${input.slice(result.pos)}
|
|
|
7225
7500
|
return result;
|
|
7226
7501
|
}
|
|
7227
7502
|
}
|
|
7228
|
-
var ImplicitInlineObjectPropertyDelimiter$0 = $S($
|
|
7503
|
+
var ImplicitInlineObjectPropertyDelimiter$0 = $S($E(_), Comma);
|
|
7229
7504
|
var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
|
|
7230
7505
|
return value[1];
|
|
7231
7506
|
});
|
|
@@ -7568,7 +7843,7 @@ ${input.slice(result.pos)}
|
|
|
7568
7843
|
expression
|
|
7569
7844
|
};
|
|
7570
7845
|
});
|
|
7571
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7846
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L18, fail, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7572
7847
|
return {
|
|
7573
7848
|
type: "ComputedPropertyName",
|
|
7574
7849
|
children: $0
|
|
@@ -7619,7 +7894,12 @@ ${input.slice(result.pos)}
|
|
|
7619
7894
|
return result;
|
|
7620
7895
|
}
|
|
7621
7896
|
}
|
|
7622
|
-
var Decorators$0 = $S($
|
|
7897
|
+
var Decorators$0 = $TS($S(ForbidClassImplicitCall, $Q($S(__, Decorator)), __, RestoreClassImplicitCall), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7898
|
+
var decorators = $2;
|
|
7899
|
+
if (!decorators.length)
|
|
7900
|
+
return $skip;
|
|
7901
|
+
return $0;
|
|
7902
|
+
});
|
|
7623
7903
|
function Decorators(state) {
|
|
7624
7904
|
let eventData;
|
|
7625
7905
|
if (state.events) {
|
|
@@ -7687,7 +7967,7 @@ ${input.slice(result.pos)}
|
|
|
7687
7967
|
return result;
|
|
7688
7968
|
}
|
|
7689
7969
|
}
|
|
7690
|
-
var MethodModifier$0 = $S(GetOrSet, $
|
|
7970
|
+
var MethodModifier$0 = $S(GetOrSet, $E(_));
|
|
7691
7971
|
var MethodModifier$1 = $S($S(Async, __), $E($S(Star, __)));
|
|
7692
7972
|
var MethodModifier$2 = $S(Star, __);
|
|
7693
7973
|
function MethodModifier(state) {
|
|
@@ -7786,7 +8066,7 @@ ${input.slice(result.pos)}
|
|
|
7786
8066
|
return result;
|
|
7787
8067
|
}
|
|
7788
8068
|
}
|
|
7789
|
-
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($
|
|
8069
|
+
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L12, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
|
|
7790
8070
|
return {
|
|
7791
8071
|
type: "Identifier",
|
|
7792
8072
|
name: $0,
|
|
@@ -7843,8 +8123,8 @@ ${input.slice(result.pos)}
|
|
|
7843
8123
|
return result;
|
|
7844
8124
|
}
|
|
7845
8125
|
}
|
|
7846
|
-
var AssignmentOp$0 = $TS($S(AssignmentOpSymbol, $
|
|
7847
|
-
if ($2
|
|
8126
|
+
var AssignmentOp$0 = $TS($S(AssignmentOpSymbol, $E(_)), function($skip, $loc, $0, $1, $2) {
|
|
8127
|
+
if ($2?.length) {
|
|
7848
8128
|
return {
|
|
7849
8129
|
token: $1,
|
|
7850
8130
|
children: [$1, ...$2]
|
|
@@ -7874,21 +8154,21 @@ ${input.slice(result.pos)}
|
|
|
7874
8154
|
return result;
|
|
7875
8155
|
}
|
|
7876
8156
|
}
|
|
7877
|
-
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($
|
|
8157
|
+
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L2, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $E(_)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7878
8158
|
return {
|
|
7879
8159
|
special: true,
|
|
7880
8160
|
call: module.getRef("xor"),
|
|
7881
8161
|
children: [$2, ...$4]
|
|
7882
8162
|
};
|
|
7883
8163
|
});
|
|
7884
|
-
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($
|
|
8164
|
+
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L2, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $E(_)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7885
8165
|
return {
|
|
7886
8166
|
special: true,
|
|
7887
8167
|
call: module.getRef("xnor"),
|
|
7888
8168
|
children: [$2, ...$4]
|
|
7889
8169
|
};
|
|
7890
8170
|
});
|
|
7891
|
-
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($
|
|
8171
|
+
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L2, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $E(_)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7892
8172
|
return {
|
|
7893
8173
|
special: true,
|
|
7894
8174
|
call: $1,
|
|
@@ -7935,7 +8215,7 @@ ${input.slice(result.pos)}
|
|
|
7935
8215
|
var AssignmentOpSymbol$15 = $T($EXPECT($L49, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
7936
8216
|
return "??=";
|
|
7937
8217
|
});
|
|
7938
|
-
var AssignmentOpSymbol$16 = $T($S($EXPECT($
|
|
8218
|
+
var AssignmentOpSymbol$16 = $T($S($EXPECT($L2, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L2, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
7939
8219
|
return value[0];
|
|
7940
8220
|
});
|
|
7941
8221
|
var AssignmentOpSymbol$17 = $T($S(CoffeeWordAssignmentOp), function(value) {
|
|
@@ -8048,7 +8328,7 @@ ${input.slice(result.pos)}
|
|
|
8048
8328
|
});
|
|
8049
8329
|
var BinaryOpSymbol$4 = $EXPECT($L57, fail, 'BinaryOpSymbol "%"');
|
|
8050
8330
|
var BinaryOpSymbol$5 = $EXPECT($L58, fail, 'BinaryOpSymbol "+"');
|
|
8051
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
8331
|
+
var BinaryOpSymbol$6 = $EXPECT($L18, fail, 'BinaryOpSymbol "-"');
|
|
8052
8332
|
var BinaryOpSymbol$7 = $EXPECT($L59, fail, 'BinaryOpSymbol "<="');
|
|
8053
8333
|
var BinaryOpSymbol$8 = $EXPECT($L60, fail, 'BinaryOpSymbol ">="');
|
|
8054
8334
|
var BinaryOpSymbol$9 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
@@ -8116,7 +8396,7 @@ ${input.slice(result.pos)}
|
|
|
8116
8396
|
};
|
|
8117
8397
|
});
|
|
8118
8398
|
var BinaryOpSymbol$28 = $EXPECT($L79, fail, 'BinaryOpSymbol "??"');
|
|
8119
|
-
var BinaryOpSymbol$29 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($
|
|
8399
|
+
var BinaryOpSymbol$29 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L4, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
8120
8400
|
return "??";
|
|
8121
8401
|
});
|
|
8122
8402
|
var BinaryOpSymbol$30 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
@@ -8206,7 +8486,7 @@ ${input.slice(result.pos)}
|
|
|
8206
8486
|
return $1;
|
|
8207
8487
|
});
|
|
8208
8488
|
var BinaryOpSymbol$40 = $EXPECT($L83, fail, 'BinaryOpSymbol "&"');
|
|
8209
|
-
var BinaryOpSymbol$41 = $EXPECT($
|
|
8489
|
+
var BinaryOpSymbol$41 = $EXPECT($L17, fail, 'BinaryOpSymbol "^"');
|
|
8210
8490
|
var BinaryOpSymbol$42 = $EXPECT($L84, fail, 'BinaryOpSymbol "|"');
|
|
8211
8491
|
function BinaryOpSymbol(state) {
|
|
8212
8492
|
let eventData;
|
|
@@ -8354,7 +8634,7 @@ ${input.slice(result.pos)}
|
|
|
8354
8634
|
return result;
|
|
8355
8635
|
}
|
|
8356
8636
|
}
|
|
8357
|
-
var PostfixedStatement$0 = $TS($S(Statement, $E($S($
|
|
8637
|
+
var PostfixedStatement$0 = $TS($S(Statement, $E($S($E(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
|
|
8358
8638
|
var statement = $1;
|
|
8359
8639
|
var post = $2;
|
|
8360
8640
|
if (post)
|
|
@@ -8383,7 +8663,7 @@ ${input.slice(result.pos)}
|
|
|
8383
8663
|
return result;
|
|
8384
8664
|
}
|
|
8385
8665
|
}
|
|
8386
|
-
var PostfixedExpression$0 = $TS($S(ExtendedExpression, $E($S($
|
|
8666
|
+
var PostfixedExpression$0 = $TS($S(ExtendedExpression, $E($S($E(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
|
|
8387
8667
|
var expression = $1;
|
|
8388
8668
|
var post = $2;
|
|
8389
8669
|
if (post)
|
|
@@ -8412,7 +8692,7 @@ ${input.slice(result.pos)}
|
|
|
8412
8692
|
return result;
|
|
8413
8693
|
}
|
|
8414
8694
|
}
|
|
8415
|
-
var NonPipelinePostfixedExpression$0 = $TS($S(NonPipelineExtendedExpression, $E($S($
|
|
8695
|
+
var NonPipelinePostfixedExpression$0 = $TS($S(NonPipelineExtendedExpression, $E($S($E(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
|
|
8416
8696
|
var expression = $1;
|
|
8417
8697
|
var post = $2;
|
|
8418
8698
|
if (post)
|
|
@@ -8505,8 +8785,8 @@ ${input.slice(result.pos)}
|
|
|
8505
8785
|
return result;
|
|
8506
8786
|
}
|
|
8507
8787
|
}
|
|
8508
|
-
var EmptyStatement$0 = $
|
|
8509
|
-
return {
|
|
8788
|
+
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L85, fail, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
|
|
8789
|
+
return { type: "EmptyStatement", children: $1 || [] };
|
|
8510
8790
|
});
|
|
8511
8791
|
function EmptyStatement(state) {
|
|
8512
8792
|
let eventData;
|
|
@@ -8530,7 +8810,7 @@ ${input.slice(result.pos)}
|
|
|
8530
8810
|
return result;
|
|
8531
8811
|
}
|
|
8532
8812
|
}
|
|
8533
|
-
var BlockStatement$0 = $T($S(ExplicitBlock, $N($S(__, $EXPECT($
|
|
8813
|
+
var BlockStatement$0 = $T($S(ExplicitBlock, $N($S(__, $EXPECT($L2, fail, 'BlockStatement "="')))), function(value) {
|
|
8534
8814
|
return value[0];
|
|
8535
8815
|
});
|
|
8536
8816
|
function BlockStatement(state) {
|
|
@@ -8670,7 +8950,7 @@ ${input.slice(result.pos)}
|
|
|
8670
8950
|
}
|
|
8671
8951
|
}
|
|
8672
8952
|
var ElseClause$0 = $S(Samedent, Else, Block);
|
|
8673
|
-
var ElseClause$1 = $S($
|
|
8953
|
+
var ElseClause$1 = $S($E(_), Else, Block);
|
|
8674
8954
|
function ElseClause(state) {
|
|
8675
8955
|
let eventData;
|
|
8676
8956
|
if (state.events) {
|
|
@@ -8805,7 +9085,7 @@ ${input.slice(result.pos)}
|
|
|
8805
9085
|
return result;
|
|
8806
9086
|
}
|
|
8807
9087
|
}
|
|
8808
|
-
var ElseExpressionClause$0 = $TS($S($C($S(Samedent, Else), $S($
|
|
9088
|
+
var ElseExpressionClause$0 = $TS($S($C($S(Samedent, Else), $S($E(_), Else)), ElseExpressionBlock), function($skip, $loc, $0, $1, $2) {
|
|
8809
9089
|
return [...$1, $2];
|
|
8810
9090
|
});
|
|
8811
9091
|
function ElseExpressionClause(state) {
|
|
@@ -9181,7 +9461,7 @@ ${input.slice(result.pos)}
|
|
|
9181
9461
|
return result;
|
|
9182
9462
|
}
|
|
9183
9463
|
}
|
|
9184
|
-
var WhileClause$0 = $TS($S($C(While, Until), $
|
|
9464
|
+
var WhileClause$0 = $TS($S($C(While, Until), $E(_), Condition), function($skip, $loc, $0, $1, $2, $3) {
|
|
9185
9465
|
var kind = $1;
|
|
9186
9466
|
var ws = $2;
|
|
9187
9467
|
var cond = $3;
|
|
@@ -9293,11 +9573,17 @@ ${input.slice(result.pos)}
|
|
|
9293
9573
|
if ($3) {
|
|
9294
9574
|
const indent = module.currentIndent.token + " ";
|
|
9295
9575
|
const block = "continue\n";
|
|
9296
|
-
$2
|
|
9297
|
-
|
|
9298
|
-
|
|
9299
|
-
|
|
9300
|
-
|
|
9576
|
+
$2 = {
|
|
9577
|
+
...$2,
|
|
9578
|
+
blockPrefix: [
|
|
9579
|
+
...$2.blockPrefix,
|
|
9580
|
+
[indent, {
|
|
9581
|
+
type: "IfStatement",
|
|
9582
|
+
then: block,
|
|
9583
|
+
children: ["if (!(", module.insertTrimmingSpace($3, ""), ")) ", block]
|
|
9584
|
+
}]
|
|
9585
|
+
]
|
|
9586
|
+
};
|
|
9301
9587
|
}
|
|
9302
9588
|
return $2;
|
|
9303
9589
|
});
|
|
@@ -10060,7 +10346,7 @@ ${input.slice(result.pos)}
|
|
|
10060
10346
|
}
|
|
10061
10347
|
}
|
|
10062
10348
|
var ImpliedColon$0 = $S($E(_), Colon);
|
|
10063
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
10349
|
+
var ImpliedColon$1 = $TV($EXPECT($L0, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
10064
10350
|
return { $loc, token: ":" };
|
|
10065
10351
|
});
|
|
10066
10352
|
function ImpliedColon(state) {
|
|
@@ -10272,7 +10558,7 @@ ${input.slice(result.pos)}
|
|
|
10272
10558
|
return result;
|
|
10273
10559
|
}
|
|
10274
10560
|
}
|
|
10275
|
-
var Condition$0 = $T($S(ParenthesizedExpression, $N($S($
|
|
10561
|
+
var Condition$0 = $T($S(ParenthesizedExpression, $N($S($E(_), $C(BinaryOp, AssignmentOp, Dot, QuestionMark))), $N($S(_, OperatorAssignmentOp))), function(value) {
|
|
10276
10562
|
return value[0];
|
|
10277
10563
|
});
|
|
10278
10564
|
var Condition$1 = $TS($S(InsertOpenParen, ExpressionWithIndentedApplicationForbidden, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3) {
|
|
@@ -10338,7 +10624,82 @@ ${input.slice(result.pos)}
|
|
|
10338
10624
|
return result;
|
|
10339
10625
|
}
|
|
10340
10626
|
}
|
|
10341
|
-
var
|
|
10627
|
+
var ForbidClassImplicitCall$0 = $TV($EXPECT($L0, fail, 'ForbidClassImplicitCall ""'), function($skip, $loc, $0, $1) {
|
|
10628
|
+
module.forbidIndentedApplication.push(true);
|
|
10629
|
+
});
|
|
10630
|
+
function ForbidClassImplicitCall(state) {
|
|
10631
|
+
let eventData;
|
|
10632
|
+
if (state.events) {
|
|
10633
|
+
const result = state.events.enter?.("ForbidClassImplicitCall", state);
|
|
10634
|
+
if (result) {
|
|
10635
|
+
if (result.cache)
|
|
10636
|
+
return result.cache;
|
|
10637
|
+
eventData = result.data;
|
|
10638
|
+
}
|
|
10639
|
+
}
|
|
10640
|
+
if (state.tokenize) {
|
|
10641
|
+
const result = $TOKEN("ForbidClassImplicitCall", state, ForbidClassImplicitCall$0(state));
|
|
10642
|
+
if (state.events)
|
|
10643
|
+
state.events.exit?.("ForbidClassImplicitCall", state, result, eventData);
|
|
10644
|
+
return result;
|
|
10645
|
+
} else {
|
|
10646
|
+
const result = ForbidClassImplicitCall$0(state);
|
|
10647
|
+
if (state.events)
|
|
10648
|
+
state.events.exit?.("ForbidClassImplicitCall", state, result, eventData);
|
|
10649
|
+
return result;
|
|
10650
|
+
}
|
|
10651
|
+
}
|
|
10652
|
+
var AllowClassImplicitCall$0 = $TV($EXPECT($L0, fail, 'AllowClassImplicitCall ""'), function($skip, $loc, $0, $1) {
|
|
10653
|
+
module.forbidIndentedApplication.push(false);
|
|
10654
|
+
});
|
|
10655
|
+
function AllowClassImplicitCall(state) {
|
|
10656
|
+
let eventData;
|
|
10657
|
+
if (state.events) {
|
|
10658
|
+
const result = state.events.enter?.("AllowClassImplicitCall", state);
|
|
10659
|
+
if (result) {
|
|
10660
|
+
if (result.cache)
|
|
10661
|
+
return result.cache;
|
|
10662
|
+
eventData = result.data;
|
|
10663
|
+
}
|
|
10664
|
+
}
|
|
10665
|
+
if (state.tokenize) {
|
|
10666
|
+
const result = $TOKEN("AllowClassImplicitCall", state, AllowClassImplicitCall$0(state));
|
|
10667
|
+
if (state.events)
|
|
10668
|
+
state.events.exit?.("AllowClassImplicitCall", state, result, eventData);
|
|
10669
|
+
return result;
|
|
10670
|
+
} else {
|
|
10671
|
+
const result = AllowClassImplicitCall$0(state);
|
|
10672
|
+
if (state.events)
|
|
10673
|
+
state.events.exit?.("AllowClassImplicitCall", state, result, eventData);
|
|
10674
|
+
return result;
|
|
10675
|
+
}
|
|
10676
|
+
}
|
|
10677
|
+
var RestoreClassImplicitCall$0 = $TV($EXPECT($L0, fail, 'RestoreClassImplicitCall ""'), function($skip, $loc, $0, $1) {
|
|
10678
|
+
module.forbidIndentedApplication.pop();
|
|
10679
|
+
});
|
|
10680
|
+
function RestoreClassImplicitCall(state) {
|
|
10681
|
+
let eventData;
|
|
10682
|
+
if (state.events) {
|
|
10683
|
+
const result = state.events.enter?.("RestoreClassImplicitCall", state);
|
|
10684
|
+
if (result) {
|
|
10685
|
+
if (result.cache)
|
|
10686
|
+
return result.cache;
|
|
10687
|
+
eventData = result.data;
|
|
10688
|
+
}
|
|
10689
|
+
}
|
|
10690
|
+
if (state.tokenize) {
|
|
10691
|
+
const result = $TOKEN("RestoreClassImplicitCall", state, RestoreClassImplicitCall$0(state));
|
|
10692
|
+
if (state.events)
|
|
10693
|
+
state.events.exit?.("RestoreClassImplicitCall", state, result, eventData);
|
|
10694
|
+
return result;
|
|
10695
|
+
} else {
|
|
10696
|
+
const result = RestoreClassImplicitCall$0(state);
|
|
10697
|
+
if (state.events)
|
|
10698
|
+
state.events.exit?.("RestoreClassImplicitCall", state, result, eventData);
|
|
10699
|
+
return result;
|
|
10700
|
+
}
|
|
10701
|
+
}
|
|
10702
|
+
var ForbidIndentedApplication$0 = $TV($EXPECT($L0, fail, 'ForbidIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10342
10703
|
module.forbidIndentedApplication.push(true);
|
|
10343
10704
|
});
|
|
10344
10705
|
function ForbidIndentedApplication(state) {
|
|
@@ -10363,7 +10724,7 @@ ${input.slice(result.pos)}
|
|
|
10363
10724
|
return result;
|
|
10364
10725
|
}
|
|
10365
10726
|
}
|
|
10366
|
-
var AllowIndentedApplication$0 = $TV($EXPECT($
|
|
10727
|
+
var AllowIndentedApplication$0 = $TV($EXPECT($L0, fail, 'AllowIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10367
10728
|
module.forbidIndentedApplication.push(false);
|
|
10368
10729
|
});
|
|
10369
10730
|
function AllowIndentedApplication(state) {
|
|
@@ -10388,7 +10749,7 @@ ${input.slice(result.pos)}
|
|
|
10388
10749
|
return result;
|
|
10389
10750
|
}
|
|
10390
10751
|
}
|
|
10391
|
-
var RestoreIndentedApplication$0 = $TV($EXPECT($
|
|
10752
|
+
var RestoreIndentedApplication$0 = $TV($EXPECT($L0, fail, 'RestoreIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
10392
10753
|
module.forbidIndentedApplication.pop();
|
|
10393
10754
|
});
|
|
10394
10755
|
function RestoreIndentedApplication(state) {
|
|
@@ -10413,7 +10774,7 @@ ${input.slice(result.pos)}
|
|
|
10413
10774
|
return result;
|
|
10414
10775
|
}
|
|
10415
10776
|
}
|
|
10416
|
-
var IndentedApplicationAllowed$0 = $TV($EXPECT($
|
|
10777
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L0, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10417
10778
|
if (module.config.verbose) {
|
|
10418
10779
|
console.log("forbidIndentedApplication:", module.forbidIndentedApplication);
|
|
10419
10780
|
}
|
|
@@ -10443,7 +10804,7 @@ ${input.slice(result.pos)}
|
|
|
10443
10804
|
return result;
|
|
10444
10805
|
}
|
|
10445
10806
|
}
|
|
10446
|
-
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10807
|
+
var ForbidTrailingMemberProperty$0 = $TV($EXPECT($L0, fail, 'ForbidTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10447
10808
|
module.forbidTrailingMemberProperty.push(true);
|
|
10448
10809
|
});
|
|
10449
10810
|
function ForbidTrailingMemberProperty(state) {
|
|
@@ -10468,7 +10829,7 @@ ${input.slice(result.pos)}
|
|
|
10468
10829
|
return result;
|
|
10469
10830
|
}
|
|
10470
10831
|
}
|
|
10471
|
-
var AllowTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10832
|
+
var AllowTrailingMemberProperty$0 = $TV($EXPECT($L0, fail, 'AllowTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10472
10833
|
module.forbidTrailingMemberProperty.push(false);
|
|
10473
10834
|
});
|
|
10474
10835
|
function AllowTrailingMemberProperty(state) {
|
|
@@ -10493,7 +10854,7 @@ ${input.slice(result.pos)}
|
|
|
10493
10854
|
return result;
|
|
10494
10855
|
}
|
|
10495
10856
|
}
|
|
10496
|
-
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($
|
|
10857
|
+
var RestoreTrailingMemberProperty$0 = $TV($EXPECT($L0, fail, 'RestoreTrailingMemberProperty ""'), function($skip, $loc, $0, $1) {
|
|
10497
10858
|
module.forbidTrailingMemberProperty.pop();
|
|
10498
10859
|
});
|
|
10499
10860
|
function RestoreTrailingMemberProperty(state) {
|
|
@@ -10518,7 +10879,7 @@ ${input.slice(result.pos)}
|
|
|
10518
10879
|
return result;
|
|
10519
10880
|
}
|
|
10520
10881
|
}
|
|
10521
|
-
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($
|
|
10882
|
+
var TrailingMemberPropertyAllowed$0 = $TV($EXPECT($L0, fail, 'TrailingMemberPropertyAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10522
10883
|
if (module.config.verbose) {
|
|
10523
10884
|
console.log("forbidTrailingMemberProperty:", module.forbidTrailingMemberProperty);
|
|
10524
10885
|
}
|
|
@@ -10547,7 +10908,7 @@ ${input.slice(result.pos)}
|
|
|
10547
10908
|
return result;
|
|
10548
10909
|
}
|
|
10549
10910
|
}
|
|
10550
|
-
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10911
|
+
var ForbidMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L0, fail, 'ForbidMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10551
10912
|
module.forbidMultiLineImplicitObjectLiteral.push(true);
|
|
10552
10913
|
});
|
|
10553
10914
|
function ForbidMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10572,7 +10933,7 @@ ${input.slice(result.pos)}
|
|
|
10572
10933
|
return result;
|
|
10573
10934
|
}
|
|
10574
10935
|
}
|
|
10575
|
-
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10936
|
+
var AllowMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L0, fail, 'AllowMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10576
10937
|
module.forbidMultiLineImplicitObjectLiteral.push(false);
|
|
10577
10938
|
});
|
|
10578
10939
|
function AllowMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10597,7 +10958,7 @@ ${input.slice(result.pos)}
|
|
|
10597
10958
|
return result;
|
|
10598
10959
|
}
|
|
10599
10960
|
}
|
|
10600
|
-
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($
|
|
10961
|
+
var RestoreMultiLineImplicitObjectLiteral$0 = $TV($EXPECT($L0, fail, 'RestoreMultiLineImplicitObjectLiteral ""'), function($skip, $loc, $0, $1) {
|
|
10601
10962
|
module.forbidMultiLineImplicitObjectLiteral.pop();
|
|
10602
10963
|
});
|
|
10603
10964
|
function RestoreMultiLineImplicitObjectLiteral(state) {
|
|
@@ -10622,7 +10983,7 @@ ${input.slice(result.pos)}
|
|
|
10622
10983
|
return result;
|
|
10623
10984
|
}
|
|
10624
10985
|
}
|
|
10625
|
-
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($
|
|
10986
|
+
var MultiLineImplicitObjectLiteralAllowed$0 = $TV($EXPECT($L0, fail, 'MultiLineImplicitObjectLiteralAllowed ""'), function($skip, $loc, $0, $1) {
|
|
10626
10987
|
if (module.config.verbose) {
|
|
10627
10988
|
console.log("forbidMultiLineImplicitObjectLiteral:", module.forbidMultiLineImplicitObjectLiteral);
|
|
10628
10989
|
}
|
|
@@ -10651,7 +11012,7 @@ ${input.slice(result.pos)}
|
|
|
10651
11012
|
return result;
|
|
10652
11013
|
}
|
|
10653
11014
|
}
|
|
10654
|
-
var AllowAll$0 = $S(AllowTrailingMemberProperty, AllowIndentedApplication, AllowMultiLineImplicitObjectLiteral);
|
|
11015
|
+
var AllowAll$0 = $S(AllowTrailingMemberProperty, AllowIndentedApplication, AllowMultiLineImplicitObjectLiteral, AllowClassImplicitCall);
|
|
10655
11016
|
function AllowAll(state) {
|
|
10656
11017
|
let eventData;
|
|
10657
11018
|
if (state.events) {
|
|
@@ -10674,7 +11035,7 @@ ${input.slice(result.pos)}
|
|
|
10674
11035
|
return result;
|
|
10675
11036
|
}
|
|
10676
11037
|
}
|
|
10677
|
-
var RestoreAll$0 = $S(RestoreTrailingMemberProperty, RestoreIndentedApplication, RestoreMultiLineImplicitObjectLiteral);
|
|
11038
|
+
var RestoreAll$0 = $S(RestoreTrailingMemberProperty, RestoreIndentedApplication, RestoreMultiLineImplicitObjectLiteral, RestoreClassImplicitCall);
|
|
10678
11039
|
function RestoreAll(state) {
|
|
10679
11040
|
let eventData;
|
|
10680
11041
|
if (state.events) {
|
|
@@ -10736,7 +11097,7 @@ ${input.slice(result.pos)}
|
|
|
10736
11097
|
var KeywordStatement$2 = $T($S(Debugger), function(value) {
|
|
10737
11098
|
return { "type": "DebuggerStatement", "children": value };
|
|
10738
11099
|
});
|
|
10739
|
-
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($
|
|
11100
|
+
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L5, fail, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
|
|
10740
11101
|
var expression = value[2];
|
|
10741
11102
|
return { "type": "ReturnStatement", "expression": expression, "children": value };
|
|
10742
11103
|
});
|
|
@@ -10926,10 +11287,14 @@ ${input.slice(result.pos)}
|
|
|
10926
11287
|
}
|
|
10927
11288
|
}
|
|
10928
11289
|
var ImportDeclaration$0 = $T($S(Import, __, TypeKeyword, __, ImportClause, __, FromClause, $E(ImportAssertion)), function(value) {
|
|
10929
|
-
return { "ts": true, "children": value };
|
|
11290
|
+
return { "type": "ImportDeclaration", "ts": true, "children": value };
|
|
11291
|
+
});
|
|
11292
|
+
var ImportDeclaration$1 = $T($S(Import, __, ImportClause, __, FromClause, $E(ImportAssertion)), function(value) {
|
|
11293
|
+
return { "type": "ImportDeclaration", "children": value };
|
|
11294
|
+
});
|
|
11295
|
+
var ImportDeclaration$2 = $T($S(Import, __, ModuleSpecifier, $E(ImportAssertion)), function(value) {
|
|
11296
|
+
return { "type": "ImportDeclaration", "children": value };
|
|
10930
11297
|
});
|
|
10931
|
-
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause, $E(ImportAssertion));
|
|
10932
|
-
var ImportDeclaration$2 = $S(Import, __, ModuleSpecifier, $E(ImportAssertion));
|
|
10933
11298
|
var ImportDeclaration$3 = $TS($S(ImpliedImport, $E($S(TypeKeyword, __)), ImportClause, __, FromClause, $E(ImportAssertion)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
10934
11299
|
var i = $1;
|
|
10935
11300
|
var t = $2;
|
|
@@ -10944,7 +11309,7 @@ ${input.slice(result.pos)}
|
|
|
10944
11309
|
const children = [i, t, c, w, f, a];
|
|
10945
11310
|
if (!t)
|
|
10946
11311
|
return children;
|
|
10947
|
-
return { ts: true, children };
|
|
11312
|
+
return { type: "ImportDeclaration", ts: true, children };
|
|
10948
11313
|
});
|
|
10949
11314
|
function ImportDeclaration(state) {
|
|
10950
11315
|
let eventData;
|
|
@@ -10968,7 +11333,7 @@ ${input.slice(result.pos)}
|
|
|
10968
11333
|
return result;
|
|
10969
11334
|
}
|
|
10970
11335
|
}
|
|
10971
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
11336
|
+
var ImpliedImport$0 = $TV($EXPECT($L0, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
10972
11337
|
return { $loc, token: "import " };
|
|
10973
11338
|
});
|
|
10974
11339
|
function ImpliedImport(state) {
|
|
@@ -11220,7 +11585,7 @@ ${input.slice(result.pos)}
|
|
|
11220
11585
|
}
|
|
11221
11586
|
}
|
|
11222
11587
|
var ImportAsToken$0 = $S(__, As);
|
|
11223
|
-
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($
|
|
11588
|
+
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($L9, fail, 'ImportAsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
11224
11589
|
var l = $1;
|
|
11225
11590
|
var ws = $2;
|
|
11226
11591
|
var c = $3;
|
|
@@ -11382,16 +11747,15 @@ ${input.slice(result.pos)}
|
|
|
11382
11747
|
return result;
|
|
11383
11748
|
}
|
|
11384
11749
|
}
|
|
11385
|
-
var ExportDeclaration$0 = $S(Export, __, Default, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression))
|
|
11750
|
+
var ExportDeclaration$0 = $TS($S(Export, __, Default, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
11751
|
+
return { type: "ExportDeclaration", children: $0 };
|
|
11752
|
+
});
|
|
11386
11753
|
var ExportDeclaration$1 = $TS($S(Export, __, ExportFromClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
11387
|
-
|
|
11388
|
-
return $0;
|
|
11389
|
-
return { ts: true, children: $0 };
|
|
11754
|
+
return { type: "ExportDeclaration", ts: $3.ts, children: $0 };
|
|
11390
11755
|
});
|
|
11391
|
-
var ExportDeclaration$2 = $TS($S(Export, __, $C(Declaration, VariableStatement, TypeAndNamedExports, ExportVarDec)), function($skip, $loc, $0, $1, $2, $3) {
|
|
11392
|
-
|
|
11393
|
-
|
|
11394
|
-
return { ts: true, children: $0 };
|
|
11756
|
+
var ExportDeclaration$2 = $TS($S($E(Decorators), Export, __, $C(Declaration, VariableStatement, TypeAndNamedExports, ExportVarDec)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
11757
|
+
var decl = $4;
|
|
11758
|
+
return { type: "ExportDeclaration", ts: decl.ts, children: $0 };
|
|
11395
11759
|
});
|
|
11396
11760
|
function ExportDeclaration(state) {
|
|
11397
11761
|
let eventData;
|
|
@@ -13159,9 +13523,7 @@ ${input.slice(result.pos)}
|
|
|
13159
13523
|
return result;
|
|
13160
13524
|
}
|
|
13161
13525
|
}
|
|
13162
|
-
var TrailingComment$0 =
|
|
13163
|
-
var TrailingComment$1 = InlineComment;
|
|
13164
|
-
var TrailingComment$2 = SingleLineComment;
|
|
13526
|
+
var TrailingComment$0 = $S($E(_), SingleLineComment);
|
|
13165
13527
|
function TrailingComment(state) {
|
|
13166
13528
|
let eventData;
|
|
13167
13529
|
if (state.events) {
|
|
@@ -13173,12 +13535,12 @@ ${input.slice(result.pos)}
|
|
|
13173
13535
|
}
|
|
13174
13536
|
}
|
|
13175
13537
|
if (state.tokenize) {
|
|
13176
|
-
const result = $TOKEN("TrailingComment", state, TrailingComment$0(state)
|
|
13538
|
+
const result = $TOKEN("TrailingComment", state, TrailingComment$0(state));
|
|
13177
13539
|
if (state.events)
|
|
13178
13540
|
state.events.exit?.("TrailingComment", state, result, eventData);
|
|
13179
13541
|
return result;
|
|
13180
13542
|
} else {
|
|
13181
|
-
const result = TrailingComment$0(state)
|
|
13543
|
+
const result = TrailingComment$0(state);
|
|
13182
13544
|
if (state.events)
|
|
13183
13545
|
state.events.exit?.("TrailingComment", state, result, eventData);
|
|
13184
13546
|
return result;
|
|
@@ -13309,7 +13671,7 @@ ${input.slice(result.pos)}
|
|
|
13309
13671
|
return result;
|
|
13310
13672
|
}
|
|
13311
13673
|
}
|
|
13312
|
-
var ExpressionDelimiter$0 = $TS($S($
|
|
13674
|
+
var ExpressionDelimiter$0 = $TS($S($E(_), Semicolon, InsertComma, $E(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
13313
13675
|
return [$1, $3, $4];
|
|
13314
13676
|
});
|
|
13315
13677
|
var ExpressionDelimiter$1 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
@@ -13362,7 +13724,7 @@ ${input.slice(result.pos)}
|
|
|
13362
13724
|
}
|
|
13363
13725
|
}
|
|
13364
13726
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
13365
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($
|
|
13727
|
+
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L3, fail, 'StatementDelimiter "("'), $EXPECT($L97, fail, 'StatementDelimiter "["'), $EXPECT($L98, fail, 'StatementDelimiter "`"'), $EXPECT($L58, fail, 'StatementDelimiter "+"'), $EXPECT($L18, fail, 'StatementDelimiter "-"'), $EXPECT($L54, fail, 'StatementDelimiter "*"'), $EXPECT($L55, fail, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, FatArrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L3, fail, 'StatementDelimiter "("'))))), InsertSemicolon);
|
|
13366
13728
|
var StatementDelimiter$2 = $Y(EOS);
|
|
13367
13729
|
function StatementDelimiter(state) {
|
|
13368
13730
|
let eventData;
|
|
@@ -13386,7 +13748,7 @@ ${input.slice(result.pos)}
|
|
|
13386
13748
|
return result;
|
|
13387
13749
|
}
|
|
13388
13750
|
}
|
|
13389
|
-
var SemicolonDelimiter$0 = $TS($S($
|
|
13751
|
+
var SemicolonDelimiter$0 = $TS($S($E(_), Semicolon, $E(TrailingComment)), function($skip, $loc, $0, $1, $2, $3) {
|
|
13390
13752
|
return {
|
|
13391
13753
|
type: "SemicolonDelimiter",
|
|
13392
13754
|
children: $0
|
|
@@ -13437,7 +13799,7 @@ ${input.slice(result.pos)}
|
|
|
13437
13799
|
return result;
|
|
13438
13800
|
}
|
|
13439
13801
|
}
|
|
13440
|
-
var Loc$0 = $TV($EXPECT($
|
|
13802
|
+
var Loc$0 = $TV($EXPECT($L0, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
13441
13803
|
return { $loc, token: "" };
|
|
13442
13804
|
});
|
|
13443
13805
|
function Loc(state) {
|
|
@@ -13462,7 +13824,7 @@ ${input.slice(result.pos)}
|
|
|
13462
13824
|
return result;
|
|
13463
13825
|
}
|
|
13464
13826
|
}
|
|
13465
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($L99, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($
|
|
13827
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L99, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L9, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
13466
13828
|
return { $loc, token: $1, ts: true };
|
|
13467
13829
|
});
|
|
13468
13830
|
function Abstract(state) {
|
|
@@ -14037,7 +14399,7 @@ ${input.slice(result.pos)}
|
|
|
14037
14399
|
return result;
|
|
14038
14400
|
}
|
|
14039
14401
|
}
|
|
14040
|
-
var Dot$0 = $TV($EXPECT($
|
|
14402
|
+
var Dot$0 = $TV($EXPECT($L5, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
14041
14403
|
return { $loc, token: $1 };
|
|
14042
14404
|
});
|
|
14043
14405
|
function Dot(state) {
|
|
@@ -14062,7 +14424,7 @@ ${input.slice(result.pos)}
|
|
|
14062
14424
|
return result;
|
|
14063
14425
|
}
|
|
14064
14426
|
}
|
|
14065
|
-
var DotDot$0 = $TS($S($EXPECT($L114, fail, 'DotDot ".."'), $N($EXPECT($
|
|
14427
|
+
var DotDot$0 = $TS($S($EXPECT($L114, fail, 'DotDot ".."'), $N($EXPECT($L5, fail, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
14066
14428
|
return { $loc, token: $1 };
|
|
14067
14429
|
});
|
|
14068
14430
|
function DotDot(state) {
|
|
@@ -14187,7 +14549,7 @@ ${input.slice(result.pos)}
|
|
|
14187
14549
|
return result;
|
|
14188
14550
|
}
|
|
14189
14551
|
}
|
|
14190
|
-
var Equals$0 = $TV($EXPECT($
|
|
14552
|
+
var Equals$0 = $TV($EXPECT($L2, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
14191
14553
|
return { $loc, token: $1 };
|
|
14192
14554
|
});
|
|
14193
14555
|
function Equals(state) {
|
|
@@ -14387,7 +14749,7 @@ ${input.slice(result.pos)}
|
|
|
14387
14749
|
return result;
|
|
14388
14750
|
}
|
|
14389
14751
|
}
|
|
14390
|
-
var If$0 = $TV($TEXT($S($EXPECT($L127, fail, 'If "if"'), NonIdContinue, $E($EXPECT($
|
|
14752
|
+
var If$0 = $TV($TEXT($S($EXPECT($L127, fail, 'If "if"'), NonIdContinue, $E($EXPECT($L9, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
14391
14753
|
return { $loc, token: $1 };
|
|
14392
14754
|
});
|
|
14393
14755
|
function If(state) {
|
|
@@ -14412,7 +14774,7 @@ ${input.slice(result.pos)}
|
|
|
14412
14774
|
return result;
|
|
14413
14775
|
}
|
|
14414
14776
|
}
|
|
14415
|
-
var Import$0 = $TS($S($EXPECT($
|
|
14777
|
+
var Import$0 = $TS($S($EXPECT($L14, fail, 'Import "import"'), $Y($EXPECT($R49, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
14416
14778
|
return { $loc, token: $1 };
|
|
14417
14779
|
});
|
|
14418
14780
|
function Import(state) {
|
|
@@ -14586,7 +14948,7 @@ ${input.slice(result.pos)}
|
|
|
14586
14948
|
return result;
|
|
14587
14949
|
}
|
|
14588
14950
|
}
|
|
14589
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L52, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($
|
|
14951
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L52, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L9, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
14590
14952
|
return { $loc, token: "!" };
|
|
14591
14953
|
});
|
|
14592
14954
|
function Not(state) {
|
|
@@ -14711,7 +15073,7 @@ ${input.slice(result.pos)}
|
|
|
14711
15073
|
return result;
|
|
14712
15074
|
}
|
|
14713
15075
|
}
|
|
14714
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
15076
|
+
var OpenParen$0 = $TV($EXPECT($L3, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
14715
15077
|
return { $loc, token: $1 };
|
|
14716
15078
|
});
|
|
14717
15079
|
function OpenParen(state) {
|
|
@@ -14867,7 +15229,7 @@ ${input.slice(result.pos)}
|
|
|
14867
15229
|
return result;
|
|
14868
15230
|
}
|
|
14869
15231
|
}
|
|
14870
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
15232
|
+
var QuestionMark$0 = $TV($EXPECT($L4, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
14871
15233
|
return { $loc, token: $1 };
|
|
14872
15234
|
});
|
|
14873
15235
|
function QuestionMark(state) {
|
|
@@ -15045,7 +15407,7 @@ ${input.slice(result.pos)}
|
|
|
15045
15407
|
var Static$0 = $TS($S($EXPECT($L145, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15046
15408
|
return { $loc, token: $1 };
|
|
15047
15409
|
});
|
|
15048
|
-
var Static$1 = $TS($S($EXPECT($L101, fail, 'Static "@"'), $N($C($EXPECT($
|
|
15410
|
+
var Static$1 = $TS($S($EXPECT($L101, fail, 'Static "@"'), $N($C($EXPECT($L3, fail, 'Static "("'), $EXPECT($L101, fail, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
15049
15411
|
return { $loc, token: "static " };
|
|
15050
15412
|
});
|
|
15051
15413
|
function Static(state) {
|
|
@@ -15716,7 +16078,7 @@ ${input.slice(result.pos)}
|
|
|
15716
16078
|
return result;
|
|
15717
16079
|
}
|
|
15718
16080
|
}
|
|
15719
|
-
var PopJSXStack$0 = $TV($EXPECT($
|
|
16081
|
+
var PopJSXStack$0 = $TV($EXPECT($L0, fail, 'PopJSXStack ""'), function($skip, $loc, $0, $1) {
|
|
15720
16082
|
module.JSXTagStack.pop();
|
|
15721
16083
|
});
|
|
15722
16084
|
function PopJSXStack(state) {
|
|
@@ -15770,7 +16132,7 @@ ${input.slice(result.pos)}
|
|
|
15770
16132
|
return $skip;
|
|
15771
16133
|
return $0;
|
|
15772
16134
|
});
|
|
15773
|
-
var JSXOptionalClosingElement$1 = $EXPECT($
|
|
16135
|
+
var JSXOptionalClosingElement$1 = $EXPECT($L0, fail, 'JSXOptionalClosingElement ""');
|
|
15774
16136
|
function JSXOptionalClosingElement(state) {
|
|
15775
16137
|
let eventData;
|
|
15776
16138
|
if (state.events) {
|
|
@@ -15893,7 +16255,7 @@ ${input.slice(result.pos)}
|
|
|
15893
16255
|
return $skip;
|
|
15894
16256
|
return $0;
|
|
15895
16257
|
});
|
|
15896
|
-
var JSXOptionalClosingFragment$1 = $EXPECT($
|
|
16258
|
+
var JSXOptionalClosingFragment$1 = $EXPECT($L0, fail, 'JSXOptionalClosingFragment ""');
|
|
15897
16259
|
function JSXOptionalClosingFragment(state) {
|
|
15898
16260
|
let eventData;
|
|
15899
16261
|
if (state.events) {
|
|
@@ -16141,7 +16503,7 @@ ${input.slice(result.pos)}
|
|
|
16141
16503
|
}
|
|
16142
16504
|
});
|
|
16143
16505
|
var JSXAttribute$2 = $S(InsertInlineOpenBrace, DotDotDot, InlineJSXAttributeValue, InsertCloseBrace, $Y(JSXAttributeSpace));
|
|
16144
|
-
var JSXAttribute$3 = $TS($S($EXPECT($
|
|
16506
|
+
var JSXAttribute$3 = $TS($S($EXPECT($L12, fail, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
16145
16507
|
return [" ", "id=", $2];
|
|
16146
16508
|
});
|
|
16147
16509
|
var JSXAttribute$4 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -16468,8 +16830,8 @@ ${input.slice(result.pos)}
|
|
|
16468
16830
|
return result;
|
|
16469
16831
|
}
|
|
16470
16832
|
}
|
|
16471
|
-
var InlineJSXCallExpression$0 = $S($EXPECT($
|
|
16472
|
-
var InlineJSXCallExpression$1 = $S($EXPECT($
|
|
16833
|
+
var InlineJSXCallExpression$0 = $S($EXPECT($L13, fail, 'InlineJSXCallExpression "super"'), ExplicitArguments);
|
|
16834
|
+
var InlineJSXCallExpression$1 = $S($EXPECT($L14, fail, 'InlineJSXCallExpression "import"'), OpenParen, PostfixedExpression, __, CloseParen);
|
|
16473
16835
|
var InlineJSXCallExpression$2 = $TS($S(InlineJSXMemberExpression, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
16474
16836
|
if ($2.length)
|
|
16475
16837
|
return $0;
|
|
@@ -16992,9 +17354,9 @@ ${input.slice(result.pos)}
|
|
|
16992
17354
|
return result;
|
|
16993
17355
|
}
|
|
16994
17356
|
}
|
|
16995
|
-
var TypeDeclarationRest$0 = $S(TypeKeyword, $
|
|
16996
|
-
var TypeDeclarationRest$1 = $S(Interface, $
|
|
16997
|
-
var TypeDeclarationRest$2 = $S(Namespace, $
|
|
17357
|
+
var TypeDeclarationRest$0 = $S(TypeKeyword, $E(_), IdentifierName, $E(TypeParameters), __, Equals, $C($S($E(_), Type), $S(__, Type)));
|
|
17358
|
+
var TypeDeclarationRest$1 = $S(Interface, $E(_), IdentifierName, $E(TypeParameters), $E(InterfaceExtendsClause), InterfaceBlock);
|
|
17359
|
+
var TypeDeclarationRest$2 = $S(Namespace, $E(_), IdentifierName, ModuleBlock);
|
|
16998
17360
|
var TypeDeclarationRest$3 = FunctionSignature;
|
|
16999
17361
|
function TypeDeclarationRest(state) {
|
|
17000
17362
|
let eventData;
|
|
@@ -17021,7 +17383,7 @@ ${input.slice(result.pos)}
|
|
|
17021
17383
|
var TypeLexicalDeclaration$0 = $S(__, LetOrConstOrVar, TypeDeclarationBinding, $Q($S(CommaDelimiter, __, TypeDeclarationBinding)));
|
|
17022
17384
|
var TypeLexicalDeclaration$1 = $S(__, EnumDeclaration);
|
|
17023
17385
|
var TypeLexicalDeclaration$2 = ClassSignature;
|
|
17024
|
-
var TypeLexicalDeclaration$3 = $S(Namespace, $
|
|
17386
|
+
var TypeLexicalDeclaration$3 = $S(Namespace, $E(_), IdentifierName, DeclareBlock);
|
|
17025
17387
|
var TypeLexicalDeclaration$4 = $S(Module, _, StringLiteral, $E(DeclareBlock));
|
|
17026
17388
|
var TypeLexicalDeclaration$5 = $S(Global, $E(DeclareBlock));
|
|
17027
17389
|
function TypeLexicalDeclaration(state) {
|
|
@@ -17565,7 +17927,7 @@ ${input.slice(result.pos)}
|
|
|
17565
17927
|
return result;
|
|
17566
17928
|
}
|
|
17567
17929
|
}
|
|
17568
|
-
var DeclareElement$0 = $T($S($E($S(Export, $E(_))), TypeLexicalDeclaration), function(value) {
|
|
17930
|
+
var DeclareElement$0 = $T($S($E(Decorators), $E($S(Export, $E(_))), TypeLexicalDeclaration), function(value) {
|
|
17569
17931
|
return { "ts": true, "children": value };
|
|
17570
17932
|
});
|
|
17571
17933
|
var DeclareElement$1 = $T($S($E($S(Export, $E(_))), TypeDeclarationRest), function(value) {
|
|
@@ -17593,7 +17955,7 @@ ${input.slice(result.pos)}
|
|
|
17593
17955
|
return result;
|
|
17594
17956
|
}
|
|
17595
17957
|
}
|
|
17596
|
-
var EnumDeclaration$0 = $TS($S($E($S(Const, _)), Enum, $
|
|
17958
|
+
var EnumDeclaration$0 = $TS($S($E($S(Const, _)), Enum, $E(_), IdentifierName, EnumBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
17597
17959
|
var isConst = $1;
|
|
17598
17960
|
var id = $4;
|
|
17599
17961
|
var block = $5;
|
|
@@ -17614,7 +17976,7 @@ ${input.slice(result.pos)}
|
|
|
17614
17976
|
let init, isString;
|
|
17615
17977
|
if (property.init) {
|
|
17616
17978
|
init = module.replaceNodes(
|
|
17617
|
-
|
|
17979
|
+
deepCopy(property.init),
|
|
17618
17980
|
(n) => n.type === "Identifier" && names.has(n.name),
|
|
17619
17981
|
(n) => [id, '["', n.name, '"]']
|
|
17620
17982
|
);
|
|
@@ -18153,8 +18515,8 @@ ${input.slice(result.pos)}
|
|
|
18153
18515
|
return result;
|
|
18154
18516
|
}
|
|
18155
18517
|
}
|
|
18156
|
-
var ImportType$0 = $S($EXPECT($
|
|
18157
|
-
var ImportType$1 = $S($EXPECT($
|
|
18518
|
+
var ImportType$0 = $S($EXPECT($L14, fail, 'ImportType "import"'), OpenParen, __, StringLiteral, __, CloseParen, $E($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
18519
|
+
var ImportType$1 = $S($EXPECT($L14, fail, 'ImportType "import"'), InsertOpenParen, Trimmed_, StringLiteral, InsertCloseParen);
|
|
18158
18520
|
function ImportType(state) {
|
|
18159
18521
|
let eventData;
|
|
18160
18522
|
if (state.events) {
|
|
@@ -18463,7 +18825,7 @@ ${input.slice(result.pos)}
|
|
|
18463
18825
|
return result;
|
|
18464
18826
|
}
|
|
18465
18827
|
}
|
|
18466
|
-
var TypeArrowFunction$0 = $TV($EXPECT($
|
|
18828
|
+
var TypeArrowFunction$0 = $TV($EXPECT($L8, fail, 'TypeArrowFunction "=>"'), function($skip, $loc, $0, $1) {
|
|
18467
18829
|
return { $loc, token: "=>" };
|
|
18468
18830
|
});
|
|
18469
18831
|
var TypeArrowFunction$1 = $TV($EXPECT($L21, fail, 'TypeArrowFunction "->"'), function($skip, $loc, $0, $1) {
|
|
@@ -18639,7 +19001,7 @@ ${input.slice(result.pos)}
|
|
|
18639
19001
|
return result;
|
|
18640
19002
|
}
|
|
18641
19003
|
}
|
|
18642
|
-
var TypeInitializer$0 = $S(__, $EXPECT($
|
|
19004
|
+
var TypeInitializer$0 = $S(__, $EXPECT($L2, fail, 'TypeInitializer "="'), Type);
|
|
18643
19005
|
function TypeInitializer(state) {
|
|
18644
19006
|
let eventData;
|
|
18645
19007
|
if (state.events) {
|
|
@@ -18928,7 +19290,7 @@ ${input.slice(result.pos)}
|
|
|
18928
19290
|
return result;
|
|
18929
19291
|
}
|
|
18930
19292
|
}
|
|
18931
|
-
var DebugHere$0 = $TV($EXPECT($
|
|
19293
|
+
var DebugHere$0 = $TV($EXPECT($L0, fail, 'DebugHere ""'), function($skip, $loc, $0, $1) {
|
|
18932
19294
|
debugger;
|
|
18933
19295
|
});
|
|
18934
19296
|
function DebugHere(state) {
|
|
@@ -18953,7 +19315,7 @@ ${input.slice(result.pos)}
|
|
|
18953
19315
|
return result;
|
|
18954
19316
|
}
|
|
18955
19317
|
}
|
|
18956
|
-
var InsertSemicolon$0 = $TV($EXPECT($
|
|
19318
|
+
var InsertSemicolon$0 = $TV($EXPECT($L0, fail, 'InsertSemicolon ""'), function($skip, $loc, $0, $1) {
|
|
18957
19319
|
return { $loc, token: ";" };
|
|
18958
19320
|
});
|
|
18959
19321
|
function InsertSemicolon(state) {
|
|
@@ -18978,7 +19340,7 @@ ${input.slice(result.pos)}
|
|
|
18978
19340
|
return result;
|
|
18979
19341
|
}
|
|
18980
19342
|
}
|
|
18981
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
19343
|
+
var InsertOpenParen$0 = $TV($EXPECT($L0, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
18982
19344
|
return { $loc, token: "(" };
|
|
18983
19345
|
});
|
|
18984
19346
|
function InsertOpenParen(state) {
|
|
@@ -19003,7 +19365,7 @@ ${input.slice(result.pos)}
|
|
|
19003
19365
|
return result;
|
|
19004
19366
|
}
|
|
19005
19367
|
}
|
|
19006
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
19368
|
+
var InsertCloseParen$0 = $TV($EXPECT($L0, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
19007
19369
|
return { $loc, token: ")" };
|
|
19008
19370
|
});
|
|
19009
19371
|
function InsertCloseParen(state) {
|
|
@@ -19028,7 +19390,7 @@ ${input.slice(result.pos)}
|
|
|
19028
19390
|
return result;
|
|
19029
19391
|
}
|
|
19030
19392
|
}
|
|
19031
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
19393
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L0, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
19032
19394
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
19033
19395
|
});
|
|
19034
19396
|
function InsertOpenBrace(state) {
|
|
@@ -19053,7 +19415,7 @@ ${input.slice(result.pos)}
|
|
|
19053
19415
|
return result;
|
|
19054
19416
|
}
|
|
19055
19417
|
}
|
|
19056
|
-
var InsertInlineOpenBrace$0 = $TV($EXPECT($
|
|
19418
|
+
var InsertInlineOpenBrace$0 = $TV($EXPECT($L0, fail, 'InsertInlineOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
19057
19419
|
return { $loc, token: "{" };
|
|
19058
19420
|
});
|
|
19059
19421
|
function InsertInlineOpenBrace(state) {
|
|
@@ -19078,7 +19440,7 @@ ${input.slice(result.pos)}
|
|
|
19078
19440
|
return result;
|
|
19079
19441
|
}
|
|
19080
19442
|
}
|
|
19081
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
19443
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L0, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
19082
19444
|
return { $loc, token: "}" };
|
|
19083
19445
|
});
|
|
19084
19446
|
function InsertCloseBrace(state) {
|
|
@@ -19103,7 +19465,7 @@ ${input.slice(result.pos)}
|
|
|
19103
19465
|
return result;
|
|
19104
19466
|
}
|
|
19105
19467
|
}
|
|
19106
|
-
var InsertOpenBracket$0 = $TV($EXPECT($
|
|
19468
|
+
var InsertOpenBracket$0 = $TV($EXPECT($L0, fail, 'InsertOpenBracket ""'), function($skip, $loc, $0, $1) {
|
|
19107
19469
|
return { $loc, token: "[" };
|
|
19108
19470
|
});
|
|
19109
19471
|
function InsertOpenBracket(state) {
|
|
@@ -19128,7 +19490,7 @@ ${input.slice(result.pos)}
|
|
|
19128
19490
|
return result;
|
|
19129
19491
|
}
|
|
19130
19492
|
}
|
|
19131
|
-
var InsertCloseBracket$0 = $TV($EXPECT($
|
|
19493
|
+
var InsertCloseBracket$0 = $TV($EXPECT($L0, fail, 'InsertCloseBracket ""'), function($skip, $loc, $0, $1) {
|
|
19132
19494
|
return { $loc, token: "]" };
|
|
19133
19495
|
});
|
|
19134
19496
|
function InsertCloseBracket(state) {
|
|
@@ -19153,7 +19515,7 @@ ${input.slice(result.pos)}
|
|
|
19153
19515
|
return result;
|
|
19154
19516
|
}
|
|
19155
19517
|
}
|
|
19156
|
-
var InsertComma$0 = $TV($EXPECT($
|
|
19518
|
+
var InsertComma$0 = $TV($EXPECT($L0, fail, 'InsertComma ""'), function($skip, $loc, $0, $1) {
|
|
19157
19519
|
return { $loc, token: "," };
|
|
19158
19520
|
});
|
|
19159
19521
|
function InsertComma(state) {
|
|
@@ -19178,7 +19540,7 @@ ${input.slice(result.pos)}
|
|
|
19178
19540
|
return result;
|
|
19179
19541
|
}
|
|
19180
19542
|
}
|
|
19181
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
19543
|
+
var InsertConst$0 = $TV($EXPECT($L0, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
19182
19544
|
return { $loc, token: "const " };
|
|
19183
19545
|
});
|
|
19184
19546
|
function InsertConst(state) {
|
|
@@ -19203,7 +19565,7 @@ ${input.slice(result.pos)}
|
|
|
19203
19565
|
return result;
|
|
19204
19566
|
}
|
|
19205
19567
|
}
|
|
19206
|
-
var InsertLet$0 = $TV($EXPECT($
|
|
19568
|
+
var InsertLet$0 = $TV($EXPECT($L0, fail, 'InsertLet ""'), function($skip, $loc, $0, $1) {
|
|
19207
19569
|
return { $loc, token: "let " };
|
|
19208
19570
|
});
|
|
19209
19571
|
function InsertLet(state) {
|
|
@@ -19228,7 +19590,7 @@ ${input.slice(result.pos)}
|
|
|
19228
19590
|
return result;
|
|
19229
19591
|
}
|
|
19230
19592
|
}
|
|
19231
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
19593
|
+
var InsertReadonly$0 = $TV($EXPECT($L0, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
19232
19594
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
19233
19595
|
});
|
|
19234
19596
|
function InsertReadonly(state) {
|
|
@@ -19253,7 +19615,7 @@ ${input.slice(result.pos)}
|
|
|
19253
19615
|
return result;
|
|
19254
19616
|
}
|
|
19255
19617
|
}
|
|
19256
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
19618
|
+
var InsertNewline$0 = $TV($EXPECT($L0, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
19257
19619
|
return "\n";
|
|
19258
19620
|
});
|
|
19259
19621
|
function InsertNewline(state) {
|
|
@@ -19278,7 +19640,7 @@ ${input.slice(result.pos)}
|
|
|
19278
19640
|
return result;
|
|
19279
19641
|
}
|
|
19280
19642
|
}
|
|
19281
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
19643
|
+
var InsertIndent$0 = $TV($EXPECT($L0, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
19282
19644
|
return module.currentIndent.token;
|
|
19283
19645
|
});
|
|
19284
19646
|
function InsertIndent(state) {
|
|
@@ -19303,7 +19665,7 @@ ${input.slice(result.pos)}
|
|
|
19303
19665
|
return result;
|
|
19304
19666
|
}
|
|
19305
19667
|
}
|
|
19306
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
19668
|
+
var InsertSpace$0 = $TV($EXPECT($L0, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
19307
19669
|
return { $loc, token: " " };
|
|
19308
19670
|
});
|
|
19309
19671
|
function InsertSpace(state) {
|
|
@@ -19328,7 +19690,7 @@ ${input.slice(result.pos)}
|
|
|
19328
19690
|
return result;
|
|
19329
19691
|
}
|
|
19330
19692
|
}
|
|
19331
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
19693
|
+
var InsertDot$0 = $TV($EXPECT($L0, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
19332
19694
|
return { $loc, token: "." };
|
|
19333
19695
|
});
|
|
19334
19696
|
function InsertDot(state) {
|
|
@@ -19353,7 +19715,7 @@ ${input.slice(result.pos)}
|
|
|
19353
19715
|
return result;
|
|
19354
19716
|
}
|
|
19355
19717
|
}
|
|
19356
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
19718
|
+
var InsertBreak$0 = $TV($EXPECT($L0, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
19357
19719
|
return { $loc, token: ";break;" };
|
|
19358
19720
|
});
|
|
19359
19721
|
function InsertBreak(state) {
|
|
@@ -19378,7 +19740,7 @@ ${input.slice(result.pos)}
|
|
|
19378
19740
|
return result;
|
|
19379
19741
|
}
|
|
19380
19742
|
}
|
|
19381
|
-
var InsertVar$0 = $TV($EXPECT($
|
|
19743
|
+
var InsertVar$0 = $TV($EXPECT($L0, fail, 'InsertVar ""'), function($skip, $loc, $0, $1) {
|
|
19382
19744
|
return { $loc, token: "var " };
|
|
19383
19745
|
});
|
|
19384
19746
|
function InsertVar(state) {
|
|
@@ -19403,7 +19765,7 @@ ${input.slice(result.pos)}
|
|
|
19403
19765
|
return result;
|
|
19404
19766
|
}
|
|
19405
19767
|
}
|
|
19406
|
-
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($
|
|
19768
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
19407
19769
|
if (module.config.coffeeBinaryExistential)
|
|
19408
19770
|
return;
|
|
19409
19771
|
return $skip;
|
|
@@ -19430,7 +19792,7 @@ ${input.slice(result.pos)}
|
|
|
19430
19792
|
return result;
|
|
19431
19793
|
}
|
|
19432
19794
|
}
|
|
19433
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
19795
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
19434
19796
|
if (module.config.coffeeBooleans)
|
|
19435
19797
|
return;
|
|
19436
19798
|
return $skip;
|
|
@@ -19457,7 +19819,7 @@ ${input.slice(result.pos)}
|
|
|
19457
19819
|
return result;
|
|
19458
19820
|
}
|
|
19459
19821
|
}
|
|
19460
|
-
var CoffeeClassesEnabled$0 = $TV($EXPECT($
|
|
19822
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
19461
19823
|
if (module.config.coffeeClasses)
|
|
19462
19824
|
return;
|
|
19463
19825
|
return $skip;
|
|
@@ -19484,7 +19846,7 @@ ${input.slice(result.pos)}
|
|
|
19484
19846
|
return result;
|
|
19485
19847
|
}
|
|
19486
19848
|
}
|
|
19487
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
19849
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
19488
19850
|
if (module.config.coffeeComment)
|
|
19489
19851
|
return;
|
|
19490
19852
|
return $skip;
|
|
@@ -19511,7 +19873,7 @@ ${input.slice(result.pos)}
|
|
|
19511
19873
|
return result;
|
|
19512
19874
|
}
|
|
19513
19875
|
}
|
|
19514
|
-
var CoffeeDoEnabled$0 = $TV($EXPECT($
|
|
19876
|
+
var CoffeeDoEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
|
|
19515
19877
|
if (module.config.coffeeDo)
|
|
19516
19878
|
return;
|
|
19517
19879
|
return $skip;
|
|
@@ -19538,7 +19900,7 @@ ${input.slice(result.pos)}
|
|
|
19538
19900
|
return result;
|
|
19539
19901
|
}
|
|
19540
19902
|
}
|
|
19541
|
-
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($
|
|
19903
|
+
var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
19542
19904
|
if (module.config.coffeeForLoops)
|
|
19543
19905
|
return;
|
|
19544
19906
|
return $skip;
|
|
@@ -19565,7 +19927,7 @@ ${input.slice(result.pos)}
|
|
|
19565
19927
|
return result;
|
|
19566
19928
|
}
|
|
19567
19929
|
}
|
|
19568
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
19930
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
19569
19931
|
if (module.config.coffeeInterpolation)
|
|
19570
19932
|
return;
|
|
19571
19933
|
return $skip;
|
|
@@ -19592,7 +19954,7 @@ ${input.slice(result.pos)}
|
|
|
19592
19954
|
return result;
|
|
19593
19955
|
}
|
|
19594
19956
|
}
|
|
19595
|
-
var CoffeeIsntEnabled$0 = $TV($EXPECT($
|
|
19957
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
19596
19958
|
if (module.config.coffeeIsnt)
|
|
19597
19959
|
return;
|
|
19598
19960
|
return $skip;
|
|
@@ -19619,7 +19981,7 @@ ${input.slice(result.pos)}
|
|
|
19619
19981
|
return result;
|
|
19620
19982
|
}
|
|
19621
19983
|
}
|
|
19622
|
-
var CoffeeJSXEnabled$0 = $TV($EXPECT($
|
|
19984
|
+
var CoffeeJSXEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeJSXEnabled ""'), function($skip, $loc, $0, $1) {
|
|
19623
19985
|
if (module.config.coffeeJSX)
|
|
19624
19986
|
return;
|
|
19625
19987
|
return $skip;
|
|
@@ -19646,7 +20008,7 @@ ${input.slice(result.pos)}
|
|
|
19646
20008
|
return result;
|
|
19647
20009
|
}
|
|
19648
20010
|
}
|
|
19649
|
-
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($
|
|
20011
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
19650
20012
|
if (module.config.coffeeLineContinuation)
|
|
19651
20013
|
return;
|
|
19652
20014
|
return $skip;
|
|
@@ -19673,7 +20035,7 @@ ${input.slice(result.pos)}
|
|
|
19673
20035
|
return result;
|
|
19674
20036
|
}
|
|
19675
20037
|
}
|
|
19676
|
-
var CoffeeNotEnabled$0 = $TV($EXPECT($
|
|
20038
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
19677
20039
|
if (module.config.coffeeNot)
|
|
19678
20040
|
return;
|
|
19679
20041
|
return $skip;
|
|
@@ -19700,7 +20062,7 @@ ${input.slice(result.pos)}
|
|
|
19700
20062
|
return result;
|
|
19701
20063
|
}
|
|
19702
20064
|
}
|
|
19703
|
-
var CoffeeOfEnabled$0 = $TV($EXPECT($
|
|
20065
|
+
var CoffeeOfEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
|
|
19704
20066
|
if (module.config.coffeeOf)
|
|
19705
20067
|
return;
|
|
19706
20068
|
return $skip;
|
|
@@ -19727,7 +20089,7 @@ ${input.slice(result.pos)}
|
|
|
19727
20089
|
return result;
|
|
19728
20090
|
}
|
|
19729
20091
|
}
|
|
19730
|
-
var CoffeePrototypeEnabled$0 = $TV($EXPECT($
|
|
20092
|
+
var CoffeePrototypeEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeePrototypeEnabled ""'), function($skip, $loc, $0, $1) {
|
|
19731
20093
|
if (module.config.coffeePrototype)
|
|
19732
20094
|
return;
|
|
19733
20095
|
return $skip;
|
|
@@ -19754,7 +20116,7 @@ ${input.slice(result.pos)}
|
|
|
19754
20116
|
return result;
|
|
19755
20117
|
}
|
|
19756
20118
|
}
|
|
19757
|
-
var ObjectIsEnabled$0 = $TV($EXPECT($
|
|
20119
|
+
var ObjectIsEnabled$0 = $TV($EXPECT($L0, fail, 'ObjectIsEnabled ""'), function($skip, $loc, $0, $1) {
|
|
19758
20120
|
if (module.config.objectIs)
|
|
19759
20121
|
return;
|
|
19760
20122
|
return $skip;
|
|
@@ -19781,11 +20143,12 @@ ${input.slice(result.pos)}
|
|
|
19781
20143
|
return result;
|
|
19782
20144
|
}
|
|
19783
20145
|
}
|
|
19784
|
-
var Reset$0 = $TV($EXPECT($
|
|
20146
|
+
var Reset$0 = $TV($EXPECT($L0, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
19785
20147
|
module.indentLevels = [{
|
|
19786
20148
|
level: 0,
|
|
19787
20149
|
token: ""
|
|
19788
20150
|
}];
|
|
20151
|
+
module.forbidClassImplicitCall = [false];
|
|
19789
20152
|
module.forbidIndentedApplication = [false];
|
|
19790
20153
|
module.forbidTrailingMemberProperty = [false];
|
|
19791
20154
|
module.forbidMultiLineImplicitObjectLiteral = [false];
|
|
@@ -19800,6 +20163,12 @@ ${input.slice(result.pos)}
|
|
|
19800
20163
|
return l[l.length - 1];
|
|
19801
20164
|
}
|
|
19802
20165
|
},
|
|
20166
|
+
classImplicitCallForbidden: {
|
|
20167
|
+
get() {
|
|
20168
|
+
const { forbidClassImplicitCall: s } = module;
|
|
20169
|
+
return s[s.length - 1];
|
|
20170
|
+
}
|
|
20171
|
+
},
|
|
19803
20172
|
indentedApplicationForbidden: {
|
|
19804
20173
|
get() {
|
|
19805
20174
|
const { forbidIndentedApplication: s } = module;
|
|
@@ -20091,7 +20460,7 @@ ${input.slice(result.pos)}
|
|
|
20091
20460
|
return result;
|
|
20092
20461
|
}
|
|
20093
20462
|
}
|
|
20094
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
20463
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L0, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
20095
20464
|
var directives = $2;
|
|
20096
20465
|
directives.forEach((directive) => {
|
|
20097
20466
|
if (directive.type === "CivetPrologue") {
|
|
@@ -20402,9 +20771,7 @@ ${input.slice(result.pos)}
|
|
|
20402
20771
|
const [, exp] = node;
|
|
20403
20772
|
if (!exp)
|
|
20404
20773
|
return;
|
|
20405
|
-
|
|
20406
|
-
if (Array.isArray(indent))
|
|
20407
|
-
indent = indent[indent.length - 1];
|
|
20774
|
+
const indent = getIndent(node);
|
|
20408
20775
|
switch (exp.type) {
|
|
20409
20776
|
case "BreakStatement":
|
|
20410
20777
|
case "ContinueStatement":
|
|
@@ -20805,7 +21172,12 @@ ${input.slice(result.pos)}
|
|
|
20805
21172
|
if (trim) {
|
|
20806
21173
|
str = str.replace(/^(\r?\n|\n)/, "").replace(/(\r?\n|\n)[ \t]*$/, "");
|
|
20807
21174
|
}
|
|
20808
|
-
str = str.replace(/(
|
|
21175
|
+
str = str.replace(/(\\.|`|\$\{)/g, (s) => {
|
|
21176
|
+
if (s[0] === "\\") {
|
|
21177
|
+
return s;
|
|
21178
|
+
}
|
|
21179
|
+
return `\\${s}`;
|
|
21180
|
+
});
|
|
20809
21181
|
return {
|
|
20810
21182
|
$loc: $loc2,
|
|
20811
21183
|
token: str
|
|
@@ -20905,55 +21277,6 @@ ${input.slice(result.pos)}
|
|
|
20905
21277
|
}, props2]
|
|
20906
21278
|
};
|
|
20907
21279
|
};
|
|
20908
|
-
function gatherNodes(node, predicate) {
|
|
20909
|
-
if (node == null)
|
|
20910
|
-
return [];
|
|
20911
|
-
if (Array.isArray(node)) {
|
|
20912
|
-
return node.flatMap((n) => gatherNodes(n, predicate));
|
|
20913
|
-
}
|
|
20914
|
-
if (predicate(node)) {
|
|
20915
|
-
return [node];
|
|
20916
|
-
}
|
|
20917
|
-
switch (node.type) {
|
|
20918
|
-
case "BlockStatement":
|
|
20919
|
-
return [];
|
|
20920
|
-
case "ForStatement":
|
|
20921
|
-
const isDec = node.declaration?.type === "Declaration";
|
|
20922
|
-
return node.children.flatMap((n) => {
|
|
20923
|
-
if (isDec && n === node.declaration)
|
|
20924
|
-
return [];
|
|
20925
|
-
return gatherNodes(n, predicate);
|
|
20926
|
-
});
|
|
20927
|
-
default:
|
|
20928
|
-
return gatherNodes(node.children, predicate);
|
|
20929
|
-
}
|
|
20930
|
-
return [];
|
|
20931
|
-
}
|
|
20932
|
-
function gatherRecursive(node, predicate, skipPredicate) {
|
|
20933
|
-
if (node == null)
|
|
20934
|
-
return [];
|
|
20935
|
-
if (Array.isArray(node)) {
|
|
20936
|
-
return node.flatMap((n) => gatherRecursive(n, predicate, skipPredicate));
|
|
20937
|
-
}
|
|
20938
|
-
if (skipPredicate?.(node))
|
|
20939
|
-
return [];
|
|
20940
|
-
if (predicate(node)) {
|
|
20941
|
-
return [node];
|
|
20942
|
-
}
|
|
20943
|
-
return gatherRecursive(node.children, predicate, skipPredicate);
|
|
20944
|
-
}
|
|
20945
|
-
function gatherRecursiveAll(node, predicate) {
|
|
20946
|
-
if (node == null)
|
|
20947
|
-
return [];
|
|
20948
|
-
if (Array.isArray(node)) {
|
|
20949
|
-
return node.flatMap((n) => gatherRecursiveAll(n, predicate));
|
|
20950
|
-
}
|
|
20951
|
-
const nodes = gatherRecursiveAll(node.children, predicate);
|
|
20952
|
-
if (predicate(node)) {
|
|
20953
|
-
nodes.push(node);
|
|
20954
|
-
}
|
|
20955
|
-
return nodes;
|
|
20956
|
-
}
|
|
20957
21280
|
function isFunction(node) {
|
|
20958
21281
|
const { type } = node;
|
|
20959
21282
|
return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition" || node.async;
|
|
@@ -20979,28 +21302,6 @@ ${input.slice(result.pos)}
|
|
|
20979
21302
|
}
|
|
20980
21303
|
}
|
|
20981
21304
|
}
|
|
20982
|
-
function removeParentPointers(node) {
|
|
20983
|
-
if (node == null)
|
|
20984
|
-
return;
|
|
20985
|
-
if (typeof node !== "object")
|
|
20986
|
-
return;
|
|
20987
|
-
if (Array.isArray(node)) {
|
|
20988
|
-
for (const child of node) {
|
|
20989
|
-
removeParentPointers(child);
|
|
20990
|
-
}
|
|
20991
|
-
return;
|
|
20992
|
-
}
|
|
20993
|
-
node.parent = null;
|
|
20994
|
-
if (node.children) {
|
|
20995
|
-
for (const child of node.children) {
|
|
20996
|
-
removeParentPointers(child);
|
|
20997
|
-
}
|
|
20998
|
-
}
|
|
20999
|
-
}
|
|
21000
|
-
function clone(node) {
|
|
21001
|
-
removeParentPointers(node);
|
|
21002
|
-
return structuredClone(node);
|
|
21003
|
-
}
|
|
21004
21305
|
function findAncestor(node, predicate, stopPredicate) {
|
|
21005
21306
|
node = node.parent;
|
|
21006
21307
|
while (node && !stopPredicate?.(node)) {
|
|
@@ -21785,11 +22086,7 @@ ${input.slice(result.pos)}
|
|
|
21785
22086
|
adjustAtBindings(statements);
|
|
21786
22087
|
};
|
|
21787
22088
|
function findDecs(statements) {
|
|
21788
|
-
const declarationNames = gatherNodes(statements, (
|
|
21789
|
-
if (node.type === "Declaration") {
|
|
21790
|
-
return true;
|
|
21791
|
-
}
|
|
21792
|
-
}).flatMap((d) => d.names);
|
|
22089
|
+
const declarationNames = gatherNodes(statements, ({ type }) => type === "Declaration").flatMap((d) => d.names);
|
|
21793
22090
|
return new Set(declarationNames);
|
|
21794
22091
|
}
|
|
21795
22092
|
function populateRefs(statements) {
|
|
@@ -21836,9 +22133,7 @@ ${input.slice(result.pos)}
|
|
|
21836
22133
|
scopes.push(decs);
|
|
21837
22134
|
const varIds = [];
|
|
21838
22135
|
const assignmentStatements = findAssignments(statements, scopes);
|
|
21839
|
-
const undeclaredIdentifiers = assignmentStatements.flatMap((a) =>
|
|
21840
|
-
return a.names;
|
|
21841
|
-
});
|
|
22136
|
+
const undeclaredIdentifiers = assignmentStatements.flatMap((a) => a.names);
|
|
21842
22137
|
undeclaredIdentifiers.filter((x, i, a) => {
|
|
21843
22138
|
if (!hasDec(x))
|
|
21844
22139
|
return a.indexOf(x) === i;
|
|
@@ -21862,9 +22157,7 @@ ${input.slice(result.pos)}
|
|
|
21862
22157
|
scopes.pop();
|
|
21863
22158
|
});
|
|
21864
22159
|
if (varIds.length) {
|
|
21865
|
-
|
|
21866
|
-
if (Array.isArray(indent))
|
|
21867
|
-
indent = indent[indent.length - 1];
|
|
22160
|
+
const indent = getIndent(statements[0]);
|
|
21868
22161
|
statements.unshift([indent, "var ", varIds.join(", "), "\n"]);
|
|
21869
22162
|
}
|
|
21870
22163
|
scopes.pop();
|
|
@@ -21971,8 +22264,12 @@ ${input.slice(result.pos)}
|
|
|
21971
22264
|
module.gatherBindingCode = gatherBindingCode;
|
|
21972
22265
|
module.constructInvocation = function(fn, arg) {
|
|
21973
22266
|
const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
|
|
21974
|
-
|
|
21975
|
-
|
|
22267
|
+
let expr = fn.expr;
|
|
22268
|
+
while (expr.type === "ParenthesizedExpression") {
|
|
22269
|
+
expr = expr.expression;
|
|
22270
|
+
}
|
|
22271
|
+
if (expr.ampersandBlock) {
|
|
22272
|
+
const { ref, body } = expr;
|
|
21976
22273
|
ref.type = "PipedExpression";
|
|
21977
22274
|
ref.children = [module.makeLeftHandSideExpression(arg)];
|
|
21978
22275
|
return {
|
|
@@ -21980,7 +22277,8 @@ ${input.slice(result.pos)}
|
|
|
21980
22277
|
children: [module.skipIfOnlyWS(fn.leadingComment), ...body, module.skipIfOnlyWS(fn.trailingComment)]
|
|
21981
22278
|
};
|
|
21982
22279
|
}
|
|
21983
|
-
|
|
22280
|
+
expr = fn.expr;
|
|
22281
|
+
const lhs = module.makeLeftHandSideExpression(expr);
|
|
21984
22282
|
let comment = module.skipIfOnlyWS(fn.trailingComment);
|
|
21985
22283
|
if (comment)
|
|
21986
22284
|
lhs.children.splice(2, 0, comment);
|
|
@@ -22097,6 +22395,7 @@ ${input.slice(result.pos)}
|
|
|
22097
22395
|
console.log("pushing indent", indent);
|
|
22098
22396
|
}
|
|
22099
22397
|
module.indentLevels.push(indent);
|
|
22398
|
+
return $1;
|
|
22100
22399
|
});
|
|
22101
22400
|
function TrackIndented(state) {
|
|
22102
22401
|
let eventData;
|
|
@@ -22235,7 +22534,7 @@ ${input.slice(result.pos)}
|
|
|
22235
22534
|
return result;
|
|
22236
22535
|
}
|
|
22237
22536
|
}
|
|
22238
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
22537
|
+
var PopIndent$0 = $TV($EXPECT($L0, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
22239
22538
|
if (module.config.verbose) {
|
|
22240
22539
|
console.log("popping indent", module.indentLevels[module.indentLevels.length - 1], "->", module.indentLevels[module.indentLevels.length - 2]);
|
|
22241
22540
|
}
|
|
@@ -22303,6 +22602,14 @@ ${input.slice(result.pos)}
|
|
|
22303
22602
|
}
|
|
22304
22603
|
exports.parse = parse2;
|
|
22305
22604
|
exports.default = { parse: parse2 };
|
|
22605
|
+
var {
|
|
22606
|
+
clone,
|
|
22607
|
+
deepCopy,
|
|
22608
|
+
gatherNodes,
|
|
22609
|
+
gatherRecursive,
|
|
22610
|
+
gatherRecursiveAll,
|
|
22611
|
+
removeParentPointers
|
|
22612
|
+
} = require_lib();
|
|
22306
22613
|
}
|
|
22307
22614
|
});
|
|
22308
22615
|
|