@danielx/civet 0.5.91 → 0.5.93
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 +336 -362
- package/dist/civet +1 -1
- package/dist/esm.mjs +9 -4
- package/dist/main.js +336 -362
- package/dist/main.mjs +336 -362
- package/package.json +4 -1
- package/register.js +9 -0
- package/dist/browser.js.gzip +0 -0
package/dist/browser.js
CHANGED
|
@@ -475,6 +475,8 @@ var Civet = (() => {
|
|
|
475
475
|
};
|
|
476
476
|
}
|
|
477
477
|
function processUnaryExpression(pre, exp, post) {
|
|
478
|
+
if (!(pre.length || post))
|
|
479
|
+
return exp;
|
|
478
480
|
if (post?.token === "?") {
|
|
479
481
|
post = {
|
|
480
482
|
$loc: post.$loc,
|
|
@@ -524,22 +526,10 @@ var Civet = (() => {
|
|
|
524
526
|
};
|
|
525
527
|
}
|
|
526
528
|
}
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
531
|
-
return Object.assign({}, exp, { children });
|
|
532
|
-
} else if (Array.isArray(exp)) {
|
|
533
|
-
const children = [...pre, ...exp];
|
|
534
|
-
if (post)
|
|
535
|
-
children.push(post);
|
|
536
|
-
return { children };
|
|
537
|
-
} else {
|
|
538
|
-
const children = [...pre, exp];
|
|
539
|
-
if (post)
|
|
540
|
-
children.push(post);
|
|
541
|
-
return { children };
|
|
542
|
-
}
|
|
529
|
+
return {
|
|
530
|
+
type: "UnaryExpression",
|
|
531
|
+
children: [...pre, exp, post]
|
|
532
|
+
};
|
|
543
533
|
}
|
|
544
534
|
module.exports = {
|
|
545
535
|
blockWithPrefix,
|
|
@@ -1052,8 +1042,6 @@ ${input.slice(result.pos)}
|
|
|
1052
1042
|
AtThis,
|
|
1053
1043
|
LeftHandSideExpression,
|
|
1054
1044
|
CallExpression,
|
|
1055
|
-
ReturnValue,
|
|
1056
|
-
AfterReturnShorthand,
|
|
1057
1045
|
CallExpressionRest,
|
|
1058
1046
|
OptionalShorthand,
|
|
1059
1047
|
OptionalDot,
|
|
@@ -1066,6 +1054,8 @@ ${input.slice(result.pos)}
|
|
|
1066
1054
|
PropertyGlob,
|
|
1067
1055
|
SuperProperty,
|
|
1068
1056
|
MetaProperty,
|
|
1057
|
+
ReturnValue,
|
|
1058
|
+
AfterReturnShorthand,
|
|
1069
1059
|
Parameters,
|
|
1070
1060
|
NonEmptyParameters,
|
|
1071
1061
|
FunctionRestParameter,
|
|
@@ -1626,106 +1616,106 @@ ${input.slice(result.pos)}
|
|
|
1626
1616
|
var $L7 = $L("--");
|
|
1627
1617
|
var $L8 = $L("=>");
|
|
1628
1618
|
var $L9 = $L(" ");
|
|
1629
|
-
var $L10 = $L("
|
|
1630
|
-
var $L11 = $L("
|
|
1631
|
-
var $L12 = $L("
|
|
1632
|
-
var $L13 = $L("
|
|
1633
|
-
var $L14 = $L("
|
|
1634
|
-
var $L15 = $L("
|
|
1619
|
+
var $L10 = $L(":");
|
|
1620
|
+
var $L11 = $L("implements");
|
|
1621
|
+
var $L12 = $L("<:");
|
|
1622
|
+
var $L13 = $L("#");
|
|
1623
|
+
var $L14 = $L("super");
|
|
1624
|
+
var $L15 = $L("import");
|
|
1635
1625
|
var $L16 = $L("!");
|
|
1636
1626
|
var $L17 = $L("^");
|
|
1637
1627
|
var $L18 = $L("-");
|
|
1638
1628
|
var $L19 = $L("import.meta");
|
|
1639
|
-
var $L20 = $L("
|
|
1640
|
-
var $L21 = $L("
|
|
1641
|
-
var $L22 = $L("
|
|
1642
|
-
var $L23 = $L("
|
|
1643
|
-
var $L24 = $L("
|
|
1644
|
-
var $L25 = $L("
|
|
1645
|
-
var $L26 = $L("
|
|
1646
|
-
var $L27 = $L("
|
|
1647
|
-
var $L28 = $L("
|
|
1648
|
-
var $L29 = $L("
|
|
1649
|
-
var $L30 = $L("
|
|
1650
|
-
var $L31 = $L("
|
|
1651
|
-
var $L32 = $L("
|
|
1652
|
-
var $L33 = $L("
|
|
1653
|
-
var $L34 = $L("
|
|
1654
|
-
var $L35 = $L("
|
|
1655
|
-
var $L36 = $L("
|
|
1656
|
-
var $L37 = $L("
|
|
1657
|
-
var $L38 = $L("
|
|
1658
|
-
var $L39 = $L("
|
|
1659
|
-
var $L40 = $L("
|
|
1660
|
-
var $L41 = $L("
|
|
1661
|
-
var $L42 = $L("
|
|
1662
|
-
var $L43 = $L("
|
|
1663
|
-
var $L44 = $L("
|
|
1664
|
-
var $L45 = $L("
|
|
1665
|
-
var $L46 = $L("
|
|
1666
|
-
var $L47 = $L("
|
|
1667
|
-
var $L48 = $L("
|
|
1668
|
-
var $L49 = $L("
|
|
1669
|
-
var $L50 = $L("
|
|
1670
|
-
var $L51 = $L("
|
|
1671
|
-
var $L52 = $L("
|
|
1672
|
-
var $L53 = $L("
|
|
1673
|
-
var $L54 = $L("
|
|
1674
|
-
var $L55 = $L("
|
|
1675
|
-
var $L56 = $L("
|
|
1676
|
-
var $L57 = $L("
|
|
1677
|
-
var $L58 = $L("
|
|
1678
|
-
var $L59 = $L("
|
|
1679
|
-
var $L60 = $L("
|
|
1680
|
-
var $L61 = $L("
|
|
1681
|
-
var $L62 = $L("
|
|
1682
|
-
var $L63 = $L("
|
|
1683
|
-
var $L64 = $L("
|
|
1684
|
-
var $L65 = $L("
|
|
1685
|
-
var $L66 = $L("
|
|
1686
|
-
var $L67 = $L("
|
|
1687
|
-
var $L68 = $L("
|
|
1688
|
-
var $L69 = $L("
|
|
1689
|
-
var $L70 = $L("
|
|
1690
|
-
var $L71 = $L("
|
|
1691
|
-
var $L72 = $L("
|
|
1692
|
-
var $L73 = $L("
|
|
1693
|
-
var $L74 = $L("
|
|
1694
|
-
var $L75 = $L("
|
|
1695
|
-
var $L76 = $L("
|
|
1696
|
-
var $L77 = $L("
|
|
1697
|
-
var $L78 = $L("
|
|
1698
|
-
var $L79 = $L("
|
|
1699
|
-
var $L80 = $L("
|
|
1700
|
-
var $L81 = $L("
|
|
1701
|
-
var $L82 = $L("
|
|
1702
|
-
var $L83 = $L("
|
|
1703
|
-
var $L84 = $L("
|
|
1704
|
-
var $L85 = $L("
|
|
1705
|
-
var $L86 = $L("
|
|
1706
|
-
var $L87 = $L("
|
|
1707
|
-
var $L88 = $L("
|
|
1708
|
-
var $L89 = $L("
|
|
1709
|
-
var $L90 = $L("
|
|
1710
|
-
var $L91 = $L("
|
|
1711
|
-
var $L92 = $L("
|
|
1712
|
-
var $L93 = $L("
|
|
1713
|
-
var $L94 = $L("
|
|
1714
|
-
var $L95 = $L("
|
|
1715
|
-
var $L96 = $L("
|
|
1716
|
-
var $L97 = $L("
|
|
1717
|
-
var $L98 = $L("
|
|
1718
|
-
var $L99 = $L("
|
|
1719
|
-
var $L100 = $L("
|
|
1720
|
-
var $L101 = $L("
|
|
1721
|
-
var $L102 = $L("
|
|
1722
|
-
var $L103 = $L("
|
|
1723
|
-
var $L104 = $L("
|
|
1724
|
-
var $L105 = $L("
|
|
1725
|
-
var $L106 = $L("
|
|
1726
|
-
var $L107 = $L("
|
|
1727
|
-
var $L108 = $L("
|
|
1728
|
-
var $L109 = $L("
|
|
1629
|
+
var $L20 = $L("return.value");
|
|
1630
|
+
var $L21 = $L(",");
|
|
1631
|
+
var $L22 = $L("->");
|
|
1632
|
+
var $L23 = $L("}");
|
|
1633
|
+
var $L24 = $L("null");
|
|
1634
|
+
var $L25 = $L("true");
|
|
1635
|
+
var $L26 = $L("false");
|
|
1636
|
+
var $L27 = $L("yes");
|
|
1637
|
+
var $L28 = $L("on");
|
|
1638
|
+
var $L29 = $L("no");
|
|
1639
|
+
var $L30 = $L("off");
|
|
1640
|
+
var $L31 = $L(">");
|
|
1641
|
+
var $L32 = $L("]");
|
|
1642
|
+
var $L33 = $L("**=");
|
|
1643
|
+
var $L34 = $L("*=");
|
|
1644
|
+
var $L35 = $L("/=");
|
|
1645
|
+
var $L36 = $L("%=");
|
|
1646
|
+
var $L37 = $L("+=");
|
|
1647
|
+
var $L38 = $L("-=");
|
|
1648
|
+
var $L39 = $L("<<=");
|
|
1649
|
+
var $L40 = $L(">>>=");
|
|
1650
|
+
var $L41 = $L(">>=");
|
|
1651
|
+
var $L42 = $L("&&=");
|
|
1652
|
+
var $L43 = $L("&=");
|
|
1653
|
+
var $L44 = $L("^=");
|
|
1654
|
+
var $L45 = $L("||=");
|
|
1655
|
+
var $L46 = $L("|=");
|
|
1656
|
+
var $L47 = $L("??=");
|
|
1657
|
+
var $L48 = $L("?=");
|
|
1658
|
+
var $L49 = $L("and=");
|
|
1659
|
+
var $L50 = $L("or=");
|
|
1660
|
+
var $L51 = $L("not");
|
|
1661
|
+
var $L52 = $L("**");
|
|
1662
|
+
var $L53 = $L("*");
|
|
1663
|
+
var $L54 = $L("/");
|
|
1664
|
+
var $L55 = $L("%%");
|
|
1665
|
+
var $L56 = $L("%");
|
|
1666
|
+
var $L57 = $L("+");
|
|
1667
|
+
var $L58 = $L("<=");
|
|
1668
|
+
var $L59 = $L(">=");
|
|
1669
|
+
var $L60 = $L("<?");
|
|
1670
|
+
var $L61 = $L("!<?");
|
|
1671
|
+
var $L62 = $L("<<");
|
|
1672
|
+
var $L63 = $L(">>>");
|
|
1673
|
+
var $L64 = $L(">>");
|
|
1674
|
+
var $L65 = $L("!==");
|
|
1675
|
+
var $L66 = $L("!=");
|
|
1676
|
+
var $L67 = $L("isnt");
|
|
1677
|
+
var $L68 = $L("===");
|
|
1678
|
+
var $L69 = $L("==");
|
|
1679
|
+
var $L70 = $L("and");
|
|
1680
|
+
var $L71 = $L("&&");
|
|
1681
|
+
var $L72 = $L("of");
|
|
1682
|
+
var $L73 = $L("or");
|
|
1683
|
+
var $L74 = $L("||");
|
|
1684
|
+
var $L75 = $L("^^");
|
|
1685
|
+
var $L76 = $L("xor");
|
|
1686
|
+
var $L77 = $L("xnor");
|
|
1687
|
+
var $L78 = $L("??");
|
|
1688
|
+
var $L79 = $L("instanceof");
|
|
1689
|
+
var $L80 = $L("in");
|
|
1690
|
+
var $L81 = $L("is");
|
|
1691
|
+
var $L82 = $L("&");
|
|
1692
|
+
var $L83 = $L("|");
|
|
1693
|
+
var $L84 = $L(";");
|
|
1694
|
+
var $L85 = $L("$:");
|
|
1695
|
+
var $L86 = $L("own");
|
|
1696
|
+
var $L87 = $L("break");
|
|
1697
|
+
var $L88 = $L("continue");
|
|
1698
|
+
var $L89 = $L("debugger");
|
|
1699
|
+
var $L90 = $L("assert");
|
|
1700
|
+
var $L91 = $L(":=");
|
|
1701
|
+
var $L92 = $L(".=");
|
|
1702
|
+
var $L93 = $L("/*");
|
|
1703
|
+
var $L94 = $L("*/");
|
|
1704
|
+
var $L95 = $L("\\");
|
|
1705
|
+
var $L96 = $L("[");
|
|
1706
|
+
var $L97 = $L("`");
|
|
1707
|
+
var $L98 = $L("abstract");
|
|
1708
|
+
var $L99 = $L("as");
|
|
1709
|
+
var $L100 = $L("@");
|
|
1710
|
+
var $L101 = $L("@@");
|
|
1711
|
+
var $L102 = $L("async");
|
|
1712
|
+
var $L103 = $L("await");
|
|
1713
|
+
var $L104 = $L("by");
|
|
1714
|
+
var $L105 = $L("case");
|
|
1715
|
+
var $L106 = $L("catch");
|
|
1716
|
+
var $L107 = $L("class");
|
|
1717
|
+
var $L108 = $L(")");
|
|
1718
|
+
var $L109 = $L("#{");
|
|
1729
1719
|
var $L110 = $L("declare");
|
|
1730
1720
|
var $L111 = $L("default");
|
|
1731
1721
|
var $L112 = $L("delete");
|
|
@@ -3119,9 +3109,9 @@ ${input.slice(result.pos)}
|
|
|
3119
3109
|
return result;
|
|
3120
3110
|
}
|
|
3121
3111
|
}
|
|
3122
|
-
var FatArrow$0 = $TS($S(
|
|
3112
|
+
var FatArrow$0 = $TS($S($E(_), $EXPECT($L8, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
|
|
3123
3113
|
var ws = $1;
|
|
3124
|
-
if (!ws
|
|
3114
|
+
if (!ws)
|
|
3125
3115
|
return " =>";
|
|
3126
3116
|
return $0;
|
|
3127
3117
|
});
|
|
@@ -3473,7 +3463,7 @@ ${input.slice(result.pos)}
|
|
|
3473
3463
|
return result;
|
|
3474
3464
|
}
|
|
3475
3465
|
}
|
|
3476
|
-
var ClassExpression$0 = $S($E(Decorators), $E($S(Abstract, __)), Class, $E(ClassBinding), $E(ClassHeritage), ClassBody);
|
|
3466
|
+
var ClassExpression$0 = $S($E(Decorators), $E($S(Abstract, __)), Class, $N($EXPECT($L10, fail, 'ClassExpression ":"')), $E(ClassBinding), $E(ClassHeritage), ClassBody);
|
|
3477
3467
|
function ClassExpression(state) {
|
|
3478
3468
|
let eventData;
|
|
3479
3469
|
if (state.events) {
|
|
@@ -3672,7 +3662,7 @@ ${input.slice(result.pos)}
|
|
|
3672
3662
|
}
|
|
3673
3663
|
return { children };
|
|
3674
3664
|
});
|
|
3675
|
-
var ImplementsToken$1 = $TS($S(__, $EXPECT($
|
|
3665
|
+
var ImplementsToken$1 = $TS($S(__, $EXPECT($L11, fail, 'ImplementsToken "implements"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
3676
3666
|
$2 = { $loc, token: $2 };
|
|
3677
3667
|
return [$1, $2];
|
|
3678
3668
|
});
|
|
@@ -3698,7 +3688,7 @@ ${input.slice(result.pos)}
|
|
|
3698
3688
|
return result;
|
|
3699
3689
|
}
|
|
3700
3690
|
}
|
|
3701
|
-
var ImplementsShorthand$0 = $TV($EXPECT($
|
|
3691
|
+
var ImplementsShorthand$0 = $TV($EXPECT($L12, fail, 'ImplementsShorthand "<:"'), function($skip, $loc, $0, $1) {
|
|
3702
3692
|
return { $loc, token: "implements " };
|
|
3703
3693
|
});
|
|
3704
3694
|
function ImplementsShorthand(state) {
|
|
@@ -4078,7 +4068,7 @@ ${input.slice(result.pos)}
|
|
|
4078
4068
|
}
|
|
4079
4069
|
}
|
|
4080
4070
|
var ThisLiteral$0 = This;
|
|
4081
|
-
var ThisLiteral$1 = $TS($S(AtThis, $TEXT($S($E($EXPECT($
|
|
4071
|
+
var ThisLiteral$1 = $TS($S(AtThis, $TEXT($S($E($EXPECT($L13, fail, 'ThisLiteral "#"')), IdentifierName))), function($skip, $loc, $0, $1, $2) {
|
|
4082
4072
|
var at = $1;
|
|
4083
4073
|
var id = $2;
|
|
4084
4074
|
return [at, ".", id];
|
|
@@ -4132,11 +4122,8 @@ ${input.slice(result.pos)}
|
|
|
4132
4122
|
return result;
|
|
4133
4123
|
}
|
|
4134
4124
|
}
|
|
4135
|
-
var LeftHandSideExpression$0 = $
|
|
4136
|
-
|
|
4137
|
-
return $0;
|
|
4138
|
-
return $2;
|
|
4139
|
-
});
|
|
4125
|
+
var LeftHandSideExpression$0 = $S($P($S(New, $N($C($EXPECT($L5, fail, 'LeftHandSideExpression "."'), $EXPECT($L10, fail, 'LeftHandSideExpression ":"'))), __)), CallExpression, $E(TypeArguments));
|
|
4126
|
+
var LeftHandSideExpression$1 = CallExpression;
|
|
4140
4127
|
function LeftHandSideExpression(state) {
|
|
4141
4128
|
let eventData;
|
|
4142
4129
|
if (state.events) {
|
|
@@ -4148,33 +4135,32 @@ ${input.slice(result.pos)}
|
|
|
4148
4135
|
}
|
|
4149
4136
|
}
|
|
4150
4137
|
if (state.tokenize) {
|
|
4151
|
-
const result = $TOKEN("LeftHandSideExpression", state, LeftHandSideExpression$0(state));
|
|
4138
|
+
const result = $TOKEN("LeftHandSideExpression", state, LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state));
|
|
4152
4139
|
if (state.events)
|
|
4153
4140
|
state.events.exit?.("LeftHandSideExpression", state, result, eventData);
|
|
4154
4141
|
return result;
|
|
4155
4142
|
} else {
|
|
4156
|
-
const result = LeftHandSideExpression$0(state);
|
|
4143
|
+
const result = LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
|
|
4157
4144
|
if (state.events)
|
|
4158
4145
|
state.events.exit?.("LeftHandSideExpression", state, result, eventData);
|
|
4159
4146
|
return result;
|
|
4160
4147
|
}
|
|
4161
4148
|
}
|
|
4162
|
-
var CallExpression$0 = $TS($S($EXPECT($
|
|
4149
|
+
var CallExpression$0 = $TS($S($EXPECT($L14, fail, 'CallExpression "super"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
4163
4150
|
var rest = $3;
|
|
4164
4151
|
return module.processGlob({
|
|
4165
4152
|
type: "CallExpression",
|
|
4166
4153
|
children: [$1, ...$2, ...rest.flat()]
|
|
4167
4154
|
});
|
|
4168
4155
|
});
|
|
4169
|
-
var CallExpression$1 = $TS($S($EXPECT($
|
|
4156
|
+
var CallExpression$1 = $TS($S($EXPECT($L15, fail, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
4170
4157
|
var rest = $3;
|
|
4171
4158
|
return module.processGlob({
|
|
4172
4159
|
type: "CallExpression",
|
|
4173
4160
|
children: [$1, ...$2, ...rest.flat()]
|
|
4174
4161
|
});
|
|
4175
4162
|
});
|
|
4176
|
-
var CallExpression$2 =
|
|
4177
|
-
var CallExpression$3 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
4163
|
+
var CallExpression$2 = $TS($S(MemberExpression, AllowedTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
4178
4164
|
var member = $1;
|
|
4179
4165
|
var trailing = $2;
|
|
4180
4166
|
var rest = $3;
|
|
@@ -4198,69 +4184,17 @@ ${input.slice(result.pos)}
|
|
|
4198
4184
|
}
|
|
4199
4185
|
}
|
|
4200
4186
|
if (state.tokenize) {
|
|
4201
|
-
const result = $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state)
|
|
4187
|
+
const result = $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state));
|
|
4202
4188
|
if (state.events)
|
|
4203
4189
|
state.events.exit?.("CallExpression", state, result, eventData);
|
|
4204
4190
|
return result;
|
|
4205
4191
|
} else {
|
|
4206
|
-
const result = CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state)
|
|
4192
|
+
const result = CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state);
|
|
4207
4193
|
if (state.events)
|
|
4208
4194
|
state.events.exit?.("CallExpression", state, result, eventData);
|
|
4209
4195
|
return result;
|
|
4210
4196
|
}
|
|
4211
4197
|
}
|
|
4212
|
-
var ReturnValue$0 = $TV($C($S($EXPECT($L15, fail, 'ReturnValue "return.value"'), NonIdContinue), $S(Return, $Y(AfterReturnShorthand))), function($skip, $loc, $0, $1) {
|
|
4213
|
-
return { type: "ReturnValue", children: [$1[0]] };
|
|
4214
|
-
});
|
|
4215
|
-
function ReturnValue(state) {
|
|
4216
|
-
let eventData;
|
|
4217
|
-
if (state.events) {
|
|
4218
|
-
const result = state.events.enter?.("ReturnValue", state);
|
|
4219
|
-
if (result) {
|
|
4220
|
-
if (result.cache)
|
|
4221
|
-
return result.cache;
|
|
4222
|
-
eventData = result.data;
|
|
4223
|
-
}
|
|
4224
|
-
}
|
|
4225
|
-
if (state.tokenize) {
|
|
4226
|
-
const result = $TOKEN("ReturnValue", state, ReturnValue$0(state));
|
|
4227
|
-
if (state.events)
|
|
4228
|
-
state.events.exit?.("ReturnValue", state, result, eventData);
|
|
4229
|
-
return result;
|
|
4230
|
-
} else {
|
|
4231
|
-
const result = ReturnValue$0(state);
|
|
4232
|
-
if (state.events)
|
|
4233
|
-
state.events.exit?.("ReturnValue", state, result, eventData);
|
|
4234
|
-
return result;
|
|
4235
|
-
}
|
|
4236
|
-
}
|
|
4237
|
-
var AfterReturnShorthand$0 = WAssignmentOp;
|
|
4238
|
-
var AfterReturnShorthand$1 = UpdateExpressionSymbol;
|
|
4239
|
-
var AfterReturnShorthand$2 = TypeSuffix;
|
|
4240
|
-
var AfterReturnShorthand$3 = $S(__, LetAssignment);
|
|
4241
|
-
var AfterReturnShorthand$4 = $S(__, ConstAssignment);
|
|
4242
|
-
function AfterReturnShorthand(state) {
|
|
4243
|
-
let eventData;
|
|
4244
|
-
if (state.events) {
|
|
4245
|
-
const result = state.events.enter?.("AfterReturnShorthand", state);
|
|
4246
|
-
if (result) {
|
|
4247
|
-
if (result.cache)
|
|
4248
|
-
return result.cache;
|
|
4249
|
-
eventData = result.data;
|
|
4250
|
-
}
|
|
4251
|
-
}
|
|
4252
|
-
if (state.tokenize) {
|
|
4253
|
-
const result = $TOKEN("AfterReturnShorthand", state, AfterReturnShorthand$0(state) || AfterReturnShorthand$1(state) || AfterReturnShorthand$2(state) || AfterReturnShorthand$3(state) || AfterReturnShorthand$4(state));
|
|
4254
|
-
if (state.events)
|
|
4255
|
-
state.events.exit?.("AfterReturnShorthand", state, result, eventData);
|
|
4256
|
-
return result;
|
|
4257
|
-
} else {
|
|
4258
|
-
const result = AfterReturnShorthand$0(state) || AfterReturnShorthand$1(state) || AfterReturnShorthand$2(state) || AfterReturnShorthand$3(state) || AfterReturnShorthand$4(state);
|
|
4259
|
-
if (state.events)
|
|
4260
|
-
state.events.exit?.("AfterReturnShorthand", state, result, eventData);
|
|
4261
|
-
return result;
|
|
4262
|
-
}
|
|
4263
|
-
}
|
|
4264
4198
|
var CallExpressionRest$0 = MemberExpressionRest;
|
|
4265
4199
|
var CallExpressionRest$1 = $TV($C(TemplateLiteral, StringLiteral), function($skip, $loc, $0, $1) {
|
|
4266
4200
|
if ($1.type === "StringLiteral") {
|
|
@@ -4671,8 +4605,8 @@ ${input.slice(result.pos)}
|
|
|
4671
4605
|
return result;
|
|
4672
4606
|
}
|
|
4673
4607
|
}
|
|
4674
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
4675
|
-
var SuperProperty$1 = $S($EXPECT($
|
|
4608
|
+
var SuperProperty$0 = $S($EXPECT($L14, fail, 'SuperProperty "super"'), MemberBracketContent);
|
|
4609
|
+
var SuperProperty$1 = $S($EXPECT($L14, fail, 'SuperProperty "super"'), $N($C(QuestionMark, NonNullAssertion)), PropertyAccess);
|
|
4676
4610
|
function SuperProperty(state) {
|
|
4677
4611
|
let eventData;
|
|
4678
4612
|
if (state.events) {
|
|
@@ -4699,6 +4633,7 @@ ${input.slice(result.pos)}
|
|
|
4699
4633
|
var MetaProperty$1 = $TS($S($EXPECT($L19, fail, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4700
4634
|
return { $loc, token: $1 };
|
|
4701
4635
|
});
|
|
4636
|
+
var MetaProperty$2 = ReturnValue;
|
|
4702
4637
|
function MetaProperty(state) {
|
|
4703
4638
|
let eventData;
|
|
4704
4639
|
if (state.events) {
|
|
@@ -4710,22 +4645,77 @@ ${input.slice(result.pos)}
|
|
|
4710
4645
|
}
|
|
4711
4646
|
}
|
|
4712
4647
|
if (state.tokenize) {
|
|
4713
|
-
const result = $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
|
|
4648
|
+
const result = $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state) || MetaProperty$2(state));
|
|
4714
4649
|
if (state.events)
|
|
4715
4650
|
state.events.exit?.("MetaProperty", state, result, eventData);
|
|
4716
4651
|
return result;
|
|
4717
4652
|
} else {
|
|
4718
|
-
const result = MetaProperty$0(state) || MetaProperty$1(state);
|
|
4653
|
+
const result = MetaProperty$0(state) || MetaProperty$1(state) || MetaProperty$2(state);
|
|
4719
4654
|
if (state.events)
|
|
4720
4655
|
state.events.exit?.("MetaProperty", state, result, eventData);
|
|
4721
4656
|
return result;
|
|
4722
4657
|
}
|
|
4723
4658
|
}
|
|
4659
|
+
var ReturnValue$0 = $TV($C($S($EXPECT($L20, fail, 'ReturnValue "return.value"'), NonIdContinue), $S(Return, $Y(AfterReturnShorthand))), function($skip, $loc, $0, $1) {
|
|
4660
|
+
return { type: "ReturnValue", children: [$1[0]] };
|
|
4661
|
+
});
|
|
4662
|
+
function ReturnValue(state) {
|
|
4663
|
+
let eventData;
|
|
4664
|
+
if (state.events) {
|
|
4665
|
+
const result = state.events.enter?.("ReturnValue", state);
|
|
4666
|
+
if (result) {
|
|
4667
|
+
if (result.cache)
|
|
4668
|
+
return result.cache;
|
|
4669
|
+
eventData = result.data;
|
|
4670
|
+
}
|
|
4671
|
+
}
|
|
4672
|
+
if (state.tokenize) {
|
|
4673
|
+
const result = $TOKEN("ReturnValue", state, ReturnValue$0(state));
|
|
4674
|
+
if (state.events)
|
|
4675
|
+
state.events.exit?.("ReturnValue", state, result, eventData);
|
|
4676
|
+
return result;
|
|
4677
|
+
} else {
|
|
4678
|
+
const result = ReturnValue$0(state);
|
|
4679
|
+
if (state.events)
|
|
4680
|
+
state.events.exit?.("ReturnValue", state, result, eventData);
|
|
4681
|
+
return result;
|
|
4682
|
+
}
|
|
4683
|
+
}
|
|
4684
|
+
var AfterReturnShorthand$0 = WAssignmentOp;
|
|
4685
|
+
var AfterReturnShorthand$1 = UpdateExpressionSymbol;
|
|
4686
|
+
var AfterReturnShorthand$2 = TypeSuffix;
|
|
4687
|
+
var AfterReturnShorthand$3 = $S(__, LetAssignment);
|
|
4688
|
+
var AfterReturnShorthand$4 = $S(__, ConstAssignment);
|
|
4689
|
+
function AfterReturnShorthand(state) {
|
|
4690
|
+
let eventData;
|
|
4691
|
+
if (state.events) {
|
|
4692
|
+
const result = state.events.enter?.("AfterReturnShorthand", state);
|
|
4693
|
+
if (result) {
|
|
4694
|
+
if (result.cache)
|
|
4695
|
+
return result.cache;
|
|
4696
|
+
eventData = result.data;
|
|
4697
|
+
}
|
|
4698
|
+
}
|
|
4699
|
+
if (state.tokenize) {
|
|
4700
|
+
const result = $TOKEN("AfterReturnShorthand", state, AfterReturnShorthand$0(state) || AfterReturnShorthand$1(state) || AfterReturnShorthand$2(state) || AfterReturnShorthand$3(state) || AfterReturnShorthand$4(state));
|
|
4701
|
+
if (state.events)
|
|
4702
|
+
state.events.exit?.("AfterReturnShorthand", state, result, eventData);
|
|
4703
|
+
return result;
|
|
4704
|
+
} else {
|
|
4705
|
+
const result = AfterReturnShorthand$0(state) || AfterReturnShorthand$1(state) || AfterReturnShorthand$2(state) || AfterReturnShorthand$3(state) || AfterReturnShorthand$4(state);
|
|
4706
|
+
if (state.events)
|
|
4707
|
+
state.events.exit?.("AfterReturnShorthand", state, result, eventData);
|
|
4708
|
+
return result;
|
|
4709
|
+
}
|
|
4710
|
+
}
|
|
4724
4711
|
var Parameters$0 = NonEmptyParameters;
|
|
4725
|
-
var Parameters$1 = $
|
|
4712
|
+
var Parameters$1 = $TS($S($E(TypeParameters), Loc), function($skip, $loc, $0, $1, $2) {
|
|
4713
|
+
var tp = $1;
|
|
4714
|
+
var p = $2;
|
|
4726
4715
|
return {
|
|
4727
4716
|
type: "Parameters",
|
|
4728
|
-
children: [{ $loc, token: "()" }],
|
|
4717
|
+
children: [tp, { $loc: p.$loc, token: "()" }],
|
|
4718
|
+
tp,
|
|
4729
4719
|
names: [],
|
|
4730
4720
|
implicit: true
|
|
4731
4721
|
};
|
|
@@ -4771,9 +4761,8 @@ ${input.slice(result.pos)}
|
|
|
4771
4761
|
}
|
|
4772
4762
|
let blockPrefix;
|
|
4773
4763
|
if (after.length) {
|
|
4774
|
-
const spliceRef = module.getRef("splice");
|
|
4775
4764
|
blockPrefix = {
|
|
4776
|
-
children: ["[", insertTrimmingSpace(after, ""), "] = ",
|
|
4765
|
+
children: ["[", insertTrimmingSpace(after, ""), "] = ", restIdentifier, ".splice(-", after.length.toString(), ")"],
|
|
4777
4766
|
names: after.flatMap((p) => p.names)
|
|
4778
4767
|
};
|
|
4779
4768
|
}
|
|
@@ -5506,7 +5495,7 @@ ${input.slice(result.pos)}
|
|
|
5506
5495
|
children: $0
|
|
5507
5496
|
};
|
|
5508
5497
|
});
|
|
5509
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
5498
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L21, fail, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
5510
5499
|
return {
|
|
5511
5500
|
children: [{
|
|
5512
5501
|
type: "ElisionElement",
|
|
@@ -6055,7 +6044,7 @@ ${input.slice(result.pos)}
|
|
|
6055
6044
|
children: [ws, binding]
|
|
6056
6045
|
};
|
|
6057
6046
|
});
|
|
6058
|
-
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($
|
|
6047
|
+
var MatchingElement$3 = $TV($Y($S($E(_), $EXPECT($L21, fail, 'MatchingElement ","'))), function($skip, $loc, $0, $1) {
|
|
6059
6048
|
return {
|
|
6060
6049
|
children: [{
|
|
6061
6050
|
type: "ElisionElement",
|
|
@@ -6157,7 +6146,7 @@ ${input.slice(result.pos)}
|
|
|
6157
6146
|
async,
|
|
6158
6147
|
generator,
|
|
6159
6148
|
block: null,
|
|
6160
|
-
children: !parameters.implicit ?
|
|
6149
|
+
children: !parameters.implicit ? [async, func, generator, wid, w, parameters, suffix] : [async, func, generator, wid, parameters, w, suffix]
|
|
6161
6150
|
};
|
|
6162
6151
|
});
|
|
6163
6152
|
function FunctionSignature(state) {
|
|
@@ -6470,7 +6459,7 @@ ${input.slice(result.pos)}
|
|
|
6470
6459
|
return result;
|
|
6471
6460
|
}
|
|
6472
6461
|
}
|
|
6473
|
-
var ThinArrowFunction$0 = $TS($S($E($S(Async, _)), Parameters, $E(ReturnTypeSuffix), $
|
|
6462
|
+
var ThinArrowFunction$0 = $TS($S($E($S(Async, _)), Parameters, $E(ReturnTypeSuffix), $E(_), Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
6474
6463
|
var async = $1;
|
|
6475
6464
|
var parameters = $2;
|
|
6476
6465
|
var suffix = $3;
|
|
@@ -6524,7 +6513,7 @@ ${input.slice(result.pos)}
|
|
|
6524
6513
|
return result;
|
|
6525
6514
|
}
|
|
6526
6515
|
}
|
|
6527
|
-
var Arrow$0 = $TV($EXPECT($
|
|
6516
|
+
var Arrow$0 = $TV($EXPECT($L22, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
6528
6517
|
return { $loc, token: $1 };
|
|
6529
6518
|
});
|
|
6530
6519
|
function Arrow(state) {
|
|
@@ -6990,7 +6979,7 @@ ${input.slice(result.pos)}
|
|
|
6990
6979
|
children: [$1, expressions]
|
|
6991
6980
|
};
|
|
6992
6981
|
});
|
|
6993
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
6982
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L23, fail, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
6994
6983
|
const expressions = [];
|
|
6995
6984
|
return {
|
|
6996
6985
|
type: "BlockStatement",
|
|
@@ -7171,7 +7160,7 @@ ${input.slice(result.pos)}
|
|
|
7171
7160
|
return result;
|
|
7172
7161
|
}
|
|
7173
7162
|
}
|
|
7174
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
7163
|
+
var NullLiteral$0 = $TS($S($EXPECT($L24, fail, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7175
7164
|
return { $loc, token: $1 };
|
|
7176
7165
|
});
|
|
7177
7166
|
function NullLiteral(state) {
|
|
@@ -7199,7 +7188,7 @@ ${input.slice(result.pos)}
|
|
|
7199
7188
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
7200
7189
|
return value[1];
|
|
7201
7190
|
});
|
|
7202
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
7191
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L25, fail, 'BooleanLiteral "true"'), $EXPECT($L26, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7203
7192
|
return { $loc, token: $1 };
|
|
7204
7193
|
});
|
|
7205
7194
|
function BooleanLiteral(state) {
|
|
@@ -7224,10 +7213,10 @@ ${input.slice(result.pos)}
|
|
|
7224
7213
|
return result;
|
|
7225
7214
|
}
|
|
7226
7215
|
}
|
|
7227
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
7216
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L27, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L28, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7228
7217
|
return { $loc, token: "true" };
|
|
7229
7218
|
});
|
|
7230
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
7219
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L29, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L30, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7231
7220
|
return { $loc, token: "false" };
|
|
7232
7221
|
});
|
|
7233
7222
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -7333,7 +7322,7 @@ ${input.slice(result.pos)}
|
|
|
7333
7322
|
return result;
|
|
7334
7323
|
}
|
|
7335
7324
|
}
|
|
7336
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L2, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L2, fail, 'UpcomingAssignment "="'), $EXPECT($
|
|
7325
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L2, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L2, fail, 'UpcomingAssignment "="'), $EXPECT($L31, fail, 'UpcomingAssignment ">"')))));
|
|
7337
7326
|
function UpcomingAssignment(state) {
|
|
7338
7327
|
let eventData;
|
|
7339
7328
|
if (state.events) {
|
|
@@ -7599,7 +7588,7 @@ ${input.slice(result.pos)}
|
|
|
7599
7588
|
}
|
|
7600
7589
|
}
|
|
7601
7590
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
7602
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7591
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L32, fail, 'ArrayElementDelimiter "]"')));
|
|
7603
7592
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7604
7593
|
return value[1];
|
|
7605
7594
|
});
|
|
@@ -8079,7 +8068,7 @@ ${input.slice(result.pos)}
|
|
|
8079
8068
|
}
|
|
8080
8069
|
}
|
|
8081
8070
|
var ObjectPropertyDelimiter$0 = $S($E(_), Comma);
|
|
8082
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
8071
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L23, fail, 'ObjectPropertyDelimiter "}"')));
|
|
8083
8072
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
8084
8073
|
return value[1];
|
|
8085
8074
|
});
|
|
@@ -8542,7 +8531,7 @@ ${input.slice(result.pos)}
|
|
|
8542
8531
|
return result;
|
|
8543
8532
|
}
|
|
8544
8533
|
}
|
|
8545
|
-
var MethodModifier$0 = $TS($S(GetOrSet, $E(_)), function($skip, $loc, $0, $1, $2) {
|
|
8534
|
+
var MethodModifier$0 = $TS($S(GetOrSet, $E(_), $Y(ClassElementName)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8546
8535
|
var kind = $1;
|
|
8547
8536
|
return {
|
|
8548
8537
|
type: "MethodModifier",
|
|
@@ -8670,7 +8659,7 @@ ${input.slice(result.pos)}
|
|
|
8670
8659
|
return result;
|
|
8671
8660
|
}
|
|
8672
8661
|
}
|
|
8673
|
-
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($
|
|
8662
|
+
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L13, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
|
|
8674
8663
|
return {
|
|
8675
8664
|
type: "Identifier",
|
|
8676
8665
|
name: $0,
|
|
@@ -8801,22 +8790,22 @@ ${input.slice(result.pos)}
|
|
|
8801
8790
|
return result;
|
|
8802
8791
|
}
|
|
8803
8792
|
}
|
|
8804
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
8805
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
8806
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
8807
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
8808
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
8809
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
8810
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
8811
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
8812
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
8813
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
8814
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
8815
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
8816
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
8817
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
8818
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
8819
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
8793
|
+
var AssignmentOpSymbol$0 = $EXPECT($L33, fail, 'AssignmentOpSymbol "**="');
|
|
8794
|
+
var AssignmentOpSymbol$1 = $EXPECT($L34, fail, 'AssignmentOpSymbol "*="');
|
|
8795
|
+
var AssignmentOpSymbol$2 = $EXPECT($L35, fail, 'AssignmentOpSymbol "/="');
|
|
8796
|
+
var AssignmentOpSymbol$3 = $EXPECT($L36, fail, 'AssignmentOpSymbol "%="');
|
|
8797
|
+
var AssignmentOpSymbol$4 = $EXPECT($L37, fail, 'AssignmentOpSymbol "+="');
|
|
8798
|
+
var AssignmentOpSymbol$5 = $EXPECT($L38, fail, 'AssignmentOpSymbol "-="');
|
|
8799
|
+
var AssignmentOpSymbol$6 = $EXPECT($L39, fail, 'AssignmentOpSymbol "<<="');
|
|
8800
|
+
var AssignmentOpSymbol$7 = $EXPECT($L40, fail, 'AssignmentOpSymbol ">>>="');
|
|
8801
|
+
var AssignmentOpSymbol$8 = $EXPECT($L41, fail, 'AssignmentOpSymbol ">>="');
|
|
8802
|
+
var AssignmentOpSymbol$9 = $EXPECT($L42, fail, 'AssignmentOpSymbol "&&="');
|
|
8803
|
+
var AssignmentOpSymbol$10 = $EXPECT($L43, fail, 'AssignmentOpSymbol "&="');
|
|
8804
|
+
var AssignmentOpSymbol$11 = $EXPECT($L44, fail, 'AssignmentOpSymbol "^="');
|
|
8805
|
+
var AssignmentOpSymbol$12 = $EXPECT($L45, fail, 'AssignmentOpSymbol "||="');
|
|
8806
|
+
var AssignmentOpSymbol$13 = $EXPECT($L46, fail, 'AssignmentOpSymbol "|="');
|
|
8807
|
+
var AssignmentOpSymbol$14 = $EXPECT($L47, fail, 'AssignmentOpSymbol "??="');
|
|
8808
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L48, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
8820
8809
|
return "??=";
|
|
8821
8810
|
});
|
|
8822
8811
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L2, fail, 'AssignmentOpSymbol "="'), $N($EXPECT($L2, fail, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -8847,10 +8836,10 @@ ${input.slice(result.pos)}
|
|
|
8847
8836
|
return result;
|
|
8848
8837
|
}
|
|
8849
8838
|
}
|
|
8850
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
8839
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L49, fail, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
8851
8840
|
return "&&=";
|
|
8852
8841
|
});
|
|
8853
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
8842
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L50, fail, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
8854
8843
|
return "||=";
|
|
8855
8844
|
});
|
|
8856
8845
|
function CoffeeWordAssignmentOp(state) {
|
|
@@ -8889,7 +8878,7 @@ ${input.slice(result.pos)}
|
|
|
8889
8878
|
special: true
|
|
8890
8879
|
};
|
|
8891
8880
|
});
|
|
8892
|
-
var BinaryOp$2 = $TS($S($EXPECT($
|
|
8881
|
+
var BinaryOp$2 = $TS($S($EXPECT($L51, fail, 'BinaryOp "not"'), NonIdContinue, __, Identifier), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8893
8882
|
var id = $4;
|
|
8894
8883
|
if (!module.operators.has(id.name))
|
|
8895
8884
|
return $skip;
|
|
@@ -8921,21 +8910,21 @@ ${input.slice(result.pos)}
|
|
|
8921
8910
|
return result;
|
|
8922
8911
|
}
|
|
8923
8912
|
}
|
|
8924
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
8925
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
8926
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
8927
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
8913
|
+
var BinaryOpSymbol$0 = $EXPECT($L52, fail, 'BinaryOpSymbol "**"');
|
|
8914
|
+
var BinaryOpSymbol$1 = $EXPECT($L53, fail, 'BinaryOpSymbol "*"');
|
|
8915
|
+
var BinaryOpSymbol$2 = $EXPECT($L54, fail, 'BinaryOpSymbol "/"');
|
|
8916
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L55, fail, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
8928
8917
|
return {
|
|
8929
8918
|
call: module.getRef("modulo"),
|
|
8930
8919
|
special: true
|
|
8931
8920
|
};
|
|
8932
8921
|
});
|
|
8933
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
8934
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
8922
|
+
var BinaryOpSymbol$4 = $EXPECT($L56, fail, 'BinaryOpSymbol "%"');
|
|
8923
|
+
var BinaryOpSymbol$5 = $EXPECT($L57, fail, 'BinaryOpSymbol "+"');
|
|
8935
8924
|
var BinaryOpSymbol$6 = $EXPECT($L18, fail, 'BinaryOpSymbol "-"');
|
|
8936
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
8937
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
8938
|
-
var BinaryOpSymbol$9 = $TV($EXPECT($
|
|
8925
|
+
var BinaryOpSymbol$7 = $EXPECT($L58, fail, 'BinaryOpSymbol "<="');
|
|
8926
|
+
var BinaryOpSymbol$8 = $EXPECT($L59, fail, 'BinaryOpSymbol ">="');
|
|
8927
|
+
var BinaryOpSymbol$9 = $TV($EXPECT($L60, fail, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
8939
8928
|
return {
|
|
8940
8929
|
$loc,
|
|
8941
8930
|
token: "instanceof",
|
|
@@ -8943,7 +8932,7 @@ ${input.slice(result.pos)}
|
|
|
8943
8932
|
special: true
|
|
8944
8933
|
};
|
|
8945
8934
|
});
|
|
8946
|
-
var BinaryOpSymbol$10 = $TV($EXPECT($
|
|
8935
|
+
var BinaryOpSymbol$10 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
8947
8936
|
return {
|
|
8948
8937
|
$loc,
|
|
8949
8938
|
token: "instanceof",
|
|
@@ -8952,58 +8941,58 @@ ${input.slice(result.pos)}
|
|
|
8952
8941
|
negated: true
|
|
8953
8942
|
};
|
|
8954
8943
|
});
|
|
8955
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
8944
|
+
var BinaryOpSymbol$11 = $EXPECT($L62, fail, 'BinaryOpSymbol "<<"');
|
|
8956
8945
|
var BinaryOpSymbol$12 = $TR($EXPECT($R7, fail, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8957
8946
|
return "<";
|
|
8958
8947
|
});
|
|
8959
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
8960
|
-
var BinaryOpSymbol$14 = $EXPECT($
|
|
8961
|
-
var BinaryOpSymbol$15 = $EXPECT($
|
|
8962
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
8963
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
8948
|
+
var BinaryOpSymbol$13 = $EXPECT($L63, fail, 'BinaryOpSymbol ">>>"');
|
|
8949
|
+
var BinaryOpSymbol$14 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>"');
|
|
8950
|
+
var BinaryOpSymbol$15 = $EXPECT($L31, fail, 'BinaryOpSymbol ">"');
|
|
8951
|
+
var BinaryOpSymbol$16 = $EXPECT($L65, fail, 'BinaryOpSymbol "!=="');
|
|
8952
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L66, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
8964
8953
|
if (module.config.coffeeEq)
|
|
8965
8954
|
return "!==";
|
|
8966
8955
|
return $1;
|
|
8967
8956
|
});
|
|
8968
|
-
var BinaryOpSymbol$18 = $TS($S($EXPECT($
|
|
8957
|
+
var BinaryOpSymbol$18 = $TS($S($EXPECT($L67, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8969
8958
|
if (module.config.coffeeIsnt)
|
|
8970
8959
|
return "!==";
|
|
8971
8960
|
return $skip;
|
|
8972
8961
|
});
|
|
8973
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
8974
|
-
var BinaryOpSymbol$20 = $TV($EXPECT($
|
|
8962
|
+
var BinaryOpSymbol$19 = $EXPECT($L68, fail, 'BinaryOpSymbol "==="');
|
|
8963
|
+
var BinaryOpSymbol$20 = $TV($EXPECT($L69, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
8975
8964
|
if (module.config.coffeeEq)
|
|
8976
8965
|
return "===";
|
|
8977
8966
|
return $1;
|
|
8978
8967
|
});
|
|
8979
|
-
var BinaryOpSymbol$21 = $T($S($EXPECT($
|
|
8968
|
+
var BinaryOpSymbol$21 = $T($S($EXPECT($L70, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
8980
8969
|
return "&&";
|
|
8981
8970
|
});
|
|
8982
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
8983
|
-
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
8971
|
+
var BinaryOpSymbol$22 = $EXPECT($L71, fail, 'BinaryOpSymbol "&&"');
|
|
8972
|
+
var BinaryOpSymbol$23 = $T($S(CoffeeOfEnabled, $EXPECT($L72, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
8984
8973
|
return "in";
|
|
8985
8974
|
});
|
|
8986
|
-
var BinaryOpSymbol$24 = $T($S($EXPECT($
|
|
8975
|
+
var BinaryOpSymbol$24 = $T($S($EXPECT($L73, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
8987
8976
|
return "||";
|
|
8988
8977
|
});
|
|
8989
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
8990
|
-
var BinaryOpSymbol$26 = $TV($C($EXPECT($
|
|
8978
|
+
var BinaryOpSymbol$25 = $EXPECT($L74, fail, 'BinaryOpSymbol "||"');
|
|
8979
|
+
var BinaryOpSymbol$26 = $TV($C($EXPECT($L75, fail, 'BinaryOpSymbol "^^"'), $S($EXPECT($L76, fail, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8991
8980
|
return {
|
|
8992
8981
|
call: module.getRef("xor"),
|
|
8993
8982
|
special: true
|
|
8994
8983
|
};
|
|
8995
8984
|
});
|
|
8996
|
-
var BinaryOpSymbol$27 = $TV($C($EXPECT($R8, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($
|
|
8985
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($R8, fail, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L77, fail, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8997
8986
|
return {
|
|
8998
8987
|
call: module.getRef("xnor"),
|
|
8999
8988
|
special: true
|
|
9000
8989
|
};
|
|
9001
8990
|
});
|
|
9002
|
-
var BinaryOpSymbol$28 = $EXPECT($
|
|
8991
|
+
var BinaryOpSymbol$28 = $EXPECT($L78, fail, 'BinaryOpSymbol "??"');
|
|
9003
8992
|
var BinaryOpSymbol$29 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L4, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
9004
8993
|
return "??";
|
|
9005
8994
|
});
|
|
9006
|
-
var BinaryOpSymbol$30 = $TS($S($EXPECT($
|
|
8995
|
+
var BinaryOpSymbol$30 = $TS($S($EXPECT($L79, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9007
8996
|
return {
|
|
9008
8997
|
$loc,
|
|
9009
8998
|
token: $1,
|
|
@@ -9011,7 +9000,7 @@ ${input.slice(result.pos)}
|
|
|
9011
9000
|
special: true
|
|
9012
9001
|
};
|
|
9013
9002
|
});
|
|
9014
|
-
var BinaryOpSymbol$31 = $TS($S($EXPECT($
|
|
9003
|
+
var BinaryOpSymbol$31 = $TS($S($EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L79, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
9015
9004
|
return {
|
|
9016
9005
|
$loc,
|
|
9017
9006
|
token: "instanceof",
|
|
@@ -9020,7 +9009,7 @@ ${input.slice(result.pos)}
|
|
|
9020
9009
|
negated: true
|
|
9021
9010
|
};
|
|
9022
9011
|
});
|
|
9023
|
-
var BinaryOpSymbol$32 = $TV($C($S($N(CoffeeOfEnabled), $EXPECT($
|
|
9012
|
+
var BinaryOpSymbol$32 = $TV($C($S($N(CoffeeOfEnabled), $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), $S(CoffeeOfEnabled, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L72, fail, 'BinaryOpSymbol "of"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
9024
9013
|
return {
|
|
9025
9014
|
$loc,
|
|
9026
9015
|
token: "in",
|
|
@@ -9028,7 +9017,7 @@ ${input.slice(result.pos)}
|
|
|
9028
9017
|
negated: true
|
|
9029
9018
|
};
|
|
9030
9019
|
});
|
|
9031
|
-
var BinaryOpSymbol$33 = $TS($S($EXPECT($
|
|
9020
|
+
var BinaryOpSymbol$33 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
9032
9021
|
return {
|
|
9033
9022
|
method: "includes",
|
|
9034
9023
|
relational: true,
|
|
@@ -9036,7 +9025,7 @@ ${input.slice(result.pos)}
|
|
|
9036
9025
|
special: true
|
|
9037
9026
|
};
|
|
9038
9027
|
});
|
|
9039
|
-
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
9028
|
+
var BinaryOpSymbol$34 = $TS($S(CoffeeOfEnabled, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
9040
9029
|
return {
|
|
9041
9030
|
call: [module.getRef("indexOf"), ".call"],
|
|
9042
9031
|
relational: true,
|
|
@@ -9045,7 +9034,7 @@ ${input.slice(result.pos)}
|
|
|
9045
9034
|
special: true
|
|
9046
9035
|
};
|
|
9047
9036
|
});
|
|
9048
|
-
var BinaryOpSymbol$35 = $TS($S($EXPECT($
|
|
9037
|
+
var BinaryOpSymbol$35 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
9049
9038
|
return {
|
|
9050
9039
|
method: "includes",
|
|
9051
9040
|
relational: true,
|
|
@@ -9054,7 +9043,7 @@ ${input.slice(result.pos)}
|
|
|
9054
9043
|
negated: true
|
|
9055
9044
|
};
|
|
9056
9045
|
});
|
|
9057
|
-
var BinaryOpSymbol$36 = $TS($S(CoffeeOfEnabled, $EXPECT($
|
|
9046
|
+
var BinaryOpSymbol$36 = $TS($S(CoffeeOfEnabled, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
9058
9047
|
return {
|
|
9059
9048
|
call: [module.getRef("indexOf"), ".call"],
|
|
9060
9049
|
relational: true,
|
|
@@ -9063,7 +9052,7 @@ ${input.slice(result.pos)}
|
|
|
9063
9052
|
special: true
|
|
9064
9053
|
};
|
|
9065
9054
|
});
|
|
9066
|
-
var BinaryOpSymbol$37 = $TS($S($N(CoffeeNotEnabled), $EXPECT($
|
|
9055
|
+
var BinaryOpSymbol$37 = $TS($S($N(CoffeeNotEnabled), $EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue, __, $EXPECT($L51, fail, 'BinaryOpSymbol "not"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
9067
9056
|
if (module.config.objectIs) {
|
|
9068
9057
|
return {
|
|
9069
9058
|
call: module.getRef("is"),
|
|
@@ -9075,7 +9064,7 @@ ${input.slice(result.pos)}
|
|
|
9075
9064
|
}
|
|
9076
9065
|
return "!==";
|
|
9077
9066
|
});
|
|
9078
|
-
var BinaryOpSymbol$38 = $TS($S($EXPECT($
|
|
9067
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9079
9068
|
if (module.config.objectIs) {
|
|
9080
9069
|
return {
|
|
9081
9070
|
call: module.getRef("is"),
|
|
@@ -9086,12 +9075,12 @@ ${input.slice(result.pos)}
|
|
|
9086
9075
|
}
|
|
9087
9076
|
return "===";
|
|
9088
9077
|
});
|
|
9089
|
-
var BinaryOpSymbol$39 = $TS($S($EXPECT($
|
|
9078
|
+
var BinaryOpSymbol$39 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9090
9079
|
return $1;
|
|
9091
9080
|
});
|
|
9092
|
-
var BinaryOpSymbol$40 = $EXPECT($
|
|
9081
|
+
var BinaryOpSymbol$40 = $EXPECT($L82, fail, 'BinaryOpSymbol "&"');
|
|
9093
9082
|
var BinaryOpSymbol$41 = $EXPECT($L17, fail, 'BinaryOpSymbol "^"');
|
|
9094
|
-
var BinaryOpSymbol$42 = $EXPECT($
|
|
9083
|
+
var BinaryOpSymbol$42 = $EXPECT($L83, fail, 'BinaryOpSymbol "|"');
|
|
9095
9084
|
function BinaryOpSymbol(state) {
|
|
9096
9085
|
let eventData;
|
|
9097
9086
|
if (state.events) {
|
|
@@ -9114,8 +9103,8 @@ ${input.slice(result.pos)}
|
|
|
9114
9103
|
return result;
|
|
9115
9104
|
}
|
|
9116
9105
|
}
|
|
9117
|
-
var Xor$0 = $EXPECT($
|
|
9118
|
-
var Xor$1 = $S($EXPECT($
|
|
9106
|
+
var Xor$0 = $EXPECT($L75, fail, 'Xor "^^"');
|
|
9107
|
+
var Xor$1 = $S($EXPECT($L76, fail, 'Xor "xor"'), NonIdContinue);
|
|
9119
9108
|
function Xor(state) {
|
|
9120
9109
|
let eventData;
|
|
9121
9110
|
if (state.events) {
|
|
@@ -9139,7 +9128,7 @@ ${input.slice(result.pos)}
|
|
|
9139
9128
|
}
|
|
9140
9129
|
}
|
|
9141
9130
|
var Xnor$0 = $R$0($EXPECT($R8, fail, "Xnor /!\\^\\^?/"));
|
|
9142
|
-
var Xnor$1 = $EXPECT($
|
|
9131
|
+
var Xnor$1 = $EXPECT($L77, fail, 'Xnor "xnor"');
|
|
9143
9132
|
function Xnor(state) {
|
|
9144
9133
|
let eventData;
|
|
9145
9134
|
if (state.events) {
|
|
@@ -9166,7 +9155,7 @@ ${input.slice(result.pos)}
|
|
|
9166
9155
|
return { $loc, token: $0 };
|
|
9167
9156
|
});
|
|
9168
9157
|
var UnaryOp$1 = AwaitOp;
|
|
9169
|
-
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $E(_));
|
|
9158
|
+
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($EXPECT($L10, fail, 'UnaryOp ":"')), $E(_));
|
|
9170
9159
|
var UnaryOp$3 = Not;
|
|
9171
9160
|
function UnaryOp(state) {
|
|
9172
9161
|
let eventData;
|
|
@@ -9425,7 +9414,7 @@ ${input.slice(result.pos)}
|
|
|
9425
9414
|
return result;
|
|
9426
9415
|
}
|
|
9427
9416
|
}
|
|
9428
|
-
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($
|
|
9417
|
+
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L84, fail, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
|
|
9429
9418
|
return { type: "EmptyStatement", children: $1 || [] };
|
|
9430
9419
|
});
|
|
9431
9420
|
function EmptyStatement(state) {
|
|
@@ -9504,7 +9493,7 @@ ${input.slice(result.pos)}
|
|
|
9504
9493
|
var w = $3;
|
|
9505
9494
|
return [id, colon, w];
|
|
9506
9495
|
});
|
|
9507
|
-
var Label$1 = $S($EXPECT($
|
|
9496
|
+
var Label$1 = $S($EXPECT($L85, fail, 'Label "$:"'), Whitespace);
|
|
9508
9497
|
function Label(state) {
|
|
9509
9498
|
let eventData;
|
|
9510
9499
|
if (state.events) {
|
|
@@ -10488,7 +10477,7 @@ ${input.slice(result.pos)}
|
|
|
10488
10477
|
return result;
|
|
10489
10478
|
}
|
|
10490
10479
|
}
|
|
10491
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
10480
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L86, fail, 'CoffeeForDeclaration "own"'), NonIdContinue)), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
10492
10481
|
var own = $1;
|
|
10493
10482
|
var binding = $2;
|
|
10494
10483
|
return {
|
|
@@ -11059,11 +11048,11 @@ ${input.slice(result.pos)}
|
|
|
11059
11048
|
return result;
|
|
11060
11049
|
}
|
|
11061
11050
|
}
|
|
11062
|
-
var TryStatement$0 = $TS($S(Try, NoPostfixBracedOrEmptyBlock, $E(CatchClause), $E(FinallyClause)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
11051
|
+
var TryStatement$0 = $TS($S(Try, $N($EXPECT($L10, fail, 'TryStatement ":"')), NoPostfixBracedOrEmptyBlock, $E(CatchClause), $E(FinallyClause)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
11063
11052
|
var t = $1;
|
|
11064
|
-
var b = $
|
|
11065
|
-
var c = $
|
|
11066
|
-
var f = $
|
|
11053
|
+
var b = $3;
|
|
11054
|
+
var c = $4;
|
|
11055
|
+
var f = $5;
|
|
11067
11056
|
if (!c && !f) {
|
|
11068
11057
|
const e = [];
|
|
11069
11058
|
const emptyCatchBlock = {
|
|
@@ -11873,7 +11862,7 @@ ${input.slice(result.pos)}
|
|
|
11873
11862
|
var KeywordStatement$2 = $T($S(Debugger), function(value) {
|
|
11874
11863
|
return { "type": "DebuggerStatement", "children": value };
|
|
11875
11864
|
});
|
|
11876
|
-
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L5, fail, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
|
|
11865
|
+
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L10, fail, 'KeywordStatement ":"'), $EXPECT($L5, fail, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
|
|
11877
11866
|
var expression = value[2];
|
|
11878
11867
|
return { "type": "ReturnStatement", "expression": expression, "children": value };
|
|
11879
11868
|
});
|
|
@@ -11902,7 +11891,7 @@ ${input.slice(result.pos)}
|
|
|
11902
11891
|
return result;
|
|
11903
11892
|
}
|
|
11904
11893
|
}
|
|
11905
|
-
var Break$0 = $TS($S($EXPECT($
|
|
11894
|
+
var Break$0 = $TS($S($EXPECT($L87, fail, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11906
11895
|
return { $loc, token: $1 };
|
|
11907
11896
|
});
|
|
11908
11897
|
function Break(state) {
|
|
@@ -11927,7 +11916,7 @@ ${input.slice(result.pos)}
|
|
|
11927
11916
|
return result;
|
|
11928
11917
|
}
|
|
11929
11918
|
}
|
|
11930
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
11919
|
+
var Continue$0 = $TS($S($EXPECT($L88, fail, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11931
11920
|
return { $loc, token: $1 };
|
|
11932
11921
|
});
|
|
11933
11922
|
function Continue(state) {
|
|
@@ -11952,7 +11941,7 @@ ${input.slice(result.pos)}
|
|
|
11952
11941
|
return result;
|
|
11953
11942
|
}
|
|
11954
11943
|
}
|
|
11955
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
11944
|
+
var Debugger$0 = $TS($S($EXPECT($L89, fail, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11956
11945
|
return { $loc, token: $1 };
|
|
11957
11946
|
});
|
|
11958
11947
|
function Debugger(state) {
|
|
@@ -12258,7 +12247,7 @@ ${input.slice(result.pos)}
|
|
|
12258
12247
|
return result;
|
|
12259
12248
|
}
|
|
12260
12249
|
}
|
|
12261
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
12250
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L90, fail, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
12262
12251
|
function ImportAssertion(state) {
|
|
12263
12252
|
let eventData;
|
|
12264
12253
|
if (state.events) {
|
|
@@ -12830,7 +12819,7 @@ ${input.slice(result.pos)}
|
|
|
12830
12819
|
return result;
|
|
12831
12820
|
}
|
|
12832
12821
|
}
|
|
12833
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
12822
|
+
var ConstAssignment$0 = $TV($EXPECT($L91, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
12834
12823
|
return { $loc, token: "=" };
|
|
12835
12824
|
});
|
|
12836
12825
|
function ConstAssignment(state) {
|
|
@@ -12855,7 +12844,7 @@ ${input.slice(result.pos)}
|
|
|
12855
12844
|
return result;
|
|
12856
12845
|
}
|
|
12857
12846
|
}
|
|
12858
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
12847
|
+
var LetAssignment$0 = $TV($EXPECT($L92, fail, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
12859
12848
|
return { $loc, token: "=" };
|
|
12860
12849
|
});
|
|
12861
12850
|
function LetAssignment(state) {
|
|
@@ -13562,7 +13551,7 @@ ${input.slice(result.pos)}
|
|
|
13562
13551
|
}
|
|
13563
13552
|
}
|
|
13564
13553
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
13565
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
13554
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L54, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L54, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
13566
13555
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
13567
13556
|
});
|
|
13568
13557
|
function RegularExpressionLiteral(state) {
|
|
@@ -14129,7 +14118,7 @@ ${input.slice(result.pos)}
|
|
|
14129
14118
|
return result;
|
|
14130
14119
|
}
|
|
14131
14120
|
}
|
|
14132
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
14121
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L93, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L94, fail, 'JSMultiLineComment "*/"')), $EXPECT($R42, fail, "JSMultiLineComment /./"))), $EXPECT($L94, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
14133
14122
|
return { type: "Comment", $loc, token: $1 };
|
|
14134
14123
|
});
|
|
14135
14124
|
function JSMultiLineComment(state) {
|
|
@@ -14228,7 +14217,7 @@ ${input.slice(result.pos)}
|
|
|
14228
14217
|
return result;
|
|
14229
14218
|
}
|
|
14230
14219
|
}
|
|
14231
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
14220
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L93, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L94, fail, 'InlineComment "*/"')), $EXPECT($R46, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L94, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
14232
14221
|
return { $loc, token: $1 };
|
|
14233
14222
|
});
|
|
14234
14223
|
function InlineComment(state) {
|
|
@@ -14325,7 +14314,7 @@ ${input.slice(result.pos)}
|
|
|
14325
14314
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R47, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
14326
14315
|
return { $loc, token: $0 };
|
|
14327
14316
|
});
|
|
14328
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
14317
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L95, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
14329
14318
|
return "";
|
|
14330
14319
|
});
|
|
14331
14320
|
function NonNewlineWhitespace(state) {
|
|
@@ -14477,7 +14466,7 @@ ${input.slice(result.pos)}
|
|
|
14477
14466
|
}
|
|
14478
14467
|
}
|
|
14479
14468
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
14480
|
-
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L3, fail, 'StatementDelimiter "("'), $EXPECT($
|
|
14469
|
+
var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L3, fail, 'StatementDelimiter "("'), $EXPECT($L96, fail, 'StatementDelimiter "["'), $EXPECT($L97, fail, 'StatementDelimiter "`"'), $EXPECT($L57, fail, 'StatementDelimiter "+"'), $EXPECT($L18, fail, 'StatementDelimiter "-"'), $EXPECT($L53, fail, 'StatementDelimiter "*"'), $EXPECT($L54, fail, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, FatArrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L3, fail, 'StatementDelimiter "("'))))), InsertSemicolon);
|
|
14481
14470
|
var StatementDelimiter$2 = $Y(EOS);
|
|
14482
14471
|
function StatementDelimiter(state) {
|
|
14483
14472
|
let eventData;
|
|
@@ -14577,7 +14566,7 @@ ${input.slice(result.pos)}
|
|
|
14577
14566
|
return result;
|
|
14578
14567
|
}
|
|
14579
14568
|
}
|
|
14580
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
14569
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L98, fail, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L9, fail, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
14581
14570
|
return { $loc, token: $1, ts: true };
|
|
14582
14571
|
});
|
|
14583
14572
|
function Abstract(state) {
|
|
@@ -14602,7 +14591,7 @@ ${input.slice(result.pos)}
|
|
|
14602
14591
|
return result;
|
|
14603
14592
|
}
|
|
14604
14593
|
}
|
|
14605
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
14594
|
+
var Ampersand$0 = $TV($EXPECT($L82, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
14606
14595
|
return { $loc, token: $1 };
|
|
14607
14596
|
});
|
|
14608
14597
|
function Ampersand(state) {
|
|
@@ -14627,7 +14616,7 @@ ${input.slice(result.pos)}
|
|
|
14627
14616
|
return result;
|
|
14628
14617
|
}
|
|
14629
14618
|
}
|
|
14630
|
-
var As$0 = $TS($S($EXPECT($
|
|
14619
|
+
var As$0 = $TS($S($EXPECT($L99, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14631
14620
|
return { $loc, token: $1 };
|
|
14632
14621
|
});
|
|
14633
14622
|
function As(state) {
|
|
@@ -14652,7 +14641,7 @@ ${input.slice(result.pos)}
|
|
|
14652
14641
|
return result;
|
|
14653
14642
|
}
|
|
14654
14643
|
}
|
|
14655
|
-
var At$0 = $TV($EXPECT($
|
|
14644
|
+
var At$0 = $TV($EXPECT($L100, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
14656
14645
|
return { $loc, token: $1 };
|
|
14657
14646
|
});
|
|
14658
14647
|
function At(state) {
|
|
@@ -14677,7 +14666,7 @@ ${input.slice(result.pos)}
|
|
|
14677
14666
|
return result;
|
|
14678
14667
|
}
|
|
14679
14668
|
}
|
|
14680
|
-
var AtAt$0 = $TV($EXPECT($
|
|
14669
|
+
var AtAt$0 = $TV($EXPECT($L101, fail, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
14681
14670
|
return { $loc, token: "@" };
|
|
14682
14671
|
});
|
|
14683
14672
|
function AtAt(state) {
|
|
@@ -14702,7 +14691,7 @@ ${input.slice(result.pos)}
|
|
|
14702
14691
|
return result;
|
|
14703
14692
|
}
|
|
14704
14693
|
}
|
|
14705
|
-
var Async$0 = $TS($S($EXPECT($
|
|
14694
|
+
var Async$0 = $TS($S($EXPECT($L102, fail, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14706
14695
|
return { $loc, token: $1, type: "Async" };
|
|
14707
14696
|
});
|
|
14708
14697
|
function Async(state) {
|
|
@@ -14727,7 +14716,7 @@ ${input.slice(result.pos)}
|
|
|
14727
14716
|
return result;
|
|
14728
14717
|
}
|
|
14729
14718
|
}
|
|
14730
|
-
var Await$0 = $TS($S($EXPECT($
|
|
14719
|
+
var Await$0 = $TS($S($EXPECT($L103, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14731
14720
|
return { $loc, token: $1, type: "Await" };
|
|
14732
14721
|
});
|
|
14733
14722
|
function Await(state) {
|
|
@@ -14752,7 +14741,7 @@ ${input.slice(result.pos)}
|
|
|
14752
14741
|
return result;
|
|
14753
14742
|
}
|
|
14754
14743
|
}
|
|
14755
|
-
var Backtick$0 = $TV($EXPECT($
|
|
14744
|
+
var Backtick$0 = $TV($EXPECT($L97, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
14756
14745
|
return { $loc, token: $1 };
|
|
14757
14746
|
});
|
|
14758
14747
|
function Backtick(state) {
|
|
@@ -14777,7 +14766,7 @@ ${input.slice(result.pos)}
|
|
|
14777
14766
|
return result;
|
|
14778
14767
|
}
|
|
14779
14768
|
}
|
|
14780
|
-
var By$0 = $TS($S($EXPECT($
|
|
14769
|
+
var By$0 = $TS($S($EXPECT($L104, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14781
14770
|
return { $loc, token: $1 };
|
|
14782
14771
|
});
|
|
14783
14772
|
function By(state) {
|
|
@@ -14802,7 +14791,7 @@ ${input.slice(result.pos)}
|
|
|
14802
14791
|
return result;
|
|
14803
14792
|
}
|
|
14804
14793
|
}
|
|
14805
|
-
var Case$0 = $TS($S($EXPECT($
|
|
14794
|
+
var Case$0 = $TS($S($EXPECT($L105, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14806
14795
|
return { $loc, token: $1 };
|
|
14807
14796
|
});
|
|
14808
14797
|
function Case(state) {
|
|
@@ -14827,7 +14816,7 @@ ${input.slice(result.pos)}
|
|
|
14827
14816
|
return result;
|
|
14828
14817
|
}
|
|
14829
14818
|
}
|
|
14830
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
14819
|
+
var Catch$0 = $TS($S($EXPECT($L106, fail, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14831
14820
|
return { $loc, token: $1 };
|
|
14832
14821
|
});
|
|
14833
14822
|
function Catch(state) {
|
|
@@ -14852,7 +14841,7 @@ ${input.slice(result.pos)}
|
|
|
14852
14841
|
return result;
|
|
14853
14842
|
}
|
|
14854
14843
|
}
|
|
14855
|
-
var Class$0 = $TS($S($EXPECT($
|
|
14844
|
+
var Class$0 = $TS($S($EXPECT($L107, fail, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
14856
14845
|
return { $loc, token: $1 };
|
|
14857
14846
|
});
|
|
14858
14847
|
function Class(state) {
|
|
@@ -14877,7 +14866,7 @@ ${input.slice(result.pos)}
|
|
|
14877
14866
|
return result;
|
|
14878
14867
|
}
|
|
14879
14868
|
}
|
|
14880
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
14869
|
+
var CloseBrace$0 = $TV($EXPECT($L23, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
14881
14870
|
return { $loc, token: $1 };
|
|
14882
14871
|
});
|
|
14883
14872
|
function CloseBrace(state) {
|
|
@@ -14902,7 +14891,7 @@ ${input.slice(result.pos)}
|
|
|
14902
14891
|
return result;
|
|
14903
14892
|
}
|
|
14904
14893
|
}
|
|
14905
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
14894
|
+
var CloseBracket$0 = $TV($EXPECT($L32, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
14906
14895
|
return { $loc, token: $1 };
|
|
14907
14896
|
});
|
|
14908
14897
|
function CloseBracket(state) {
|
|
@@ -14927,7 +14916,7 @@ ${input.slice(result.pos)}
|
|
|
14927
14916
|
return result;
|
|
14928
14917
|
}
|
|
14929
14918
|
}
|
|
14930
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
14919
|
+
var CloseParen$0 = $TV($EXPECT($L108, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
14931
14920
|
return { $loc, token: $1 };
|
|
14932
14921
|
});
|
|
14933
14922
|
function CloseParen(state) {
|
|
@@ -14952,7 +14941,7 @@ ${input.slice(result.pos)}
|
|
|
14952
14941
|
return result;
|
|
14953
14942
|
}
|
|
14954
14943
|
}
|
|
14955
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
14944
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L109, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
14956
14945
|
return { $loc, token: "${" };
|
|
14957
14946
|
});
|
|
14958
14947
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -14977,7 +14966,7 @@ ${input.slice(result.pos)}
|
|
|
14977
14966
|
return result;
|
|
14978
14967
|
}
|
|
14979
14968
|
}
|
|
14980
|
-
var Colon$0 = $TS($S($EXPECT($
|
|
14969
|
+
var Colon$0 = $TS($S($EXPECT($L10, fail, 'Colon ":"'), $N($EXPECT($L2, fail, 'Colon "="'))), function($skip, $loc, $0, $1, $2) {
|
|
14981
14970
|
return { $loc, token: $1 };
|
|
14982
14971
|
});
|
|
14983
14972
|
function Colon(state) {
|
|
@@ -15002,7 +14991,7 @@ ${input.slice(result.pos)}
|
|
|
15002
14991
|
return result;
|
|
15003
14992
|
}
|
|
15004
14993
|
}
|
|
15005
|
-
var Comma$0 = $TV($EXPECT($
|
|
14994
|
+
var Comma$0 = $TV($EXPECT($L21, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
15006
14995
|
return { $loc, token: $1 };
|
|
15007
14996
|
});
|
|
15008
14997
|
function Comma(state) {
|
|
@@ -15027,7 +15016,7 @@ ${input.slice(result.pos)}
|
|
|
15027
15016
|
return result;
|
|
15028
15017
|
}
|
|
15029
15018
|
}
|
|
15030
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
15019
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L100, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
15031
15020
|
return { $loc, token: "constructor" };
|
|
15032
15021
|
});
|
|
15033
15022
|
function ConstructorShorthand(state) {
|
|
@@ -15527,7 +15516,7 @@ ${input.slice(result.pos)}
|
|
|
15527
15516
|
return result;
|
|
15528
15517
|
}
|
|
15529
15518
|
}
|
|
15530
|
-
var Import$0 = $TS($S($EXPECT($
|
|
15519
|
+
var Import$0 = $TS($S($EXPECT($L15, fail, 'Import "import"'), $Y($EXPECT($R49, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
15531
15520
|
return { $loc, token: $1 };
|
|
15532
15521
|
});
|
|
15533
15522
|
function Import(state) {
|
|
@@ -15552,7 +15541,7 @@ ${input.slice(result.pos)}
|
|
|
15552
15541
|
return result;
|
|
15553
15542
|
}
|
|
15554
15543
|
}
|
|
15555
|
-
var In$0 = $TS($S($EXPECT($
|
|
15544
|
+
var In$0 = $TS($S($EXPECT($L80, fail, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15556
15545
|
return { $loc, token: $1 };
|
|
15557
15546
|
});
|
|
15558
15547
|
function In(state) {
|
|
@@ -15701,7 +15690,7 @@ ${input.slice(result.pos)}
|
|
|
15701
15690
|
return result;
|
|
15702
15691
|
}
|
|
15703
15692
|
}
|
|
15704
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
15693
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L51, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L9, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
15705
15694
|
return { $loc, token: "!" };
|
|
15706
15695
|
});
|
|
15707
15696
|
function Not(state) {
|
|
@@ -15726,7 +15715,7 @@ ${input.slice(result.pos)}
|
|
|
15726
15715
|
return result;
|
|
15727
15716
|
}
|
|
15728
15717
|
}
|
|
15729
|
-
var Of$0 = $TS($S($EXPECT($
|
|
15718
|
+
var Of$0 = $TS($S($EXPECT($L72, fail, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
15730
15719
|
return { $loc, token: $1 };
|
|
15731
15720
|
});
|
|
15732
15721
|
function Of(state) {
|
|
@@ -15801,7 +15790,7 @@ ${input.slice(result.pos)}
|
|
|
15801
15790
|
return result;
|
|
15802
15791
|
}
|
|
15803
15792
|
}
|
|
15804
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
15793
|
+
var OpenBracket$0 = $TV($EXPECT($L96, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
15805
15794
|
return { $loc, token: $1 };
|
|
15806
15795
|
});
|
|
15807
15796
|
function OpenBracket(state) {
|
|
@@ -16082,7 +16071,7 @@ ${input.slice(result.pos)}
|
|
|
16082
16071
|
return result;
|
|
16083
16072
|
}
|
|
16084
16073
|
}
|
|
16085
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
16074
|
+
var Semicolon$0 = $TV($EXPECT($L84, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
16086
16075
|
return { $loc, token: $1 };
|
|
16087
16076
|
});
|
|
16088
16077
|
function Semicolon(state) {
|
|
@@ -16132,7 +16121,7 @@ ${input.slice(result.pos)}
|
|
|
16132
16121
|
return result;
|
|
16133
16122
|
}
|
|
16134
16123
|
}
|
|
16135
|
-
var Star$0 = $TV($EXPECT($
|
|
16124
|
+
var Star$0 = $TV($EXPECT($L53, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
16136
16125
|
return { $loc, token: $1 };
|
|
16137
16126
|
});
|
|
16138
16127
|
function Star(state) {
|
|
@@ -16160,7 +16149,7 @@ ${input.slice(result.pos)}
|
|
|
16160
16149
|
var Static$0 = $TS($S($EXPECT($L145, fail, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
16161
16150
|
return { $loc, token: $1 };
|
|
16162
16151
|
});
|
|
16163
|
-
var Static$1 = $TS($S($EXPECT($
|
|
16152
|
+
var Static$1 = $TS($S($EXPECT($L100, fail, 'Static "@"'), $N($C($EXPECT($L3, fail, 'Static "("'), $EXPECT($L100, fail, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
16164
16153
|
return { $loc, token: "static " };
|
|
16165
16154
|
});
|
|
16166
16155
|
function Static(state) {
|
|
@@ -16856,7 +16845,7 @@ ${input.slice(result.pos)}
|
|
|
16856
16845
|
return result;
|
|
16857
16846
|
}
|
|
16858
16847
|
}
|
|
16859
|
-
var JSXOpeningElement$0 = $S($EXPECT($L132, fail, 'JSXOpeningElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($
|
|
16848
|
+
var JSXOpeningElement$0 = $S($EXPECT($L132, fail, 'JSXOpeningElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L31, fail, 'JSXOpeningElement ">"'));
|
|
16860
16849
|
function JSXOpeningElement(state) {
|
|
16861
16850
|
let eventData;
|
|
16862
16851
|
if (state.events) {
|
|
@@ -16908,7 +16897,7 @@ ${input.slice(result.pos)}
|
|
|
16908
16897
|
return result;
|
|
16909
16898
|
}
|
|
16910
16899
|
}
|
|
16911
|
-
var JSXClosingElement$0 = $S($EXPECT($L166, fail, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($
|
|
16900
|
+
var JSXClosingElement$0 = $S($EXPECT($L166, fail, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L31, fail, 'JSXClosingElement ">"'));
|
|
16912
16901
|
function JSXClosingElement(state) {
|
|
16913
16902
|
let eventData;
|
|
16914
16903
|
if (state.events) {
|
|
@@ -17054,7 +17043,7 @@ ${input.slice(result.pos)}
|
|
|
17054
17043
|
return result;
|
|
17055
17044
|
}
|
|
17056
17045
|
}
|
|
17057
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
17046
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L13, fail, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
17058
17047
|
return module.config.defaultElement;
|
|
17059
17048
|
});
|
|
17060
17049
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -17259,7 +17248,7 @@ ${input.slice(result.pos)}
|
|
|
17259
17248
|
}
|
|
17260
17249
|
});
|
|
17261
17250
|
var JSXAttribute$2 = $S(InsertInlineOpenBrace, DotDotDot, InlineJSXAttributeValue, InsertCloseBrace, $Y(JSXAttributeSpace));
|
|
17262
|
-
var JSXAttribute$3 = $TS($S($EXPECT($
|
|
17251
|
+
var JSXAttribute$3 = $TS($S($EXPECT($L13, fail, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
17263
17252
|
return [" ", "id=", $2];
|
|
17264
17253
|
});
|
|
17265
17254
|
var JSXAttribute$4 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -17400,7 +17389,8 @@ ${input.slice(result.pos)}
|
|
|
17400
17389
|
var JSXAttributeValue$1 = JSXElement;
|
|
17401
17390
|
var JSXAttributeValue$2 = JSXFragment;
|
|
17402
17391
|
var JSXAttributeValue$3 = $TS($S(InsertInlineOpenBrace, InlineJSXAttributeValue, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3) {
|
|
17403
|
-
|
|
17392
|
+
var value = $2;
|
|
17393
|
+
if (value.type === "StringLiteral") {
|
|
17404
17394
|
return $skip;
|
|
17405
17395
|
}
|
|
17406
17396
|
return $0;
|
|
@@ -17586,8 +17576,8 @@ ${input.slice(result.pos)}
|
|
|
17586
17576
|
return result;
|
|
17587
17577
|
}
|
|
17588
17578
|
}
|
|
17589
|
-
var InlineJSXCallExpression$0 = $S($EXPECT($
|
|
17590
|
-
var InlineJSXCallExpression$1 = $S($EXPECT($
|
|
17579
|
+
var InlineJSXCallExpression$0 = $S($EXPECT($L14, fail, 'InlineJSXCallExpression "super"'), ExplicitArguments);
|
|
17580
|
+
var InlineJSXCallExpression$1 = $S($EXPECT($L15, fail, 'InlineJSXCallExpression "import"'), OpenParen, PostfixedExpression, __, CloseParen);
|
|
17591
17581
|
var InlineJSXCallExpression$2 = $TS($S(InlineJSXMemberExpression, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
17592
17582
|
if ($2.length)
|
|
17593
17583
|
return $0;
|
|
@@ -17801,7 +17791,7 @@ ${input.slice(result.pos)}
|
|
|
17801
17791
|
}
|
|
17802
17792
|
return $skip;
|
|
17803
17793
|
});
|
|
17804
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
17794
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L23, fail, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
17805
17795
|
return { children: [], jsxChildren: [] };
|
|
17806
17796
|
});
|
|
17807
17797
|
function JSXNestedChildren(state) {
|
|
@@ -19042,7 +19032,7 @@ ${input.slice(result.pos)}
|
|
|
19042
19032
|
return result;
|
|
19043
19033
|
}
|
|
19044
19034
|
}
|
|
19045
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
19035
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L81, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
19046
19036
|
var lhs = $1;
|
|
19047
19037
|
var rhs = $2;
|
|
19048
19038
|
if (!rhs)
|
|
@@ -19271,8 +19261,8 @@ ${input.slice(result.pos)}
|
|
|
19271
19261
|
return result;
|
|
19272
19262
|
}
|
|
19273
19263
|
}
|
|
19274
|
-
var ImportType$0 = $S($EXPECT($
|
|
19275
|
-
var ImportType$1 = $S($EXPECT($
|
|
19264
|
+
var ImportType$0 = $S($EXPECT($L15, fail, 'ImportType "import"'), OpenParen, __, StringLiteral, __, CloseParen, $E($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
19265
|
+
var ImportType$1 = $S($EXPECT($L15, fail, 'ImportType "import"'), InsertOpenParen, Trimmed_, StringLiteral, InsertCloseParen);
|
|
19276
19266
|
function ImportType(state) {
|
|
19277
19267
|
let eventData;
|
|
19278
19268
|
if (state.events) {
|
|
@@ -19603,7 +19593,7 @@ ${input.slice(result.pos)}
|
|
|
19603
19593
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
19604
19594
|
return value[1];
|
|
19605
19595
|
});
|
|
19606
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
19596
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L10, fail, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L108, fail, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L32, fail, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L23, fail, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
19607
19597
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
19608
19598
|
function InlineInterfacePropertyDelimiter(state) {
|
|
19609
19599
|
let eventData;
|
|
@@ -19627,10 +19617,10 @@ ${input.slice(result.pos)}
|
|
|
19627
19617
|
return result;
|
|
19628
19618
|
}
|
|
19629
19619
|
}
|
|
19630
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
19620
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L83, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
19631
19621
|
return { $loc, token: "|" };
|
|
19632
19622
|
});
|
|
19633
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
19623
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L82, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
19634
19624
|
return { $loc, token: "&" };
|
|
19635
19625
|
});
|
|
19636
19626
|
function TypeBinaryOp(state) {
|
|
@@ -19687,7 +19677,7 @@ ${input.slice(result.pos)}
|
|
|
19687
19677
|
var TypeArrowFunction$0 = $TV($EXPECT($L8, fail, 'TypeArrowFunction "=>"'), function($skip, $loc, $0, $1) {
|
|
19688
19678
|
return { $loc, token: "=>" };
|
|
19689
19679
|
});
|
|
19690
|
-
var TypeArrowFunction$1 = $TV($EXPECT($
|
|
19680
|
+
var TypeArrowFunction$1 = $TV($EXPECT($L22, fail, 'TypeArrowFunction "->"'), function($skip, $loc, $0, $1) {
|
|
19691
19681
|
return { $loc, token: "=>" };
|
|
19692
19682
|
});
|
|
19693
19683
|
function TypeArrowFunction(state) {
|
|
@@ -19712,7 +19702,7 @@ ${input.slice(result.pos)}
|
|
|
19712
19702
|
return result;
|
|
19713
19703
|
}
|
|
19714
19704
|
}
|
|
19715
|
-
var TypeArguments$0 = $TS($S($EXPECT($L132, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($
|
|
19705
|
+
var TypeArguments$0 = $TS($S($EXPECT($L132, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L31, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
19716
19706
|
return { ts: true, children: $0 };
|
|
19717
19707
|
});
|
|
19718
19708
|
function TypeArguments(state) {
|
|
@@ -19783,7 +19773,7 @@ ${input.slice(result.pos)}
|
|
|
19783
19773
|
return result;
|
|
19784
19774
|
}
|
|
19785
19775
|
}
|
|
19786
|
-
var TypeParameters$0 = $TS($S(
|
|
19776
|
+
var TypeParameters$0 = $TS($S($E(_), $EXPECT($L132, fail, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L31, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
19787
19777
|
var parameters = $3;
|
|
19788
19778
|
return {
|
|
19789
19779
|
type: "TypeParameters",
|
|
@@ -19884,7 +19874,7 @@ ${input.slice(result.pos)}
|
|
|
19884
19874
|
}
|
|
19885
19875
|
}
|
|
19886
19876
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
19887
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
19877
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L31, fail, 'TypeParameterDelimiter ">"')));
|
|
19888
19878
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
19889
19879
|
return value[1];
|
|
19890
19880
|
});
|
|
@@ -21934,10 +21924,9 @@ ${input.slice(result.pos)}
|
|
|
21934
21924
|
names.push(...rest.names);
|
|
21935
21925
|
}
|
|
21936
21926
|
if (after.length) {
|
|
21937
|
-
const spliceRef = module.getRef("splice");
|
|
21938
21927
|
blockPrefix = {
|
|
21939
21928
|
type: "PostRestBindingElements",
|
|
21940
|
-
children: ["[", insertTrimmingSpace(after, ""), "] = ",
|
|
21929
|
+
children: ["[", insertTrimmingSpace(after, ""), "] = ", restIdentifier, ".splice(-", after.length.toString(), ")"],
|
|
21941
21930
|
names: after.flatMap((p) => p.names)
|
|
21942
21931
|
};
|
|
21943
21932
|
}
|
|
@@ -22298,16 +22287,6 @@ ${input.slice(result.pos)}
|
|
|
22298
22287
|
exp.children.push(...post);
|
|
22299
22288
|
});
|
|
22300
22289
|
}
|
|
22301
|
-
function checkSpliceRef(statements) {
|
|
22302
|
-
const spliceRef = module.getRef("splice");
|
|
22303
|
-
if (gatherRecursiveAll(statements, (n) => n === spliceRef).length) {
|
|
22304
|
-
const typeSuffix = {
|
|
22305
|
-
ts: true,
|
|
22306
|
-
children: [": <T>(this: T[], start: number, deleteCount?: number) => T[]"]
|
|
22307
|
-
};
|
|
22308
|
-
module.prelude.push(["", ["const ", spliceRef, typeSuffix, " = [].splice", module.asAny, "\n"]]);
|
|
22309
|
-
}
|
|
22310
|
-
}
|
|
22311
22290
|
module.attachPostfixStatementAsExpression = function(exp, post) {
|
|
22312
22291
|
let clause;
|
|
22313
22292
|
switch (post[1].type) {
|
|
@@ -22795,7 +22774,6 @@ ${input.slice(result.pos)}
|
|
|
22795
22774
|
processTryExpressions(statements);
|
|
22796
22775
|
hoistRefDecs(statements);
|
|
22797
22776
|
gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
|
|
22798
|
-
checkSpliceRef(statements);
|
|
22799
22777
|
statements.unshift(...module.prelude);
|
|
22800
22778
|
if (module.config.autoLet) {
|
|
22801
22779
|
createLetDecs(statements, []);
|
|
@@ -23606,17 +23584,17 @@ ${input.slice(result.pos)}
|
|
|
23606
23584
|
smRegexp = /\n\/\/# sourceMappingURL=data:application\/json;charset=utf-8;base64,([+a-zA-Z0-9\/]*=?=?)$/;
|
|
23607
23585
|
SourceMap.remap = function(codeWithSourceMap, upstreamMap, sourcePath, targetPath) {
|
|
23608
23586
|
var codeWithoutSourceMap, composedLines, newSourceMap, parsed, remappedCodeWithSourceMap, remappedSourceMapJSON, sourceMapText;
|
|
23609
|
-
sourceMapText =
|
|
23587
|
+
sourceMapText = null;
|
|
23588
|
+
codeWithoutSourceMap = codeWithSourceMap.replace(smRegexp, (match, sm) => {
|
|
23589
|
+
sourceMapText = sm;
|
|
23590
|
+
return "";
|
|
23591
|
+
});
|
|
23610
23592
|
if (sourceMapText) {
|
|
23611
|
-
parsed = SourceMap.parseWithLines(sourceMapText
|
|
23612
|
-
|
|
23613
|
-
|
|
23614
|
-
return codeWithSourceMap;
|
|
23593
|
+
parsed = SourceMap.parseWithLines(sourceMapText);
|
|
23594
|
+
composedLines = SourceMap.composeLines(upstreamMap.data.lines, parsed.lines);
|
|
23595
|
+
upstreamMap.data.lines = composedLines;
|
|
23615
23596
|
}
|
|
23616
|
-
composedLines = SourceMap.composeLines(upstreamMap.data.lines, parsed.lines);
|
|
23617
|
-
upstreamMap.data.lines = composedLines;
|
|
23618
23597
|
remappedSourceMapJSON = upstreamMap.json(sourcePath, targetPath);
|
|
23619
|
-
codeWithoutSourceMap = codeWithSourceMap.replace(smRegexp, "");
|
|
23620
23598
|
newSourceMap = `${"sourceMapping"}URL=data:application/json;charset=utf-8;base64,${base64Encode(JSON.stringify(remappedSourceMapJSON))}`;
|
|
23621
23599
|
remappedCodeWithSourceMap = `${codeWithoutSourceMap}
|
|
23622
23600
|
//# ${newSourceMap}`;
|
|
@@ -23786,15 +23764,14 @@ ${input.slice(result.pos)}
|
|
|
23786
23764
|
// source/main.coffee
|
|
23787
23765
|
"civet coffeeCompat";
|
|
23788
23766
|
var SourceMap2;
|
|
23789
|
-
var base64Encode2;
|
|
23790
23767
|
var makeCache;
|
|
23791
23768
|
var parse;
|
|
23792
23769
|
var uncacheable;
|
|
23793
23770
|
({ parse } = import_parser.default);
|
|
23794
|
-
({ SourceMap: SourceMap2
|
|
23771
|
+
({ SourceMap: SourceMap2 } = util_exports);
|
|
23795
23772
|
uncacheable = /* @__PURE__ */ new Set(["ActualAssignment", "AllowAll", "AllowClassImplicitCall", "AllowIndentedApplication", "AllowMultiLineImplicitObjectLiteral", "AllowTrailingMemberProperty", "AllowedTrailingMemberExpressions", "ApplicationStart", "Arguments", "ArgumentsWithTrailingMemberExpressions", "ArrowFunction", "ArrowFunctionTail", "AssignmentExpression", "AssignmentExpressionTail", "BinaryOpExpression", "BinaryOpRHS", "BracedBlock", "BracedObjectLiteralContent", "BracedOrEmptyBlock", "CallExpression", "CallExpressionRest", "ClassImplicitCallForbidden", "CoffeeCommentEnabled", "CommaDelimiter", "ConditionalExpression", "Declaration", "Debugger", "Dedented", "ElementListWithIndentedApplicationForbidden", "ElseClause", "Expression", "ExpressionStatement", "ExpressionWithIndentedApplicationForbidden", "ExtendedExpression", "FatArrowBody", "ForbidClassImplicitCall", "ForbidIndentedApplication", "ForbidMultiLineImplicitObjectLiteral", "ForbidTrailingMemberProperty", "FunctionDeclaration", "FunctionExpression", "HoistableDeclaration", "ImplicitArguments", "ImplicitInlineObjectPropertyDelimiter", "ImplicitNestedBlock", "IndentedApplicationAllowed", "IndentedFurther", "IndentedJSXChildExpression", "InlineObjectLiteral", "InsertIndent", "JSXChild", "JSXChildren", "JSXElement", "JSXFragment", "JSXImplicitFragment", "JSXMixedChildren", "JSXNested", "JSXNestedChildren", "JSXOptionalClosingElement", "JSXOptionalClosingFragment", "JSXTag", "LeftHandSideExpression", "MemberExpression", "MemberExpressionRest", "Nested", "NestedBindingElement", "NestedBindingElements", "NestedBlockExpression", "NestedBlockExpression", "NestedBlockStatement", "NestedBlockStatements", "NestedClassSignatureElement", "NestedClassSignatureElements", "NestedDeclareElement", "NestedDeclareElements", "NestedElement", "NestedElementList", "NestedImplicitObjectLiteral", "NestedImplicitPropertyDefinition", "NestedImplicitPropertyDefinitions", "NestedInterfaceProperty", "NestedJSXChildExpression", "NestedModuleItem", "NestedModuleItems", "NestedNonAssignmentExtendedExpression", "NestedObject", "NestedPropertyDefinitions", "NonSingleBracedBlock", "NotDedented", "ObjectLiteral", "PopIndent", "PopJSXStack", "PostfixedExpression", "PostfixedStatement", "PrimaryExpression", "PushIndent", "PushJSXOpeningElement", "PushJSXOpeningFragment", "RestoreAll", "RestoreClassImplicitCall", "RestoreMultiLineImplicitObjectLiteral", "RestoreIndentedApplication", "RestoreTrailingMemberProperty", "RHS", "Samedent", "ShortCircuitExpression", "SingleLineAssignmentExpression", "SingleLineComment", "SingleLineStatements", "SnugNamedProperty", "Statement", "StatementListItem", "SuffixedExpression", "SuffixedStatement", "ThinArrowFunction", "TrackIndented", "TrailingMemberExpressions", "TrailingMemberPropertyAllowed", "TypedJSXElement", "TypedJSXFragment", "UnaryExpression", "UpdateExpression"]);
|
|
23796
23773
|
var compile = function(src, options) {
|
|
23797
|
-
var ast, code, events, filename, ref, result, sm
|
|
23774
|
+
var ast, code, events, filename, ref, result, sm;
|
|
23798
23775
|
if (!options) {
|
|
23799
23776
|
options = {};
|
|
23800
23777
|
} else {
|
|
@@ -23816,10 +23793,7 @@ ${input.slice(result.pos)}
|
|
|
23816
23793
|
options.updateSourceMap = sm.updateSourceMap;
|
|
23817
23794
|
code = generate_default(ast, options);
|
|
23818
23795
|
if (options.inlineMap) {
|
|
23819
|
-
|
|
23820
|
-
return `${code}
|
|
23821
|
-
${"//#"} sourceMappingURL=data:application/json;base64,${base64Encode2(JSON.stringify(srcMapJSON))}
|
|
23822
|
-
`;
|
|
23796
|
+
return SourceMap2.remap(code, sm, filename, filename + ".tsx");
|
|
23823
23797
|
} else {
|
|
23824
23798
|
return {
|
|
23825
23799
|
code,
|