@danielx/civet 0.6.27 → 0.6.28
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/README.md +4 -0
- package/dist/browser.js +552 -505
- package/dist/civet +0 -0
- package/dist/main.js +552 -505
- package/dist/main.mjs +552 -505
- package/dist/unplugin.d.mts +10 -10
- package/dist/unplugin.d.ts +10 -10
- package/package.json +2 -2
package/dist/browser.js
CHANGED
|
@@ -1546,26 +1546,32 @@ ${input.slice(result.pos)}
|
|
|
1546
1546
|
return gatherRecursive(node, predicate, isFunction);
|
|
1547
1547
|
}
|
|
1548
1548
|
function insertTrimmingSpace(target, c) {
|
|
1549
|
-
if (!target)
|
|
1549
|
+
if (!target) {
|
|
1550
1550
|
return target;
|
|
1551
|
-
|
|
1551
|
+
}
|
|
1552
|
+
if (Array.isArray(target)) {
|
|
1553
|
+
if (target.length === 0) {
|
|
1554
|
+
return c;
|
|
1555
|
+
}
|
|
1552
1556
|
return target.map((e, i) => {
|
|
1553
|
-
if (i === 0)
|
|
1557
|
+
if (i === 0) {
|
|
1554
1558
|
return insertTrimmingSpace(e, c);
|
|
1559
|
+
}
|
|
1555
1560
|
return e;
|
|
1556
1561
|
});
|
|
1557
|
-
|
|
1558
|
-
|
|
1559
|
-
|
|
1560
|
-
|
|
1561
|
-
|
|
1562
|
-
|
|
1563
|
-
|
|
1564
|
-
|
|
1565
|
-
|
|
1566
|
-
|
|
1562
|
+
}
|
|
1563
|
+
if (target.children) {
|
|
1564
|
+
return {
|
|
1565
|
+
...target,
|
|
1566
|
+
children: insertTrimmingSpace(target.children, c)
|
|
1567
|
+
};
|
|
1568
|
+
}
|
|
1569
|
+
if (target.token) {
|
|
1570
|
+
return {
|
|
1571
|
+
...target,
|
|
1567
1572
|
token: target.token.replace(/^ ?/, c)
|
|
1568
|
-
}
|
|
1573
|
+
};
|
|
1574
|
+
}
|
|
1569
1575
|
return target;
|
|
1570
1576
|
}
|
|
1571
1577
|
function getTrimmingSpace(target) {
|
|
@@ -2012,25 +2018,6 @@ ${input.slice(result.pos)}
|
|
|
2012
2018
|
length: assign.$loc.length + 1
|
|
2013
2019
|
}
|
|
2014
2020
|
};
|
|
2015
|
-
if (decl.token.startsWith("const")) {
|
|
2016
|
-
let exp;
|
|
2017
|
-
if (e.type === "FunctionExpression") {
|
|
2018
|
-
exp = e;
|
|
2019
|
-
} else {
|
|
2020
|
-
exp = e[1];
|
|
2021
|
-
}
|
|
2022
|
-
if (exp?.children?.[0]?.token?.match(/^\s+$/))
|
|
2023
|
-
exp.children.shift();
|
|
2024
|
-
if (id.type === "Identifier" && exp?.type === "FunctionExpression" && !exp.id) {
|
|
2025
|
-
const i = exp.children.findIndex((c) => c?.token === "function") + 1;
|
|
2026
|
-
exp = {
|
|
2027
|
-
...exp,
|
|
2028
|
-
children: [...exp.children.slice(0, i), " ", id, suffix, ws, ...exp.children.slice(i)],
|
|
2029
|
-
id
|
|
2030
|
-
};
|
|
2031
|
-
return exp;
|
|
2032
|
-
}
|
|
2033
|
-
}
|
|
2034
2021
|
let [splices, thisAssignments] = gatherBindingCode(id);
|
|
2035
2022
|
splices = splices.map((s) => [", ", s]);
|
|
2036
2023
|
thisAssignments = thisAssignments.map((a) => ["", a, ";"]);
|
|
@@ -3420,8 +3407,10 @@ ${input.slice(result.pos)}
|
|
|
3420
3407
|
NonNullAssertion,
|
|
3421
3408
|
MemberExpression,
|
|
3422
3409
|
MemberExpressionRest,
|
|
3410
|
+
MemberExpressionRestBody,
|
|
3423
3411
|
MemberBracketContent,
|
|
3424
3412
|
SliceParameters,
|
|
3413
|
+
AccessStart,
|
|
3425
3414
|
PropertyAccess,
|
|
3426
3415
|
PropertyGlob,
|
|
3427
3416
|
PropertyBind,
|
|
@@ -3534,6 +3523,7 @@ ${input.slice(result.pos)}
|
|
|
3534
3523
|
AssignmentOpSymbol,
|
|
3535
3524
|
CoffeeWordAssignmentOp,
|
|
3536
3525
|
NotDedentedBinaryOp,
|
|
3526
|
+
IdentifierBinaryOp,
|
|
3537
3527
|
BinaryOp,
|
|
3538
3528
|
BinaryOpSymbol,
|
|
3539
3529
|
Xor,
|
|
@@ -4008,193 +3998,194 @@ ${input.slice(result.pos)}
|
|
|
4008
3998
|
var $L19 = $L("import.meta");
|
|
4009
3999
|
var $L20 = $L("return.value");
|
|
4010
4000
|
var $L21 = $L(",");
|
|
4011
|
-
var $L22 = $L("
|
|
4012
|
-
var $L23 = $L("
|
|
4013
|
-
var $L24 = $L("
|
|
4014
|
-
var $L25 = $L("
|
|
4015
|
-
var $L26 = $L("
|
|
4016
|
-
var $L27 = $L("
|
|
4017
|
-
var $L28 = $L("
|
|
4018
|
-
var $L29 = $L("
|
|
4019
|
-
var $L30 = $L("
|
|
4020
|
-
var $L31 = $L("
|
|
4021
|
-
var $L32 = $L("
|
|
4022
|
-
var $L33 = $L("
|
|
4023
|
-
var $L34 = $L("
|
|
4024
|
-
var $L35 = $L("
|
|
4025
|
-
var $L36 = $L("
|
|
4026
|
-
var $L37 = $L("
|
|
4027
|
-
var $L38 = $L("
|
|
4028
|
-
var $L39 = $L("
|
|
4029
|
-
var $L40 = $L("
|
|
4030
|
-
var $L41 = $L("
|
|
4031
|
-
var $L42 = $L("
|
|
4032
|
-
var $L43 = $L("
|
|
4033
|
-
var $L44 = $L("
|
|
4034
|
-
var $L45 = $L("
|
|
4035
|
-
var $L46 = $L("
|
|
4036
|
-
var $L47 = $L("
|
|
4037
|
-
var $L48 = $L("
|
|
4038
|
-
var $L49 = $L("
|
|
4039
|
-
var $L50 = $L("
|
|
4040
|
-
var $L51 = $L("
|
|
4041
|
-
var $L52 = $L("
|
|
4042
|
-
var $L53 = $L("
|
|
4043
|
-
var $L54 = $L("
|
|
4044
|
-
var $L55 = $L("
|
|
4045
|
-
var $L56 = $L("
|
|
4046
|
-
var $L57 = $L("
|
|
4047
|
-
var $L58 = $L("
|
|
4048
|
-
var $L59 = $L("
|
|
4049
|
-
var $L60 = $L("
|
|
4050
|
-
var $L61 = $L("
|
|
4051
|
-
var $L62 = $L("
|
|
4052
|
-
var $L63 = $L("
|
|
4053
|
-
var $L64 = $L("
|
|
4054
|
-
var $L65 = $L("
|
|
4055
|
-
var $L66 = $L("
|
|
4056
|
-
var $L67 = $L("
|
|
4057
|
-
var $L68 = $L("
|
|
4058
|
-
var $L69 = $L("
|
|
4059
|
-
var $L70 = $L("
|
|
4060
|
-
var $L71 = $L("
|
|
4061
|
-
var $L72 = $L("
|
|
4062
|
-
var $L73 = $L("
|
|
4063
|
-
var $L74 = $L("
|
|
4064
|
-
var $L75 = $L("
|
|
4065
|
-
var $L76 = $L("
|
|
4066
|
-
var $L77 = $L("\
|
|
4067
|
-
var $L78 = $L("
|
|
4068
|
-
var $L79 = $L("
|
|
4069
|
-
var $L80 = $L("\
|
|
4070
|
-
var $L81 = $L("
|
|
4071
|
-
var $L82 = $L("
|
|
4072
|
-
var $L83 = $L("
|
|
4073
|
-
var $L84 = $L("
|
|
4074
|
-
var $L85 = $L("
|
|
4075
|
-
var $L86 = $L("
|
|
4076
|
-
var $L87 = $L("
|
|
4077
|
-
var $L88 = $L("
|
|
4078
|
-
var $L89 = $L("
|
|
4079
|
-
var $L90 = $L("
|
|
4080
|
-
var $L91 = $L("
|
|
4081
|
-
var $L92 = $L("
|
|
4082
|
-
var $L93 = $L("
|
|
4083
|
-
var $L94 = $L("\
|
|
4084
|
-
var $L95 = $L("\
|
|
4085
|
-
var $L96 = $L("\
|
|
4086
|
-
var $L97 = $L("
|
|
4087
|
-
var $L98 = $L("
|
|
4088
|
-
var $L99 = $L("
|
|
4089
|
-
var $L100 = $L("
|
|
4090
|
-
var $L101 = $L("
|
|
4091
|
-
var $L102 = $L("
|
|
4092
|
-
var $L103 = $L("
|
|
4093
|
-
var $L104 = $L("
|
|
4094
|
-
var $L105 = $L("
|
|
4095
|
-
var $L106 = $L("
|
|
4096
|
-
var $L107 = $L("
|
|
4097
|
-
var $L108 = $L("
|
|
4098
|
-
var $L109 = $L("
|
|
4099
|
-
var $L110 = $L("
|
|
4100
|
-
var $L111 = $L("
|
|
4101
|
-
var $L112 = $L("
|
|
4102
|
-
var $L113 = $L("
|
|
4103
|
-
var $L114 = $L("
|
|
4104
|
-
var $L115 = $L("
|
|
4105
|
-
var $L116 = $L("
|
|
4106
|
-
var $L117 = $L("
|
|
4107
|
-
var $L118 = $L("
|
|
4108
|
-
var $L119 = $L("
|
|
4109
|
-
var $L120 = $L("
|
|
4110
|
-
var $L121 = $L("
|
|
4111
|
-
var $L122 = $L("
|
|
4112
|
-
var $L123 = $L("
|
|
4113
|
-
var $L124 = $L("
|
|
4114
|
-
var $L125 = $L("
|
|
4115
|
-
var $L126 = $L("
|
|
4116
|
-
var $L127 = $L("
|
|
4117
|
-
var $L128 = $L("
|
|
4118
|
-
var $L129 = $L("
|
|
4119
|
-
var $L130 = $L("
|
|
4120
|
-
var $L131 = $L("
|
|
4121
|
-
var $L132 = $L("
|
|
4122
|
-
var $L133 = $L("
|
|
4123
|
-
var $L134 = $L(
|
|
4124
|
-
var $L135 = $L("
|
|
4125
|
-
var $L136 = $L("
|
|
4126
|
-
var $L137 = $L("
|
|
4127
|
-
var $L138 = $L("
|
|
4128
|
-
var $L139 = $L("
|
|
4129
|
-
var $L140 = $L("
|
|
4130
|
-
var $L141 = $L("
|
|
4131
|
-
var $L142 = $L("
|
|
4132
|
-
var $L143 = $L("
|
|
4133
|
-
var $L144 = $L("
|
|
4134
|
-
var $L145 = $L("
|
|
4135
|
-
var $L146 = $L("
|
|
4136
|
-
var $L147 = $L("
|
|
4137
|
-
var $L148 = $L("
|
|
4138
|
-
var $L149 = $L("
|
|
4139
|
-
var $L150 = $L("
|
|
4140
|
-
var $L151 = $L("
|
|
4141
|
-
var $L152 = $L("
|
|
4142
|
-
var $L153 = $L("
|
|
4143
|
-
var $L154 = $L("
|
|
4144
|
-
var $L155 = $L("
|
|
4145
|
-
var $L156 = $L("
|
|
4146
|
-
var $L157 = $L("
|
|
4147
|
-
var $L158 = $L("
|
|
4148
|
-
var $L159 = $L("
|
|
4149
|
-
var $L160 = $L("
|
|
4150
|
-
var $L161 = $L("
|
|
4151
|
-
var $L162 = $L("
|
|
4152
|
-
var $L163 = $L("
|
|
4153
|
-
var $L164 = $L("
|
|
4154
|
-
var $L165 = $L("
|
|
4155
|
-
var $L166 = $L("
|
|
4156
|
-
var $L167 = $L("
|
|
4157
|
-
var $L168 = $L("
|
|
4158
|
-
var $L169 = $L("
|
|
4159
|
-
var $L170 = $L("
|
|
4160
|
-
var $L171 = $L("
|
|
4161
|
-
var $L172 = $L("
|
|
4162
|
-
var $L173 = $L("
|
|
4163
|
-
var $L174 = $L("
|
|
4164
|
-
var $L175 = $L("
|
|
4165
|
-
var $L176 = $L("
|
|
4166
|
-
var $L177 = $L("
|
|
4167
|
-
var $L178 = $L(
|
|
4168
|
-
var $L179 = $L("'
|
|
4169
|
-
var $L180 = $L("
|
|
4170
|
-
var $L181 = $L("
|
|
4171
|
-
var $L182 = $L("
|
|
4172
|
-
var $L183 = $L("
|
|
4173
|
-
var $L184 = $L("
|
|
4174
|
-
var $L185 = $L("
|
|
4175
|
-
var $L186 = $L("
|
|
4176
|
-
var $L187 = $L("
|
|
4177
|
-
var $L188 = $L("
|
|
4178
|
-
var $L189 = $L("
|
|
4179
|
-
var $L190 = $L("
|
|
4180
|
-
var $L191 = $L("
|
|
4181
|
-
var $L192 = $L("
|
|
4182
|
-
var $L193 = $L("
|
|
4183
|
-
var $L194 = $L("
|
|
4184
|
-
var $L195 = $L("
|
|
4185
|
-
var $L196 = $L("
|
|
4186
|
-
var $L197 = $L("
|
|
4187
|
-
var $L198 = $L("
|
|
4188
|
-
var $L199 = $L("
|
|
4189
|
-
var $L200 = $L("
|
|
4190
|
-
var $L201 = $L("
|
|
4191
|
-
var $L202 = $L("
|
|
4192
|
-
var $L203 = $L("
|
|
4193
|
-
var $L204 = $L("
|
|
4194
|
-
var $L205 = $L("
|
|
4195
|
-
var $L206 = $L("
|
|
4196
|
-
var $L207 = $L("
|
|
4197
|
-
var $L208 = $L("
|
|
4001
|
+
var $L22 = $L("(&)");
|
|
4002
|
+
var $L23 = $L("->");
|
|
4003
|
+
var $L24 = $L("\u2192");
|
|
4004
|
+
var $L25 = $L("}");
|
|
4005
|
+
var $L26 = $L("null");
|
|
4006
|
+
var $L27 = $L("true");
|
|
4007
|
+
var $L28 = $L("false");
|
|
4008
|
+
var $L29 = $L("yes");
|
|
4009
|
+
var $L30 = $L("on");
|
|
4010
|
+
var $L31 = $L("no");
|
|
4011
|
+
var $L32 = $L("off");
|
|
4012
|
+
var $L33 = $L(">");
|
|
4013
|
+
var $L34 = $L("]");
|
|
4014
|
+
var $L35 = $L("**=");
|
|
4015
|
+
var $L36 = $L("*=");
|
|
4016
|
+
var $L37 = $L("/=");
|
|
4017
|
+
var $L38 = $L("%=");
|
|
4018
|
+
var $L39 = $L("+=");
|
|
4019
|
+
var $L40 = $L("-=");
|
|
4020
|
+
var $L41 = $L("<<=");
|
|
4021
|
+
var $L42 = $L(">>>=");
|
|
4022
|
+
var $L43 = $L(">>=");
|
|
4023
|
+
var $L44 = $L("&&=");
|
|
4024
|
+
var $L45 = $L("&=");
|
|
4025
|
+
var $L46 = $L("^=");
|
|
4026
|
+
var $L47 = $L("||=");
|
|
4027
|
+
var $L48 = $L("|=");
|
|
4028
|
+
var $L49 = $L("??=");
|
|
4029
|
+
var $L50 = $L("?=");
|
|
4030
|
+
var $L51 = $L("and=");
|
|
4031
|
+
var $L52 = $L("or=");
|
|
4032
|
+
var $L53 = $L("**");
|
|
4033
|
+
var $L54 = $L("*");
|
|
4034
|
+
var $L55 = $L("/");
|
|
4035
|
+
var $L56 = $L("%%");
|
|
4036
|
+
var $L57 = $L("%");
|
|
4037
|
+
var $L58 = $L("+");
|
|
4038
|
+
var $L59 = $L("<=");
|
|
4039
|
+
var $L60 = $L("\u2264");
|
|
4040
|
+
var $L61 = $L(">=");
|
|
4041
|
+
var $L62 = $L("\u2265");
|
|
4042
|
+
var $L63 = $L("<?");
|
|
4043
|
+
var $L64 = $L("!<?");
|
|
4044
|
+
var $L65 = $L("<<");
|
|
4045
|
+
var $L66 = $L("\xAB");
|
|
4046
|
+
var $L67 = $L(">>>");
|
|
4047
|
+
var $L68 = $L("\u22D9");
|
|
4048
|
+
var $L69 = $L(">>");
|
|
4049
|
+
var $L70 = $L("\xBB");
|
|
4050
|
+
var $L71 = $L("!==");
|
|
4051
|
+
var $L72 = $L("\u2262");
|
|
4052
|
+
var $L73 = $L("!=");
|
|
4053
|
+
var $L74 = $L("\u2260");
|
|
4054
|
+
var $L75 = $L("isnt");
|
|
4055
|
+
var $L76 = $L("===");
|
|
4056
|
+
var $L77 = $L("\u2263");
|
|
4057
|
+
var $L78 = $L("\u2A76");
|
|
4058
|
+
var $L79 = $L("==");
|
|
4059
|
+
var $L80 = $L("\u2261");
|
|
4060
|
+
var $L81 = $L("\u2A75");
|
|
4061
|
+
var $L82 = $L("and");
|
|
4062
|
+
var $L83 = $L("&&");
|
|
4063
|
+
var $L84 = $L("of");
|
|
4064
|
+
var $L85 = $L("or");
|
|
4065
|
+
var $L86 = $L("||");
|
|
4066
|
+
var $L87 = $L("\u2016");
|
|
4067
|
+
var $L88 = $L("^^");
|
|
4068
|
+
var $L89 = $L("xor");
|
|
4069
|
+
var $L90 = $L("xnor");
|
|
4070
|
+
var $L91 = $L("??");
|
|
4071
|
+
var $L92 = $L("\u2047");
|
|
4072
|
+
var $L93 = $L("instanceof");
|
|
4073
|
+
var $L94 = $L("\u2208");
|
|
4074
|
+
var $L95 = $L("\u220B");
|
|
4075
|
+
var $L96 = $L("\u220C");
|
|
4076
|
+
var $L97 = $L("\u2209");
|
|
4077
|
+
var $L98 = $L("&");
|
|
4078
|
+
var $L99 = $L("|");
|
|
4079
|
+
var $L100 = $L(";");
|
|
4080
|
+
var $L101 = $L("$:");
|
|
4081
|
+
var $L102 = $L("break");
|
|
4082
|
+
var $L103 = $L("continue");
|
|
4083
|
+
var $L104 = $L("debugger");
|
|
4084
|
+
var $L105 = $L("assert");
|
|
4085
|
+
var $L106 = $L(":=");
|
|
4086
|
+
var $L107 = $L("\u2254");
|
|
4087
|
+
var $L108 = $L(".=");
|
|
4088
|
+
var $L109 = $L("/*");
|
|
4089
|
+
var $L110 = $L("*/");
|
|
4090
|
+
var $L111 = $L("\\");
|
|
4091
|
+
var $L112 = $L("[");
|
|
4092
|
+
var $L113 = $L("`");
|
|
4093
|
+
var $L114 = $L(")");
|
|
4094
|
+
var $L115 = $L("abstract");
|
|
4095
|
+
var $L116 = $L("as");
|
|
4096
|
+
var $L117 = $L("@");
|
|
4097
|
+
var $L118 = $L("@@");
|
|
4098
|
+
var $L119 = $L("async");
|
|
4099
|
+
var $L120 = $L("await");
|
|
4100
|
+
var $L121 = $L("by");
|
|
4101
|
+
var $L122 = $L("case");
|
|
4102
|
+
var $L123 = $L("catch");
|
|
4103
|
+
var $L124 = $L("class");
|
|
4104
|
+
var $L125 = $L("#{");
|
|
4105
|
+
var $L126 = $L("declare");
|
|
4106
|
+
var $L127 = $L("default");
|
|
4107
|
+
var $L128 = $L("delete");
|
|
4108
|
+
var $L129 = $L("do");
|
|
4109
|
+
var $L130 = $L("..");
|
|
4110
|
+
var $L131 = $L("\u2025");
|
|
4111
|
+
var $L132 = $L("...");
|
|
4112
|
+
var $L133 = $L("\u2026");
|
|
4113
|
+
var $L134 = $L("::");
|
|
4114
|
+
var $L135 = $L('"');
|
|
4115
|
+
var $L136 = $L("each");
|
|
4116
|
+
var $L137 = $L("else");
|
|
4117
|
+
var $L138 = $L("export");
|
|
4118
|
+
var $L139 = $L("extends");
|
|
4119
|
+
var $L140 = $L("finally");
|
|
4120
|
+
var $L141 = $L("for");
|
|
4121
|
+
var $L142 = $L("from");
|
|
4122
|
+
var $L143 = $L("function");
|
|
4123
|
+
var $L144 = $L("get");
|
|
4124
|
+
var $L145 = $L("set");
|
|
4125
|
+
var $L146 = $L("#");
|
|
4126
|
+
var $L147 = $L("if");
|
|
4127
|
+
var $L148 = $L("in");
|
|
4128
|
+
var $L149 = $L("let");
|
|
4129
|
+
var $L150 = $L("const");
|
|
4130
|
+
var $L151 = $L("is");
|
|
4131
|
+
var $L152 = $L("loop");
|
|
4132
|
+
var $L153 = $L("new");
|
|
4133
|
+
var $L154 = $L("not");
|
|
4134
|
+
var $L155 = $L("<");
|
|
4135
|
+
var $L156 = $L("operator");
|
|
4136
|
+
var $L157 = $L("own");
|
|
4137
|
+
var $L158 = $L("public");
|
|
4138
|
+
var $L159 = $L("private");
|
|
4139
|
+
var $L160 = $L("protected");
|
|
4140
|
+
var $L161 = $L("||>");
|
|
4141
|
+
var $L162 = $L("|\u25B7");
|
|
4142
|
+
var $L163 = $L("|>=");
|
|
4143
|
+
var $L164 = $L("\u25B7=");
|
|
4144
|
+
var $L165 = $L("|>");
|
|
4145
|
+
var $L166 = $L("\u25B7");
|
|
4146
|
+
var $L167 = $L("readonly");
|
|
4147
|
+
var $L168 = $L("return");
|
|
4148
|
+
var $L169 = $L("satisfies");
|
|
4149
|
+
var $L170 = $L("'");
|
|
4150
|
+
var $L171 = $L("static");
|
|
4151
|
+
var $L172 = $L("${");
|
|
4152
|
+
var $L173 = $L("super");
|
|
4153
|
+
var $L174 = $L("switch");
|
|
4154
|
+
var $L175 = $L("target");
|
|
4155
|
+
var $L176 = $L("then");
|
|
4156
|
+
var $L177 = $L("this");
|
|
4157
|
+
var $L178 = $L("throw");
|
|
4158
|
+
var $L179 = $L('"""');
|
|
4159
|
+
var $L180 = $L("'''");
|
|
4160
|
+
var $L181 = $L("///");
|
|
4161
|
+
var $L182 = $L("```");
|
|
4162
|
+
var $L183 = $L("try");
|
|
4163
|
+
var $L184 = $L("typeof");
|
|
4164
|
+
var $L185 = $L("unless");
|
|
4165
|
+
var $L186 = $L("until");
|
|
4166
|
+
var $L187 = $L("var");
|
|
4167
|
+
var $L188 = $L("void");
|
|
4168
|
+
var $L189 = $L("when");
|
|
4169
|
+
var $L190 = $L("while");
|
|
4170
|
+
var $L191 = $L("yield");
|
|
4171
|
+
var $L192 = $L("/>");
|
|
4172
|
+
var $L193 = $L("</");
|
|
4173
|
+
var $L194 = $L("<>");
|
|
4174
|
+
var $L195 = $L("</>");
|
|
4175
|
+
var $L196 = $L("<!--");
|
|
4176
|
+
var $L197 = $L("-->");
|
|
4177
|
+
var $L198 = $L("type");
|
|
4178
|
+
var $L199 = $L("enum");
|
|
4179
|
+
var $L200 = $L("interface");
|
|
4180
|
+
var $L201 = $L("global");
|
|
4181
|
+
var $L202 = $L("module");
|
|
4182
|
+
var $L203 = $L("namespace");
|
|
4183
|
+
var $L204 = $L("asserts");
|
|
4184
|
+
var $L205 = $L("keyof");
|
|
4185
|
+
var $L206 = $L("infer");
|
|
4186
|
+
var $L207 = $L("???");
|
|
4187
|
+
var $L208 = $L("[]");
|
|
4188
|
+
var $L209 = $L("civet");
|
|
4198
4189
|
var $R0 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
4199
4190
|
var $R1 = $R(new RegExp("[0-9]", "suy"));
|
|
4200
4191
|
var $R2 = $R(new RegExp("[)}]", "suy"));
|
|
@@ -4440,7 +4431,7 @@ ${input.slice(result.pos)}
|
|
|
4440
4431
|
function ExplicitArguments(ctx, state) {
|
|
4441
4432
|
return $EVENT(ctx, state, "ExplicitArguments", ExplicitArguments$0);
|
|
4442
4433
|
}
|
|
4443
|
-
var ApplicationStart$0 = $S(IndentedApplicationAllowed, $Y(
|
|
4434
|
+
var ApplicationStart$0 = $S(IndentedApplicationAllowed, $Y($S(IndentedFurther, $N(IdentifierBinaryOp), $N(AccessStart))));
|
|
4444
4435
|
var ApplicationStart$1 = $S($N(EOS), $Y($S(_, $C(BracedApplicationAllowed, $N($EXPECT($L1, 'ApplicationStart "{"'))), $N(ForbiddenImplicitCalls))));
|
|
4445
4436
|
var ApplicationStart$$ = [ApplicationStart$0, ApplicationStart$1];
|
|
4446
4437
|
function ApplicationStart(ctx, state) {
|
|
@@ -5223,7 +5214,7 @@ ${input.slice(result.pos)}
|
|
|
5223
5214
|
function CallExpressionRest(ctx, state) {
|
|
5224
5215
|
return $EVENT_C(ctx, state, "CallExpressionRest", CallExpressionRest$$);
|
|
5225
5216
|
}
|
|
5226
|
-
var OptionalShorthand$0 = $TS($S(QuestionMark, OptionalDot), function($skip, $loc, $0, $1, $2) {
|
|
5217
|
+
var OptionalShorthand$0 = $TS($S($Q(MultiLineComment), QuestionMark, OptionalDot), function($skip, $loc, $0, $1, $2, $3) {
|
|
5227
5218
|
return {
|
|
5228
5219
|
type: "Optional",
|
|
5229
5220
|
children: $0
|
|
@@ -5232,8 +5223,8 @@ ${input.slice(result.pos)}
|
|
|
5232
5223
|
function OptionalShorthand(ctx, state) {
|
|
5233
5224
|
return $EVENT(ctx, state, "OptionalShorthand", OptionalShorthand$0);
|
|
5234
5225
|
}
|
|
5235
|
-
var OptionalDot$0 = Dot;
|
|
5236
|
-
var OptionalDot$1 = InsertDot;
|
|
5226
|
+
var OptionalDot$0 = $S($Q(MultiLineComment), Dot);
|
|
5227
|
+
var OptionalDot$1 = $S(InsertDot, $Q(MultiLineComment));
|
|
5237
5228
|
var OptionalDot$$ = [OptionalDot$0, OptionalDot$1];
|
|
5238
5229
|
function OptionalDot(ctx, state) {
|
|
5239
5230
|
return $EVENT_C(ctx, state, "OptionalDot", OptionalDot$$);
|
|
@@ -5257,22 +5248,38 @@ ${input.slice(result.pos)}
|
|
|
5257
5248
|
function MemberExpression(ctx, state) {
|
|
5258
5249
|
return $EVENT(ctx, state, "MemberExpression", MemberExpression$0);
|
|
5259
5250
|
}
|
|
5260
|
-
var MemberExpressionRest$0 = $TS($S($
|
|
5261
|
-
|
|
5262
|
-
|
|
5263
|
-
|
|
5251
|
+
var MemberExpressionRest$0 = $TS($S($Q(MultiLineComment), MemberExpressionRestBody), function($skip, $loc, $0, $1, $2) {
|
|
5252
|
+
var comments = $1;
|
|
5253
|
+
var body = $2;
|
|
5254
|
+
if (Array.isArray(body))
|
|
5255
|
+
return [...comments, ...body];
|
|
5256
|
+
return {
|
|
5257
|
+
...body,
|
|
5258
|
+
children: [...comments, ...body.children]
|
|
5259
|
+
};
|
|
5260
|
+
});
|
|
5261
|
+
function MemberExpressionRest(ctx, state) {
|
|
5262
|
+
return $EVENT(ctx, state, "MemberExpressionRest", MemberExpressionRest$0);
|
|
5263
|
+
}
|
|
5264
|
+
var MemberExpressionRestBody$0 = $TS($S($E($C(OptionalShorthand, NonNullAssertion)), $Q(MultiLineComment), MemberBracketContent), function($skip, $loc, $0, $1, $2, $3) {
|
|
5265
|
+
var dot = $1;
|
|
5266
|
+
var comments = $2;
|
|
5267
|
+
var content = $3;
|
|
5268
|
+
if (dot) {
|
|
5269
|
+
if (dot.type === "Optional" && content.type === "SliceExpression") {
|
|
5270
|
+
return [...dot.children.slice(0, -1), ...comments, content];
|
|
5264
5271
|
}
|
|
5265
5272
|
return $0.flat();
|
|
5266
5273
|
}
|
|
5267
|
-
return
|
|
5274
|
+
return content;
|
|
5268
5275
|
});
|
|
5269
|
-
var
|
|
5270
|
-
var
|
|
5271
|
-
var
|
|
5272
|
-
var
|
|
5273
|
-
var
|
|
5274
|
-
function
|
|
5275
|
-
return $EVENT_C(ctx, state, "
|
|
5276
|
+
var MemberExpressionRestBody$1 = PropertyAccess;
|
|
5277
|
+
var MemberExpressionRestBody$2 = PropertyGlob;
|
|
5278
|
+
var MemberExpressionRestBody$3 = PropertyBind;
|
|
5279
|
+
var MemberExpressionRestBody$4 = NonNullAssertion;
|
|
5280
|
+
var MemberExpressionRestBody$$ = [MemberExpressionRestBody$0, MemberExpressionRestBody$1, MemberExpressionRestBody$2, MemberExpressionRestBody$3, MemberExpressionRestBody$4];
|
|
5281
|
+
function MemberExpressionRestBody(ctx, state) {
|
|
5282
|
+
return $EVENT_C(ctx, state, "MemberExpressionRestBody", MemberExpressionRestBody$$);
|
|
5276
5283
|
}
|
|
5277
5284
|
var MemberBracketContent$0 = $TS($S(OpenBracket, $C(SliceParameters, PostfixedExpression), __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5278
5285
|
var open = $1;
|
|
@@ -5403,11 +5410,19 @@ ${input.slice(result.pos)}
|
|
|
5403
5410
|
function SliceParameters(ctx, state) {
|
|
5404
5411
|
return $EVENT_C(ctx, state, "SliceParameters", SliceParameters$$);
|
|
5405
5412
|
}
|
|
5406
|
-
var
|
|
5407
|
-
var id = $3;
|
|
5408
|
-
const children = [$2, ...id.children];
|
|
5413
|
+
var AccessStart$0 = $TS($S($E($C(QuestionMark, NonNullAssertion)), Dot, $N(Dot)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5409
5414
|
if ($1)
|
|
5410
|
-
|
|
5415
|
+
return [$1, $2];
|
|
5416
|
+
return $2;
|
|
5417
|
+
});
|
|
5418
|
+
function AccessStart(ctx, state) {
|
|
5419
|
+
return $EVENT(ctx, state, "AccessStart", AccessStart$0);
|
|
5420
|
+
}
|
|
5421
|
+
var PropertyAccess$0 = $TS($S(AccessStart, $Q(MultiLineComment), $C(IdentifierName, PrivateIdentifier)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5422
|
+
var access = $1;
|
|
5423
|
+
var comments = $2;
|
|
5424
|
+
var id = $3;
|
|
5425
|
+
const children = [access, ...comments, ...id.children];
|
|
5411
5426
|
return {
|
|
5412
5427
|
type: "PropertyAccess",
|
|
5413
5428
|
name: id.name,
|
|
@@ -5418,19 +5433,26 @@ ${input.slice(result.pos)}
|
|
|
5418
5433
|
var p = $2;
|
|
5419
5434
|
var id = $3;
|
|
5420
5435
|
if (id) {
|
|
5421
|
-
|
|
5422
|
-
|
|
5436
|
+
return {
|
|
5437
|
+
type: "PropertyAccess",
|
|
5438
|
+
name: id.name,
|
|
5439
|
+
children: [{ token: ".prototype.", $loc: p.$loc }, id]
|
|
5440
|
+
};
|
|
5441
|
+
} else {
|
|
5442
|
+
return {
|
|
5443
|
+
type: "PropertyAccess",
|
|
5444
|
+
name: "prototype",
|
|
5445
|
+
children: [{ token: ".prototype", $loc: p.$loc }]
|
|
5446
|
+
};
|
|
5423
5447
|
}
|
|
5424
|
-
p.token = ".prototype";
|
|
5425
|
-
return p;
|
|
5426
5448
|
});
|
|
5427
5449
|
var PropertyAccess$$ = [PropertyAccess$0, PropertyAccess$1];
|
|
5428
5450
|
function PropertyAccess(ctx, state) {
|
|
5429
5451
|
return $EVENT_C(ctx, state, "PropertyAccess", PropertyAccess$$);
|
|
5430
5452
|
}
|
|
5431
|
-
var PropertyGlob$0 = $TS($S(OptionalDot, BracedObjectLiteral), function($skip, $loc, $0, $1, $2) {
|
|
5453
|
+
var PropertyGlob$0 = $TS($S(OptionalDot, $Q(MultiLineComment), BracedObjectLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
5432
5454
|
var dot = $1;
|
|
5433
|
-
var object = $
|
|
5455
|
+
var object = $3;
|
|
5434
5456
|
return {
|
|
5435
5457
|
type: "PropertyGlob",
|
|
5436
5458
|
dot,
|
|
@@ -5974,8 +5996,29 @@ ${input.slice(result.pos)}
|
|
|
5974
5996
|
block
|
|
5975
5997
|
};
|
|
5976
5998
|
});
|
|
5977
|
-
var FunctionExpression$1 =
|
|
5978
|
-
|
|
5999
|
+
var FunctionExpression$1 = $TV($EXPECT($L22, 'FunctionExpression "(&)"'), function($skip, $loc, $0, $1) {
|
|
6000
|
+
const ref = makeRef("$"), body = [ref];
|
|
6001
|
+
return {
|
|
6002
|
+
type: "ArrowFunction",
|
|
6003
|
+
children: [ref, " => ", body],
|
|
6004
|
+
ref,
|
|
6005
|
+
body,
|
|
6006
|
+
ampersandBlock: true
|
|
6007
|
+
};
|
|
6008
|
+
});
|
|
6009
|
+
var FunctionExpression$2 = AmpersandFunctionExpression;
|
|
6010
|
+
var FunctionExpression$3 = $TS($S(Identifier, __, ConstAssignment, $Q(_), ThinArrowFunction), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
6011
|
+
var id = $1;
|
|
6012
|
+
var ws = $4;
|
|
6013
|
+
var fn = $5;
|
|
6014
|
+
debugger;
|
|
6015
|
+
return {
|
|
6016
|
+
...fn,
|
|
6017
|
+
id,
|
|
6018
|
+
children: [...fn.children.slice(0, 2), insertTrimmingSpace(ws, " "), id, ...fn.children.slice(2)]
|
|
6019
|
+
};
|
|
6020
|
+
});
|
|
6021
|
+
var FunctionExpression$$ = [FunctionExpression$0, FunctionExpression$1, FunctionExpression$2, FunctionExpression$3];
|
|
5979
6022
|
function FunctionExpression(ctx, state) {
|
|
5980
6023
|
return $EVENT_C(ctx, state, "FunctionExpression", FunctionExpression$$);
|
|
5981
6024
|
}
|
|
@@ -6154,7 +6197,7 @@ ${input.slice(result.pos)}
|
|
|
6154
6197
|
function ThinArrowFunction(ctx, state) {
|
|
6155
6198
|
return $EVENT(ctx, state, "ThinArrowFunction", ThinArrowFunction$0);
|
|
6156
6199
|
}
|
|
6157
|
-
var Arrow$0 = $TV($C($EXPECT($
|
|
6200
|
+
var Arrow$0 = $TV($C($EXPECT($L23, 'Arrow "->"'), $EXPECT($L24, 'Arrow "\u2192"')), function($skip, $loc, $0, $1) {
|
|
6158
6201
|
return { $loc, token: "->" };
|
|
6159
6202
|
});
|
|
6160
6203
|
function Arrow(ctx, state) {
|
|
@@ -6387,7 +6430,7 @@ ${input.slice(result.pos)}
|
|
|
6387
6430
|
}
|
|
6388
6431
|
var BracedContent$0 = NestedBlockStatements;
|
|
6389
6432
|
var BracedContent$1 = SingleLineStatements;
|
|
6390
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
6433
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L25, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
6391
6434
|
const expressions = [];
|
|
6392
6435
|
return {
|
|
6393
6436
|
type: "BlockStatement",
|
|
@@ -6456,7 +6499,7 @@ ${input.slice(result.pos)}
|
|
|
6456
6499
|
function LiteralContent(ctx, state) {
|
|
6457
6500
|
return $EVENT_C(ctx, state, "LiteralContent", LiteralContent$$);
|
|
6458
6501
|
}
|
|
6459
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
6502
|
+
var NullLiteral$0 = $TS($S($EXPECT($L26, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6460
6503
|
return { $loc, token: $1 };
|
|
6461
6504
|
});
|
|
6462
6505
|
function NullLiteral(ctx, state) {
|
|
@@ -6465,17 +6508,17 @@ ${input.slice(result.pos)}
|
|
|
6465
6508
|
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
6466
6509
|
return value[1];
|
|
6467
6510
|
});
|
|
6468
|
-
var BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6511
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L27, 'BooleanLiteral "true"'), $EXPECT($L28, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6469
6512
|
return { $loc, token: $1 };
|
|
6470
6513
|
});
|
|
6471
6514
|
var BooleanLiteral$$ = [BooleanLiteral$0, BooleanLiteral$1];
|
|
6472
6515
|
function BooleanLiteral(ctx, state) {
|
|
6473
6516
|
return $EVENT_C(ctx, state, "BooleanLiteral", BooleanLiteral$$);
|
|
6474
6517
|
}
|
|
6475
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
6518
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L29, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L30, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6476
6519
|
return { $loc, token: "true" };
|
|
6477
6520
|
});
|
|
6478
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
6521
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L31, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L32, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6479
6522
|
return { $loc, token: "false" };
|
|
6480
6523
|
});
|
|
6481
6524
|
var CoffeeScriptBooleanLiteral$$ = [CoffeeScriptBooleanLiteral$0, CoffeeScriptBooleanLiteral$1];
|
|
@@ -6506,7 +6549,7 @@ ${input.slice(result.pos)}
|
|
|
6506
6549
|
function IdentifierReference(ctx, state) {
|
|
6507
6550
|
return $EVENT(ctx, state, "IdentifierReference", IdentifierReference$0);
|
|
6508
6551
|
}
|
|
6509
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L3, 'UpcomingAssignment "="'), $N($C($EXPECT($L3, 'UpcomingAssignment "="'), $EXPECT($
|
|
6552
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L3, 'UpcomingAssignment "="'), $N($C($EXPECT($L3, 'UpcomingAssignment "="'), $EXPECT($L33, 'UpcomingAssignment ">"')))));
|
|
6510
6553
|
function UpcomingAssignment(ctx, state) {
|
|
6511
6554
|
return $EVENT(ctx, state, "UpcomingAssignment", UpcomingAssignment$0);
|
|
6512
6555
|
}
|
|
@@ -6658,7 +6701,7 @@ ${input.slice(result.pos)}
|
|
|
6658
6701
|
return $EVENT(ctx, state, "NestedElement", NestedElement$0);
|
|
6659
6702
|
}
|
|
6660
6703
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
6661
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6704
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L34, 'ArrayElementDelimiter "]"')));
|
|
6662
6705
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6663
6706
|
return value[1];
|
|
6664
6707
|
});
|
|
@@ -6770,6 +6813,8 @@ ${input.slice(result.pos)}
|
|
|
6770
6813
|
line = line.flatMap(([prop, delim]) => {
|
|
6771
6814
|
prop = Array.isArray(prop) ? prop : [prop];
|
|
6772
6815
|
let last = prop[prop.length - 1];
|
|
6816
|
+
if (!last)
|
|
6817
|
+
return [];
|
|
6773
6818
|
last = {
|
|
6774
6819
|
...last,
|
|
6775
6820
|
delim,
|
|
@@ -6884,7 +6929,7 @@ ${input.slice(result.pos)}
|
|
|
6884
6929
|
return $EVENT_C(ctx, state, "ImplicitInlineObjectPropertyDelimiter", ImplicitInlineObjectPropertyDelimiter$$);
|
|
6885
6930
|
}
|
|
6886
6931
|
var ObjectPropertyDelimiter$0 = $S($E(_), Comma);
|
|
6887
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
6932
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L25, 'ObjectPropertyDelimiter "}"')));
|
|
6888
6933
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6889
6934
|
return value[1];
|
|
6890
6935
|
});
|
|
@@ -7296,22 +7341,22 @@ ${input.slice(result.pos)}
|
|
|
7296
7341
|
function OperatorAssignmentOp(ctx, state) {
|
|
7297
7342
|
return $EVENT_C(ctx, state, "OperatorAssignmentOp", OperatorAssignmentOp$$);
|
|
7298
7343
|
}
|
|
7299
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
7300
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
7301
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
7302
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
7303
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
7304
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
7305
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
7306
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
7307
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
7308
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
7309
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
7310
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
7311
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
7312
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
7313
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
7314
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
7344
|
+
var AssignmentOpSymbol$0 = $EXPECT($L35, 'AssignmentOpSymbol "**="');
|
|
7345
|
+
var AssignmentOpSymbol$1 = $EXPECT($L36, 'AssignmentOpSymbol "*="');
|
|
7346
|
+
var AssignmentOpSymbol$2 = $EXPECT($L37, 'AssignmentOpSymbol "/="');
|
|
7347
|
+
var AssignmentOpSymbol$3 = $EXPECT($L38, 'AssignmentOpSymbol "%="');
|
|
7348
|
+
var AssignmentOpSymbol$4 = $EXPECT($L39, 'AssignmentOpSymbol "+="');
|
|
7349
|
+
var AssignmentOpSymbol$5 = $EXPECT($L40, 'AssignmentOpSymbol "-="');
|
|
7350
|
+
var AssignmentOpSymbol$6 = $EXPECT($L41, 'AssignmentOpSymbol "<<="');
|
|
7351
|
+
var AssignmentOpSymbol$7 = $EXPECT($L42, 'AssignmentOpSymbol ">>>="');
|
|
7352
|
+
var AssignmentOpSymbol$8 = $EXPECT($L43, 'AssignmentOpSymbol ">>="');
|
|
7353
|
+
var AssignmentOpSymbol$9 = $EXPECT($L44, 'AssignmentOpSymbol "&&="');
|
|
7354
|
+
var AssignmentOpSymbol$10 = $EXPECT($L45, 'AssignmentOpSymbol "&="');
|
|
7355
|
+
var AssignmentOpSymbol$11 = $EXPECT($L46, 'AssignmentOpSymbol "^="');
|
|
7356
|
+
var AssignmentOpSymbol$12 = $EXPECT($L47, 'AssignmentOpSymbol "||="');
|
|
7357
|
+
var AssignmentOpSymbol$13 = $EXPECT($L48, 'AssignmentOpSymbol "|="');
|
|
7358
|
+
var AssignmentOpSymbol$14 = $EXPECT($L49, 'AssignmentOpSymbol "??="');
|
|
7359
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L50, 'AssignmentOpSymbol "?="'), function(value) {
|
|
7315
7360
|
return "??=";
|
|
7316
7361
|
});
|
|
7317
7362
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L3, 'AssignmentOpSymbol "="'), $N($EXPECT($L3, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -7324,10 +7369,10 @@ ${input.slice(result.pos)}
|
|
|
7324
7369
|
function AssignmentOpSymbol(ctx, state) {
|
|
7325
7370
|
return $EVENT_C(ctx, state, "AssignmentOpSymbol", AssignmentOpSymbol$$);
|
|
7326
7371
|
}
|
|
7327
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
7372
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L51, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
7328
7373
|
return "&&=";
|
|
7329
7374
|
});
|
|
7330
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
7375
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L52, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
7331
7376
|
return "||=";
|
|
7332
7377
|
});
|
|
7333
7378
|
var CoffeeWordAssignmentOp$$ = [CoffeeWordAssignmentOp$0, CoffeeWordAssignmentOp$1];
|
|
@@ -7352,6 +7397,15 @@ ${input.slice(result.pos)}
|
|
|
7352
7397
|
function NotDedentedBinaryOp(ctx, state) {
|
|
7353
7398
|
return $EVENT_C(ctx, state, "NotDedentedBinaryOp", NotDedentedBinaryOp$$);
|
|
7354
7399
|
}
|
|
7400
|
+
var IdentifierBinaryOp$0 = $TV(Identifier, function($skip, $loc, $0, $1) {
|
|
7401
|
+
var id = $0;
|
|
7402
|
+
if (module.operators.has(id.name))
|
|
7403
|
+
return id;
|
|
7404
|
+
return $skip;
|
|
7405
|
+
});
|
|
7406
|
+
function IdentifierBinaryOp(ctx, state) {
|
|
7407
|
+
return $EVENT(ctx, state, "IdentifierBinaryOp", IdentifierBinaryOp$0);
|
|
7408
|
+
}
|
|
7355
7409
|
var BinaryOp$0 = $TS($S(BinaryOpSymbol), function($skip, $loc, $0, $1) {
|
|
7356
7410
|
if (typeof $1 === "string")
|
|
7357
7411
|
return { $loc, token: $1 };
|
|
@@ -7380,27 +7434,27 @@ ${input.slice(result.pos)}
|
|
|
7380
7434
|
function BinaryOp(ctx, state) {
|
|
7381
7435
|
return $EVENT_C(ctx, state, "BinaryOp", BinaryOp$$);
|
|
7382
7436
|
}
|
|
7383
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
7384
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
7385
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
7386
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
7437
|
+
var BinaryOpSymbol$0 = $EXPECT($L53, 'BinaryOpSymbol "**"');
|
|
7438
|
+
var BinaryOpSymbol$1 = $EXPECT($L54, 'BinaryOpSymbol "*"');
|
|
7439
|
+
var BinaryOpSymbol$2 = $EXPECT($L55, 'BinaryOpSymbol "/"');
|
|
7440
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L56, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
7387
7441
|
return {
|
|
7388
7442
|
call: module.getRef("modulo"),
|
|
7389
7443
|
special: true
|
|
7390
7444
|
};
|
|
7391
7445
|
});
|
|
7392
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
7393
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
7446
|
+
var BinaryOpSymbol$4 = $EXPECT($L57, 'BinaryOpSymbol "%"');
|
|
7447
|
+
var BinaryOpSymbol$5 = $EXPECT($L58, 'BinaryOpSymbol "+"');
|
|
7394
7448
|
var BinaryOpSymbol$6 = $EXPECT($L18, 'BinaryOpSymbol "-"');
|
|
7395
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
7396
|
-
var BinaryOpSymbol$8 = $T($EXPECT($
|
|
7449
|
+
var BinaryOpSymbol$7 = $EXPECT($L59, 'BinaryOpSymbol "<="');
|
|
7450
|
+
var BinaryOpSymbol$8 = $T($EXPECT($L60, 'BinaryOpSymbol "\u2264"'), function(value) {
|
|
7397
7451
|
return "<=";
|
|
7398
7452
|
});
|
|
7399
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
7400
|
-
var BinaryOpSymbol$10 = $T($EXPECT($
|
|
7453
|
+
var BinaryOpSymbol$9 = $EXPECT($L61, 'BinaryOpSymbol ">="');
|
|
7454
|
+
var BinaryOpSymbol$10 = $T($EXPECT($L62, 'BinaryOpSymbol "\u2265"'), function(value) {
|
|
7401
7455
|
return ">=";
|
|
7402
7456
|
});
|
|
7403
|
-
var BinaryOpSymbol$11 = $TV($EXPECT($
|
|
7457
|
+
var BinaryOpSymbol$11 = $TV($EXPECT($L63, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
7404
7458
|
return {
|
|
7405
7459
|
$loc,
|
|
7406
7460
|
token: "instanceof",
|
|
@@ -7408,7 +7462,7 @@ ${input.slice(result.pos)}
|
|
|
7408
7462
|
special: true
|
|
7409
7463
|
};
|
|
7410
7464
|
});
|
|
7411
|
-
var BinaryOpSymbol$12 = $TV($EXPECT($
|
|
7465
|
+
var BinaryOpSymbol$12 = $TV($EXPECT($L64, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
7412
7466
|
return {
|
|
7413
7467
|
$loc,
|
|
7414
7468
|
token: "instanceof",
|
|
@@ -7417,79 +7471,79 @@ ${input.slice(result.pos)}
|
|
|
7417
7471
|
negated: true
|
|
7418
7472
|
};
|
|
7419
7473
|
});
|
|
7420
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
7421
|
-
var BinaryOpSymbol$14 = $T($EXPECT($
|
|
7474
|
+
var BinaryOpSymbol$13 = $EXPECT($L65, 'BinaryOpSymbol "<<"');
|
|
7475
|
+
var BinaryOpSymbol$14 = $T($EXPECT($L66, 'BinaryOpSymbol "\xAB"'), function(value) {
|
|
7422
7476
|
return "<<";
|
|
7423
7477
|
});
|
|
7424
7478
|
var BinaryOpSymbol$15 = $TR($EXPECT($R7, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7425
7479
|
return "<";
|
|
7426
7480
|
});
|
|
7427
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
7428
|
-
var BinaryOpSymbol$17 = $T($EXPECT($
|
|
7481
|
+
var BinaryOpSymbol$16 = $EXPECT($L67, 'BinaryOpSymbol ">>>"');
|
|
7482
|
+
var BinaryOpSymbol$17 = $T($EXPECT($L68, 'BinaryOpSymbol "\u22D9"'), function(value) {
|
|
7429
7483
|
return ">>>";
|
|
7430
7484
|
});
|
|
7431
|
-
var BinaryOpSymbol$18 = $EXPECT($
|
|
7432
|
-
var BinaryOpSymbol$19 = $T($EXPECT($
|
|
7485
|
+
var BinaryOpSymbol$18 = $EXPECT($L69, 'BinaryOpSymbol ">>"');
|
|
7486
|
+
var BinaryOpSymbol$19 = $T($EXPECT($L70, 'BinaryOpSymbol "\xBB"'), function(value) {
|
|
7433
7487
|
return ">>";
|
|
7434
7488
|
});
|
|
7435
|
-
var BinaryOpSymbol$20 = $EXPECT($
|
|
7436
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
7437
|
-
var BinaryOpSymbol$22 = $T($EXPECT($
|
|
7489
|
+
var BinaryOpSymbol$20 = $EXPECT($L33, 'BinaryOpSymbol ">"');
|
|
7490
|
+
var BinaryOpSymbol$21 = $EXPECT($L71, 'BinaryOpSymbol "!=="');
|
|
7491
|
+
var BinaryOpSymbol$22 = $T($EXPECT($L72, 'BinaryOpSymbol "\u2262"'), function(value) {
|
|
7438
7492
|
return "!==";
|
|
7439
7493
|
});
|
|
7440
|
-
var BinaryOpSymbol$23 = $TV($C($EXPECT($
|
|
7494
|
+
var BinaryOpSymbol$23 = $TV($C($EXPECT($L73, 'BinaryOpSymbol "!="'), $EXPECT($L74, 'BinaryOpSymbol "\u2260"')), function($skip, $loc, $0, $1) {
|
|
7441
7495
|
if (module.config.coffeeEq)
|
|
7442
7496
|
return "!==";
|
|
7443
7497
|
return "!=";
|
|
7444
7498
|
});
|
|
7445
|
-
var BinaryOpSymbol$24 = $TS($S($EXPECT($
|
|
7499
|
+
var BinaryOpSymbol$24 = $TS($S($EXPECT($L75, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7446
7500
|
if (module.config.coffeeIsnt)
|
|
7447
7501
|
return "!==";
|
|
7448
7502
|
return $skip;
|
|
7449
7503
|
});
|
|
7450
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
7451
|
-
var BinaryOpSymbol$26 = $T($C($EXPECT($
|
|
7504
|
+
var BinaryOpSymbol$25 = $EXPECT($L76, 'BinaryOpSymbol "==="');
|
|
7505
|
+
var BinaryOpSymbol$26 = $T($C($EXPECT($L77, 'BinaryOpSymbol "\u2263"'), $EXPECT($L78, 'BinaryOpSymbol "\u2A76"')), function(value) {
|
|
7452
7506
|
return "===";
|
|
7453
7507
|
});
|
|
7454
|
-
var BinaryOpSymbol$27 = $TV($C($EXPECT($
|
|
7508
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($L79, 'BinaryOpSymbol "=="'), $EXPECT($L80, 'BinaryOpSymbol "\u2261"'), $EXPECT($L81, 'BinaryOpSymbol "\u2A75"')), function($skip, $loc, $0, $1) {
|
|
7455
7509
|
if (module.config.coffeeEq)
|
|
7456
7510
|
return "===";
|
|
7457
7511
|
return "==";
|
|
7458
7512
|
});
|
|
7459
|
-
var BinaryOpSymbol$28 = $T($S($EXPECT($
|
|
7513
|
+
var BinaryOpSymbol$28 = $T($S($EXPECT($L82, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
7460
7514
|
return "&&";
|
|
7461
7515
|
});
|
|
7462
|
-
var BinaryOpSymbol$29 = $EXPECT($
|
|
7463
|
-
var BinaryOpSymbol$30 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
7516
|
+
var BinaryOpSymbol$29 = $EXPECT($L83, 'BinaryOpSymbol "&&"');
|
|
7517
|
+
var BinaryOpSymbol$30 = $T($S(CoffeeOfEnabled, $EXPECT($L84, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
7464
7518
|
return "in";
|
|
7465
7519
|
});
|
|
7466
|
-
var BinaryOpSymbol$31 = $T($S($EXPECT($
|
|
7520
|
+
var BinaryOpSymbol$31 = $T($S($EXPECT($L85, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
7467
7521
|
return "||";
|
|
7468
7522
|
});
|
|
7469
|
-
var BinaryOpSymbol$32 = $EXPECT($
|
|
7470
|
-
var BinaryOpSymbol$33 = $T($EXPECT($
|
|
7523
|
+
var BinaryOpSymbol$32 = $EXPECT($L86, 'BinaryOpSymbol "||"');
|
|
7524
|
+
var BinaryOpSymbol$33 = $T($EXPECT($L87, 'BinaryOpSymbol "\u2016"'), function(value) {
|
|
7471
7525
|
return "||";
|
|
7472
7526
|
});
|
|
7473
|
-
var BinaryOpSymbol$34 = $TV($C($EXPECT($
|
|
7527
|
+
var BinaryOpSymbol$34 = $TV($C($EXPECT($L88, 'BinaryOpSymbol "^^"'), $S($EXPECT($L89, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7474
7528
|
return {
|
|
7475
7529
|
call: module.getRef("xor"),
|
|
7476
7530
|
special: true
|
|
7477
7531
|
};
|
|
7478
7532
|
});
|
|
7479
|
-
var BinaryOpSymbol$35 = $TV($C($EXPECT($R8, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($
|
|
7533
|
+
var BinaryOpSymbol$35 = $TV($C($EXPECT($R8, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L90, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7480
7534
|
return {
|
|
7481
7535
|
call: module.getRef("xnor"),
|
|
7482
7536
|
special: true
|
|
7483
7537
|
};
|
|
7484
7538
|
});
|
|
7485
|
-
var BinaryOpSymbol$36 = $EXPECT($
|
|
7486
|
-
var BinaryOpSymbol$37 = $T($EXPECT($
|
|
7539
|
+
var BinaryOpSymbol$36 = $EXPECT($L91, 'BinaryOpSymbol "??"');
|
|
7540
|
+
var BinaryOpSymbol$37 = $T($EXPECT($L92, 'BinaryOpSymbol "\u2047"'), function(value) {
|
|
7487
7541
|
return "??";
|
|
7488
7542
|
});
|
|
7489
7543
|
var BinaryOpSymbol$38 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L5, 'BinaryOpSymbol "?"')), function(value) {
|
|
7490
7544
|
return "??";
|
|
7491
7545
|
});
|
|
7492
|
-
var BinaryOpSymbol$39 = $TS($S($EXPECT($
|
|
7546
|
+
var BinaryOpSymbol$39 = $TS($S($EXPECT($L93, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7493
7547
|
return {
|
|
7494
7548
|
$loc,
|
|
7495
7549
|
token: $1,
|
|
@@ -7497,7 +7551,7 @@ ${input.slice(result.pos)}
|
|
|
7497
7551
|
special: true
|
|
7498
7552
|
};
|
|
7499
7553
|
});
|
|
7500
|
-
var BinaryOpSymbol$40 = $TS($S(Not, __, $EXPECT($
|
|
7554
|
+
var BinaryOpSymbol$40 = $TS($S(Not, __, $EXPECT($L93, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7501
7555
|
return {
|
|
7502
7556
|
$loc,
|
|
7503
7557
|
token: "instanceof",
|
|
@@ -7506,7 +7560,7 @@ ${input.slice(result.pos)}
|
|
|
7506
7560
|
negated: true
|
|
7507
7561
|
};
|
|
7508
7562
|
});
|
|
7509
|
-
var BinaryOpSymbol$41 = $TV($C($S($N(CoffeeOfEnabled), Not, __, In), $S(CoffeeOfEnabled, Not, __, $EXPECT($
|
|
7563
|
+
var BinaryOpSymbol$41 = $TV($C($S($N(CoffeeOfEnabled), Not, __, In), $S(CoffeeOfEnabled, Not, __, $EXPECT($L84, 'BinaryOpSymbol "of"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
7510
7564
|
return {
|
|
7511
7565
|
$loc,
|
|
7512
7566
|
token: "in",
|
|
@@ -7514,7 +7568,7 @@ ${input.slice(result.pos)}
|
|
|
7514
7568
|
negated: true
|
|
7515
7569
|
};
|
|
7516
7570
|
});
|
|
7517
|
-
var BinaryOpSymbol$42 = $TV($C($S(Is, __, In), $EXPECT($
|
|
7571
|
+
var BinaryOpSymbol$42 = $TV($C($S(Is, __, In), $EXPECT($L94, 'BinaryOpSymbol "\u2208"')), function($skip, $loc, $0, $1) {
|
|
7518
7572
|
return {
|
|
7519
7573
|
method: "includes",
|
|
7520
7574
|
relational: true,
|
|
@@ -7522,14 +7576,14 @@ ${input.slice(result.pos)}
|
|
|
7522
7576
|
special: true
|
|
7523
7577
|
};
|
|
7524
7578
|
});
|
|
7525
|
-
var BinaryOpSymbol$43 = $TV($EXPECT($
|
|
7579
|
+
var BinaryOpSymbol$43 = $TV($EXPECT($L95, 'BinaryOpSymbol "\u220B"'), function($skip, $loc, $0, $1) {
|
|
7526
7580
|
return {
|
|
7527
7581
|
method: "includes",
|
|
7528
7582
|
relational: true,
|
|
7529
7583
|
special: true
|
|
7530
7584
|
};
|
|
7531
7585
|
});
|
|
7532
|
-
var BinaryOpSymbol$44 = $TV($EXPECT($
|
|
7586
|
+
var BinaryOpSymbol$44 = $TV($EXPECT($L96, 'BinaryOpSymbol "\u220C"'), function($skip, $loc, $0, $1) {
|
|
7533
7587
|
return {
|
|
7534
7588
|
method: "includes",
|
|
7535
7589
|
relational: true,
|
|
@@ -7546,7 +7600,7 @@ ${input.slice(result.pos)}
|
|
|
7546
7600
|
special: true
|
|
7547
7601
|
};
|
|
7548
7602
|
});
|
|
7549
|
-
var BinaryOpSymbol$46 = $TV($C($S(Is, __, Not, __, In), $EXPECT($
|
|
7603
|
+
var BinaryOpSymbol$46 = $TV($C($S(Is, __, Not, __, In), $EXPECT($L97, 'BinaryOpSymbol "\u2209"')), function($skip, $loc, $0, $1) {
|
|
7550
7604
|
return {
|
|
7551
7605
|
method: "includes",
|
|
7552
7606
|
relational: true,
|
|
@@ -7590,21 +7644,21 @@ ${input.slice(result.pos)}
|
|
|
7590
7644
|
var BinaryOpSymbol$50 = $TS($S(In), function($skip, $loc, $0, $1) {
|
|
7591
7645
|
return "in";
|
|
7592
7646
|
});
|
|
7593
|
-
var BinaryOpSymbol$51 = $EXPECT($
|
|
7647
|
+
var BinaryOpSymbol$51 = $EXPECT($L98, 'BinaryOpSymbol "&"');
|
|
7594
7648
|
var BinaryOpSymbol$52 = $EXPECT($L17, 'BinaryOpSymbol "^"');
|
|
7595
|
-
var BinaryOpSymbol$53 = $EXPECT($
|
|
7649
|
+
var BinaryOpSymbol$53 = $EXPECT($L99, 'BinaryOpSymbol "|"');
|
|
7596
7650
|
var BinaryOpSymbol$$ = [BinaryOpSymbol$0, BinaryOpSymbol$1, BinaryOpSymbol$2, BinaryOpSymbol$3, BinaryOpSymbol$4, BinaryOpSymbol$5, BinaryOpSymbol$6, BinaryOpSymbol$7, BinaryOpSymbol$8, BinaryOpSymbol$9, BinaryOpSymbol$10, BinaryOpSymbol$11, BinaryOpSymbol$12, BinaryOpSymbol$13, BinaryOpSymbol$14, BinaryOpSymbol$15, BinaryOpSymbol$16, BinaryOpSymbol$17, BinaryOpSymbol$18, BinaryOpSymbol$19, BinaryOpSymbol$20, BinaryOpSymbol$21, BinaryOpSymbol$22, BinaryOpSymbol$23, BinaryOpSymbol$24, BinaryOpSymbol$25, BinaryOpSymbol$26, BinaryOpSymbol$27, BinaryOpSymbol$28, BinaryOpSymbol$29, BinaryOpSymbol$30, BinaryOpSymbol$31, BinaryOpSymbol$32, BinaryOpSymbol$33, BinaryOpSymbol$34, BinaryOpSymbol$35, BinaryOpSymbol$36, BinaryOpSymbol$37, BinaryOpSymbol$38, BinaryOpSymbol$39, BinaryOpSymbol$40, BinaryOpSymbol$41, BinaryOpSymbol$42, BinaryOpSymbol$43, BinaryOpSymbol$44, BinaryOpSymbol$45, BinaryOpSymbol$46, BinaryOpSymbol$47, BinaryOpSymbol$48, BinaryOpSymbol$49, BinaryOpSymbol$50, BinaryOpSymbol$51, BinaryOpSymbol$52, BinaryOpSymbol$53];
|
|
7597
7651
|
function BinaryOpSymbol(ctx, state) {
|
|
7598
7652
|
return $EVENT_C(ctx, state, "BinaryOpSymbol", BinaryOpSymbol$$);
|
|
7599
7653
|
}
|
|
7600
|
-
var Xor$0 = $EXPECT($
|
|
7601
|
-
var Xor$1 = $S($EXPECT($
|
|
7654
|
+
var Xor$0 = $EXPECT($L88, 'Xor "^^"');
|
|
7655
|
+
var Xor$1 = $S($EXPECT($L89, 'Xor "xor"'), NonIdContinue);
|
|
7602
7656
|
var Xor$$ = [Xor$0, Xor$1];
|
|
7603
7657
|
function Xor(ctx, state) {
|
|
7604
7658
|
return $EVENT_C(ctx, state, "Xor", Xor$$);
|
|
7605
7659
|
}
|
|
7606
7660
|
var Xnor$0 = $R$0($EXPECT($R8, "Xnor /!\\^\\^?/"));
|
|
7607
|
-
var Xnor$1 = $EXPECT($
|
|
7661
|
+
var Xnor$1 = $EXPECT($L90, 'Xnor "xnor"');
|
|
7608
7662
|
var Xnor$$ = [Xnor$0, Xnor$1];
|
|
7609
7663
|
function Xnor(ctx, state) {
|
|
7610
7664
|
return $EVENT_C(ctx, state, "Xnor", Xnor$$);
|
|
@@ -7708,7 +7762,7 @@ ${input.slice(result.pos)}
|
|
|
7708
7762
|
function Statement(ctx, state) {
|
|
7709
7763
|
return $EVENT_C(ctx, state, "Statement", Statement$$);
|
|
7710
7764
|
}
|
|
7711
|
-
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($
|
|
7765
|
+
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L100, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
|
|
7712
7766
|
return { type: "EmptyStatement", children: $1 || [] };
|
|
7713
7767
|
});
|
|
7714
7768
|
function EmptyStatement(ctx, state) {
|
|
@@ -7730,7 +7784,7 @@ ${input.slice(result.pos)}
|
|
|
7730
7784
|
var w = $3;
|
|
7731
7785
|
return [id, colon, w];
|
|
7732
7786
|
});
|
|
7733
|
-
var Label$1 = $S($EXPECT($
|
|
7787
|
+
var Label$1 = $S($EXPECT($L101, 'Label "$:"'), Whitespace);
|
|
7734
7788
|
var Label$$ = [Label$0, Label$1];
|
|
7735
7789
|
function Label(ctx, state) {
|
|
7736
7790
|
return $EVENT_C(ctx, state, "Label", Label$$);
|
|
@@ -8429,8 +8483,10 @@ ${input.slice(result.pos)}
|
|
|
8429
8483
|
return $EVENT(ctx, state, "PatternExpressionList", PatternExpressionList$0);
|
|
8430
8484
|
}
|
|
8431
8485
|
var ConditionFragment$0 = BindingPattern;
|
|
8432
|
-
var ConditionFragment$1 = $
|
|
8433
|
-
var pattern = $
|
|
8486
|
+
var ConditionFragment$1 = $TS($S(ForbidIndentedApplication, $E($P(SingleLineBinaryOpRHS)), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3) {
|
|
8487
|
+
var pattern = $2;
|
|
8488
|
+
if (!pattern)
|
|
8489
|
+
return $skip;
|
|
8434
8490
|
return {
|
|
8435
8491
|
type: "ConditionFragment",
|
|
8436
8492
|
children: pattern
|
|
@@ -8591,8 +8647,10 @@ ${input.slice(result.pos)}
|
|
|
8591
8647
|
function Condition(ctx, state) {
|
|
8592
8648
|
return $EVENT_C(ctx, state, "Condition", Condition$$);
|
|
8593
8649
|
}
|
|
8594
|
-
var DeclarationCondition$0 = $
|
|
8595
|
-
var dec = $
|
|
8650
|
+
var DeclarationCondition$0 = $TS($S(ForbidIndentedApplication, $E(LexicalDeclaration), RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3) {
|
|
8651
|
+
var dec = $2;
|
|
8652
|
+
if (!dec)
|
|
8653
|
+
return $skip;
|
|
8596
8654
|
const ref = makeRef();
|
|
8597
8655
|
const { decl, bindings } = dec;
|
|
8598
8656
|
const binding = bindings[0];
|
|
@@ -8813,19 +8871,19 @@ ${input.slice(result.pos)}
|
|
|
8813
8871
|
function KeywordStatement(ctx, state) {
|
|
8814
8872
|
return $EVENT_C(ctx, state, "KeywordStatement", KeywordStatement$$);
|
|
8815
8873
|
}
|
|
8816
|
-
var Break$0 = $TS($S($EXPECT($
|
|
8874
|
+
var Break$0 = $TS($S($EXPECT($L102, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8817
8875
|
return { $loc, token: $1 };
|
|
8818
8876
|
});
|
|
8819
8877
|
function Break(ctx, state) {
|
|
8820
8878
|
return $EVENT(ctx, state, "Break", Break$0);
|
|
8821
8879
|
}
|
|
8822
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
8880
|
+
var Continue$0 = $TS($S($EXPECT($L103, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8823
8881
|
return { $loc, token: $1 };
|
|
8824
8882
|
});
|
|
8825
8883
|
function Continue(ctx, state) {
|
|
8826
8884
|
return $EVENT(ctx, state, "Continue", Continue$0);
|
|
8827
8885
|
}
|
|
8828
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
8886
|
+
var Debugger$0 = $TS($S($EXPECT($L104, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8829
8887
|
return { $loc, token: $1 };
|
|
8830
8888
|
});
|
|
8831
8889
|
function Debugger(ctx, state) {
|
|
@@ -8944,7 +9002,7 @@ ${input.slice(result.pos)}
|
|
|
8944
9002
|
function FromClause(ctx, state) {
|
|
8945
9003
|
return $EVENT(ctx, state, "FromClause", FromClause$0);
|
|
8946
9004
|
}
|
|
8947
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
9005
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L105, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
8948
9006
|
function ImportAssertion(ctx, state) {
|
|
8949
9007
|
return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
|
|
8950
9008
|
}
|
|
@@ -9163,13 +9221,13 @@ ${input.slice(result.pos)}
|
|
|
9163
9221
|
function LexicalDeclaration(ctx, state) {
|
|
9164
9222
|
return $EVENT_C(ctx, state, "LexicalDeclaration", LexicalDeclaration$$);
|
|
9165
9223
|
}
|
|
9166
|
-
var ConstAssignment$0 = $TV($C($EXPECT($
|
|
9224
|
+
var ConstAssignment$0 = $TV($C($EXPECT($L106, 'ConstAssignment ":="'), $EXPECT($L107, 'ConstAssignment "\u2254"')), function($skip, $loc, $0, $1) {
|
|
9167
9225
|
return { $loc, token: "=" };
|
|
9168
9226
|
});
|
|
9169
9227
|
function ConstAssignment(ctx, state) {
|
|
9170
9228
|
return $EVENT(ctx, state, "ConstAssignment", ConstAssignment$0);
|
|
9171
9229
|
}
|
|
9172
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
9230
|
+
var LetAssignment$0 = $TV($EXPECT($L108, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
9173
9231
|
return { $loc, token: "=" };
|
|
9174
9232
|
});
|
|
9175
9233
|
function LetAssignment(ctx, state) {
|
|
@@ -9364,7 +9422,7 @@ ${input.slice(result.pos)}
|
|
|
9364
9422
|
return $EVENT(ctx, state, "CoffeeDoubleQuotedStringCharacters", CoffeeDoubleQuotedStringCharacters$0);
|
|
9365
9423
|
}
|
|
9366
9424
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
9367
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
9425
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L55, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L55, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
9368
9426
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
9369
9427
|
});
|
|
9370
9428
|
var RegularExpressionLiteral$$ = [RegularExpressionLiteral$0, RegularExpressionLiteral$1];
|
|
@@ -9560,7 +9618,7 @@ ${input.slice(result.pos)}
|
|
|
9560
9618
|
function MultiLineComment(ctx, state) {
|
|
9561
9619
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
9562
9620
|
}
|
|
9563
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
9621
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L109, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L110, 'JSMultiLineComment "*/"')), $EXPECT($R42, "JSMultiLineComment /./"))), $EXPECT($L110, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
9564
9622
|
return { type: "Comment", $loc, token: $1 };
|
|
9565
9623
|
});
|
|
9566
9624
|
function JSMultiLineComment(ctx, state) {
|
|
@@ -9583,7 +9641,7 @@ ${input.slice(result.pos)}
|
|
|
9583
9641
|
function CoffeeHereCommentStart(ctx, state) {
|
|
9584
9642
|
return $EVENT(ctx, state, "CoffeeHereCommentStart", CoffeeHereCommentStart$0);
|
|
9585
9643
|
}
|
|
9586
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
9644
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L109, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L110, 'InlineComment "*/"')), $EXPECT($R46, "InlineComment /[^\\r\\n]/")))), $EXPECT($L110, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
9587
9645
|
return { $loc, token: $1 };
|
|
9588
9646
|
});
|
|
9589
9647
|
function InlineComment(ctx, state) {
|
|
@@ -9604,7 +9662,7 @@ ${input.slice(result.pos)}
|
|
|
9604
9662
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R47, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9605
9663
|
return { $loc, token: $0 };
|
|
9606
9664
|
});
|
|
9607
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
9665
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L111, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
9608
9666
|
return "";
|
|
9609
9667
|
});
|
|
9610
9668
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
@@ -9645,9 +9703,9 @@ ${input.slice(result.pos)}
|
|
|
9645
9703
|
return $EVENT_C(ctx, state, "SimpleStatementDelimiter", SimpleStatementDelimiter$$);
|
|
9646
9704
|
}
|
|
9647
9705
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
9648
|
-
var StatementDelimiter$1 = $S($Y($S(Nested, $C($EXPECT($L4, 'StatementDelimiter "("'), $EXPECT($
|
|
9706
|
+
var StatementDelimiter$1 = $S($Y($S(Nested, $C($EXPECT($L4, 'StatementDelimiter "("'), $EXPECT($L112, 'StatementDelimiter "["'), $EXPECT($L113, 'StatementDelimiter "`"'), $EXPECT($L58, 'StatementDelimiter "+"'), $EXPECT($L18, 'StatementDelimiter "-"'), $EXPECT($L54, 'StatementDelimiter "*"'), $EXPECT($L55, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, FatArrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L4, 'StatementDelimiter "("'))))), InsertSemicolon);
|
|
9649
9707
|
var StatementDelimiter$2 = $Y(EOS);
|
|
9650
|
-
var StatementDelimiter$3 = $Y($S($Q(_), $C($EXPECT($
|
|
9708
|
+
var StatementDelimiter$3 = $Y($S($Q(_), $C($EXPECT($L25, 'StatementDelimiter "}"'), $EXPECT($L114, 'StatementDelimiter ")"'), $EXPECT($L34, 'StatementDelimiter "]"'))));
|
|
9651
9709
|
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2, StatementDelimiter$3];
|
|
9652
9710
|
function StatementDelimiter(ctx, state) {
|
|
9653
9711
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
@@ -9671,97 +9729,97 @@ ${input.slice(result.pos)}
|
|
|
9671
9729
|
function Loc(ctx, state) {
|
|
9672
9730
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
9673
9731
|
}
|
|
9674
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
9732
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L115, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L11, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
9675
9733
|
return { $loc, token: $1, ts: true };
|
|
9676
9734
|
});
|
|
9677
9735
|
function Abstract(ctx, state) {
|
|
9678
9736
|
return $EVENT(ctx, state, "Abstract", Abstract$0);
|
|
9679
9737
|
}
|
|
9680
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
9738
|
+
var Ampersand$0 = $TV($EXPECT($L98, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
9681
9739
|
return { $loc, token: $1 };
|
|
9682
9740
|
});
|
|
9683
9741
|
function Ampersand(ctx, state) {
|
|
9684
9742
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
9685
9743
|
}
|
|
9686
|
-
var As$0 = $TS($S($EXPECT($
|
|
9744
|
+
var As$0 = $TS($S($EXPECT($L116, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9687
9745
|
return { $loc, token: $1 };
|
|
9688
9746
|
});
|
|
9689
9747
|
function As(ctx, state) {
|
|
9690
9748
|
return $EVENT(ctx, state, "As", As$0);
|
|
9691
9749
|
}
|
|
9692
|
-
var At$0 = $TV($EXPECT($
|
|
9750
|
+
var At$0 = $TV($EXPECT($L117, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
9693
9751
|
return { $loc, token: $1 };
|
|
9694
9752
|
});
|
|
9695
9753
|
function At(ctx, state) {
|
|
9696
9754
|
return $EVENT(ctx, state, "At", At$0);
|
|
9697
9755
|
}
|
|
9698
|
-
var AtAt$0 = $TV($EXPECT($
|
|
9756
|
+
var AtAt$0 = $TV($EXPECT($L118, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
9699
9757
|
return { $loc, token: "@" };
|
|
9700
9758
|
});
|
|
9701
9759
|
function AtAt(ctx, state) {
|
|
9702
9760
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
9703
9761
|
}
|
|
9704
|
-
var Async$0 = $TS($S($EXPECT($
|
|
9762
|
+
var Async$0 = $TS($S($EXPECT($L119, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9705
9763
|
return { $loc, token: $1, type: "Async" };
|
|
9706
9764
|
});
|
|
9707
9765
|
function Async(ctx, state) {
|
|
9708
9766
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
9709
9767
|
}
|
|
9710
|
-
var Await$0 = $TS($S($EXPECT($
|
|
9768
|
+
var Await$0 = $TS($S($EXPECT($L120, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9711
9769
|
return { $loc, token: $1, type: "Await" };
|
|
9712
9770
|
});
|
|
9713
9771
|
function Await(ctx, state) {
|
|
9714
9772
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
9715
9773
|
}
|
|
9716
|
-
var Backtick$0 = $TV($EXPECT($
|
|
9774
|
+
var Backtick$0 = $TV($EXPECT($L113, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
9717
9775
|
return { $loc, token: $1 };
|
|
9718
9776
|
});
|
|
9719
9777
|
function Backtick(ctx, state) {
|
|
9720
9778
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
9721
9779
|
}
|
|
9722
|
-
var By$0 = $TS($S($EXPECT($
|
|
9780
|
+
var By$0 = $TS($S($EXPECT($L121, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9723
9781
|
return { $loc, token: $1 };
|
|
9724
9782
|
});
|
|
9725
9783
|
function By(ctx, state) {
|
|
9726
9784
|
return $EVENT(ctx, state, "By", By$0);
|
|
9727
9785
|
}
|
|
9728
|
-
var Case$0 = $TS($S($EXPECT($
|
|
9786
|
+
var Case$0 = $TS($S($EXPECT($L122, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9729
9787
|
return { $loc, token: $1 };
|
|
9730
9788
|
});
|
|
9731
9789
|
function Case(ctx, state) {
|
|
9732
9790
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
9733
9791
|
}
|
|
9734
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
9792
|
+
var Catch$0 = $TS($S($EXPECT($L123, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9735
9793
|
return { $loc, token: $1 };
|
|
9736
9794
|
});
|
|
9737
9795
|
function Catch(ctx, state) {
|
|
9738
9796
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
9739
9797
|
}
|
|
9740
|
-
var Class$0 = $TS($S($EXPECT($
|
|
9798
|
+
var Class$0 = $TS($S($EXPECT($L124, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9741
9799
|
return { $loc, token: $1 };
|
|
9742
9800
|
});
|
|
9743
9801
|
function Class(ctx, state) {
|
|
9744
9802
|
return $EVENT(ctx, state, "Class", Class$0);
|
|
9745
9803
|
}
|
|
9746
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
9804
|
+
var CloseBrace$0 = $TV($EXPECT($L25, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
9747
9805
|
return { $loc, token: $1 };
|
|
9748
9806
|
});
|
|
9749
9807
|
function CloseBrace(ctx, state) {
|
|
9750
9808
|
return $EVENT(ctx, state, "CloseBrace", CloseBrace$0);
|
|
9751
9809
|
}
|
|
9752
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
9810
|
+
var CloseBracket$0 = $TV($EXPECT($L34, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
9753
9811
|
return { $loc, token: $1 };
|
|
9754
9812
|
});
|
|
9755
9813
|
function CloseBracket(ctx, state) {
|
|
9756
9814
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
9757
9815
|
}
|
|
9758
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
9816
|
+
var CloseParen$0 = $TV($EXPECT($L114, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
9759
9817
|
return { $loc, token: $1 };
|
|
9760
9818
|
});
|
|
9761
9819
|
function CloseParen(ctx, state) {
|
|
9762
9820
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
9763
9821
|
}
|
|
9764
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
9822
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L125, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
9765
9823
|
return { $loc, token: "${" };
|
|
9766
9824
|
});
|
|
9767
9825
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
@@ -9779,31 +9837,31 @@ ${input.slice(result.pos)}
|
|
|
9779
9837
|
function Comma(ctx, state) {
|
|
9780
9838
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
9781
9839
|
}
|
|
9782
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
9840
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L117, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
9783
9841
|
return { $loc, token: "constructor" };
|
|
9784
9842
|
});
|
|
9785
9843
|
function ConstructorShorthand(ctx, state) {
|
|
9786
9844
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
9787
9845
|
}
|
|
9788
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
9846
|
+
var Declare$0 = $TS($S($EXPECT($L126, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9789
9847
|
return { $loc, token: $1 };
|
|
9790
9848
|
});
|
|
9791
9849
|
function Declare(ctx, state) {
|
|
9792
9850
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
9793
9851
|
}
|
|
9794
|
-
var Default$0 = $TS($S($EXPECT($
|
|
9852
|
+
var Default$0 = $TS($S($EXPECT($L127, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9795
9853
|
return { $loc, token: $1 };
|
|
9796
9854
|
});
|
|
9797
9855
|
function Default(ctx, state) {
|
|
9798
9856
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
9799
9857
|
}
|
|
9800
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
9858
|
+
var Delete$0 = $TS($S($EXPECT($L128, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9801
9859
|
return { $loc, token: $1 };
|
|
9802
9860
|
});
|
|
9803
9861
|
function Delete(ctx, state) {
|
|
9804
9862
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
9805
9863
|
}
|
|
9806
|
-
var Do$0 = $TS($S($EXPECT($
|
|
9864
|
+
var Do$0 = $TS($S($EXPECT($L129, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9807
9865
|
return { $loc, token: $1 };
|
|
9808
9866
|
});
|
|
9809
9867
|
function Do(ctx, state) {
|
|
@@ -9823,45 +9881,45 @@ ${input.slice(result.pos)}
|
|
|
9823
9881
|
function Dot(ctx, state) {
|
|
9824
9882
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
9825
9883
|
}
|
|
9826
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
9884
|
+
var DotDot$0 = $TS($S($EXPECT($L130, 'DotDot ".."'), $N($EXPECT($L6, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
9827
9885
|
return { $loc, token: $1 };
|
|
9828
9886
|
});
|
|
9829
|
-
var DotDot$1 = $TV($EXPECT($
|
|
9887
|
+
var DotDot$1 = $TV($EXPECT($L131, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
9830
9888
|
return { $loc, token: ".." };
|
|
9831
9889
|
});
|
|
9832
9890
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
9833
9891
|
function DotDot(ctx, state) {
|
|
9834
9892
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
9835
9893
|
}
|
|
9836
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
9894
|
+
var DotDotDot$0 = $TV($EXPECT($L132, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
9837
9895
|
return { $loc, token: $1 };
|
|
9838
9896
|
});
|
|
9839
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
9897
|
+
var DotDotDot$1 = $TV($EXPECT($L133, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
9840
9898
|
return { $loc, token: "..." };
|
|
9841
9899
|
});
|
|
9842
9900
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
9843
9901
|
function DotDotDot(ctx, state) {
|
|
9844
9902
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
9845
9903
|
}
|
|
9846
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
9904
|
+
var DoubleColon$0 = $TV($EXPECT($L134, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
9847
9905
|
return { $loc, token: $1 };
|
|
9848
9906
|
});
|
|
9849
9907
|
function DoubleColon(ctx, state) {
|
|
9850
9908
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
9851
9909
|
}
|
|
9852
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
9910
|
+
var DoubleQuote$0 = $TV($EXPECT($L135, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
9853
9911
|
return { $loc, token: $1 };
|
|
9854
9912
|
});
|
|
9855
9913
|
function DoubleQuote(ctx, state) {
|
|
9856
9914
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
9857
9915
|
}
|
|
9858
|
-
var Each$0 = $TS($S($EXPECT($
|
|
9916
|
+
var Each$0 = $TS($S($EXPECT($L136, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9859
9917
|
return { $loc, token: $1 };
|
|
9860
9918
|
});
|
|
9861
9919
|
function Each(ctx, state) {
|
|
9862
9920
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
9863
9921
|
}
|
|
9864
|
-
var Else$0 = $TS($S($EXPECT($
|
|
9922
|
+
var Else$0 = $TS($S($EXPECT($L137, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9865
9923
|
return { $loc, token: $1 };
|
|
9866
9924
|
});
|
|
9867
9925
|
function Else(ctx, state) {
|
|
@@ -9873,55 +9931,55 @@ ${input.slice(result.pos)}
|
|
|
9873
9931
|
function Equals(ctx, state) {
|
|
9874
9932
|
return $EVENT(ctx, state, "Equals", Equals$0);
|
|
9875
9933
|
}
|
|
9876
|
-
var Export$0 = $TS($S($EXPECT($
|
|
9934
|
+
var Export$0 = $TS($S($EXPECT($L138, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9877
9935
|
return { $loc, token: $1 };
|
|
9878
9936
|
});
|
|
9879
9937
|
function Export(ctx, state) {
|
|
9880
9938
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
9881
9939
|
}
|
|
9882
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
9940
|
+
var Extends$0 = $TS($S($EXPECT($L139, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9883
9941
|
return { $loc, token: $1 };
|
|
9884
9942
|
});
|
|
9885
9943
|
function Extends(ctx, state) {
|
|
9886
9944
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
9887
9945
|
}
|
|
9888
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
9946
|
+
var Finally$0 = $TS($S($EXPECT($L140, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9889
9947
|
return { $loc, token: $1 };
|
|
9890
9948
|
});
|
|
9891
9949
|
function Finally(ctx, state) {
|
|
9892
9950
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
9893
9951
|
}
|
|
9894
|
-
var For$0 = $TS($S($EXPECT($
|
|
9952
|
+
var For$0 = $TS($S($EXPECT($L141, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9895
9953
|
return { $loc, token: $1 };
|
|
9896
9954
|
});
|
|
9897
9955
|
function For(ctx, state) {
|
|
9898
9956
|
return $EVENT(ctx, state, "For", For$0);
|
|
9899
9957
|
}
|
|
9900
|
-
var From$0 = $TS($S($EXPECT($
|
|
9958
|
+
var From$0 = $TS($S($EXPECT($L142, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9901
9959
|
return { $loc, token: $1 };
|
|
9902
9960
|
});
|
|
9903
9961
|
function From(ctx, state) {
|
|
9904
9962
|
return $EVENT(ctx, state, "From", From$0);
|
|
9905
9963
|
}
|
|
9906
|
-
var Function$0 = $TS($S($EXPECT($
|
|
9964
|
+
var Function$0 = $TS($S($EXPECT($L143, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9907
9965
|
return { $loc, token: $1 };
|
|
9908
9966
|
});
|
|
9909
9967
|
function Function(ctx, state) {
|
|
9910
9968
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
9911
9969
|
}
|
|
9912
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
9970
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L144, 'GetOrSet "get"'), $EXPECT($L145, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9913
9971
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
9914
9972
|
});
|
|
9915
9973
|
function GetOrSet(ctx, state) {
|
|
9916
9974
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
9917
9975
|
}
|
|
9918
|
-
var Hash$0 = $TV($EXPECT($
|
|
9976
|
+
var Hash$0 = $TV($EXPECT($L146, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
9919
9977
|
return { $loc, token: $1 };
|
|
9920
9978
|
});
|
|
9921
9979
|
function Hash(ctx, state) {
|
|
9922
9980
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
9923
9981
|
}
|
|
9924
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
9982
|
+
var If$0 = $TV($TEXT($S($EXPECT($L147, 'If "if"'), NonIdContinue, $E($EXPECT($L11, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
9925
9983
|
return { $loc, token: $1 };
|
|
9926
9984
|
});
|
|
9927
9985
|
function If(ctx, state) {
|
|
@@ -9933,25 +9991,25 @@ ${input.slice(result.pos)}
|
|
|
9933
9991
|
function Import(ctx, state) {
|
|
9934
9992
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
9935
9993
|
}
|
|
9936
|
-
var In$0 = $TS($S($EXPECT($
|
|
9994
|
+
var In$0 = $TS($S($EXPECT($L148, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9937
9995
|
return { $loc, token: $1 };
|
|
9938
9996
|
});
|
|
9939
9997
|
function In(ctx, state) {
|
|
9940
9998
|
return $EVENT(ctx, state, "In", In$0);
|
|
9941
9999
|
}
|
|
9942
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
10000
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L149, 'LetOrConst "let"'), $EXPECT($L150, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9943
10001
|
return { $loc, token: $1 };
|
|
9944
10002
|
});
|
|
9945
10003
|
function LetOrConst(ctx, state) {
|
|
9946
10004
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
9947
10005
|
}
|
|
9948
|
-
var Const$0 = $TS($S($EXPECT($
|
|
10006
|
+
var Const$0 = $TS($S($EXPECT($L150, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9949
10007
|
return { $loc, token: $1 };
|
|
9950
10008
|
});
|
|
9951
10009
|
function Const(ctx, state) {
|
|
9952
10010
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
9953
10011
|
}
|
|
9954
|
-
var Is$0 = $TS($S($EXPECT($
|
|
10012
|
+
var Is$0 = $TS($S($EXPECT($L151, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9955
10013
|
return { $loc, token: $1 };
|
|
9956
10014
|
});
|
|
9957
10015
|
function Is(ctx, state) {
|
|
@@ -9963,31 +10021,31 @@ ${input.slice(result.pos)}
|
|
|
9963
10021
|
function LetOrConstOrVar(ctx, state) {
|
|
9964
10022
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
9965
10023
|
}
|
|
9966
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
10024
|
+
var Loop$0 = $TS($S($EXPECT($L152, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9967
10025
|
return { $loc, token: "while(true)" };
|
|
9968
10026
|
});
|
|
9969
10027
|
function Loop(ctx, state) {
|
|
9970
10028
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
9971
10029
|
}
|
|
9972
|
-
var New$0 = $TS($S($EXPECT($
|
|
10030
|
+
var New$0 = $TS($S($EXPECT($L153, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9973
10031
|
return { $loc, token: $1 };
|
|
9974
10032
|
});
|
|
9975
10033
|
function New(ctx, state) {
|
|
9976
10034
|
return $EVENT(ctx, state, "New", New$0);
|
|
9977
10035
|
}
|
|
9978
|
-
var Not$0 = $TS($S($EXPECT($
|
|
10036
|
+
var Not$0 = $TS($S($EXPECT($L154, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L12, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
9979
10037
|
return { $loc, token: "!" };
|
|
9980
10038
|
});
|
|
9981
10039
|
function Not(ctx, state) {
|
|
9982
10040
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
9983
10041
|
}
|
|
9984
|
-
var Of$0 = $TS($S($EXPECT($
|
|
10042
|
+
var Of$0 = $TS($S($EXPECT($L84, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9985
10043
|
return { $loc, token: $1 };
|
|
9986
10044
|
});
|
|
9987
10045
|
function Of(ctx, state) {
|
|
9988
10046
|
return $EVENT(ctx, state, "Of", Of$0);
|
|
9989
10047
|
}
|
|
9990
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
10048
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L155, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
9991
10049
|
return { $loc, token: $1 };
|
|
9992
10050
|
});
|
|
9993
10051
|
function OpenAngleBracket(ctx, state) {
|
|
@@ -9999,7 +10057,7 @@ ${input.slice(result.pos)}
|
|
|
9999
10057
|
function OpenBrace(ctx, state) {
|
|
10000
10058
|
return $EVENT(ctx, state, "OpenBrace", OpenBrace$0);
|
|
10001
10059
|
}
|
|
10002
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
10060
|
+
var OpenBracket$0 = $TV($EXPECT($L112, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
10003
10061
|
return { $loc, token: $1 };
|
|
10004
10062
|
});
|
|
10005
10063
|
function OpenBracket(ctx, state) {
|
|
@@ -10011,43 +10069,43 @@ ${input.slice(result.pos)}
|
|
|
10011
10069
|
function OpenParen(ctx, state) {
|
|
10012
10070
|
return $EVENT(ctx, state, "OpenParen", OpenParen$0);
|
|
10013
10071
|
}
|
|
10014
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
10072
|
+
var Operator$0 = $TS($S($EXPECT($L156, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10015
10073
|
return { $loc, token: $1 };
|
|
10016
10074
|
});
|
|
10017
10075
|
function Operator(ctx, state) {
|
|
10018
10076
|
return $EVENT(ctx, state, "Operator", Operator$0);
|
|
10019
10077
|
}
|
|
10020
|
-
var Own$0 = $TS($S($EXPECT($
|
|
10078
|
+
var Own$0 = $TS($S($EXPECT($L157, 'Own "own"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10021
10079
|
return { $loc, token: $1 };
|
|
10022
10080
|
});
|
|
10023
10081
|
function Own(ctx, state) {
|
|
10024
10082
|
return $EVENT(ctx, state, "Own", Own$0);
|
|
10025
10083
|
}
|
|
10026
|
-
var Public$0 = $TS($S($EXPECT($
|
|
10084
|
+
var Public$0 = $TS($S($EXPECT($L158, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10027
10085
|
return { $loc, token: $1 };
|
|
10028
10086
|
});
|
|
10029
10087
|
function Public(ctx, state) {
|
|
10030
10088
|
return $EVENT(ctx, state, "Public", Public$0);
|
|
10031
10089
|
}
|
|
10032
|
-
var Private$0 = $TS($S($EXPECT($
|
|
10090
|
+
var Private$0 = $TS($S($EXPECT($L159, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10033
10091
|
return { $loc, token: $1 };
|
|
10034
10092
|
});
|
|
10035
10093
|
function Private(ctx, state) {
|
|
10036
10094
|
return $EVENT(ctx, state, "Private", Private$0);
|
|
10037
10095
|
}
|
|
10038
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
10096
|
+
var Protected$0 = $TS($S($EXPECT($L160, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10039
10097
|
return { $loc, token: $1 };
|
|
10040
10098
|
});
|
|
10041
10099
|
function Protected(ctx, state) {
|
|
10042
10100
|
return $EVENT(ctx, state, "Protected", Protected$0);
|
|
10043
10101
|
}
|
|
10044
|
-
var Pipe$0 = $TV($C($EXPECT($
|
|
10102
|
+
var Pipe$0 = $TV($C($EXPECT($L161, 'Pipe "||>"'), $EXPECT($L162, 'Pipe "|\u25B7"')), function($skip, $loc, $0, $1) {
|
|
10045
10103
|
return { $loc, token: "||>" };
|
|
10046
10104
|
});
|
|
10047
|
-
var Pipe$1 = $TV($C($EXPECT($
|
|
10105
|
+
var Pipe$1 = $TV($C($EXPECT($L163, 'Pipe "|>="'), $EXPECT($L164, 'Pipe "\u25B7="')), function($skip, $loc, $0, $1) {
|
|
10048
10106
|
return { $loc, token: "|>=" };
|
|
10049
10107
|
});
|
|
10050
|
-
var Pipe$2 = $TV($C($EXPECT($
|
|
10108
|
+
var Pipe$2 = $TV($C($EXPECT($L165, 'Pipe "|>"'), $EXPECT($L166, 'Pipe "\u25B7"')), function($skip, $loc, $0, $1) {
|
|
10051
10109
|
return { $loc, token: "|>" };
|
|
10052
10110
|
});
|
|
10053
10111
|
var Pipe$$ = [Pipe$0, Pipe$1, Pipe$2];
|
|
@@ -10060,167 +10118,167 @@ ${input.slice(result.pos)}
|
|
|
10060
10118
|
function QuestionMark(ctx, state) {
|
|
10061
10119
|
return $EVENT(ctx, state, "QuestionMark", QuestionMark$0);
|
|
10062
10120
|
}
|
|
10063
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
10121
|
+
var Readonly$0 = $TS($S($EXPECT($L167, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10064
10122
|
return { $loc, token: $1, ts: true };
|
|
10065
10123
|
});
|
|
10066
10124
|
function Readonly(ctx, state) {
|
|
10067
10125
|
return $EVENT(ctx, state, "Readonly", Readonly$0);
|
|
10068
10126
|
}
|
|
10069
|
-
var Return$0 = $TS($S($EXPECT($
|
|
10127
|
+
var Return$0 = $TS($S($EXPECT($L168, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10070
10128
|
return { $loc, token: $1 };
|
|
10071
10129
|
});
|
|
10072
10130
|
function Return(ctx, state) {
|
|
10073
10131
|
return $EVENT(ctx, state, "Return", Return$0);
|
|
10074
10132
|
}
|
|
10075
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
10133
|
+
var Satisfies$0 = $TS($S($EXPECT($L169, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10076
10134
|
return { $loc, token: $1 };
|
|
10077
10135
|
});
|
|
10078
10136
|
function Satisfies(ctx, state) {
|
|
10079
10137
|
return $EVENT(ctx, state, "Satisfies", Satisfies$0);
|
|
10080
10138
|
}
|
|
10081
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
10139
|
+
var Semicolon$0 = $TV($EXPECT($L100, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
10082
10140
|
return { $loc, token: $1 };
|
|
10083
10141
|
});
|
|
10084
10142
|
function Semicolon(ctx, state) {
|
|
10085
10143
|
return $EVENT(ctx, state, "Semicolon", Semicolon$0);
|
|
10086
10144
|
}
|
|
10087
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
10145
|
+
var SingleQuote$0 = $TV($EXPECT($L170, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
10088
10146
|
return { $loc, token: $1 };
|
|
10089
10147
|
});
|
|
10090
10148
|
function SingleQuote(ctx, state) {
|
|
10091
10149
|
return $EVENT(ctx, state, "SingleQuote", SingleQuote$0);
|
|
10092
10150
|
}
|
|
10093
|
-
var Star$0 = $TV($EXPECT($
|
|
10151
|
+
var Star$0 = $TV($EXPECT($L54, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
10094
10152
|
return { $loc, token: $1 };
|
|
10095
10153
|
});
|
|
10096
10154
|
function Star(ctx, state) {
|
|
10097
10155
|
return $EVENT(ctx, state, "Star", Star$0);
|
|
10098
10156
|
}
|
|
10099
|
-
var Static$0 = $TS($S($EXPECT($
|
|
10157
|
+
var Static$0 = $TS($S($EXPECT($L171, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10100
10158
|
return { $loc, token: $1 };
|
|
10101
10159
|
});
|
|
10102
|
-
var Static$1 = $TS($S($EXPECT($
|
|
10160
|
+
var Static$1 = $TS($S($EXPECT($L117, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L117, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
10103
10161
|
return { $loc, token: "static " };
|
|
10104
10162
|
});
|
|
10105
10163
|
var Static$$ = [Static$0, Static$1];
|
|
10106
10164
|
function Static(ctx, state) {
|
|
10107
10165
|
return $EVENT_C(ctx, state, "Static", Static$$);
|
|
10108
10166
|
}
|
|
10109
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
10167
|
+
var SubstitutionStart$0 = $TV($EXPECT($L172, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
10110
10168
|
return { $loc, token: $1 };
|
|
10111
10169
|
});
|
|
10112
10170
|
function SubstitutionStart(ctx, state) {
|
|
10113
10171
|
return $EVENT(ctx, state, "SubstitutionStart", SubstitutionStart$0);
|
|
10114
10172
|
}
|
|
10115
|
-
var Super$0 = $TS($S($EXPECT($
|
|
10173
|
+
var Super$0 = $TS($S($EXPECT($L173, 'Super "super"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10116
10174
|
return { $loc, token: $1 };
|
|
10117
10175
|
});
|
|
10118
10176
|
function Super(ctx, state) {
|
|
10119
10177
|
return $EVENT(ctx, state, "Super", Super$0);
|
|
10120
10178
|
}
|
|
10121
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
10179
|
+
var Switch$0 = $TS($S($EXPECT($L174, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10122
10180
|
return { $loc, token: $1 };
|
|
10123
10181
|
});
|
|
10124
10182
|
function Switch(ctx, state) {
|
|
10125
10183
|
return $EVENT(ctx, state, "Switch", Switch$0);
|
|
10126
10184
|
}
|
|
10127
|
-
var Target$0 = $TS($S($EXPECT($
|
|
10185
|
+
var Target$0 = $TS($S($EXPECT($L175, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10128
10186
|
return { $loc, token: $1 };
|
|
10129
10187
|
});
|
|
10130
10188
|
function Target(ctx, state) {
|
|
10131
10189
|
return $EVENT(ctx, state, "Target", Target$0);
|
|
10132
10190
|
}
|
|
10133
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
10191
|
+
var Then$0 = $TS($S(__, $EXPECT($L176, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
10134
10192
|
return { $loc, token: "" };
|
|
10135
10193
|
});
|
|
10136
10194
|
function Then(ctx, state) {
|
|
10137
10195
|
return $EVENT(ctx, state, "Then", Then$0);
|
|
10138
10196
|
}
|
|
10139
|
-
var This$0 = $TS($S($EXPECT($
|
|
10197
|
+
var This$0 = $TS($S($EXPECT($L177, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10140
10198
|
return { $loc, token: $1 };
|
|
10141
10199
|
});
|
|
10142
10200
|
function This(ctx, state) {
|
|
10143
10201
|
return $EVENT(ctx, state, "This", This$0);
|
|
10144
10202
|
}
|
|
10145
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
10203
|
+
var Throw$0 = $TS($S($EXPECT($L178, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10146
10204
|
return { $loc, token: $1 };
|
|
10147
10205
|
});
|
|
10148
10206
|
function Throw(ctx, state) {
|
|
10149
10207
|
return $EVENT(ctx, state, "Throw", Throw$0);
|
|
10150
10208
|
}
|
|
10151
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
10209
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L179, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
10152
10210
|
return { $loc, token: "`" };
|
|
10153
10211
|
});
|
|
10154
10212
|
function TripleDoubleQuote(ctx, state) {
|
|
10155
10213
|
return $EVENT(ctx, state, "TripleDoubleQuote", TripleDoubleQuote$0);
|
|
10156
10214
|
}
|
|
10157
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
10215
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L180, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
10158
10216
|
return { $loc, token: "`" };
|
|
10159
10217
|
});
|
|
10160
10218
|
function TripleSingleQuote(ctx, state) {
|
|
10161
10219
|
return $EVENT(ctx, state, "TripleSingleQuote", TripleSingleQuote$0);
|
|
10162
10220
|
}
|
|
10163
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
10221
|
+
var TripleSlash$0 = $TV($EXPECT($L181, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
10164
10222
|
return { $loc, token: "/" };
|
|
10165
10223
|
});
|
|
10166
10224
|
function TripleSlash(ctx, state) {
|
|
10167
10225
|
return $EVENT(ctx, state, "TripleSlash", TripleSlash$0);
|
|
10168
10226
|
}
|
|
10169
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
10227
|
+
var TripleTick$0 = $TV($EXPECT($L182, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
10170
10228
|
return { $loc, token: "`" };
|
|
10171
10229
|
});
|
|
10172
10230
|
function TripleTick(ctx, state) {
|
|
10173
10231
|
return $EVENT(ctx, state, "TripleTick", TripleTick$0);
|
|
10174
10232
|
}
|
|
10175
|
-
var Try$0 = $TS($S($EXPECT($
|
|
10233
|
+
var Try$0 = $TS($S($EXPECT($L183, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10176
10234
|
return { $loc, token: $1 };
|
|
10177
10235
|
});
|
|
10178
10236
|
function Try(ctx, state) {
|
|
10179
10237
|
return $EVENT(ctx, state, "Try", Try$0);
|
|
10180
10238
|
}
|
|
10181
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
10239
|
+
var Typeof$0 = $TS($S($EXPECT($L184, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10182
10240
|
return { $loc, token: $1 };
|
|
10183
10241
|
});
|
|
10184
10242
|
function Typeof(ctx, state) {
|
|
10185
10243
|
return $EVENT(ctx, state, "Typeof", Typeof$0);
|
|
10186
10244
|
}
|
|
10187
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
10245
|
+
var Unless$0 = $TS($S($EXPECT($L185, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10188
10246
|
return { $loc, token: $1 };
|
|
10189
10247
|
});
|
|
10190
10248
|
function Unless(ctx, state) {
|
|
10191
10249
|
return $EVENT(ctx, state, "Unless", Unless$0);
|
|
10192
10250
|
}
|
|
10193
|
-
var Until$0 = $TS($S($EXPECT($
|
|
10251
|
+
var Until$0 = $TS($S($EXPECT($L186, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10194
10252
|
return { $loc, token: $1 };
|
|
10195
10253
|
});
|
|
10196
10254
|
function Until(ctx, state) {
|
|
10197
10255
|
return $EVENT(ctx, state, "Until", Until$0);
|
|
10198
10256
|
}
|
|
10199
|
-
var Var$0 = $TS($S($EXPECT($
|
|
10257
|
+
var Var$0 = $TS($S($EXPECT($L187, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10200
10258
|
return { $loc, token: $1 };
|
|
10201
10259
|
});
|
|
10202
10260
|
function Var(ctx, state) {
|
|
10203
10261
|
return $EVENT(ctx, state, "Var", Var$0);
|
|
10204
10262
|
}
|
|
10205
|
-
var Void$0 = $TS($S($EXPECT($
|
|
10263
|
+
var Void$0 = $TS($S($EXPECT($L188, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10206
10264
|
return { $loc, token: $1 };
|
|
10207
10265
|
});
|
|
10208
10266
|
function Void(ctx, state) {
|
|
10209
10267
|
return $EVENT(ctx, state, "Void", Void$0);
|
|
10210
10268
|
}
|
|
10211
|
-
var When$0 = $TS($S($EXPECT($
|
|
10269
|
+
var When$0 = $TS($S($EXPECT($L189, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10212
10270
|
return { $loc, token: "case" };
|
|
10213
10271
|
});
|
|
10214
10272
|
function When(ctx, state) {
|
|
10215
10273
|
return $EVENT(ctx, state, "When", When$0);
|
|
10216
10274
|
}
|
|
10217
|
-
var While$0 = $TS($S($EXPECT($
|
|
10275
|
+
var While$0 = $TS($S($EXPECT($L190, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10218
10276
|
return { $loc, token: $1 };
|
|
10219
10277
|
});
|
|
10220
10278
|
function While(ctx, state) {
|
|
10221
10279
|
return $EVENT(ctx, state, "While", While$0);
|
|
10222
10280
|
}
|
|
10223
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
10281
|
+
var Yield$0 = $TS($S($EXPECT($L191, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10224
10282
|
return { $loc, token: $1, type: "Yield" };
|
|
10225
10283
|
});
|
|
10226
10284
|
function Yield(ctx, state) {
|
|
@@ -10291,7 +10349,7 @@ ${input.slice(result.pos)}
|
|
|
10291
10349
|
function JSXElement(ctx, state) {
|
|
10292
10350
|
return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
|
|
10293
10351
|
}
|
|
10294
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
10352
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L155, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L192, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
10295
10353
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
10296
10354
|
});
|
|
10297
10355
|
function JSXSelfClosingElement(ctx, state) {
|
|
@@ -10310,7 +10368,7 @@ ${input.slice(result.pos)}
|
|
|
10310
10368
|
function PopJSXStack(ctx, state) {
|
|
10311
10369
|
return $EVENT(ctx, state, "PopJSXStack", PopJSXStack$0);
|
|
10312
10370
|
}
|
|
10313
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
10371
|
+
var JSXOpeningElement$0 = $S($EXPECT($L155, 'JSXOpeningElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L33, 'JSXOpeningElement ">"'));
|
|
10314
10372
|
function JSXOpeningElement(ctx, state) {
|
|
10315
10373
|
return $EVENT(ctx, state, "JSXOpeningElement", JSXOpeningElement$0);
|
|
10316
10374
|
}
|
|
@@ -10325,7 +10383,7 @@ ${input.slice(result.pos)}
|
|
|
10325
10383
|
function JSXOptionalClosingElement(ctx, state) {
|
|
10326
10384
|
return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
|
|
10327
10385
|
}
|
|
10328
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
10386
|
+
var JSXClosingElement$0 = $S($EXPECT($L193, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L33, 'JSXClosingElement ">"'));
|
|
10329
10387
|
function JSXClosingElement(ctx, state) {
|
|
10330
10388
|
return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
|
|
10331
10389
|
}
|
|
@@ -10344,7 +10402,7 @@ ${input.slice(result.pos)}
|
|
|
10344
10402
|
];
|
|
10345
10403
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
10346
10404
|
});
|
|
10347
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
10405
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L194, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
10348
10406
|
var children = $3;
|
|
10349
10407
|
$0 = $0.slice(1);
|
|
10350
10408
|
return {
|
|
@@ -10357,7 +10415,7 @@ ${input.slice(result.pos)}
|
|
|
10357
10415
|
function JSXFragment(ctx, state) {
|
|
10358
10416
|
return $EVENT_C(ctx, state, "JSXFragment", JSXFragment$$);
|
|
10359
10417
|
}
|
|
10360
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
10418
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L194, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
10361
10419
|
module.JSXTagStack.push("");
|
|
10362
10420
|
return $1;
|
|
10363
10421
|
});
|
|
@@ -10374,11 +10432,11 @@ ${input.slice(result.pos)}
|
|
|
10374
10432
|
function JSXOptionalClosingFragment(ctx, state) {
|
|
10375
10433
|
return $EVENT_C(ctx, state, "JSXOptionalClosingFragment", JSXOptionalClosingFragment$$);
|
|
10376
10434
|
}
|
|
10377
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
10435
|
+
var JSXClosingFragment$0 = $EXPECT($L195, 'JSXClosingFragment "</>"');
|
|
10378
10436
|
function JSXClosingFragment(ctx, state) {
|
|
10379
10437
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
10380
10438
|
}
|
|
10381
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
10439
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L146, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
10382
10440
|
return module.config.defaultElement;
|
|
10383
10441
|
});
|
|
10384
10442
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -10550,7 +10608,7 @@ ${input.slice(result.pos)}
|
|
|
10550
10608
|
}
|
|
10551
10609
|
return $skip;
|
|
10552
10610
|
});
|
|
10553
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
10611
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L146, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
10554
10612
|
return [" ", "id=", $2];
|
|
10555
10613
|
});
|
|
10556
10614
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -10788,7 +10846,7 @@ ${input.slice(result.pos)}
|
|
|
10788
10846
|
}
|
|
10789
10847
|
return $skip;
|
|
10790
10848
|
});
|
|
10791
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
10849
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L25, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
10792
10850
|
return { children: [], jsxChildren: [] };
|
|
10793
10851
|
});
|
|
10794
10852
|
var JSXNestedChildren$$ = [JSXNestedChildren$0, JSXNestedChildren$1];
|
|
@@ -10843,7 +10901,7 @@ ${input.slice(result.pos)}
|
|
|
10843
10901
|
function JSXChild(ctx, state) {
|
|
10844
10902
|
return $EVENT_C(ctx, state, "JSXChild", JSXChild$$);
|
|
10845
10903
|
}
|
|
10846
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
10904
|
+
var JSXComment$0 = $TS($S($EXPECT($L196, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L197, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
10847
10905
|
return ["{/*", $2, "*/}"];
|
|
10848
10906
|
});
|
|
10849
10907
|
function JSXComment(ctx, state) {
|
|
@@ -10929,37 +10987,37 @@ ${input.slice(result.pos)}
|
|
|
10929
10987
|
function InterfaceExtendsTarget(ctx, state) {
|
|
10930
10988
|
return $EVENT(ctx, state, "InterfaceExtendsTarget", InterfaceExtendsTarget$0);
|
|
10931
10989
|
}
|
|
10932
|
-
var TypeKeyword$0 = $TS($S($EXPECT($
|
|
10990
|
+
var TypeKeyword$0 = $TS($S($EXPECT($L198, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10933
10991
|
return { $loc, token: $1 };
|
|
10934
10992
|
});
|
|
10935
10993
|
function TypeKeyword(ctx, state) {
|
|
10936
10994
|
return $EVENT(ctx, state, "TypeKeyword", TypeKeyword$0);
|
|
10937
10995
|
}
|
|
10938
|
-
var Enum$0 = $TS($S($EXPECT($
|
|
10996
|
+
var Enum$0 = $TS($S($EXPECT($L199, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10939
10997
|
return { $loc, token: $1 };
|
|
10940
10998
|
});
|
|
10941
10999
|
function Enum(ctx, state) {
|
|
10942
11000
|
return $EVENT(ctx, state, "Enum", Enum$0);
|
|
10943
11001
|
}
|
|
10944
|
-
var Interface$0 = $TS($S($EXPECT($
|
|
11002
|
+
var Interface$0 = $TS($S($EXPECT($L200, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10945
11003
|
return { $loc, token: $1 };
|
|
10946
11004
|
});
|
|
10947
11005
|
function Interface(ctx, state) {
|
|
10948
11006
|
return $EVENT(ctx, state, "Interface", Interface$0);
|
|
10949
11007
|
}
|
|
10950
|
-
var Global$0 = $TS($S($EXPECT($
|
|
11008
|
+
var Global$0 = $TS($S($EXPECT($L201, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10951
11009
|
return { $loc, token: $1 };
|
|
10952
11010
|
});
|
|
10953
11011
|
function Global(ctx, state) {
|
|
10954
11012
|
return $EVENT(ctx, state, "Global", Global$0);
|
|
10955
11013
|
}
|
|
10956
|
-
var Module$0 = $TS($S($EXPECT($
|
|
11014
|
+
var Module$0 = $TS($S($EXPECT($L202, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10957
11015
|
return { $loc, token: $1 };
|
|
10958
11016
|
});
|
|
10959
11017
|
function Module(ctx, state) {
|
|
10960
11018
|
return $EVENT(ctx, state, "Module", Module$0);
|
|
10961
11019
|
}
|
|
10962
|
-
var Namespace$0 = $TS($S($EXPECT($
|
|
11020
|
+
var Namespace$0 = $TS($S($EXPECT($L203, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10963
11021
|
return { $loc, token: $1 };
|
|
10964
11022
|
});
|
|
10965
11023
|
function Namespace(ctx, state) {
|
|
@@ -11204,7 +11262,7 @@ ${input.slice(result.pos)}
|
|
|
11204
11262
|
function ReturnTypeSuffix(ctx, state) {
|
|
11205
11263
|
return $EVENT(ctx, state, "ReturnTypeSuffix", ReturnTypeSuffix$0);
|
|
11206
11264
|
}
|
|
11207
|
-
var ReturnType$0 = $TS($S($E($S(__, $EXPECT($
|
|
11265
|
+
var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L204, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
|
|
11208
11266
|
var asserts = $1;
|
|
11209
11267
|
var t = $2;
|
|
11210
11268
|
if (asserts) {
|
|
@@ -11225,7 +11283,7 @@ ${input.slice(result.pos)}
|
|
|
11225
11283
|
function ReturnType(ctx, state) {
|
|
11226
11284
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
11227
11285
|
}
|
|
11228
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
11286
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L151, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
11229
11287
|
var lhs = $1;
|
|
11230
11288
|
var rhs = $2;
|
|
11231
11289
|
if (!rhs)
|
|
@@ -11273,10 +11331,10 @@ ${input.slice(result.pos)}
|
|
|
11273
11331
|
function TypeUnarySuffix(ctx, state) {
|
|
11274
11332
|
return $EVENT_C(ctx, state, "TypeUnarySuffix", TypeUnarySuffix$$);
|
|
11275
11333
|
}
|
|
11276
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
11277
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
11278
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
11279
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
11334
|
+
var TypeUnaryOp$0 = $S($EXPECT($L205, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
11335
|
+
var TypeUnaryOp$1 = $S($EXPECT($L184, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
11336
|
+
var TypeUnaryOp$2 = $S($EXPECT($L206, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
11337
|
+
var TypeUnaryOp$3 = $S($EXPECT($L167, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
11280
11338
|
var TypeUnaryOp$$ = [TypeUnaryOp$0, TypeUnaryOp$1, TypeUnaryOp$2, TypeUnaryOp$3];
|
|
11281
11339
|
function TypeUnaryOp(ctx, state) {
|
|
11282
11340
|
return $EVENT_C(ctx, state, "TypeUnaryOp", TypeUnaryOp$$);
|
|
@@ -11285,7 +11343,7 @@ ${input.slice(result.pos)}
|
|
|
11285
11343
|
function TypeIndexedAccess(ctx, state) {
|
|
11286
11344
|
return $EVENT(ctx, state, "TypeIndexedAccess", TypeIndexedAccess$0);
|
|
11287
11345
|
}
|
|
11288
|
-
var UnknownAlias$0 = $TV($EXPECT($
|
|
11346
|
+
var UnknownAlias$0 = $TV($EXPECT($L207, 'UnknownAlias "???"'), function($skip, $loc, $0, $1) {
|
|
11289
11347
|
return { $loc, token: "unknown" };
|
|
11290
11348
|
});
|
|
11291
11349
|
function UnknownAlias(ctx, state) {
|
|
@@ -11387,7 +11445,7 @@ ${input.slice(result.pos)}
|
|
|
11387
11445
|
function NestedType(ctx, state) {
|
|
11388
11446
|
return $EVENT(ctx, state, "NestedType", NestedType$0);
|
|
11389
11447
|
}
|
|
11390
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
11448
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L139, 'TypeConditional "extends"'), NonIdContinue, Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
11391
11449
|
if ($2)
|
|
11392
11450
|
return $0;
|
|
11393
11451
|
return $1;
|
|
@@ -11425,10 +11483,10 @@ ${input.slice(result.pos)}
|
|
|
11425
11483
|
}
|
|
11426
11484
|
var TypeLiteral$0 = TypeTemplateLiteral;
|
|
11427
11485
|
var TypeLiteral$1 = Literal;
|
|
11428
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
11486
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L188, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11429
11487
|
return { type: "VoidType", $loc, token: $1 };
|
|
11430
11488
|
});
|
|
11431
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
11489
|
+
var TypeLiteral$3 = $TV($EXPECT($L208, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
11432
11490
|
return { $loc, token: "[]" };
|
|
11433
11491
|
});
|
|
11434
11492
|
var TypeLiteral$$ = [TypeLiteral$0, TypeLiteral$1, TypeLiteral$2, TypeLiteral$3];
|
|
@@ -11447,16 +11505,16 @@ ${input.slice(result.pos)}
|
|
|
11447
11505
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
11448
11506
|
return value[1];
|
|
11449
11507
|
});
|
|
11450
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L12, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($
|
|
11508
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L12, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L114, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L34, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L25, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
11451
11509
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
11452
11510
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
11453
11511
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
11454
11512
|
return $EVENT_C(ctx, state, "InlineInterfacePropertyDelimiter", InlineInterfacePropertyDelimiter$$);
|
|
11455
11513
|
}
|
|
11456
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
11514
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L99, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
11457
11515
|
return { $loc, token: "|" };
|
|
11458
11516
|
});
|
|
11459
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
11517
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L98, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
11460
11518
|
return { $loc, token: "&" };
|
|
11461
11519
|
});
|
|
11462
11520
|
var TypeBinaryOp$$ = [TypeBinaryOp$0, TypeBinaryOp$1];
|
|
@@ -11473,13 +11531,13 @@ ${input.slice(result.pos)}
|
|
|
11473
11531
|
function FunctionType(ctx, state) {
|
|
11474
11532
|
return $EVENT(ctx, state, "FunctionType", FunctionType$0);
|
|
11475
11533
|
}
|
|
11476
|
-
var TypeArrowFunction$0 = $TV($C($EXPECT($L9, 'TypeArrowFunction "=>"'), $EXPECT($L10, 'TypeArrowFunction "\u21D2"'), $EXPECT($
|
|
11534
|
+
var TypeArrowFunction$0 = $TV($C($EXPECT($L9, 'TypeArrowFunction "=>"'), $EXPECT($L10, 'TypeArrowFunction "\u21D2"'), $EXPECT($L23, 'TypeArrowFunction "->"'), $EXPECT($L24, 'TypeArrowFunction "\u2192"')), function($skip, $loc, $0, $1) {
|
|
11477
11535
|
return { $loc, token: "=>" };
|
|
11478
11536
|
});
|
|
11479
11537
|
function TypeArrowFunction(ctx, state) {
|
|
11480
11538
|
return $EVENT(ctx, state, "TypeArrowFunction", TypeArrowFunction$0);
|
|
11481
11539
|
}
|
|
11482
|
-
var TypeArguments$0 = $TS($S($EXPECT($
|
|
11540
|
+
var TypeArguments$0 = $TS($S($EXPECT($L155, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L33, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
11483
11541
|
var args = $2;
|
|
11484
11542
|
return { ts: true, types: args.map(([, t]) => t), children: $0 };
|
|
11485
11543
|
});
|
|
@@ -11494,7 +11552,7 @@ ${input.slice(result.pos)}
|
|
|
11494
11552
|
function TypeArgumentDelimiter(ctx, state) {
|
|
11495
11553
|
return $EVENT(ctx, state, "TypeArgumentDelimiter", TypeArgumentDelimiter$0);
|
|
11496
11554
|
}
|
|
11497
|
-
var TypeParameters$0 = $TS($S($E(_), $EXPECT($
|
|
11555
|
+
var TypeParameters$0 = $TS($S($E(_), $EXPECT($L155, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L33, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
11498
11556
|
var parameters = $3;
|
|
11499
11557
|
return {
|
|
11500
11558
|
type: "TypeParameters",
|
|
@@ -11506,11 +11564,11 @@ ${input.slice(result.pos)}
|
|
|
11506
11564
|
function TypeParameters(ctx, state) {
|
|
11507
11565
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
11508
11566
|
}
|
|
11509
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
11567
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L150, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
11510
11568
|
function TypeParameter(ctx, state) {
|
|
11511
11569
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
11512
11570
|
}
|
|
11513
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
11571
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L139, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
11514
11572
|
function TypeConstraint(ctx, state) {
|
|
11515
11573
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
11516
11574
|
}
|
|
@@ -11519,7 +11577,7 @@ ${input.slice(result.pos)}
|
|
|
11519
11577
|
return $EVENT(ctx, state, "TypeInitializer", TypeInitializer$0);
|
|
11520
11578
|
}
|
|
11521
11579
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
11522
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
11580
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L33, 'TypeParameterDelimiter ">"')));
|
|
11523
11581
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
11524
11582
|
return value[1];
|
|
11525
11583
|
});
|
|
@@ -11549,7 +11607,7 @@ ${input.slice(result.pos)}
|
|
|
11549
11607
|
function CivetPrologue(ctx, state) {
|
|
11550
11608
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
11551
11609
|
}
|
|
11552
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
11610
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L209, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R63, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
11553
11611
|
var options = $3;
|
|
11554
11612
|
return {
|
|
11555
11613
|
type: "CivetPrologue",
|
|
@@ -12290,8 +12348,10 @@ ${input.slice(result.pos)}
|
|
|
12290
12348
|
exports.NonNullAssertion = NonNullAssertion;
|
|
12291
12349
|
exports.MemberExpression = MemberExpression;
|
|
12292
12350
|
exports.MemberExpressionRest = MemberExpressionRest;
|
|
12351
|
+
exports.MemberExpressionRestBody = MemberExpressionRestBody;
|
|
12293
12352
|
exports.MemberBracketContent = MemberBracketContent;
|
|
12294
12353
|
exports.SliceParameters = SliceParameters;
|
|
12354
|
+
exports.AccessStart = AccessStart;
|
|
12295
12355
|
exports.PropertyAccess = PropertyAccess;
|
|
12296
12356
|
exports.PropertyGlob = PropertyGlob;
|
|
12297
12357
|
exports.PropertyBind = PropertyBind;
|
|
@@ -12404,6 +12464,7 @@ ${input.slice(result.pos)}
|
|
|
12404
12464
|
exports.AssignmentOpSymbol = AssignmentOpSymbol;
|
|
12405
12465
|
exports.CoffeeWordAssignmentOp = CoffeeWordAssignmentOp;
|
|
12406
12466
|
exports.NotDedentedBinaryOp = NotDedentedBinaryOp;
|
|
12467
|
+
exports.IdentifierBinaryOp = IdentifierBinaryOp;
|
|
12407
12468
|
exports.BinaryOp = BinaryOp;
|
|
12408
12469
|
exports.BinaryOpSymbol = BinaryOpSymbol;
|
|
12409
12470
|
exports.Xor = Xor;
|
|
@@ -12909,9 +12970,7 @@ ${input.slice(result.pos)}
|
|
|
12909
12970
|
var import_parser = __toESM(require_parser());
|
|
12910
12971
|
|
|
12911
12972
|
// source/generate.civet
|
|
12912
|
-
|
|
12913
|
-
var generate_default = gen = function(node, options) {
|
|
12914
|
-
var token, $loc;
|
|
12973
|
+
function gen(node, options) {
|
|
12915
12974
|
if (node === null || node === void 0) {
|
|
12916
12975
|
return "";
|
|
12917
12976
|
}
|
|
@@ -12937,7 +12996,7 @@ ${input.slice(result.pos)}
|
|
|
12937
12996
|
return "";
|
|
12938
12997
|
}
|
|
12939
12998
|
if (node.$loc != null) {
|
|
12940
|
-
|
|
12999
|
+
const { token, $loc } = node;
|
|
12941
13000
|
options?.updateSourceMap?.(token, $loc.pos);
|
|
12942
13001
|
return token;
|
|
12943
13002
|
}
|
|
@@ -12955,9 +13014,9 @@ ${input.slice(result.pos)}
|
|
|
12955
13014
|
}
|
|
12956
13015
|
debugger;
|
|
12957
13016
|
throw new Error(`Unknown node ${JSON.stringify(node)}`);
|
|
12958
|
-
}
|
|
12959
|
-
var
|
|
12960
|
-
|
|
13017
|
+
}
|
|
13018
|
+
var generate_default = gen;
|
|
13019
|
+
function prune(node) {
|
|
12961
13020
|
if (node === null || node === void 0) {
|
|
12962
13021
|
return;
|
|
12963
13022
|
}
|
|
@@ -12968,11 +13027,9 @@ ${input.slice(result.pos)}
|
|
|
12968
13027
|
delete node.parent;
|
|
12969
13028
|
}
|
|
12970
13029
|
if (Array.isArray(node)) {
|
|
12971
|
-
a = node.map(function(n) {
|
|
13030
|
+
const a = node.map(function(n) {
|
|
12972
13031
|
return prune(n);
|
|
12973
|
-
}).filter(
|
|
12974
|
-
return !!n;
|
|
12975
|
-
});
|
|
13032
|
+
}).filter(($) => !!$);
|
|
12976
13033
|
if (a.length > 1) {
|
|
12977
13034
|
return a;
|
|
12978
13035
|
}
|
|
@@ -12986,7 +13043,7 @@ ${input.slice(result.pos)}
|
|
|
12986
13043
|
return node;
|
|
12987
13044
|
}
|
|
12988
13045
|
return node;
|
|
12989
|
-
}
|
|
13046
|
+
}
|
|
12990
13047
|
|
|
12991
13048
|
// source/util.civet
|
|
12992
13049
|
var util_exports = {};
|
|
@@ -13363,13 +13420,9 @@ ${input.slice(result.pos)}
|
|
|
13363
13420
|
};
|
|
13364
13421
|
|
|
13365
13422
|
// source/main.civet
|
|
13366
|
-
var parse;
|
|
13367
|
-
var SourceMap2;
|
|
13368
|
-
var uncacheable
|
|
13369
|
-
var makeCache;
|
|
13370
|
-
({ parse } = import_parser.default);
|
|
13371
|
-
({ SourceMap: SourceMap2 } = util_exports);
|
|
13372
|
-
uncacheable = /* @__PURE__ */ new Set([
|
|
13423
|
+
var { parse } = import_parser.default;
|
|
13424
|
+
var { SourceMap: SourceMap2 } = util_exports;
|
|
13425
|
+
var uncacheable = /* @__PURE__ */ new Set([
|
|
13373
13426
|
"DebugHere",
|
|
13374
13427
|
"Init",
|
|
13375
13428
|
"Program",
|
|
@@ -13401,23 +13454,23 @@ ${input.slice(result.pos)}
|
|
|
13401
13454
|
"RestoreTrailingMemberProperty",
|
|
13402
13455
|
"RestoreNewlineBinaryOp"
|
|
13403
13456
|
]);
|
|
13404
|
-
|
|
13405
|
-
var filename, ast, result, events, sm, code;
|
|
13457
|
+
function compile(src, options) {
|
|
13406
13458
|
if (!options) {
|
|
13407
13459
|
options = {};
|
|
13408
13460
|
} else {
|
|
13409
13461
|
options = { ...options };
|
|
13410
13462
|
}
|
|
13411
13463
|
options.parseOptions ?? (options.parseOptions = {});
|
|
13412
|
-
filename = options.filename || "unknown";
|
|
13464
|
+
const filename = options.filename || "unknown";
|
|
13413
13465
|
if (filename.endsWith(".coffee") && !/^(#![^\r\n]*(\r\n|\n|\r))?\s*['"]civet/.test(src)) {
|
|
13414
13466
|
options.parseOptions.coffeeCompat = true;
|
|
13415
13467
|
}
|
|
13468
|
+
let events;
|
|
13416
13469
|
if (!options.noCache) {
|
|
13417
13470
|
events = makeCache();
|
|
13418
13471
|
}
|
|
13419
13472
|
parse.config = options.parseOptions || {};
|
|
13420
|
-
ast = prune(parse(src, {
|
|
13473
|
+
const ast = prune(parse(src, {
|
|
13421
13474
|
filename,
|
|
13422
13475
|
events
|
|
13423
13476
|
}));
|
|
@@ -13425,9 +13478,9 @@ ${input.slice(result.pos)}
|
|
|
13425
13478
|
return ast;
|
|
13426
13479
|
}
|
|
13427
13480
|
if (options.sourceMap || options.inlineMap) {
|
|
13428
|
-
sm = SourceMap2(src);
|
|
13481
|
+
const sm = SourceMap2(src);
|
|
13429
13482
|
options.updateSourceMap = sm.updateSourceMap;
|
|
13430
|
-
code = generate_default(ast, options);
|
|
13483
|
+
const code = generate_default(ast, options);
|
|
13431
13484
|
if (options.inlineMap) {
|
|
13432
13485
|
return SourceMap2.remap(code, sm, filename, filename + ".tsx");
|
|
13433
13486
|
} else {
|
|
@@ -13437,27 +13490,24 @@ ${input.slice(result.pos)}
|
|
|
13437
13490
|
};
|
|
13438
13491
|
}
|
|
13439
13492
|
}
|
|
13440
|
-
result = generate_default(ast, options);
|
|
13493
|
+
const result = generate_default(ast, options);
|
|
13441
13494
|
if (options.errors?.length) {
|
|
13442
|
-
throw new Error(`Parse errors: ${options.errors.map(
|
|
13443
|
-
return e.message;
|
|
13444
|
-
}).join("\n")} `);
|
|
13495
|
+
throw new Error(`Parse errors: ${options.errors.map(($) => $.message).join("\n")} `);
|
|
13445
13496
|
}
|
|
13446
13497
|
return result;
|
|
13447
|
-
}
|
|
13448
|
-
makeCache
|
|
13449
|
-
|
|
13450
|
-
|
|
13451
|
-
|
|
13452
|
-
events = {
|
|
13498
|
+
}
|
|
13499
|
+
function makeCache() {
|
|
13500
|
+
const stateCache = new StateCache();
|
|
13501
|
+
let getStateKey = null;
|
|
13502
|
+
const events = {
|
|
13453
13503
|
enter: function(ruleName, state) {
|
|
13454
|
-
var key, result;
|
|
13455
13504
|
if (uncacheable.has(ruleName)) {
|
|
13456
13505
|
return;
|
|
13457
13506
|
}
|
|
13458
|
-
|
|
13507
|
+
;
|
|
13508
|
+
const key = [ruleName, state.pos, ...getStateKey()];
|
|
13459
13509
|
if (stateCache.has(key)) {
|
|
13460
|
-
result = stateCache.get(key);
|
|
13510
|
+
const result = stateCache.get(key);
|
|
13461
13511
|
return {
|
|
13462
13512
|
cache: result ? { ...result } : void 0
|
|
13463
13513
|
};
|
|
@@ -13465,12 +13515,11 @@ ${input.slice(result.pos)}
|
|
|
13465
13515
|
return;
|
|
13466
13516
|
},
|
|
13467
13517
|
exit: function(ruleName, state, result) {
|
|
13468
|
-
var key;
|
|
13469
13518
|
if (ruleName === "Reset") {
|
|
13470
13519
|
({ getStateKey } = result.value);
|
|
13471
13520
|
}
|
|
13472
13521
|
if (!uncacheable.has(ruleName)) {
|
|
13473
|
-
key = [ruleName, state.pos, ...getStateKey()];
|
|
13522
|
+
const key = [ruleName, state.pos, ...getStateKey()];
|
|
13474
13523
|
if (result) {
|
|
13475
13524
|
stateCache.set(key, { ...result });
|
|
13476
13525
|
} else {
|
|
@@ -13484,11 +13533,9 @@ ${input.slice(result.pos)}
|
|
|
13484
13533
|
}
|
|
13485
13534
|
};
|
|
13486
13535
|
return events;
|
|
13487
|
-
}
|
|
13536
|
+
}
|
|
13488
13537
|
var isCompileError = function(err) {
|
|
13489
|
-
return err instanceof Error && [err.message, err.name, err.filename, err.line, err.column, err.offset].every(
|
|
13490
|
-
return value !== void 0;
|
|
13491
|
-
});
|
|
13538
|
+
return err instanceof Error && [err.message, err.name, err.filename, err.line, err.column, err.offset].every(($1) => $1 !== void 0);
|
|
13492
13539
|
};
|
|
13493
13540
|
var main_default = { parse, generate: generate_default, util: util_exports, compile, isCompileError };
|
|
13494
13541
|
return __toCommonJS(main_exports);
|