@danielx/civet 0.6.59 → 0.6.60
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/browser.js +516 -518
- package/dist/main.js +516 -518
- package/dist/main.mjs +516 -518
- package/package.json +2 -2
package/dist/browser.js
CHANGED
|
@@ -1166,10 +1166,9 @@ ${input.slice(result.pos)}
|
|
|
1166
1166
|
}
|
|
1167
1167
|
return;
|
|
1168
1168
|
case "CaseBlock":
|
|
1169
|
-
node.clauses.forEach((clause) => {
|
|
1170
|
-
insertPush:
|
|
1171
|
-
|
|
1172
|
-
});
|
|
1169
|
+
node.clauses.forEach((clause) => ({
|
|
1170
|
+
insertPush: insertPush(clause, ref)
|
|
1171
|
+
}));
|
|
1173
1172
|
return;
|
|
1174
1173
|
case "WhenClause":
|
|
1175
1174
|
insertPush(node.block, ref);
|
|
@@ -1927,7 +1926,9 @@ ${input.slice(result.pos)}
|
|
|
1927
1926
|
break;
|
|
1928
1927
|
}
|
|
1929
1928
|
default:
|
|
1930
|
-
|
|
1929
|
+
(() => {
|
|
1930
|
+
throw new Error(`for item, index must use 'of' or 'in' instead of '${inOf.token}'`);
|
|
1931
|
+
})();
|
|
1931
1932
|
}
|
|
1932
1933
|
return {
|
|
1933
1934
|
declaration,
|
|
@@ -1999,14 +2000,13 @@ ${input.slice(result.pos)}
|
|
|
1999
2000
|
return;
|
|
2000
2001
|
}
|
|
2001
2002
|
if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
|
|
2002
|
-
n.names.forEach((id) => {
|
|
2003
|
-
push:
|
|
2004
|
-
|
|
2005
|
-
|
|
2006
|
-
|
|
2007
|
-
|
|
2008
|
-
|
|
2009
|
-
});
|
|
2003
|
+
n.names.forEach((id) => ({
|
|
2004
|
+
push: thisAssignments2.push({
|
|
2005
|
+
type: "AssignmentExpression",
|
|
2006
|
+
children: [`this.${id} = `, id],
|
|
2007
|
+
js: true
|
|
2008
|
+
})
|
|
2009
|
+
}));
|
|
2010
2010
|
return;
|
|
2011
2011
|
}
|
|
2012
2012
|
const { blockPrefix } = n;
|
|
@@ -2207,7 +2207,9 @@ ${input.slice(result.pos)}
|
|
|
2207
2207
|
}
|
|
2208
2208
|
break;
|
|
2209
2209
|
default:
|
|
2210
|
-
|
|
2210
|
+
(() => {
|
|
2211
|
+
throw new Error(`invalid object literal type in JSX attribute: ${part.type}`);
|
|
2212
|
+
})();
|
|
2211
2213
|
}
|
|
2212
2214
|
}
|
|
2213
2215
|
if (rest.length) {
|
|
@@ -2662,24 +2664,20 @@ ${input.slice(result.pos)}
|
|
|
2662
2664
|
}
|
|
2663
2665
|
function insertSemicolon(statements) {
|
|
2664
2666
|
const l = statements.length;
|
|
2665
|
-
|
|
2667
|
+
for (let i4 = 0, len4 = statements.length; i4 < len4; i4++) {
|
|
2668
|
+
const i = i4;
|
|
2669
|
+
const s = statements[i4];
|
|
2666
2670
|
if (i < l - 1) {
|
|
2667
2671
|
if (needsPrecedingSemicolon(statements[i + 1])) {
|
|
2668
2672
|
const delim = s[2];
|
|
2669
2673
|
if (!delim) {
|
|
2670
|
-
|
|
2674
|
+
s[2] = ";";
|
|
2671
2675
|
} else if (typeof delim === "string" && !delim.match(/;/)) {
|
|
2672
|
-
|
|
2676
|
+
s[2] = `;${delim}`;
|
|
2673
2677
|
}
|
|
2674
|
-
;
|
|
2675
|
-
return;
|
|
2676
2678
|
}
|
|
2677
|
-
;
|
|
2678
|
-
return;
|
|
2679
2679
|
}
|
|
2680
|
-
|
|
2681
|
-
return;
|
|
2682
|
-
});
|
|
2680
|
+
}
|
|
2683
2681
|
}
|
|
2684
2682
|
function needsPrecedingSemicolon(exp) {
|
|
2685
2683
|
let following;
|
|
@@ -2699,7 +2697,8 @@ ${input.slice(result.pos)}
|
|
|
2699
2697
|
case "ArrayExpression":
|
|
2700
2698
|
case "ArrowFunction":
|
|
2701
2699
|
case "TemplateLiteral":
|
|
2702
|
-
case "RegularExpressionLiteral":
|
|
2700
|
+
case "RegularExpressionLiteral":
|
|
2701
|
+
case "RangeExpression": {
|
|
2703
2702
|
return true;
|
|
2704
2703
|
}
|
|
2705
2704
|
case "AssignmentExpression": {
|
|
@@ -2733,7 +2732,9 @@ ${input.slice(result.pos)}
|
|
|
2733
2732
|
case "IfStatement":
|
|
2734
2733
|
return expressionizeIfClause(post[1], exp);
|
|
2735
2734
|
default:
|
|
2736
|
-
|
|
2735
|
+
(() => {
|
|
2736
|
+
throw new Error("Unknown postfix statement");
|
|
2737
|
+
})();
|
|
2737
2738
|
}
|
|
2738
2739
|
}
|
|
2739
2740
|
function getPatternConditions(pattern, ref, conditions) {
|
|
@@ -2950,10 +2951,9 @@ ${input.slice(result.pos)}
|
|
|
2950
2951
|
pos: 0,
|
|
2951
2952
|
input: key
|
|
2952
2953
|
})) {
|
|
2953
|
-
shared.forEach((p) => {
|
|
2954
|
-
aliasBinding:
|
|
2955
|
-
|
|
2956
|
-
});
|
|
2954
|
+
shared.forEach((p) => ({
|
|
2955
|
+
aliasBinding: aliasBinding(p, makeRef(`_${key}`, key))
|
|
2956
|
+
}));
|
|
2957
2957
|
return;
|
|
2958
2958
|
}
|
|
2959
2959
|
if (shared.length === 1)
|
|
@@ -3621,9 +3621,9 @@ ${input.slice(result.pos)}
|
|
|
3621
3621
|
return root;
|
|
3622
3622
|
}
|
|
3623
3623
|
}
|
|
3624
|
-
for (let
|
|
3625
|
-
const i =
|
|
3626
|
-
const node = array[
|
|
3624
|
+
for (let i5 = 0, len5 = array.length; i5 < len5; i5++) {
|
|
3625
|
+
const i = i5;
|
|
3626
|
+
const node = array[i5];
|
|
3627
3627
|
if (!(node != null)) {
|
|
3628
3628
|
return;
|
|
3629
3629
|
}
|
|
@@ -3698,7 +3698,9 @@ ${input.slice(result.pos)}
|
|
|
3698
3698
|
}
|
|
3699
3699
|
break;
|
|
3700
3700
|
default:
|
|
3701
|
-
|
|
3701
|
+
(() => {
|
|
3702
|
+
throw new Error(`unknown child in JSXFragment: ${JSON.stringify(child)}`);
|
|
3703
|
+
})();
|
|
3702
3704
|
}
|
|
3703
3705
|
lastType = child.type;
|
|
3704
3706
|
}
|
|
@@ -4016,7 +4018,6 @@ ${input.slice(result.pos)}
|
|
|
4016
4018
|
OperatorSignature,
|
|
4017
4019
|
AmpersandBlockRHS,
|
|
4018
4020
|
AmpersandBlockRHSBody,
|
|
4019
|
-
AmpersandUnaryPrefix,
|
|
4020
4021
|
ThinArrowFunction,
|
|
4021
4022
|
Arrow,
|
|
4022
4023
|
ExplicitBlock,
|
|
@@ -4575,213 +4576,214 @@ ${input.slice(result.pos)}
|
|
|
4575
4576
|
var $L2 = $L("/ ");
|
|
4576
4577
|
var $L3 = $L("=");
|
|
4577
4578
|
var $L4 = $L("(");
|
|
4578
|
-
var $L5 = $L("
|
|
4579
|
-
var $L6 = $L("
|
|
4580
|
-
var $L7 = $L("
|
|
4581
|
-
var $L8 = $L("
|
|
4582
|
-
var $L9 = $L("
|
|
4583
|
-
var $L10 = $L("
|
|
4584
|
-
var $L11 = $L("
|
|
4585
|
-
var $L12 = $L("
|
|
4586
|
-
var $L13 = $L("
|
|
4587
|
-
var $L14 = $L("
|
|
4588
|
-
var $L15 = $L("
|
|
4589
|
-
var $L16 = $L("
|
|
4590
|
-
var $L17 = $L("
|
|
4591
|
-
var $L18 = $L("
|
|
4592
|
-
var $L19 = $L("
|
|
4593
|
-
var $L20 = $L("
|
|
4594
|
-
var $L21 = $L("
|
|
4595
|
-
var $L22 = $L("
|
|
4596
|
-
var $L23 = $L("
|
|
4597
|
-
var $L24 = $L("
|
|
4598
|
-
var $L25 = $L("
|
|
4599
|
-
var $L26 = $L("
|
|
4600
|
-
var $L27 = $L("
|
|
4601
|
-
var $L28 = $L("
|
|
4602
|
-
var $L29 = $L("
|
|
4603
|
-
var $L30 = $L("
|
|
4604
|
-
var $L31 = $L("
|
|
4605
|
-
var $L32 = $L("
|
|
4606
|
-
var $L33 = $L("
|
|
4607
|
-
var $L34 = $L("
|
|
4608
|
-
var $L35 = $L("
|
|
4609
|
-
var $L36 = $L("
|
|
4610
|
-
var $L37 = $L("
|
|
4611
|
-
var $L38 = $L("
|
|
4612
|
-
var $L39 = $L("
|
|
4613
|
-
var $L40 = $L("
|
|
4614
|
-
var $L41 = $L("
|
|
4615
|
-
var $L42 = $L("
|
|
4616
|
-
var $L43 = $L("
|
|
4617
|
-
var $L44 = $L("
|
|
4618
|
-
var $L45 = $L("
|
|
4619
|
-
var $L46 = $L("
|
|
4620
|
-
var $L47 = $L("
|
|
4621
|
-
var $L48 = $L("
|
|
4622
|
-
var $L49 = $L("
|
|
4623
|
-
var $L50 = $L("
|
|
4624
|
-
var $L51 = $L("
|
|
4625
|
-
var $L52 = $L("
|
|
4626
|
-
var $L53 = $L("
|
|
4627
|
-
var $L54 = $L("
|
|
4628
|
-
var $L55 = $L("
|
|
4629
|
-
var $L56 = $L("
|
|
4630
|
-
var $L57 = $L("
|
|
4631
|
-
var $L58 = $L("
|
|
4632
|
-
var $L59 = $L("
|
|
4633
|
-
var $L60 = $L("
|
|
4634
|
-
var $L61 = $L("
|
|
4635
|
-
var $L62 = $L("
|
|
4636
|
-
var $L63 = $L("
|
|
4637
|
-
var $L64 = $L("
|
|
4638
|
-
var $L65 = $L("
|
|
4639
|
-
var $L66 = $L("
|
|
4640
|
-
var $L67 = $L("
|
|
4641
|
-
var $L68 = $L("
|
|
4642
|
-
var $L69 = $L("
|
|
4643
|
-
var $L70 = $L("
|
|
4644
|
-
var $L71 = $L("
|
|
4645
|
-
var $L72 = $L("
|
|
4646
|
-
var $L73 = $L("
|
|
4647
|
-
var $L74 = $L("
|
|
4648
|
-
var $L75 = $L("
|
|
4649
|
-
var $L76 = $L("
|
|
4650
|
-
var $L77 = $L("
|
|
4651
|
-
var $L78 = $L("
|
|
4652
|
-
var $L79 = $L("\
|
|
4653
|
-
var $L80 = $L("
|
|
4654
|
-
var $L81 = $L("
|
|
4655
|
-
var $L82 = $L("\
|
|
4656
|
-
var $L83 = $L("
|
|
4657
|
-
var $L84 = $L("
|
|
4658
|
-
var $L85 = $L("
|
|
4659
|
-
var $L86 = $L("
|
|
4660
|
-
var $L87 = $L("
|
|
4661
|
-
var $L88 = $L("
|
|
4662
|
-
var $L89 = $L("
|
|
4663
|
-
var $L90 = $L("
|
|
4664
|
-
var $L91 = $L("
|
|
4665
|
-
var $L92 = $L("
|
|
4666
|
-
var $L93 = $L("
|
|
4667
|
-
var $L94 = $L("
|
|
4668
|
-
var $L95 = $L("\
|
|
4669
|
-
var $L96 = $L("\
|
|
4670
|
-
var $L97 = $L("\
|
|
4671
|
-
var $L98 = $L("
|
|
4672
|
-
var $L99 = $L("
|
|
4673
|
-
var $L100 = $L("
|
|
4674
|
-
var $L101 = $L("
|
|
4675
|
-
var $L102 = $L("
|
|
4676
|
-
var $L103 = $L("
|
|
4677
|
-
var $L104 = $L("
|
|
4678
|
-
var $L105 = $L("
|
|
4679
|
-
var $L106 = $L("
|
|
4680
|
-
var $L107 = $L("
|
|
4681
|
-
var $L108 = $L("
|
|
4682
|
-
var $L109 = $L("
|
|
4683
|
-
var $L110 = $L("
|
|
4684
|
-
var $L111 = $L("
|
|
4685
|
-
var $L112 = $L("
|
|
4686
|
-
var $L113 = $L("
|
|
4687
|
-
var $L114 = $L("
|
|
4688
|
-
var $L115 = $L("
|
|
4689
|
-
var $L116 = $L("
|
|
4690
|
-
var $L117 = $L("
|
|
4691
|
-
var $L118 = $L("
|
|
4692
|
-
var $L119 = $L("
|
|
4693
|
-
var $L120 = $L("
|
|
4694
|
-
var $L121 = $L("
|
|
4695
|
-
var $L122 = $L("
|
|
4696
|
-
var $L123 = $L("
|
|
4697
|
-
var $L124 = $L("
|
|
4698
|
-
var $L125 = $L("
|
|
4699
|
-
var $L126 = $L("
|
|
4700
|
-
var $L127 = $L("
|
|
4701
|
-
var $L128 = $L("
|
|
4702
|
-
var $L129 = $L("
|
|
4703
|
-
var $L130 = $L("
|
|
4704
|
-
var $L131 = $L("
|
|
4705
|
-
var $L132 = $L("
|
|
4706
|
-
var $L133 = $L("
|
|
4707
|
-
var $L134 = $L("
|
|
4708
|
-
var $L135 = $L(
|
|
4709
|
-
var $L136 = $L("
|
|
4710
|
-
var $L137 = $L("
|
|
4711
|
-
var $L138 = $L("
|
|
4712
|
-
var $L139 = $L("
|
|
4713
|
-
var $L140 = $L("
|
|
4714
|
-
var $L141 = $L("
|
|
4715
|
-
var $L142 = $L("
|
|
4716
|
-
var $L143 = $L("
|
|
4717
|
-
var $L144 = $L("
|
|
4718
|
-
var $L145 = $L("
|
|
4719
|
-
var $L146 = $L("
|
|
4720
|
-
var $L147 = $L("
|
|
4721
|
-
var $L148 = $L("
|
|
4722
|
-
var $L149 = $L("
|
|
4723
|
-
var $L150 = $L("
|
|
4724
|
-
var $L151 = $L("
|
|
4725
|
-
var $L152 = $L("
|
|
4726
|
-
var $L153 = $L("
|
|
4727
|
-
var $L154 = $L("
|
|
4728
|
-
var $L155 = $L("
|
|
4729
|
-
var $L156 = $L("
|
|
4730
|
-
var $L157 = $L("
|
|
4731
|
-
var $L158 = $L("
|
|
4732
|
-
var $L159 = $L("
|
|
4733
|
-
var $L160 = $L("
|
|
4734
|
-
var $L161 = $L("
|
|
4735
|
-
var $L162 = $L("
|
|
4736
|
-
var $L163 = $L("
|
|
4737
|
-
var $L164 = $L("
|
|
4738
|
-
var $L165 = $L("
|
|
4739
|
-
var $L166 = $L("
|
|
4740
|
-
var $L167 = $L("
|
|
4741
|
-
var $L168 = $L("
|
|
4742
|
-
var $L169 = $L("
|
|
4743
|
-
var $L170 = $L("
|
|
4744
|
-
var $L171 = $L("
|
|
4745
|
-
var $L172 = $L("
|
|
4746
|
-
var $L173 = $L("
|
|
4747
|
-
var $L174 = $L("
|
|
4748
|
-
var $L175 = $L("
|
|
4749
|
-
var $L176 = $L("
|
|
4750
|
-
var $L177 = $L("
|
|
4751
|
-
var $L178 = $L("
|
|
4752
|
-
var $L179 = $L("
|
|
4753
|
-
var $L180 = $L(
|
|
4754
|
-
var $L181 = $L("'
|
|
4755
|
-
var $L182 = $L("
|
|
4756
|
-
var $L183 = $L("
|
|
4757
|
-
var $L184 = $L("
|
|
4758
|
-
var $L185 = $L("
|
|
4759
|
-
var $L186 = $L("
|
|
4760
|
-
var $L187 = $L("
|
|
4761
|
-
var $L188 = $L("
|
|
4762
|
-
var $L189 = $L("
|
|
4763
|
-
var $L190 = $L("
|
|
4764
|
-
var $L191 = $L("
|
|
4765
|
-
var $L192 = $L("
|
|
4766
|
-
var $L193 = $L("
|
|
4767
|
-
var $L194 = $L("
|
|
4768
|
-
var $L195 = $L("
|
|
4769
|
-
var $L196 = $L("
|
|
4770
|
-
var $L197 = $L("
|
|
4771
|
-
var $L198 = $L("
|
|
4772
|
-
var $L199 = $L("
|
|
4773
|
-
var $L200 = $L("
|
|
4774
|
-
var $L201 = $L("
|
|
4775
|
-
var $L202 = $L("
|
|
4776
|
-
var $L203 = $L("
|
|
4777
|
-
var $L204 = $L("
|
|
4778
|
-
var $L205 = $L("
|
|
4779
|
-
var $L206 = $L("
|
|
4780
|
-
var $L207 = $L("
|
|
4781
|
-
var $L208 = $L("
|
|
4782
|
-
var $L209 = $L("
|
|
4783
|
-
var $L210 = $L("
|
|
4784
|
-
var $L211 = $L("
|
|
4579
|
+
var $L5 = $L("... ");
|
|
4580
|
+
var $L6 = $L("?");
|
|
4581
|
+
var $L7 = $L(".");
|
|
4582
|
+
var $L8 = $L("++");
|
|
4583
|
+
var $L9 = $L("--");
|
|
4584
|
+
var $L10 = $L("=>");
|
|
4585
|
+
var $L11 = $L("\u21D2");
|
|
4586
|
+
var $L12 = $L(":");
|
|
4587
|
+
var $L13 = $L(" ");
|
|
4588
|
+
var $L14 = $L("<");
|
|
4589
|
+
var $L15 = $L("implements");
|
|
4590
|
+
var $L16 = $L("<:");
|
|
4591
|
+
var $L17 = $L("import");
|
|
4592
|
+
var $L18 = $L("!");
|
|
4593
|
+
var $L19 = $L("^");
|
|
4594
|
+
var $L20 = $L("-");
|
|
4595
|
+
var $L21 = $L("import.meta");
|
|
4596
|
+
var $L22 = $L("return.value");
|
|
4597
|
+
var $L23 = $L(",");
|
|
4598
|
+
var $L24 = $L("(&)");
|
|
4599
|
+
var $L25 = $L("->");
|
|
4600
|
+
var $L26 = $L("\u2192");
|
|
4601
|
+
var $L27 = $L("}");
|
|
4602
|
+
var $L28 = $L("null");
|
|
4603
|
+
var $L29 = $L("true");
|
|
4604
|
+
var $L30 = $L("false");
|
|
4605
|
+
var $L31 = $L("yes");
|
|
4606
|
+
var $L32 = $L("on");
|
|
4607
|
+
var $L33 = $L("no");
|
|
4608
|
+
var $L34 = $L("off");
|
|
4609
|
+
var $L35 = $L(">");
|
|
4610
|
+
var $L36 = $L("]");
|
|
4611
|
+
var $L37 = $L("**=");
|
|
4612
|
+
var $L38 = $L("*=");
|
|
4613
|
+
var $L39 = $L("/=");
|
|
4614
|
+
var $L40 = $L("%=");
|
|
4615
|
+
var $L41 = $L("+=");
|
|
4616
|
+
var $L42 = $L("-=");
|
|
4617
|
+
var $L43 = $L("<<=");
|
|
4618
|
+
var $L44 = $L(">>>=");
|
|
4619
|
+
var $L45 = $L(">>=");
|
|
4620
|
+
var $L46 = $L("&&=");
|
|
4621
|
+
var $L47 = $L("&=");
|
|
4622
|
+
var $L48 = $L("^=");
|
|
4623
|
+
var $L49 = $L("||=");
|
|
4624
|
+
var $L50 = $L("|=");
|
|
4625
|
+
var $L51 = $L("??=");
|
|
4626
|
+
var $L52 = $L("?=");
|
|
4627
|
+
var $L53 = $L("and=");
|
|
4628
|
+
var $L54 = $L("or=");
|
|
4629
|
+
var $L55 = $L("**");
|
|
4630
|
+
var $L56 = $L("*");
|
|
4631
|
+
var $L57 = $L("/");
|
|
4632
|
+
var $L58 = $L("%%");
|
|
4633
|
+
var $L59 = $L("%");
|
|
4634
|
+
var $L60 = $L("+");
|
|
4635
|
+
var $L61 = $L("<=");
|
|
4636
|
+
var $L62 = $L("\u2264");
|
|
4637
|
+
var $L63 = $L(">=");
|
|
4638
|
+
var $L64 = $L("\u2265");
|
|
4639
|
+
var $L65 = $L("<?");
|
|
4640
|
+
var $L66 = $L("!<?");
|
|
4641
|
+
var $L67 = $L("<<");
|
|
4642
|
+
var $L68 = $L("\xAB");
|
|
4643
|
+
var $L69 = $L(">>>");
|
|
4644
|
+
var $L70 = $L("\u22D9");
|
|
4645
|
+
var $L71 = $L(">>");
|
|
4646
|
+
var $L72 = $L("\xBB");
|
|
4647
|
+
var $L73 = $L("!==");
|
|
4648
|
+
var $L74 = $L("\u2262");
|
|
4649
|
+
var $L75 = $L("!=");
|
|
4650
|
+
var $L76 = $L("\u2260");
|
|
4651
|
+
var $L77 = $L("isnt");
|
|
4652
|
+
var $L78 = $L("===");
|
|
4653
|
+
var $L79 = $L("\u2263");
|
|
4654
|
+
var $L80 = $L("\u2A76");
|
|
4655
|
+
var $L81 = $L("==");
|
|
4656
|
+
var $L82 = $L("\u2261");
|
|
4657
|
+
var $L83 = $L("\u2A75");
|
|
4658
|
+
var $L84 = $L("and");
|
|
4659
|
+
var $L85 = $L("&&");
|
|
4660
|
+
var $L86 = $L("or");
|
|
4661
|
+
var $L87 = $L("||");
|
|
4662
|
+
var $L88 = $L("\u2016");
|
|
4663
|
+
var $L89 = $L("^^");
|
|
4664
|
+
var $L90 = $L("xor");
|
|
4665
|
+
var $L91 = $L("xnor");
|
|
4666
|
+
var $L92 = $L("??");
|
|
4667
|
+
var $L93 = $L("\u2047");
|
|
4668
|
+
var $L94 = $L("instanceof");
|
|
4669
|
+
var $L95 = $L("\u2208");
|
|
4670
|
+
var $L96 = $L("\u220B");
|
|
4671
|
+
var $L97 = $L("\u220C");
|
|
4672
|
+
var $L98 = $L("\u2209");
|
|
4673
|
+
var $L99 = $L("&");
|
|
4674
|
+
var $L100 = $L("|");
|
|
4675
|
+
var $L101 = $L(";");
|
|
4676
|
+
var $L102 = $L("$:");
|
|
4677
|
+
var $L103 = $L("break");
|
|
4678
|
+
var $L104 = $L("continue");
|
|
4679
|
+
var $L105 = $L("debugger");
|
|
4680
|
+
var $L106 = $L("with");
|
|
4681
|
+
var $L107 = $L("assert");
|
|
4682
|
+
var $L108 = $L(":=");
|
|
4683
|
+
var $L109 = $L("\u2254");
|
|
4684
|
+
var $L110 = $L(".=");
|
|
4685
|
+
var $L111 = $L("/*");
|
|
4686
|
+
var $L112 = $L("*/");
|
|
4687
|
+
var $L113 = $L("\\");
|
|
4688
|
+
var $L114 = $L(")");
|
|
4689
|
+
var $L115 = $L("abstract");
|
|
4690
|
+
var $L116 = $L("as");
|
|
4691
|
+
var $L117 = $L("@");
|
|
4692
|
+
var $L118 = $L("@@");
|
|
4693
|
+
var $L119 = $L("async");
|
|
4694
|
+
var $L120 = $L("await");
|
|
4695
|
+
var $L121 = $L("`");
|
|
4696
|
+
var $L122 = $L("by");
|
|
4697
|
+
var $L123 = $L("case");
|
|
4698
|
+
var $L124 = $L("catch");
|
|
4699
|
+
var $L125 = $L("class");
|
|
4700
|
+
var $L126 = $L("#{");
|
|
4701
|
+
var $L127 = $L("declare");
|
|
4702
|
+
var $L128 = $L("default");
|
|
4703
|
+
var $L129 = $L("delete");
|
|
4704
|
+
var $L130 = $L("do");
|
|
4705
|
+
var $L131 = $L("..");
|
|
4706
|
+
var $L132 = $L("\u2025");
|
|
4707
|
+
var $L133 = $L("...");
|
|
4708
|
+
var $L134 = $L("\u2026");
|
|
4709
|
+
var $L135 = $L("::");
|
|
4710
|
+
var $L136 = $L('"');
|
|
4711
|
+
var $L137 = $L("each");
|
|
4712
|
+
var $L138 = $L("else");
|
|
4713
|
+
var $L139 = $L("export");
|
|
4714
|
+
var $L140 = $L("extends");
|
|
4715
|
+
var $L141 = $L("finally");
|
|
4716
|
+
var $L142 = $L("for");
|
|
4717
|
+
var $L143 = $L("from");
|
|
4718
|
+
var $L144 = $L("function");
|
|
4719
|
+
var $L145 = $L("get");
|
|
4720
|
+
var $L146 = $L("set");
|
|
4721
|
+
var $L147 = $L("#");
|
|
4722
|
+
var $L148 = $L("if");
|
|
4723
|
+
var $L149 = $L("in");
|
|
4724
|
+
var $L150 = $L("let");
|
|
4725
|
+
var $L151 = $L("const");
|
|
4726
|
+
var $L152 = $L("is");
|
|
4727
|
+
var $L153 = $L("loop");
|
|
4728
|
+
var $L154 = $L("new");
|
|
4729
|
+
var $L155 = $L("not");
|
|
4730
|
+
var $L156 = $L("of");
|
|
4731
|
+
var $L157 = $L("[");
|
|
4732
|
+
var $L158 = $L("operator");
|
|
4733
|
+
var $L159 = $L("own");
|
|
4734
|
+
var $L160 = $L("public");
|
|
4735
|
+
var $L161 = $L("private");
|
|
4736
|
+
var $L162 = $L("protected");
|
|
4737
|
+
var $L163 = $L("||>");
|
|
4738
|
+
var $L164 = $L("|\u25B7");
|
|
4739
|
+
var $L165 = $L("|>=");
|
|
4740
|
+
var $L166 = $L("\u25B7=");
|
|
4741
|
+
var $L167 = $L("|>");
|
|
4742
|
+
var $L168 = $L("\u25B7");
|
|
4743
|
+
var $L169 = $L("readonly");
|
|
4744
|
+
var $L170 = $L("return");
|
|
4745
|
+
var $L171 = $L("satisfies");
|
|
4746
|
+
var $L172 = $L("'");
|
|
4747
|
+
var $L173 = $L("static");
|
|
4748
|
+
var $L174 = $L("${");
|
|
4749
|
+
var $L175 = $L("super");
|
|
4750
|
+
var $L176 = $L("switch");
|
|
4751
|
+
var $L177 = $L("target");
|
|
4752
|
+
var $L178 = $L("then");
|
|
4753
|
+
var $L179 = $L("this");
|
|
4754
|
+
var $L180 = $L("throw");
|
|
4755
|
+
var $L181 = $L('"""');
|
|
4756
|
+
var $L182 = $L("'''");
|
|
4757
|
+
var $L183 = $L("///");
|
|
4758
|
+
var $L184 = $L("```");
|
|
4759
|
+
var $L185 = $L("try");
|
|
4760
|
+
var $L186 = $L("typeof");
|
|
4761
|
+
var $L187 = $L("unless");
|
|
4762
|
+
var $L188 = $L("until");
|
|
4763
|
+
var $L189 = $L("using");
|
|
4764
|
+
var $L190 = $L("var");
|
|
4765
|
+
var $L191 = $L("void");
|
|
4766
|
+
var $L192 = $L("when");
|
|
4767
|
+
var $L193 = $L("while");
|
|
4768
|
+
var $L194 = $L("yield");
|
|
4769
|
+
var $L195 = $L("/>");
|
|
4770
|
+
var $L196 = $L("</");
|
|
4771
|
+
var $L197 = $L("<>");
|
|
4772
|
+
var $L198 = $L("</>");
|
|
4773
|
+
var $L199 = $L("<!--");
|
|
4774
|
+
var $L200 = $L("-->");
|
|
4775
|
+
var $L201 = $L("type");
|
|
4776
|
+
var $L202 = $L("enum");
|
|
4777
|
+
var $L203 = $L("interface");
|
|
4778
|
+
var $L204 = $L("global");
|
|
4779
|
+
var $L205 = $L("module");
|
|
4780
|
+
var $L206 = $L("namespace");
|
|
4781
|
+
var $L207 = $L("asserts");
|
|
4782
|
+
var $L208 = $L("keyof");
|
|
4783
|
+
var $L209 = $L("infer");
|
|
4784
|
+
var $L210 = $L("???");
|
|
4785
|
+
var $L211 = $L("[]");
|
|
4786
|
+
var $L212 = $L("civet");
|
|
4785
4787
|
var $R0 = $R(new RegExp("(?=debugger|if|unless|do|for|loop|until|while|switch|throw|try)", "suy"));
|
|
4786
4788
|
var $R1 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
4787
4789
|
var $R2 = $R(new RegExp("[0-9]", "suy"));
|
|
@@ -4791,16 +4793,16 @@ ${input.slice(result.pos)}
|
|
|
4791
4793
|
var $R6 = $R(new RegExp("(?=[\\/\\[{?.!@'\u2019:])", "suy"));
|
|
4792
4794
|
var $R7 = $R(new RegExp("[)}]", "suy"));
|
|
4793
4795
|
var $R8 = $R(new RegExp("[&]", "suy"));
|
|
4794
|
-
var $R9 = $R(new RegExp("
|
|
4795
|
-
var $R10 = $R(new RegExp(
|
|
4796
|
-
var $R11 = $R(new RegExp("(
|
|
4797
|
-
var $R12 = $R(new RegExp("(
|
|
4798
|
-
var $R13 = $R(new RegExp("(
|
|
4799
|
-
var $R14 = $R(new RegExp("
|
|
4800
|
-
var $R15 = $R(new RegExp("[
|
|
4801
|
-
var $R16 = $R(new RegExp("
|
|
4802
|
-
var $R17 = $R(new RegExp("
|
|
4803
|
-
var $R18 = $R(new RegExp("
|
|
4796
|
+
var $R9 = $R(new RegExp(`(?=[0-9.'"tfyno])`, "suy"));
|
|
4797
|
+
var $R10 = $R(new RegExp("(?=true|false|yes|no|on|off)", "suy"));
|
|
4798
|
+
var $R11 = $R(new RegExp("(?=\\p{ID_Start}|[_$])", "suy"));
|
|
4799
|
+
var $R12 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
4800
|
+
var $R13 = $R(new RegExp("(?=\\[)", "suy"));
|
|
4801
|
+
var $R14 = $R(new RegExp("[!+-]", "suy"));
|
|
4802
|
+
var $R15 = $R(new RegExp("(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>+-])", "suy"));
|
|
4803
|
+
var $R16 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
4804
|
+
var $R17 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s)", "suy"));
|
|
4805
|
+
var $R18 = $R(new RegExp("[:.]", "suy"));
|
|
4804
4806
|
var $R19 = $R(new RegExp("(?=for|if|loop|unless|until|while)", "suy"));
|
|
4805
4807
|
var $R20 = $R(new RegExp("(?=loop|do|for|until|while)", "suy"));
|
|
4806
4808
|
var $R21 = $R(new RegExp("(?=[\\s\\),])", "suy"));
|
|
@@ -5081,7 +5083,8 @@ ${input.slice(result.pos)}
|
|
|
5081
5083
|
return $0;
|
|
5082
5084
|
return $skip;
|
|
5083
5085
|
});
|
|
5084
|
-
var ForbiddenImplicitCalls
|
|
5086
|
+
var ForbiddenImplicitCalls$6 = $EXPECT($L5, 'ForbiddenImplicitCalls "... "');
|
|
5087
|
+
var ForbiddenImplicitCalls$$ = [ForbiddenImplicitCalls$0, ForbiddenImplicitCalls$1, ForbiddenImplicitCalls$2, ForbiddenImplicitCalls$3, ForbiddenImplicitCalls$4, ForbiddenImplicitCalls$5, ForbiddenImplicitCalls$6];
|
|
5085
5088
|
function ForbiddenImplicitCalls(ctx, state) {
|
|
5086
5089
|
return $EVENT_C(ctx, state, "ForbiddenImplicitCalls", ForbiddenImplicitCalls$$);
|
|
5087
5090
|
}
|
|
@@ -5097,7 +5100,7 @@ ${input.slice(result.pos)}
|
|
|
5097
5100
|
function ArgumentsWithTrailingMemberExpressions(ctx, state) {
|
|
5098
5101
|
return $EVENT(ctx, state, "ArgumentsWithTrailingMemberExpressions", ArgumentsWithTrailingMemberExpressions$0);
|
|
5099
5102
|
}
|
|
5100
|
-
var TrailingMemberExpressions$0 = $TS($S($Q(MemberExpressionRest), $Q($S(IndentedAtLeast, $Y($S($E($EXPECT($
|
|
5103
|
+
var TrailingMemberExpressions$0 = $TS($S($Q(MemberExpressionRest), $Q($S(IndentedAtLeast, $Y($S($E($EXPECT($L6, 'TrailingMemberExpressions "?"')), $EXPECT($L7, 'TrailingMemberExpressions "."'), $N($EXPECT($R2, "TrailingMemberExpressions /[0-9]/")))), MemberExpressionRest))), function($skip, $loc, $0, $1, $2) {
|
|
5101
5104
|
return $1.concat($2);
|
|
5102
5105
|
});
|
|
5103
5106
|
function TrailingMemberExpressions(ctx, state) {
|
|
@@ -5111,7 +5114,7 @@ ${input.slice(result.pos)}
|
|
|
5111
5114
|
function AllowedTrailingMemberExpressions(ctx, state) {
|
|
5112
5115
|
return $EVENT_C(ctx, state, "AllowedTrailingMemberExpressions", AllowedTrailingMemberExpressions$$);
|
|
5113
5116
|
}
|
|
5114
|
-
var TrailingCallExpressions$0 = $P($S(IndentedAtLeast, $Y($S($E($EXPECT($
|
|
5117
|
+
var TrailingCallExpressions$0 = $P($S(IndentedAtLeast, $Y($S($E($EXPECT($L6, 'TrailingCallExpressions "?"')), $EXPECT($L7, 'TrailingCallExpressions "."'), $N($R$0($EXPECT($R2, "TrailingCallExpressions /[0-9]/"))))), $P(CallExpressionRest)));
|
|
5115
5118
|
function TrailingCallExpressions(ctx, state) {
|
|
5116
5119
|
return $EVENT(ctx, state, "TrailingCallExpressions", TrailingCallExpressions$0);
|
|
5117
5120
|
}
|
|
@@ -5245,19 +5248,20 @@ ${input.slice(result.pos)}
|
|
|
5245
5248
|
function ParenthesizedAssignment(ctx, state) {
|
|
5246
5249
|
return $EVENT(ctx, state, "ParenthesizedAssignment", ParenthesizedAssignment$0);
|
|
5247
5250
|
}
|
|
5248
|
-
var UnaryExpression$0 =
|
|
5251
|
+
var UnaryExpression$0 = AmpersandFunctionExpression;
|
|
5252
|
+
var UnaryExpression$1 = $TS($S($Q(UnaryOp), UnaryBody, $E(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5249
5253
|
var pre = $1;
|
|
5250
5254
|
var exp = $2;
|
|
5251
5255
|
var post = $3;
|
|
5252
5256
|
return processUnaryExpression(pre, exp, post);
|
|
5253
5257
|
});
|
|
5254
|
-
var UnaryExpression$
|
|
5258
|
+
var UnaryExpression$2 = $TS($S(CoffeeDoEnabled, Do, __, $C($S(LeftHandSideExpression, $N($S(__, AssignmentOpSymbol))), ArrowFunction, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5255
5259
|
var ws = $3;
|
|
5256
5260
|
var exp = $4;
|
|
5257
5261
|
ws = insertTrimmingSpace(ws, "");
|
|
5258
5262
|
return ["(", ...ws, exp, ")()"];
|
|
5259
5263
|
});
|
|
5260
|
-
var UnaryExpression$$ = [UnaryExpression$0, UnaryExpression$1];
|
|
5264
|
+
var UnaryExpression$$ = [UnaryExpression$0, UnaryExpression$1, UnaryExpression$2];
|
|
5261
5265
|
function UnaryExpression(ctx, state) {
|
|
5262
5266
|
return $EVENT_C(ctx, state, "UnaryExpression", UnaryExpression$$);
|
|
5263
5267
|
}
|
|
@@ -5313,7 +5317,7 @@ ${input.slice(result.pos)}
|
|
|
5313
5317
|
function UpdateExpression(ctx, state) {
|
|
5314
5318
|
return $EVENT_C(ctx, state, "UpdateExpression", UpdateExpression$$);
|
|
5315
5319
|
}
|
|
5316
|
-
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($
|
|
5320
|
+
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L8, 'UpdateExpressionSymbol "++"'), $EXPECT($L9, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
|
|
5317
5321
|
return { $loc, token: $1 };
|
|
5318
5322
|
});
|
|
5319
5323
|
function UpdateExpressionSymbol(ctx, state) {
|
|
@@ -5420,7 +5424,7 @@ ${input.slice(result.pos)}
|
|
|
5420
5424
|
function ArrowFunction(ctx, state) {
|
|
5421
5425
|
return $EVENT_C(ctx, state, "ArrowFunction", ArrowFunction$$);
|
|
5422
5426
|
}
|
|
5423
|
-
var FatArrow$0 = $TS($S($E(_), $C($EXPECT($
|
|
5427
|
+
var FatArrow$0 = $TS($S($E(_), $C($EXPECT($L10, 'FatArrow "=>"'), $EXPECT($L11, 'FatArrow "\u21D2"'))), function($skip, $loc, $0, $1, $2) {
|
|
5424
5428
|
var ws = $1;
|
|
5425
5429
|
if (!ws)
|
|
5426
5430
|
return " =>";
|
|
@@ -5583,7 +5587,7 @@ ${input.slice(result.pos)}
|
|
|
5583
5587
|
function ClassDeclaration(ctx, state) {
|
|
5584
5588
|
return $EVENT(ctx, state, "ClassDeclaration", ClassDeclaration$0);
|
|
5585
5589
|
}
|
|
5586
|
-
var ClassExpression$0 = $S($E(Decorators), $E($S(Abstract, __)), Class, $N($EXPECT($
|
|
5590
|
+
var ClassExpression$0 = $S($E(Decorators), $E($S(Abstract, __)), Class, $N($EXPECT($L12, 'ClassExpression ":"')), $E(ClassBinding), $E(ClassHeritage), ClassBody);
|
|
5587
5591
|
function ClassExpression(ctx, state) {
|
|
5588
5592
|
return $EVENT(ctx, state, "ClassExpression", ClassExpression$0);
|
|
5589
5593
|
}
|
|
@@ -5603,7 +5607,7 @@ ${input.slice(result.pos)}
|
|
|
5603
5607
|
function ExtendsClause(ctx, state) {
|
|
5604
5608
|
return $EVENT(ctx, state, "ExtendsClause", ExtendsClause$0);
|
|
5605
5609
|
}
|
|
5606
|
-
var ExtendsToken$0 = $TS($S(Loc, __, ExtendsShorthand, $E($EXPECT($
|
|
5610
|
+
var ExtendsToken$0 = $TS($S(Loc, __, ExtendsShorthand, $E($EXPECT($L13, 'ExtendsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5607
5611
|
var l = $1;
|
|
5608
5612
|
var ws = $2;
|
|
5609
5613
|
var t = $3;
|
|
@@ -5618,7 +5622,7 @@ ${input.slice(result.pos)}
|
|
|
5618
5622
|
function ExtendsToken(ctx, state) {
|
|
5619
5623
|
return $EVENT_C(ctx, state, "ExtendsToken", ExtendsToken$$);
|
|
5620
5624
|
}
|
|
5621
|
-
var ExtendsShorthand$0 = $TV($EXPECT($
|
|
5625
|
+
var ExtendsShorthand$0 = $TV($EXPECT($L14, 'ExtendsShorthand "<"'), function($skip, $loc, $0, $1) {
|
|
5622
5626
|
return { $loc, token: "extends " };
|
|
5623
5627
|
});
|
|
5624
5628
|
function ExtendsShorthand(ctx, state) {
|
|
@@ -5644,7 +5648,7 @@ ${input.slice(result.pos)}
|
|
|
5644
5648
|
function ImplementsClause(ctx, state) {
|
|
5645
5649
|
return $EVENT(ctx, state, "ImplementsClause", ImplementsClause$0);
|
|
5646
5650
|
}
|
|
5647
|
-
var ImplementsToken$0 = $TS($S(Loc, __, ImplementsShorthand, $E($EXPECT($
|
|
5651
|
+
var ImplementsToken$0 = $TS($S(Loc, __, ImplementsShorthand, $E($EXPECT($L13, 'ImplementsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5648
5652
|
var l = $1;
|
|
5649
5653
|
var ws = $2;
|
|
5650
5654
|
var token = $3;
|
|
@@ -5654,7 +5658,7 @@ ${input.slice(result.pos)}
|
|
|
5654
5658
|
}
|
|
5655
5659
|
return { children };
|
|
5656
5660
|
});
|
|
5657
|
-
var ImplementsToken$1 = $TS($S(__, $EXPECT($
|
|
5661
|
+
var ImplementsToken$1 = $TS($S(__, $EXPECT($L15, 'ImplementsToken "implements"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
5658
5662
|
$2 = { $loc, token: $2 };
|
|
5659
5663
|
return [$1, $2];
|
|
5660
5664
|
});
|
|
@@ -5662,7 +5666,7 @@ ${input.slice(result.pos)}
|
|
|
5662
5666
|
function ImplementsToken(ctx, state) {
|
|
5663
5667
|
return $EVENT_C(ctx, state, "ImplementsToken", ImplementsToken$$);
|
|
5664
5668
|
}
|
|
5665
|
-
var ImplementsShorthand$0 = $TV($EXPECT($
|
|
5669
|
+
var ImplementsShorthand$0 = $TV($EXPECT($L16, 'ImplementsShorthand "<:"'), function($skip, $loc, $0, $1) {
|
|
5666
5670
|
return { $loc, token: "implements " };
|
|
5667
5671
|
});
|
|
5668
5672
|
function ImplementsShorthand(ctx, state) {
|
|
@@ -5874,7 +5878,7 @@ ${input.slice(result.pos)}
|
|
|
5874
5878
|
function AtThis(ctx, state) {
|
|
5875
5879
|
return $EVENT(ctx, state, "AtThis", AtThis$0);
|
|
5876
5880
|
}
|
|
5877
|
-
var LeftHandSideExpression$0 = $S($P($S(New, $N($C($EXPECT($
|
|
5881
|
+
var LeftHandSideExpression$0 = $S($P($S(New, $N($C($EXPECT($L7, 'LeftHandSideExpression "."'), $EXPECT($L12, 'LeftHandSideExpression ":"'))), __)), CallExpression, $E(TypeArguments));
|
|
5878
5882
|
var LeftHandSideExpression$1 = CallExpression;
|
|
5879
5883
|
var LeftHandSideExpression$$ = [LeftHandSideExpression$0, LeftHandSideExpression$1];
|
|
5880
5884
|
function LeftHandSideExpression(ctx, state) {
|
|
@@ -5887,7 +5891,7 @@ ${input.slice(result.pos)}
|
|
|
5887
5891
|
children: [$1, ...$2, ...rest.flat()]
|
|
5888
5892
|
});
|
|
5889
5893
|
});
|
|
5890
|
-
var CallExpression$1 = $TS($S($EXPECT($
|
|
5894
|
+
var CallExpression$1 = $TS($S($EXPECT($L17, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5891
5895
|
var rest = $3;
|
|
5892
5896
|
return processCallMemberExpression({
|
|
5893
5897
|
type: "CallExpression",
|
|
@@ -5948,7 +5952,7 @@ ${input.slice(result.pos)}
|
|
|
5948
5952
|
function OptionalDot(ctx, state) {
|
|
5949
5953
|
return $EVENT_C(ctx, state, "OptionalDot", OptionalDot$$);
|
|
5950
5954
|
}
|
|
5951
|
-
var NonNullAssertion$0 = $T($S($EXPECT($
|
|
5955
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L18, 'NonNullAssertion "!"'), $N($EXPECT($L19, 'NonNullAssertion "^"'))), function(value) {
|
|
5952
5956
|
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
5953
5957
|
});
|
|
5954
5958
|
function NonNullAssertion(ctx, state) {
|
|
@@ -6139,7 +6143,7 @@ ${input.slice(result.pos)}
|
|
|
6139
6143
|
]
|
|
6140
6144
|
};
|
|
6141
6145
|
});
|
|
6142
|
-
var PropertyAccess$1 = $TS($S(AccessStart, $EXPECT($
|
|
6146
|
+
var PropertyAccess$1 = $TS($S(AccessStart, $EXPECT($L20, 'PropertyAccess "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
6143
6147
|
var dot = $1;
|
|
6144
6148
|
var neg = $2;
|
|
6145
6149
|
var num = $3;
|
|
@@ -6215,7 +6219,7 @@ ${input.slice(result.pos)}
|
|
|
6215
6219
|
return $EVENT_C(ctx, state, "SuperProperty", SuperProperty$$);
|
|
6216
6220
|
}
|
|
6217
6221
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
6218
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
6222
|
+
var MetaProperty$1 = $TS($S($EXPECT($L21, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6219
6223
|
return { $loc, token: $1 };
|
|
6220
6224
|
});
|
|
6221
6225
|
var MetaProperty$2 = ReturnValue;
|
|
@@ -6223,7 +6227,7 @@ ${input.slice(result.pos)}
|
|
|
6223
6227
|
function MetaProperty(ctx, state) {
|
|
6224
6228
|
return $EVENT_C(ctx, state, "MetaProperty", MetaProperty$$);
|
|
6225
6229
|
}
|
|
6226
|
-
var ReturnValue$0 = $TV($C($S($EXPECT($
|
|
6230
|
+
var ReturnValue$0 = $TV($C($S($EXPECT($L22, 'ReturnValue "return.value"'), NonIdContinue), $S(Return, $Y(AfterReturnShorthand))), function($skip, $loc, $0, $1) {
|
|
6227
6231
|
return { type: "ReturnValue", children: [$1[0]] };
|
|
6228
6232
|
});
|
|
6229
6233
|
function ReturnValue(ctx, state) {
|
|
@@ -6736,7 +6740,7 @@ ${input.slice(result.pos)}
|
|
|
6736
6740
|
children: [ws, binding]
|
|
6737
6741
|
};
|
|
6738
6742
|
});
|
|
6739
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
6743
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L23, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
6740
6744
|
return {
|
|
6741
6745
|
children: [{
|
|
6742
6746
|
type: "ElisionElement",
|
|
@@ -6860,7 +6864,7 @@ ${input.slice(result.pos)}
|
|
|
6860
6864
|
block
|
|
6861
6865
|
};
|
|
6862
6866
|
});
|
|
6863
|
-
var FunctionExpression$1 = $TV($EXPECT($
|
|
6867
|
+
var FunctionExpression$1 = $TV($EXPECT($L24, 'FunctionExpression "(&)"'), function($skip, $loc, $0, $1) {
|
|
6864
6868
|
const ref = makeRef("$"), body = [ref];
|
|
6865
6869
|
const parameters = {
|
|
6866
6870
|
type: "Parameters",
|
|
@@ -6903,10 +6907,10 @@ ${input.slice(result.pos)}
|
|
|
6903
6907
|
function FunctionExpression(ctx, state) {
|
|
6904
6908
|
return $EVENT_C(ctx, state, "FunctionExpression", FunctionExpression$$);
|
|
6905
6909
|
}
|
|
6906
|
-
var AmpersandFunctionExpression$0 = $TS($S($
|
|
6910
|
+
var AmpersandFunctionExpression$0 = $TS($S($Q(UnaryOp), $C(Ampersand, $S($N(NumericLiteral), $Y($S($E(QuestionMark), Dot, $N(Dot))))), $E(AmpersandBlockRHS)), function($skip, $loc, $0, $1, $2, $3) {
|
|
6907
6911
|
var prefix = $1;
|
|
6908
6912
|
var rhs = $3;
|
|
6909
|
-
if (!prefix && !rhs)
|
|
6913
|
+
if (!prefix.length && !rhs)
|
|
6910
6914
|
return $skip;
|
|
6911
6915
|
let body, ref;
|
|
6912
6916
|
if (!rhs) {
|
|
@@ -6922,7 +6926,7 @@ ${input.slice(result.pos)}
|
|
|
6922
6926
|
}
|
|
6923
6927
|
body = rhs;
|
|
6924
6928
|
}
|
|
6925
|
-
if (prefix) {
|
|
6929
|
+
if (prefix.length) {
|
|
6926
6930
|
body = {
|
|
6927
6931
|
type: "UnaryExpression",
|
|
6928
6932
|
children: [prefix, body, void 0]
|
|
@@ -7077,10 +7081,6 @@ ${input.slice(result.pos)}
|
|
|
7077
7081
|
function AmpersandBlockRHSBody(ctx, state) {
|
|
7078
7082
|
return $EVENT(ctx, state, "AmpersandBlockRHSBody", AmpersandBlockRHSBody$0);
|
|
7079
7083
|
}
|
|
7080
|
-
var AmpersandUnaryPrefix$0 = $R$0($EXPECT($R9, "AmpersandUnaryPrefix /[!~+-]+/"));
|
|
7081
|
-
function AmpersandUnaryPrefix(ctx, state) {
|
|
7082
|
-
return $EVENT(ctx, state, "AmpersandUnaryPrefix", AmpersandUnaryPrefix$0);
|
|
7083
|
-
}
|
|
7084
7084
|
var ThinArrowFunction$0 = $TS($S($E($S(Async, _)), ArrowParameters, $E(ReturnTypeSuffix), $E(_), Arrow, NoCommaBracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
7085
7085
|
var async = $1;
|
|
7086
7086
|
var parameters = $2;
|
|
@@ -7124,7 +7124,7 @@ ${input.slice(result.pos)}
|
|
|
7124
7124
|
function ThinArrowFunction(ctx, state) {
|
|
7125
7125
|
return $EVENT(ctx, state, "ThinArrowFunction", ThinArrowFunction$0);
|
|
7126
7126
|
}
|
|
7127
|
-
var Arrow$0 = $TV($C($EXPECT($
|
|
7127
|
+
var Arrow$0 = $TV($C($EXPECT($L25, 'Arrow "->"'), $EXPECT($L26, 'Arrow "\u2192"')), function($skip, $loc, $0, $1) {
|
|
7128
7128
|
return { $loc, token: "->" };
|
|
7129
7129
|
});
|
|
7130
7130
|
function Arrow(ctx, state) {
|
|
@@ -7410,7 +7410,7 @@ ${input.slice(result.pos)}
|
|
|
7410
7410
|
}
|
|
7411
7411
|
var BracedContent$0 = NestedBlockStatements;
|
|
7412
7412
|
var BracedContent$1 = SingleLineStatements;
|
|
7413
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
7413
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L27, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
7414
7414
|
const expressions = [];
|
|
7415
7415
|
return {
|
|
7416
7416
|
type: "BlockStatement",
|
|
@@ -7460,7 +7460,7 @@ ${input.slice(result.pos)}
|
|
|
7460
7460
|
function BlockStatementPart(ctx, state) {
|
|
7461
7461
|
return $EVENT(ctx, state, "BlockStatementPart", BlockStatementPart$0);
|
|
7462
7462
|
}
|
|
7463
|
-
var Literal$0 = $TS($S($EXPECT($
|
|
7463
|
+
var Literal$0 = $TS($S($EXPECT($R9, `Literal /(?=[0-9.'"tfyno])/`), LiteralContent), function($skip, $loc, $0, $1, $2) {
|
|
7464
7464
|
var literal = $2;
|
|
7465
7465
|
return {
|
|
7466
7466
|
type: "Literal",
|
|
@@ -7480,13 +7480,13 @@ ${input.slice(result.pos)}
|
|
|
7480
7480
|
function LiteralContent(ctx, state) {
|
|
7481
7481
|
return $EVENT_C(ctx, state, "LiteralContent", LiteralContent$$);
|
|
7482
7482
|
}
|
|
7483
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
7483
|
+
var NullLiteral$0 = $TS($S($EXPECT($L28, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7484
7484
|
return { $loc, token: $1 };
|
|
7485
7485
|
});
|
|
7486
7486
|
function NullLiteral(ctx, state) {
|
|
7487
7487
|
return $EVENT(ctx, state, "NullLiteral", NullLiteral$0);
|
|
7488
7488
|
}
|
|
7489
|
-
var BooleanLiteral$0 = $T($S($EXPECT($
|
|
7489
|
+
var BooleanLiteral$0 = $T($S($EXPECT($R10, "BooleanLiteral /(?=true|false|yes|no|on|off)/"), _BooleanLiteral), function(value) {
|
|
7490
7490
|
return value[1];
|
|
7491
7491
|
});
|
|
7492
7492
|
function BooleanLiteral(ctx, state) {
|
|
@@ -7495,31 +7495,31 @@ ${input.slice(result.pos)}
|
|
|
7495
7495
|
var _BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
7496
7496
|
return value[1];
|
|
7497
7497
|
});
|
|
7498
|
-
var _BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
7498
|
+
var _BooleanLiteral$1 = $TS($S($C($EXPECT($L29, '_BooleanLiteral "true"'), $EXPECT($L30, '_BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7499
7499
|
return { $loc, token: $1 };
|
|
7500
7500
|
});
|
|
7501
7501
|
var _BooleanLiteral$$ = [_BooleanLiteral$0, _BooleanLiteral$1];
|
|
7502
7502
|
function _BooleanLiteral(ctx, state) {
|
|
7503
7503
|
return $EVENT_C(ctx, state, "_BooleanLiteral", _BooleanLiteral$$);
|
|
7504
7504
|
}
|
|
7505
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
7505
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L31, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L32, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7506
7506
|
return { $loc, token: "true" };
|
|
7507
7507
|
});
|
|
7508
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
7508
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L33, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L34, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7509
7509
|
return { $loc, token: "false" };
|
|
7510
7510
|
});
|
|
7511
7511
|
var CoffeeScriptBooleanLiteral$$ = [CoffeeScriptBooleanLiteral$0, CoffeeScriptBooleanLiteral$1];
|
|
7512
7512
|
function CoffeeScriptBooleanLiteral(ctx, state) {
|
|
7513
7513
|
return $EVENT_C(ctx, state, "CoffeeScriptBooleanLiteral", CoffeeScriptBooleanLiteral$$);
|
|
7514
7514
|
}
|
|
7515
|
-
var Identifier$0 = $T($S($EXPECT($
|
|
7515
|
+
var Identifier$0 = $T($S($EXPECT($R11, "Identifier /(?=\\p{ID_Start}|[_$])/"), $N(ReservedWord), IdentifierName), function(value) {
|
|
7516
7516
|
var id = value[2];
|
|
7517
7517
|
return id;
|
|
7518
7518
|
});
|
|
7519
7519
|
function Identifier(ctx, state) {
|
|
7520
7520
|
return $EVENT(ctx, state, "Identifier", Identifier$0);
|
|
7521
7521
|
}
|
|
7522
|
-
var IdentifierName$0 = $TR($EXPECT($
|
|
7522
|
+
var IdentifierName$0 = $TR($EXPECT($R12, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
7523
7523
|
return {
|
|
7524
7524
|
type: "Identifier",
|
|
7525
7525
|
name: $0,
|
|
@@ -7537,11 +7537,11 @@ ${input.slice(result.pos)}
|
|
|
7537
7537
|
function IdentifierReference(ctx, state) {
|
|
7538
7538
|
return $EVENT(ctx, state, "IdentifierReference", IdentifierReference$0);
|
|
7539
7539
|
}
|
|
7540
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L3, 'UpcomingAssignment "="'), $N($C($EXPECT($L3, 'UpcomingAssignment "="'), $EXPECT($
|
|
7540
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L3, 'UpcomingAssignment "="'), $N($C($EXPECT($L3, 'UpcomingAssignment "="'), $EXPECT($L35, 'UpcomingAssignment ">"')))));
|
|
7541
7541
|
function UpcomingAssignment(ctx, state) {
|
|
7542
7542
|
return $EVENT(ctx, state, "UpcomingAssignment", UpcomingAssignment$0);
|
|
7543
7543
|
}
|
|
7544
|
-
var ArrayLiteral$0 = $T($S($EXPECT($
|
|
7544
|
+
var ArrayLiteral$0 = $T($S($EXPECT($R13, "ArrayLiteral /(?=\\[)/"), _ArrayLiteral), function(value) {
|
|
7545
7545
|
return value[1];
|
|
7546
7546
|
});
|
|
7547
7547
|
function ArrayLiteral(ctx, state) {
|
|
@@ -7695,7 +7695,7 @@ ${input.slice(result.pos)}
|
|
|
7695
7695
|
return $EVENT(ctx, state, "NestedElement", NestedElement$0);
|
|
7696
7696
|
}
|
|
7697
7697
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
7698
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7698
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L36, 'ArrayElementDelimiter "]"')));
|
|
7699
7699
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7700
7700
|
return value[1];
|
|
7701
7701
|
});
|
|
@@ -7925,7 +7925,7 @@ ${input.slice(result.pos)}
|
|
|
7925
7925
|
return $EVENT_C(ctx, state, "ImplicitInlineObjectPropertyDelimiter", ImplicitInlineObjectPropertyDelimiter$$);
|
|
7926
7926
|
}
|
|
7927
7927
|
var ObjectPropertyDelimiter$0 = $S($E(_), Comma);
|
|
7928
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7928
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L27, 'ObjectPropertyDelimiter "}"')));
|
|
7929
7929
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7930
7930
|
return value[1];
|
|
7931
7931
|
});
|
|
@@ -7941,7 +7941,7 @@ ${input.slice(result.pos)}
|
|
|
7941
7941
|
children: [ws, ...prop.children]
|
|
7942
7942
|
};
|
|
7943
7943
|
});
|
|
7944
|
-
var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($
|
|
7944
|
+
var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($R14, "PropertyDefinition /[!+-]/")), PropertyName), function($skip, $loc, $0, $1, $2, $3) {
|
|
7945
7945
|
var ws = $1;
|
|
7946
7946
|
var toggle = $2;
|
|
7947
7947
|
var id = $3;
|
|
@@ -8108,7 +8108,7 @@ ${input.slice(result.pos)}
|
|
|
8108
8108
|
implicit: true
|
|
8109
8109
|
};
|
|
8110
8110
|
});
|
|
8111
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
8111
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L20, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8112
8112
|
const expression = [$2, $3];
|
|
8113
8113
|
return {
|
|
8114
8114
|
type: "ComputedPropertyName",
|
|
@@ -8403,22 +8403,22 @@ ${input.slice(result.pos)}
|
|
|
8403
8403
|
function OperatorAssignmentOp(ctx, state) {
|
|
8404
8404
|
return $EVENT_C(ctx, state, "OperatorAssignmentOp", OperatorAssignmentOp$$);
|
|
8405
8405
|
}
|
|
8406
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
8407
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
8408
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
8409
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
8410
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
8411
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
8412
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
8413
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
8414
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
8415
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
8416
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
8417
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
8418
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
8419
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
8420
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
8421
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
8406
|
+
var AssignmentOpSymbol$0 = $EXPECT($L37, 'AssignmentOpSymbol "**="');
|
|
8407
|
+
var AssignmentOpSymbol$1 = $EXPECT($L38, 'AssignmentOpSymbol "*="');
|
|
8408
|
+
var AssignmentOpSymbol$2 = $EXPECT($L39, 'AssignmentOpSymbol "/="');
|
|
8409
|
+
var AssignmentOpSymbol$3 = $EXPECT($L40, 'AssignmentOpSymbol "%="');
|
|
8410
|
+
var AssignmentOpSymbol$4 = $EXPECT($L41, 'AssignmentOpSymbol "+="');
|
|
8411
|
+
var AssignmentOpSymbol$5 = $EXPECT($L42, 'AssignmentOpSymbol "-="');
|
|
8412
|
+
var AssignmentOpSymbol$6 = $EXPECT($L43, 'AssignmentOpSymbol "<<="');
|
|
8413
|
+
var AssignmentOpSymbol$7 = $EXPECT($L44, 'AssignmentOpSymbol ">>>="');
|
|
8414
|
+
var AssignmentOpSymbol$8 = $EXPECT($L45, 'AssignmentOpSymbol ">>="');
|
|
8415
|
+
var AssignmentOpSymbol$9 = $EXPECT($L46, 'AssignmentOpSymbol "&&="');
|
|
8416
|
+
var AssignmentOpSymbol$10 = $EXPECT($L47, 'AssignmentOpSymbol "&="');
|
|
8417
|
+
var AssignmentOpSymbol$11 = $EXPECT($L48, 'AssignmentOpSymbol "^="');
|
|
8418
|
+
var AssignmentOpSymbol$12 = $EXPECT($L49, 'AssignmentOpSymbol "||="');
|
|
8419
|
+
var AssignmentOpSymbol$13 = $EXPECT($L50, 'AssignmentOpSymbol "|="');
|
|
8420
|
+
var AssignmentOpSymbol$14 = $EXPECT($L51, 'AssignmentOpSymbol "??="');
|
|
8421
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L52, 'AssignmentOpSymbol "?="'), function(value) {
|
|
8422
8422
|
return "??=";
|
|
8423
8423
|
});
|
|
8424
8424
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L3, 'AssignmentOpSymbol "="'), $N($EXPECT($L3, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -8431,10 +8431,10 @@ ${input.slice(result.pos)}
|
|
|
8431
8431
|
function AssignmentOpSymbol(ctx, state) {
|
|
8432
8432
|
return $EVENT_C(ctx, state, "AssignmentOpSymbol", AssignmentOpSymbol$$);
|
|
8433
8433
|
}
|
|
8434
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
8434
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L53, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
8435
8435
|
return "&&=";
|
|
8436
8436
|
});
|
|
8437
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
8437
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L54, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
8438
8438
|
return "||=";
|
|
8439
8439
|
});
|
|
8440
8440
|
var CoffeeWordAssignmentOp$$ = [CoffeeWordAssignmentOp$0, CoffeeWordAssignmentOp$1];
|
|
@@ -8468,7 +8468,7 @@ ${input.slice(result.pos)}
|
|
|
8468
8468
|
function IdentifierBinaryOp(ctx, state) {
|
|
8469
8469
|
return $EVENT(ctx, state, "IdentifierBinaryOp", IdentifierBinaryOp$0);
|
|
8470
8470
|
}
|
|
8471
|
-
var BinaryOp$0 = $T($S($EXPECT($
|
|
8471
|
+
var BinaryOp$0 = $T($S($EXPECT($R15, "BinaryOp /(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>+-])/"), _BinaryOp), function(value) {
|
|
8472
8472
|
var op = value[1];
|
|
8473
8473
|
return op;
|
|
8474
8474
|
});
|
|
@@ -8503,27 +8503,27 @@ ${input.slice(result.pos)}
|
|
|
8503
8503
|
function _BinaryOp(ctx, state) {
|
|
8504
8504
|
return $EVENT_C(ctx, state, "_BinaryOp", _BinaryOp$$);
|
|
8505
8505
|
}
|
|
8506
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
8507
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
8508
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
8509
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
8506
|
+
var BinaryOpSymbol$0 = $EXPECT($L55, 'BinaryOpSymbol "**"');
|
|
8507
|
+
var BinaryOpSymbol$1 = $EXPECT($L56, 'BinaryOpSymbol "*"');
|
|
8508
|
+
var BinaryOpSymbol$2 = $EXPECT($L57, 'BinaryOpSymbol "/"');
|
|
8509
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L58, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
8510
8510
|
return {
|
|
8511
8511
|
call: module.getRef("modulo"),
|
|
8512
8512
|
special: true
|
|
8513
8513
|
};
|
|
8514
8514
|
});
|
|
8515
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
8516
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
8517
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
8518
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
8519
|
-
var BinaryOpSymbol$8 = $T($EXPECT($
|
|
8515
|
+
var BinaryOpSymbol$4 = $EXPECT($L59, 'BinaryOpSymbol "%"');
|
|
8516
|
+
var BinaryOpSymbol$5 = $EXPECT($L60, 'BinaryOpSymbol "+"');
|
|
8517
|
+
var BinaryOpSymbol$6 = $EXPECT($L20, 'BinaryOpSymbol "-"');
|
|
8518
|
+
var BinaryOpSymbol$7 = $EXPECT($L61, 'BinaryOpSymbol "<="');
|
|
8519
|
+
var BinaryOpSymbol$8 = $T($EXPECT($L62, 'BinaryOpSymbol "\u2264"'), function(value) {
|
|
8520
8520
|
return "<=";
|
|
8521
8521
|
});
|
|
8522
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
8523
|
-
var BinaryOpSymbol$10 = $T($EXPECT($
|
|
8522
|
+
var BinaryOpSymbol$9 = $EXPECT($L63, 'BinaryOpSymbol ">="');
|
|
8523
|
+
var BinaryOpSymbol$10 = $T($EXPECT($L64, 'BinaryOpSymbol "\u2265"'), function(value) {
|
|
8524
8524
|
return ">=";
|
|
8525
8525
|
});
|
|
8526
|
-
var BinaryOpSymbol$11 = $TV($EXPECT($
|
|
8526
|
+
var BinaryOpSymbol$11 = $TV($EXPECT($L65, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
8527
8527
|
return {
|
|
8528
8528
|
$loc,
|
|
8529
8529
|
token: "instanceof",
|
|
@@ -8531,7 +8531,7 @@ ${input.slice(result.pos)}
|
|
|
8531
8531
|
special: true
|
|
8532
8532
|
};
|
|
8533
8533
|
});
|
|
8534
|
-
var BinaryOpSymbol$12 = $TV($EXPECT($
|
|
8534
|
+
var BinaryOpSymbol$12 = $TV($EXPECT($L66, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
8535
8535
|
return {
|
|
8536
8536
|
$loc,
|
|
8537
8537
|
token: "instanceof",
|
|
@@ -8540,74 +8540,74 @@ ${input.slice(result.pos)}
|
|
|
8540
8540
|
negated: true
|
|
8541
8541
|
};
|
|
8542
8542
|
});
|
|
8543
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
8544
|
-
var BinaryOpSymbol$14 = $T($EXPECT($
|
|
8543
|
+
var BinaryOpSymbol$13 = $EXPECT($L67, 'BinaryOpSymbol "<<"');
|
|
8544
|
+
var BinaryOpSymbol$14 = $T($EXPECT($L68, 'BinaryOpSymbol "\xAB"'), function(value) {
|
|
8545
8545
|
return "<<";
|
|
8546
8546
|
});
|
|
8547
|
-
var BinaryOpSymbol$15 = $EXPECT($
|
|
8548
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
8549
|
-
var BinaryOpSymbol$17 = $T($EXPECT($
|
|
8547
|
+
var BinaryOpSymbol$15 = $EXPECT($L14, 'BinaryOpSymbol "<"');
|
|
8548
|
+
var BinaryOpSymbol$16 = $EXPECT($L69, 'BinaryOpSymbol ">>>"');
|
|
8549
|
+
var BinaryOpSymbol$17 = $T($EXPECT($L70, 'BinaryOpSymbol "\u22D9"'), function(value) {
|
|
8550
8550
|
return ">>>";
|
|
8551
8551
|
});
|
|
8552
|
-
var BinaryOpSymbol$18 = $EXPECT($
|
|
8553
|
-
var BinaryOpSymbol$19 = $T($EXPECT($
|
|
8552
|
+
var BinaryOpSymbol$18 = $EXPECT($L71, 'BinaryOpSymbol ">>"');
|
|
8553
|
+
var BinaryOpSymbol$19 = $T($EXPECT($L72, 'BinaryOpSymbol "\xBB"'), function(value) {
|
|
8554
8554
|
return ">>";
|
|
8555
8555
|
});
|
|
8556
|
-
var BinaryOpSymbol$20 = $EXPECT($
|
|
8557
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
8558
|
-
var BinaryOpSymbol$22 = $T($EXPECT($
|
|
8556
|
+
var BinaryOpSymbol$20 = $EXPECT($L35, 'BinaryOpSymbol ">"');
|
|
8557
|
+
var BinaryOpSymbol$21 = $EXPECT($L73, 'BinaryOpSymbol "!=="');
|
|
8558
|
+
var BinaryOpSymbol$22 = $T($EXPECT($L74, 'BinaryOpSymbol "\u2262"'), function(value) {
|
|
8559
8559
|
return "!==";
|
|
8560
8560
|
});
|
|
8561
|
-
var BinaryOpSymbol$23 = $TV($C($EXPECT($
|
|
8561
|
+
var BinaryOpSymbol$23 = $TV($C($EXPECT($L75, 'BinaryOpSymbol "!="'), $EXPECT($L76, 'BinaryOpSymbol "\u2260"')), function($skip, $loc, $0, $1) {
|
|
8562
8562
|
if (module.config.coffeeEq)
|
|
8563
8563
|
return "!==";
|
|
8564
8564
|
return "!=";
|
|
8565
8565
|
});
|
|
8566
|
-
var BinaryOpSymbol$24 = $TS($S($EXPECT($
|
|
8566
|
+
var BinaryOpSymbol$24 = $TS($S($EXPECT($L77, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8567
8567
|
if (module.config.coffeeIsnt)
|
|
8568
8568
|
return "!==";
|
|
8569
8569
|
return $skip;
|
|
8570
8570
|
});
|
|
8571
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
8572
|
-
var BinaryOpSymbol$26 = $T($C($EXPECT($
|
|
8571
|
+
var BinaryOpSymbol$25 = $EXPECT($L78, 'BinaryOpSymbol "==="');
|
|
8572
|
+
var BinaryOpSymbol$26 = $T($C($EXPECT($L79, 'BinaryOpSymbol "\u2263"'), $EXPECT($L80, 'BinaryOpSymbol "\u2A76"')), function(value) {
|
|
8573
8573
|
return "===";
|
|
8574
8574
|
});
|
|
8575
|
-
var BinaryOpSymbol$27 = $TV($C($EXPECT($
|
|
8575
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($L81, 'BinaryOpSymbol "=="'), $EXPECT($L82, 'BinaryOpSymbol "\u2261"'), $EXPECT($L83, 'BinaryOpSymbol "\u2A75"')), function($skip, $loc, $0, $1) {
|
|
8576
8576
|
if (module.config.coffeeEq)
|
|
8577
8577
|
return "===";
|
|
8578
8578
|
return "==";
|
|
8579
8579
|
});
|
|
8580
|
-
var BinaryOpSymbol$28 = $T($S($EXPECT($
|
|
8580
|
+
var BinaryOpSymbol$28 = $T($S($EXPECT($L84, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
8581
8581
|
return "&&";
|
|
8582
8582
|
});
|
|
8583
|
-
var BinaryOpSymbol$29 = $EXPECT($
|
|
8584
|
-
var BinaryOpSymbol$30 = $T($S($EXPECT($
|
|
8583
|
+
var BinaryOpSymbol$29 = $EXPECT($L85, 'BinaryOpSymbol "&&"');
|
|
8584
|
+
var BinaryOpSymbol$30 = $T($S($EXPECT($L86, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
8585
8585
|
return "||";
|
|
8586
8586
|
});
|
|
8587
|
-
var BinaryOpSymbol$31 = $EXPECT($
|
|
8588
|
-
var BinaryOpSymbol$32 = $T($EXPECT($
|
|
8587
|
+
var BinaryOpSymbol$31 = $EXPECT($L87, 'BinaryOpSymbol "||"');
|
|
8588
|
+
var BinaryOpSymbol$32 = $T($EXPECT($L88, 'BinaryOpSymbol "\u2016"'), function(value) {
|
|
8589
8589
|
return "||";
|
|
8590
8590
|
});
|
|
8591
|
-
var BinaryOpSymbol$33 = $TV($C($EXPECT($
|
|
8591
|
+
var BinaryOpSymbol$33 = $TV($C($EXPECT($L89, 'BinaryOpSymbol "^^"'), $S($EXPECT($L90, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8592
8592
|
return {
|
|
8593
8593
|
call: module.getRef("xor"),
|
|
8594
8594
|
special: true
|
|
8595
8595
|
};
|
|
8596
8596
|
});
|
|
8597
|
-
var BinaryOpSymbol$34 = $TV($C($EXPECT($
|
|
8597
|
+
var BinaryOpSymbol$34 = $TV($C($EXPECT($R16, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L91, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8598
8598
|
return {
|
|
8599
8599
|
call: module.getRef("xnor"),
|
|
8600
8600
|
special: true
|
|
8601
8601
|
};
|
|
8602
8602
|
});
|
|
8603
|
-
var BinaryOpSymbol$35 = $EXPECT($
|
|
8604
|
-
var BinaryOpSymbol$36 = $T($EXPECT($
|
|
8603
|
+
var BinaryOpSymbol$35 = $EXPECT($L92, 'BinaryOpSymbol "??"');
|
|
8604
|
+
var BinaryOpSymbol$36 = $T($EXPECT($L93, 'BinaryOpSymbol "\u2047"'), function(value) {
|
|
8605
8605
|
return "??";
|
|
8606
8606
|
});
|
|
8607
|
-
var BinaryOpSymbol$37 = $T($S($EXPECT($
|
|
8607
|
+
var BinaryOpSymbol$37 = $T($S($EXPECT($L6, 'BinaryOpSymbol "?"'), CoffeeBinaryExistentialEnabled), function(value) {
|
|
8608
8608
|
return "??";
|
|
8609
8609
|
});
|
|
8610
|
-
var BinaryOpSymbol$38 = $TS($S($EXPECT($
|
|
8610
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L94, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8611
8611
|
return {
|
|
8612
8612
|
$loc,
|
|
8613
8613
|
token: $1,
|
|
@@ -8624,7 +8624,7 @@ ${input.slice(result.pos)}
|
|
|
8624
8624
|
var op = $3;
|
|
8625
8625
|
return { ...op, $loc };
|
|
8626
8626
|
});
|
|
8627
|
-
var BinaryOpSymbol$41 = $TV($C($S(Is, __, In), $EXPECT($
|
|
8627
|
+
var BinaryOpSymbol$41 = $TV($C($S(Is, __, In), $EXPECT($L95, 'BinaryOpSymbol "\u2208"')), function($skip, $loc, $0, $1) {
|
|
8628
8628
|
return {
|
|
8629
8629
|
method: "includes",
|
|
8630
8630
|
relational: true,
|
|
@@ -8632,14 +8632,14 @@ ${input.slice(result.pos)}
|
|
|
8632
8632
|
special: true
|
|
8633
8633
|
};
|
|
8634
8634
|
});
|
|
8635
|
-
var BinaryOpSymbol$42 = $TV($EXPECT($
|
|
8635
|
+
var BinaryOpSymbol$42 = $TV($EXPECT($L96, 'BinaryOpSymbol "\u220B"'), function($skip, $loc, $0, $1) {
|
|
8636
8636
|
return {
|
|
8637
8637
|
method: "includes",
|
|
8638
8638
|
relational: true,
|
|
8639
8639
|
special: true
|
|
8640
8640
|
};
|
|
8641
8641
|
});
|
|
8642
|
-
var BinaryOpSymbol$43 = $TV($EXPECT($
|
|
8642
|
+
var BinaryOpSymbol$43 = $TV($EXPECT($L97, 'BinaryOpSymbol "\u220C"'), function($skip, $loc, $0, $1) {
|
|
8643
8643
|
return {
|
|
8644
8644
|
method: "includes",
|
|
8645
8645
|
relational: true,
|
|
@@ -8647,7 +8647,7 @@ ${input.slice(result.pos)}
|
|
|
8647
8647
|
negated: true
|
|
8648
8648
|
};
|
|
8649
8649
|
});
|
|
8650
|
-
var BinaryOpSymbol$44 = $TV($C($S(Is, __, Not, __, In), $EXPECT($
|
|
8650
|
+
var BinaryOpSymbol$44 = $TV($C($S(Is, __, Not, __, In), $EXPECT($L98, 'BinaryOpSymbol "\u2209"')), function($skip, $loc, $0, $1) {
|
|
8651
8651
|
return {
|
|
8652
8652
|
method: "includes",
|
|
8653
8653
|
relational: true,
|
|
@@ -8680,9 +8680,9 @@ ${input.slice(result.pos)}
|
|
|
8680
8680
|
return "===";
|
|
8681
8681
|
});
|
|
8682
8682
|
var BinaryOpSymbol$47 = In;
|
|
8683
|
-
var BinaryOpSymbol$48 = $EXPECT($
|
|
8684
|
-
var BinaryOpSymbol$49 = $EXPECT($
|
|
8685
|
-
var BinaryOpSymbol$50 = $EXPECT($
|
|
8683
|
+
var BinaryOpSymbol$48 = $EXPECT($L99, 'BinaryOpSymbol "&"');
|
|
8684
|
+
var BinaryOpSymbol$49 = $EXPECT($L19, 'BinaryOpSymbol "^"');
|
|
8685
|
+
var BinaryOpSymbol$50 = $EXPECT($L100, 'BinaryOpSymbol "|"');
|
|
8686
8686
|
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];
|
|
8687
8687
|
function BinaryOpSymbol(ctx, state) {
|
|
8688
8688
|
return $EVENT_C(ctx, state, "BinaryOpSymbol", BinaryOpSymbol$$);
|
|
@@ -8720,7 +8720,7 @@ ${input.slice(result.pos)}
|
|
|
8720
8720
|
function CoffeeOfOp(ctx, state) {
|
|
8721
8721
|
return $EVENT_C(ctx, state, "CoffeeOfOp", CoffeeOfOp$$);
|
|
8722
8722
|
}
|
|
8723
|
-
var NotOp$0 = $TS($S($EXPECT($
|
|
8723
|
+
var NotOp$0 = $TS($S($EXPECT($L94, 'NotOp "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8724
8724
|
return {
|
|
8725
8725
|
$loc,
|
|
8726
8726
|
token: "instanceof",
|
|
@@ -8741,25 +8741,25 @@ ${input.slice(result.pos)}
|
|
|
8741
8741
|
function NotOp(ctx, state) {
|
|
8742
8742
|
return $EVENT_C(ctx, state, "NotOp", NotOp$$);
|
|
8743
8743
|
}
|
|
8744
|
-
var Xor$0 = $EXPECT($
|
|
8745
|
-
var Xor$1 = $S($EXPECT($
|
|
8744
|
+
var Xor$0 = $EXPECT($L89, 'Xor "^^"');
|
|
8745
|
+
var Xor$1 = $S($EXPECT($L90, 'Xor "xor"'), NonIdContinue);
|
|
8746
8746
|
var Xor$$ = [Xor$0, Xor$1];
|
|
8747
8747
|
function Xor(ctx, state) {
|
|
8748
8748
|
return $EVENT_C(ctx, state, "Xor", Xor$$);
|
|
8749
8749
|
}
|
|
8750
|
-
var Xnor$0 = $R$0($EXPECT($
|
|
8751
|
-
var Xnor$1 = $EXPECT($
|
|
8750
|
+
var Xnor$0 = $R$0($EXPECT($R16, "Xnor /!\\^\\^?/"));
|
|
8751
|
+
var Xnor$1 = $EXPECT($L91, 'Xnor "xnor"');
|
|
8752
8752
|
var Xnor$$ = [Xnor$0, Xnor$1];
|
|
8753
8753
|
function Xnor(ctx, state) {
|
|
8754
8754
|
return $EVENT_C(ctx, state, "Xnor", Xnor$$);
|
|
8755
8755
|
}
|
|
8756
|
-
var UnaryOp$0 = $TR($EXPECT($
|
|
8756
|
+
var UnaryOp$0 = $TR($EXPECT($R17, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8757
8757
|
return { $loc, token: $0 };
|
|
8758
8758
|
});
|
|
8759
8759
|
var UnaryOp$1 = AwaitOp;
|
|
8760
|
-
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($EXPECT($
|
|
8761
|
-
var UnaryOp$3 = $T($S(Not, $E($EXPECT($
|
|
8762
|
-
return [value[0], value[
|
|
8760
|
+
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($R$0($EXPECT($R18, "UnaryOp /[:.]/"))), $E(_));
|
|
8761
|
+
var UnaryOp$3 = $T($S(Not, $N($EXPECT($R18, "UnaryOp /[:.]/")), $E($EXPECT($L13, 'UnaryOp " "')), $E(_)), function(value) {
|
|
8762
|
+
return [value[0], value[3]];
|
|
8763
8763
|
});
|
|
8764
8764
|
var UnaryOp$$ = [UnaryOp$0, UnaryOp$1, UnaryOp$2, UnaryOp$3];
|
|
8765
8765
|
function UnaryOp(ctx, state) {
|
|
@@ -8896,7 +8896,7 @@ ${input.slice(result.pos)}
|
|
|
8896
8896
|
function NoCommaStatement(ctx, state) {
|
|
8897
8897
|
return $EVENT_C(ctx, state, "NoCommaStatement", NoCommaStatement$$);
|
|
8898
8898
|
}
|
|
8899
|
-
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($
|
|
8899
|
+
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L101, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
|
|
8900
8900
|
return { type: "EmptyStatement", children: $1 || [] };
|
|
8901
8901
|
});
|
|
8902
8902
|
function EmptyStatement(ctx, state) {
|
|
@@ -8927,7 +8927,7 @@ ${input.slice(result.pos)}
|
|
|
8927
8927
|
var w = $3;
|
|
8928
8928
|
return [id, colon, w];
|
|
8929
8929
|
});
|
|
8930
|
-
var Label$1 = $S($EXPECT($
|
|
8930
|
+
var Label$1 = $S($EXPECT($L102, 'Label "$:"'), Whitespace);
|
|
8931
8931
|
var Label$$ = [Label$0, Label$1];
|
|
8932
8932
|
function Label(ctx, state) {
|
|
8933
8933
|
return $EVENT_C(ctx, state, "Label", Label$$);
|
|
@@ -9679,7 +9679,7 @@ ${input.slice(result.pos)}
|
|
|
9679
9679
|
function IgnoreColon(ctx, state) {
|
|
9680
9680
|
return $EVENT(ctx, state, "IgnoreColon", IgnoreColon$0);
|
|
9681
9681
|
}
|
|
9682
|
-
var TryStatement$0 = $TS($S(Try, $N($EXPECT($
|
|
9682
|
+
var TryStatement$0 = $TS($S(Try, $N($EXPECT($L12, 'TryStatement ":"')), NoPostfixBracedOrEmptyBlock, $E(CatchClause), $E(FinallyClause)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
9683
9683
|
var t = $1;
|
|
9684
9684
|
var b = $3;
|
|
9685
9685
|
var c = $4;
|
|
@@ -10015,7 +10015,7 @@ ${input.slice(result.pos)}
|
|
|
10015
10015
|
};
|
|
10016
10016
|
});
|
|
10017
10017
|
var KeywordStatement$2 = DebuggerStatement;
|
|
10018
|
-
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($
|
|
10018
|
+
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L12, 'KeywordStatement ":"'), $EXPECT($L7, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
|
|
10019
10019
|
var expression = value[2];
|
|
10020
10020
|
return { "type": "ReturnStatement", "expression": expression, "children": value };
|
|
10021
10021
|
});
|
|
@@ -10036,19 +10036,19 @@ ${input.slice(result.pos)}
|
|
|
10036
10036
|
function ThrowStatement(ctx, state) {
|
|
10037
10037
|
return $EVENT(ctx, state, "ThrowStatement", ThrowStatement$0);
|
|
10038
10038
|
}
|
|
10039
|
-
var Break$0 = $TS($S($EXPECT($
|
|
10039
|
+
var Break$0 = $TS($S($EXPECT($L103, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10040
10040
|
return { $loc, token: $1 };
|
|
10041
10041
|
});
|
|
10042
10042
|
function Break(ctx, state) {
|
|
10043
10043
|
return $EVENT(ctx, state, "Break", Break$0);
|
|
10044
10044
|
}
|
|
10045
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
10045
|
+
var Continue$0 = $TS($S($EXPECT($L104, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10046
10046
|
return { $loc, token: $1 };
|
|
10047
10047
|
});
|
|
10048
10048
|
function Continue(ctx, state) {
|
|
10049
10049
|
return $EVENT(ctx, state, "Continue", Continue$0);
|
|
10050
10050
|
}
|
|
10051
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
10051
|
+
var Debugger$0 = $TS($S($EXPECT($L105, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10052
10052
|
return { $loc, token: $1 };
|
|
10053
10053
|
});
|
|
10054
10054
|
function Debugger(ctx, state) {
|
|
@@ -10169,7 +10169,7 @@ ${input.slice(result.pos)}
|
|
|
10169
10169
|
function FromClause(ctx, state) {
|
|
10170
10170
|
return $EVENT(ctx, state, "FromClause", FromClause$0);
|
|
10171
10171
|
}
|
|
10172
|
-
var ImportAssertion$0 = $S($E(_), $C($EXPECT($
|
|
10172
|
+
var ImportAssertion$0 = $S($E(_), $C($EXPECT($L106, 'ImportAssertion "with"'), $EXPECT($L107, 'ImportAssertion "assert"')), NonIdContinue, $E(_), ObjectLiteral);
|
|
10173
10173
|
function ImportAssertion(ctx, state) {
|
|
10174
10174
|
return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
|
|
10175
10175
|
}
|
|
@@ -10217,7 +10217,7 @@ ${input.slice(result.pos)}
|
|
|
10217
10217
|
return $EVENT_C(ctx, state, "ImportSpecifier", ImportSpecifier$$);
|
|
10218
10218
|
}
|
|
10219
10219
|
var ImportAsToken$0 = $S(__, As);
|
|
10220
|
-
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($
|
|
10220
|
+
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($L13, 'ImportAsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
10221
10221
|
var l = $1;
|
|
10222
10222
|
var ws = $2;
|
|
10223
10223
|
var c = $3;
|
|
@@ -10389,13 +10389,13 @@ ${input.slice(result.pos)}
|
|
|
10389
10389
|
function LexicalDeclaration(ctx, state) {
|
|
10390
10390
|
return $EVENT_C(ctx, state, "LexicalDeclaration", LexicalDeclaration$$);
|
|
10391
10391
|
}
|
|
10392
|
-
var ConstAssignment$0 = $TV($C($EXPECT($
|
|
10392
|
+
var ConstAssignment$0 = $TV($C($EXPECT($L108, 'ConstAssignment ":="'), $EXPECT($L109, 'ConstAssignment "\u2254"')), function($skip, $loc, $0, $1) {
|
|
10393
10393
|
return { $loc, token: "=" };
|
|
10394
10394
|
});
|
|
10395
10395
|
function ConstAssignment(ctx, state) {
|
|
10396
10396
|
return $EVENT(ctx, state, "ConstAssignment", ConstAssignment$0);
|
|
10397
10397
|
}
|
|
10398
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
10398
|
+
var LetAssignment$0 = $TV($EXPECT($L110, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10399
10399
|
return { $loc, token: "=" };
|
|
10400
10400
|
});
|
|
10401
10401
|
function LetAssignment(ctx, state) {
|
|
@@ -10592,7 +10592,7 @@ ${input.slice(result.pos)}
|
|
|
10592
10592
|
return $EVENT(ctx, state, "CoffeeDoubleQuotedStringCharacters", CoffeeDoubleQuotedStringCharacters$0);
|
|
10593
10593
|
}
|
|
10594
10594
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
10595
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
10595
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L57, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L57, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
10596
10596
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
10597
10597
|
});
|
|
10598
10598
|
var RegularExpressionLiteral$$ = [RegularExpressionLiteral$0, RegularExpressionLiteral$1];
|
|
@@ -10801,7 +10801,7 @@ ${input.slice(result.pos)}
|
|
|
10801
10801
|
function MultiLineComment(ctx, state) {
|
|
10802
10802
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
10803
10803
|
}
|
|
10804
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
10804
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L111, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L112, 'JSMultiLineComment "*/"')), $EXPECT($R57, "JSMultiLineComment /./"))), $EXPECT($L112, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
10805
10805
|
return { type: "Comment", $loc, token: $1 };
|
|
10806
10806
|
});
|
|
10807
10807
|
function JSMultiLineComment(ctx, state) {
|
|
@@ -10847,7 +10847,7 @@ ${input.slice(result.pos)}
|
|
|
10847
10847
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R63, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10848
10848
|
return { $loc, token: $0 };
|
|
10849
10849
|
});
|
|
10850
|
-
var NonNewlineWhitespace$1 = $T($S($EXPECT($
|
|
10850
|
+
var NonNewlineWhitespace$1 = $T($S($EXPECT($L113, 'NonNewlineWhitespace "\\\\\\\\"'), CoffeeLineContinuationEnabled, EOL), function(value) {
|
|
10851
10851
|
return " ";
|
|
10852
10852
|
});
|
|
10853
10853
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
@@ -10893,7 +10893,7 @@ ${input.slice(result.pos)}
|
|
|
10893
10893
|
}
|
|
10894
10894
|
var StatementDelimiter$0 = $Y(EOS);
|
|
10895
10895
|
var StatementDelimiter$1 = SemicolonDelimiter;
|
|
10896
|
-
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($
|
|
10896
|
+
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L27, 'StatementDelimiter "}"'), $EXPECT($L114, 'StatementDelimiter ")"'), $EXPECT($L36, 'StatementDelimiter "]"'))));
|
|
10897
10897
|
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2];
|
|
10898
10898
|
function StatementDelimiter(ctx, state) {
|
|
10899
10899
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
@@ -10917,157 +10917,157 @@ ${input.slice(result.pos)}
|
|
|
10917
10917
|
function Loc(ctx, state) {
|
|
10918
10918
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
10919
10919
|
}
|
|
10920
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
10920
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L115, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L13, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
10921
10921
|
return { $loc, token: $1, ts: true };
|
|
10922
10922
|
});
|
|
10923
10923
|
function Abstract(ctx, state) {
|
|
10924
10924
|
return $EVENT(ctx, state, "Abstract", Abstract$0);
|
|
10925
10925
|
}
|
|
10926
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
10926
|
+
var Ampersand$0 = $TV($EXPECT($L99, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
10927
10927
|
return { $loc, token: $1 };
|
|
10928
10928
|
});
|
|
10929
10929
|
function Ampersand(ctx, state) {
|
|
10930
10930
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
10931
10931
|
}
|
|
10932
|
-
var As$0 = $TS($S($EXPECT($
|
|
10932
|
+
var As$0 = $TS($S($EXPECT($L116, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10933
10933
|
return { $loc, token: $1 };
|
|
10934
10934
|
});
|
|
10935
10935
|
function As(ctx, state) {
|
|
10936
10936
|
return $EVENT(ctx, state, "As", As$0);
|
|
10937
10937
|
}
|
|
10938
|
-
var At$0 = $TV($EXPECT($
|
|
10938
|
+
var At$0 = $TV($EXPECT($L117, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
10939
10939
|
return { $loc, token: $1 };
|
|
10940
10940
|
});
|
|
10941
10941
|
function At(ctx, state) {
|
|
10942
10942
|
return $EVENT(ctx, state, "At", At$0);
|
|
10943
10943
|
}
|
|
10944
|
-
var AtAt$0 = $TV($EXPECT($
|
|
10944
|
+
var AtAt$0 = $TV($EXPECT($L118, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
10945
10945
|
return { $loc, token: "@" };
|
|
10946
10946
|
});
|
|
10947
10947
|
function AtAt(ctx, state) {
|
|
10948
10948
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
10949
10949
|
}
|
|
10950
|
-
var Async$0 = $TS($S($EXPECT($
|
|
10950
|
+
var Async$0 = $TS($S($EXPECT($L119, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10951
10951
|
return { $loc, token: $1, type: "Async" };
|
|
10952
10952
|
});
|
|
10953
10953
|
function Async(ctx, state) {
|
|
10954
10954
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
10955
10955
|
}
|
|
10956
|
-
var Await$0 = $TS($S($EXPECT($
|
|
10956
|
+
var Await$0 = $TS($S($EXPECT($L120, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10957
10957
|
return { $loc, token: $1, type: "Await" };
|
|
10958
10958
|
});
|
|
10959
10959
|
function Await(ctx, state) {
|
|
10960
10960
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
10961
10961
|
}
|
|
10962
|
-
var Backtick$0 = $TV($EXPECT($
|
|
10962
|
+
var Backtick$0 = $TV($EXPECT($L121, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
10963
10963
|
return { $loc, token: $1 };
|
|
10964
10964
|
});
|
|
10965
10965
|
function Backtick(ctx, state) {
|
|
10966
10966
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
10967
10967
|
}
|
|
10968
|
-
var By$0 = $TS($S($EXPECT($
|
|
10968
|
+
var By$0 = $TS($S($EXPECT($L122, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10969
10969
|
return { $loc, token: $1 };
|
|
10970
10970
|
});
|
|
10971
10971
|
function By(ctx, state) {
|
|
10972
10972
|
return $EVENT(ctx, state, "By", By$0);
|
|
10973
10973
|
}
|
|
10974
|
-
var Caret$0 = $TV($EXPECT($
|
|
10974
|
+
var Caret$0 = $TV($EXPECT($L19, 'Caret "^"'), function($skip, $loc, $0, $1) {
|
|
10975
10975
|
return { $loc, token: $1 };
|
|
10976
10976
|
});
|
|
10977
10977
|
function Caret(ctx, state) {
|
|
10978
10978
|
return $EVENT(ctx, state, "Caret", Caret$0);
|
|
10979
10979
|
}
|
|
10980
|
-
var Case$0 = $TS($S($EXPECT($
|
|
10980
|
+
var Case$0 = $TS($S($EXPECT($L123, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10981
10981
|
return { $loc, token: $1 };
|
|
10982
10982
|
});
|
|
10983
10983
|
function Case(ctx, state) {
|
|
10984
10984
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
10985
10985
|
}
|
|
10986
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
10986
|
+
var Catch$0 = $TS($S($EXPECT($L124, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10987
10987
|
return { $loc, token: $1 };
|
|
10988
10988
|
});
|
|
10989
10989
|
function Catch(ctx, state) {
|
|
10990
10990
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
10991
10991
|
}
|
|
10992
|
-
var Class$0 = $TS($S($EXPECT($
|
|
10992
|
+
var Class$0 = $TS($S($EXPECT($L125, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10993
10993
|
return { $loc, token: $1 };
|
|
10994
10994
|
});
|
|
10995
10995
|
function Class(ctx, state) {
|
|
10996
10996
|
return $EVENT(ctx, state, "Class", Class$0);
|
|
10997
10997
|
}
|
|
10998
|
-
var CloseAngleBracket$0 = $TV($EXPECT($
|
|
10998
|
+
var CloseAngleBracket$0 = $TV($EXPECT($L35, 'CloseAngleBracket ">"'), function($skip, $loc, $0, $1) {
|
|
10999
10999
|
return { $loc, token: $1 };
|
|
11000
11000
|
});
|
|
11001
11001
|
function CloseAngleBracket(ctx, state) {
|
|
11002
11002
|
return $EVENT(ctx, state, "CloseAngleBracket", CloseAngleBracket$0);
|
|
11003
11003
|
}
|
|
11004
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
11004
|
+
var CloseBrace$0 = $TV($EXPECT($L27, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
11005
11005
|
return { $loc, token: $1 };
|
|
11006
11006
|
});
|
|
11007
11007
|
function CloseBrace(ctx, state) {
|
|
11008
11008
|
return $EVENT(ctx, state, "CloseBrace", CloseBrace$0);
|
|
11009
11009
|
}
|
|
11010
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
11010
|
+
var CloseBracket$0 = $TV($EXPECT($L36, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
11011
11011
|
return { $loc, token: $1 };
|
|
11012
11012
|
});
|
|
11013
11013
|
function CloseBracket(ctx, state) {
|
|
11014
11014
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
11015
11015
|
}
|
|
11016
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
11016
|
+
var CloseParen$0 = $TV($EXPECT($L114, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
11017
11017
|
return { $loc, token: $1 };
|
|
11018
11018
|
});
|
|
11019
11019
|
function CloseParen(ctx, state) {
|
|
11020
11020
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
11021
11021
|
}
|
|
11022
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
11022
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L126, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
11023
11023
|
return { $loc, token: "${" };
|
|
11024
11024
|
});
|
|
11025
11025
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
11026
11026
|
return $EVENT(ctx, state, "CoffeeSubstitutionStart", CoffeeSubstitutionStart$0);
|
|
11027
11027
|
}
|
|
11028
|
-
var Colon$0 = $TS($S($EXPECT($
|
|
11028
|
+
var Colon$0 = $TS($S($EXPECT($L12, 'Colon ":"'), $N($EXPECT($L3, 'Colon "="'))), function($skip, $loc, $0, $1, $2) {
|
|
11029
11029
|
return { $loc, token: $1 };
|
|
11030
11030
|
});
|
|
11031
11031
|
function Colon(ctx, state) {
|
|
11032
11032
|
return $EVENT(ctx, state, "Colon", Colon$0);
|
|
11033
11033
|
}
|
|
11034
|
-
var Comma$0 = $TV($EXPECT($
|
|
11034
|
+
var Comma$0 = $TV($EXPECT($L23, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
11035
11035
|
return { $loc, token: $1 };
|
|
11036
11036
|
});
|
|
11037
11037
|
function Comma(ctx, state) {
|
|
11038
11038
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
11039
11039
|
}
|
|
11040
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
11040
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L117, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
11041
11041
|
return { $loc, token: "constructor" };
|
|
11042
11042
|
});
|
|
11043
11043
|
function ConstructorShorthand(ctx, state) {
|
|
11044
11044
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
11045
11045
|
}
|
|
11046
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
11046
|
+
var Declare$0 = $TS($S($EXPECT($L127, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11047
11047
|
return { $loc, token: $1 };
|
|
11048
11048
|
});
|
|
11049
11049
|
function Declare(ctx, state) {
|
|
11050
11050
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
11051
11051
|
}
|
|
11052
|
-
var Default$0 = $TS($S($EXPECT($
|
|
11052
|
+
var Default$0 = $TS($S($EXPECT($L128, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11053
11053
|
return { $loc, token: $1 };
|
|
11054
11054
|
});
|
|
11055
11055
|
function Default(ctx, state) {
|
|
11056
11056
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
11057
11057
|
}
|
|
11058
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
11058
|
+
var Delete$0 = $TS($S($EXPECT($L129, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11059
11059
|
return { $loc, token: $1 };
|
|
11060
11060
|
});
|
|
11061
11061
|
function Delete(ctx, state) {
|
|
11062
11062
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
11063
11063
|
}
|
|
11064
|
-
var Do$0 = $TS($S($EXPECT($
|
|
11064
|
+
var Do$0 = $TS($S($EXPECT($L130, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11065
11065
|
return { $loc, token: $1 };
|
|
11066
11066
|
});
|
|
11067
11067
|
function Do(ctx, state) {
|
|
11068
11068
|
return $EVENT(ctx, state, "Do", Do$0);
|
|
11069
11069
|
}
|
|
11070
|
-
var Dot$0 = $TV($EXPECT($
|
|
11070
|
+
var Dot$0 = $TV($EXPECT($L7, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
11071
11071
|
return { $loc, token: $1 };
|
|
11072
11072
|
});
|
|
11073
11073
|
var Dot$1 = $TS($S($EXPECT($R66, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
|
|
@@ -11081,45 +11081,45 @@ ${input.slice(result.pos)}
|
|
|
11081
11081
|
function Dot(ctx, state) {
|
|
11082
11082
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
11083
11083
|
}
|
|
11084
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
11084
|
+
var DotDot$0 = $TS($S($EXPECT($L131, 'DotDot ".."'), $N($EXPECT($L7, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
11085
11085
|
return { $loc, token: $1 };
|
|
11086
11086
|
});
|
|
11087
|
-
var DotDot$1 = $TV($EXPECT($
|
|
11087
|
+
var DotDot$1 = $TV($EXPECT($L132, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
11088
11088
|
return { $loc, token: ".." };
|
|
11089
11089
|
});
|
|
11090
11090
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
11091
11091
|
function DotDot(ctx, state) {
|
|
11092
11092
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
11093
11093
|
}
|
|
11094
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
11094
|
+
var DotDotDot$0 = $TV($EXPECT($L133, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
11095
11095
|
return { $loc, token: $1 };
|
|
11096
11096
|
});
|
|
11097
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
11097
|
+
var DotDotDot$1 = $TV($EXPECT($L134, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
11098
11098
|
return { $loc, token: "..." };
|
|
11099
11099
|
});
|
|
11100
11100
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
11101
11101
|
function DotDotDot(ctx, state) {
|
|
11102
11102
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
11103
11103
|
}
|
|
11104
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
11104
|
+
var DoubleColon$0 = $TV($EXPECT($L135, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
11105
11105
|
return { $loc, token: $1 };
|
|
11106
11106
|
});
|
|
11107
11107
|
function DoubleColon(ctx, state) {
|
|
11108
11108
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
11109
11109
|
}
|
|
11110
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
11110
|
+
var DoubleQuote$0 = $TV($EXPECT($L136, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
11111
11111
|
return { $loc, token: $1 };
|
|
11112
11112
|
});
|
|
11113
11113
|
function DoubleQuote(ctx, state) {
|
|
11114
11114
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
11115
11115
|
}
|
|
11116
|
-
var Each$0 = $TS($S($EXPECT($
|
|
11116
|
+
var Each$0 = $TS($S($EXPECT($L137, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11117
11117
|
return { $loc, token: $1 };
|
|
11118
11118
|
});
|
|
11119
11119
|
function Each(ctx, state) {
|
|
11120
11120
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
11121
11121
|
}
|
|
11122
|
-
var Else$0 = $TS($S($EXPECT($
|
|
11122
|
+
var Else$0 = $TS($S($EXPECT($L138, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11123
11123
|
return { $loc, token: $1 };
|
|
11124
11124
|
});
|
|
11125
11125
|
function Else(ctx, state) {
|
|
@@ -11131,85 +11131,85 @@ ${input.slice(result.pos)}
|
|
|
11131
11131
|
function Equals(ctx, state) {
|
|
11132
11132
|
return $EVENT(ctx, state, "Equals", Equals$0);
|
|
11133
11133
|
}
|
|
11134
|
-
var Export$0 = $TS($S($EXPECT($
|
|
11134
|
+
var Export$0 = $TS($S($EXPECT($L139, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11135
11135
|
return { $loc, token: $1 };
|
|
11136
11136
|
});
|
|
11137
11137
|
function Export(ctx, state) {
|
|
11138
11138
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
11139
11139
|
}
|
|
11140
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
11140
|
+
var Extends$0 = $TS($S($EXPECT($L140, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11141
11141
|
return { $loc, token: $1 };
|
|
11142
11142
|
});
|
|
11143
11143
|
function Extends(ctx, state) {
|
|
11144
11144
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
11145
11145
|
}
|
|
11146
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
11146
|
+
var Finally$0 = $TS($S($EXPECT($L141, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11147
11147
|
return { $loc, token: $1 };
|
|
11148
11148
|
});
|
|
11149
11149
|
function Finally(ctx, state) {
|
|
11150
11150
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
11151
11151
|
}
|
|
11152
|
-
var For$0 = $TS($S($EXPECT($
|
|
11152
|
+
var For$0 = $TS($S($EXPECT($L142, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11153
11153
|
return { $loc, token: $1 };
|
|
11154
11154
|
});
|
|
11155
11155
|
function For(ctx, state) {
|
|
11156
11156
|
return $EVENT(ctx, state, "For", For$0);
|
|
11157
11157
|
}
|
|
11158
|
-
var From$0 = $TS($S($EXPECT($
|
|
11158
|
+
var From$0 = $TS($S($EXPECT($L143, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11159
11159
|
return { $loc, token: $1 };
|
|
11160
11160
|
});
|
|
11161
11161
|
function From(ctx, state) {
|
|
11162
11162
|
return $EVENT(ctx, state, "From", From$0);
|
|
11163
11163
|
}
|
|
11164
|
-
var Function$0 = $TS($S($EXPECT($
|
|
11164
|
+
var Function$0 = $TS($S($EXPECT($L144, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11165
11165
|
return { $loc, token: $1 };
|
|
11166
11166
|
});
|
|
11167
11167
|
function Function(ctx, state) {
|
|
11168
11168
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
11169
11169
|
}
|
|
11170
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
11170
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L145, 'GetOrSet "get"'), $EXPECT($L146, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11171
11171
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
11172
11172
|
});
|
|
11173
11173
|
function GetOrSet(ctx, state) {
|
|
11174
11174
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
11175
11175
|
}
|
|
11176
|
-
var Hash$0 = $TV($EXPECT($
|
|
11176
|
+
var Hash$0 = $TV($EXPECT($L147, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
11177
11177
|
return { $loc, token: $1 };
|
|
11178
11178
|
});
|
|
11179
11179
|
function Hash(ctx, state) {
|
|
11180
11180
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
11181
11181
|
}
|
|
11182
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
11182
|
+
var If$0 = $TV($TEXT($S($EXPECT($L148, 'If "if"'), NonIdContinue, $E($EXPECT($L13, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
11183
11183
|
return { $loc, token: $1 };
|
|
11184
11184
|
});
|
|
11185
11185
|
function If(ctx, state) {
|
|
11186
11186
|
return $EVENT(ctx, state, "If", If$0);
|
|
11187
11187
|
}
|
|
11188
|
-
var Import$0 = $TS($S($EXPECT($
|
|
11188
|
+
var Import$0 = $TS($S($EXPECT($L17, 'Import "import"'), $Y($EXPECT($R67, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
11189
11189
|
return { $loc, token: $1 };
|
|
11190
11190
|
});
|
|
11191
11191
|
function Import(ctx, state) {
|
|
11192
11192
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
11193
11193
|
}
|
|
11194
|
-
var In$0 = $TS($S($EXPECT($
|
|
11194
|
+
var In$0 = $TS($S($EXPECT($L149, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11195
11195
|
return { $loc, token: $1 };
|
|
11196
11196
|
});
|
|
11197
11197
|
function In(ctx, state) {
|
|
11198
11198
|
return $EVENT(ctx, state, "In", In$0);
|
|
11199
11199
|
}
|
|
11200
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
11200
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L150, 'LetOrConst "let"'), $EXPECT($L151, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11201
11201
|
return { $loc, token: $1 };
|
|
11202
11202
|
});
|
|
11203
11203
|
function LetOrConst(ctx, state) {
|
|
11204
11204
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
11205
11205
|
}
|
|
11206
|
-
var Const$0 = $TS($S($EXPECT($
|
|
11206
|
+
var Const$0 = $TS($S($EXPECT($L151, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11207
11207
|
return { $loc, token: $1 };
|
|
11208
11208
|
});
|
|
11209
11209
|
function Const(ctx, state) {
|
|
11210
11210
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
11211
11211
|
}
|
|
11212
|
-
var Is$0 = $TS($S($EXPECT($
|
|
11212
|
+
var Is$0 = $TS($S($EXPECT($L152, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11213
11213
|
return { $loc, token: $1 };
|
|
11214
11214
|
});
|
|
11215
11215
|
function Is(ctx, state) {
|
|
@@ -11221,31 +11221,31 @@ ${input.slice(result.pos)}
|
|
|
11221
11221
|
function LetOrConstOrVar(ctx, state) {
|
|
11222
11222
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
11223
11223
|
}
|
|
11224
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
11224
|
+
var Loop$0 = $TS($S($EXPECT($L153, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11225
11225
|
return { $loc, token: "while(true)" };
|
|
11226
11226
|
});
|
|
11227
11227
|
function Loop(ctx, state) {
|
|
11228
11228
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
11229
11229
|
}
|
|
11230
|
-
var New$0 = $TS($S($EXPECT($
|
|
11230
|
+
var New$0 = $TS($S($EXPECT($L154, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11231
11231
|
return { $loc, token: $1 };
|
|
11232
11232
|
});
|
|
11233
11233
|
function New(ctx, state) {
|
|
11234
11234
|
return $EVENT(ctx, state, "New", New$0);
|
|
11235
11235
|
}
|
|
11236
|
-
var Not$0 = $TS($S($EXPECT($
|
|
11236
|
+
var Not$0 = $TS($S($EXPECT($L155, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L12, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
11237
11237
|
return { $loc, token: "!" };
|
|
11238
11238
|
});
|
|
11239
11239
|
function Not(ctx, state) {
|
|
11240
11240
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
11241
11241
|
}
|
|
11242
|
-
var Of$0 = $TS($S($EXPECT($
|
|
11242
|
+
var Of$0 = $TS($S($EXPECT($L156, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11243
11243
|
return { $loc, token: $1 };
|
|
11244
11244
|
});
|
|
11245
11245
|
function Of(ctx, state) {
|
|
11246
11246
|
return $EVENT(ctx, state, "Of", Of$0);
|
|
11247
11247
|
}
|
|
11248
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
11248
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L14, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
11249
11249
|
return { $loc, token: $1 };
|
|
11250
11250
|
});
|
|
11251
11251
|
function OpenAngleBracket(ctx, state) {
|
|
@@ -11257,7 +11257,7 @@ ${input.slice(result.pos)}
|
|
|
11257
11257
|
function OpenBrace(ctx, state) {
|
|
11258
11258
|
return $EVENT(ctx, state, "OpenBrace", OpenBrace$0);
|
|
11259
11259
|
}
|
|
11260
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
11260
|
+
var OpenBracket$0 = $TV($EXPECT($L157, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
11261
11261
|
return { $loc, token: $1 };
|
|
11262
11262
|
});
|
|
11263
11263
|
function OpenBracket(ctx, state) {
|
|
@@ -11269,222 +11269,222 @@ ${input.slice(result.pos)}
|
|
|
11269
11269
|
function OpenParen(ctx, state) {
|
|
11270
11270
|
return $EVENT(ctx, state, "OpenParen", OpenParen$0);
|
|
11271
11271
|
}
|
|
11272
|
-
var Operator$0 = $TS($S($EXPECT($
|
|
11272
|
+
var Operator$0 = $TS($S($EXPECT($L158, 'Operator "operator"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11273
11273
|
return { $loc, token: $1 };
|
|
11274
11274
|
});
|
|
11275
11275
|
function Operator(ctx, state) {
|
|
11276
11276
|
return $EVENT(ctx, state, "Operator", Operator$0);
|
|
11277
11277
|
}
|
|
11278
|
-
var Own$0 = $TS($S($EXPECT($
|
|
11278
|
+
var Own$0 = $TS($S($EXPECT($L159, 'Own "own"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11279
11279
|
return { $loc, token: $1 };
|
|
11280
11280
|
});
|
|
11281
11281
|
function Own(ctx, state) {
|
|
11282
11282
|
return $EVENT(ctx, state, "Own", Own$0);
|
|
11283
11283
|
}
|
|
11284
|
-
var Public$0 = $TS($S($EXPECT($
|
|
11284
|
+
var Public$0 = $TS($S($EXPECT($L160, 'Public "public"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11285
11285
|
return { $loc, token: $1 };
|
|
11286
11286
|
});
|
|
11287
11287
|
function Public(ctx, state) {
|
|
11288
11288
|
return $EVENT(ctx, state, "Public", Public$0);
|
|
11289
11289
|
}
|
|
11290
|
-
var Private$0 = $TS($S($EXPECT($
|
|
11290
|
+
var Private$0 = $TS($S($EXPECT($L161, 'Private "private"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11291
11291
|
return { $loc, token: $1 };
|
|
11292
11292
|
});
|
|
11293
11293
|
function Private(ctx, state) {
|
|
11294
11294
|
return $EVENT(ctx, state, "Private", Private$0);
|
|
11295
11295
|
}
|
|
11296
|
-
var Protected$0 = $TS($S($EXPECT($
|
|
11296
|
+
var Protected$0 = $TS($S($EXPECT($L162, 'Protected "protected"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11297
11297
|
return { $loc, token: $1 };
|
|
11298
11298
|
});
|
|
11299
11299
|
function Protected(ctx, state) {
|
|
11300
11300
|
return $EVENT(ctx, state, "Protected", Protected$0);
|
|
11301
11301
|
}
|
|
11302
|
-
var Pipe$0 = $TV($C($EXPECT($
|
|
11302
|
+
var Pipe$0 = $TV($C($EXPECT($L163, 'Pipe "||>"'), $EXPECT($L164, 'Pipe "|\u25B7"')), function($skip, $loc, $0, $1) {
|
|
11303
11303
|
return { $loc, token: "||>" };
|
|
11304
11304
|
});
|
|
11305
|
-
var Pipe$1 = $TV($C($EXPECT($
|
|
11305
|
+
var Pipe$1 = $TV($C($EXPECT($L165, 'Pipe "|>="'), $EXPECT($L166, 'Pipe "\u25B7="')), function($skip, $loc, $0, $1) {
|
|
11306
11306
|
return { $loc, token: "|>=" };
|
|
11307
11307
|
});
|
|
11308
|
-
var Pipe$2 = $TV($C($EXPECT($
|
|
11308
|
+
var Pipe$2 = $TV($C($EXPECT($L167, 'Pipe "|>"'), $EXPECT($L168, 'Pipe "\u25B7"')), function($skip, $loc, $0, $1) {
|
|
11309
11309
|
return { $loc, token: "|>" };
|
|
11310
11310
|
});
|
|
11311
11311
|
var Pipe$$ = [Pipe$0, Pipe$1, Pipe$2];
|
|
11312
11312
|
function Pipe(ctx, state) {
|
|
11313
11313
|
return $EVENT_C(ctx, state, "Pipe", Pipe$$);
|
|
11314
11314
|
}
|
|
11315
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
11315
|
+
var QuestionMark$0 = $TV($EXPECT($L6, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
11316
11316
|
return { $loc, token: $1 };
|
|
11317
11317
|
});
|
|
11318
11318
|
function QuestionMark(ctx, state) {
|
|
11319
11319
|
return $EVENT(ctx, state, "QuestionMark", QuestionMark$0);
|
|
11320
11320
|
}
|
|
11321
|
-
var Readonly$0 = $TS($S($EXPECT($
|
|
11321
|
+
var Readonly$0 = $TS($S($EXPECT($L169, 'Readonly "readonly"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11322
11322
|
return { $loc, token: $1, ts: true };
|
|
11323
11323
|
});
|
|
11324
11324
|
function Readonly(ctx, state) {
|
|
11325
11325
|
return $EVENT(ctx, state, "Readonly", Readonly$0);
|
|
11326
11326
|
}
|
|
11327
|
-
var Return$0 = $TS($S($EXPECT($
|
|
11327
|
+
var Return$0 = $TS($S($EXPECT($L170, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11328
11328
|
return { $loc, token: $1 };
|
|
11329
11329
|
});
|
|
11330
11330
|
function Return(ctx, state) {
|
|
11331
11331
|
return $EVENT(ctx, state, "Return", Return$0);
|
|
11332
11332
|
}
|
|
11333
|
-
var Satisfies$0 = $TS($S($EXPECT($
|
|
11333
|
+
var Satisfies$0 = $TS($S($EXPECT($L171, 'Satisfies "satisfies"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11334
11334
|
return { $loc, token: $1 };
|
|
11335
11335
|
});
|
|
11336
11336
|
function Satisfies(ctx, state) {
|
|
11337
11337
|
return $EVENT(ctx, state, "Satisfies", Satisfies$0);
|
|
11338
11338
|
}
|
|
11339
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
11339
|
+
var Semicolon$0 = $TV($EXPECT($L101, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
11340
11340
|
return { $loc, token: $1 };
|
|
11341
11341
|
});
|
|
11342
11342
|
function Semicolon(ctx, state) {
|
|
11343
11343
|
return $EVENT(ctx, state, "Semicolon", Semicolon$0);
|
|
11344
11344
|
}
|
|
11345
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
11345
|
+
var SingleQuote$0 = $TV($EXPECT($L172, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
11346
11346
|
return { $loc, token: $1 };
|
|
11347
11347
|
});
|
|
11348
11348
|
function SingleQuote(ctx, state) {
|
|
11349
11349
|
return $EVENT(ctx, state, "SingleQuote", SingleQuote$0);
|
|
11350
11350
|
}
|
|
11351
|
-
var Star$0 = $TV($EXPECT($
|
|
11351
|
+
var Star$0 = $TV($EXPECT($L56, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
11352
11352
|
return { $loc, token: $1 };
|
|
11353
11353
|
});
|
|
11354
11354
|
function Star(ctx, state) {
|
|
11355
11355
|
return $EVENT(ctx, state, "Star", Star$0);
|
|
11356
11356
|
}
|
|
11357
|
-
var Static$0 = $TS($S($EXPECT($
|
|
11357
|
+
var Static$0 = $TS($S($EXPECT($L173, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11358
11358
|
return { $loc, token: $1 };
|
|
11359
11359
|
});
|
|
11360
|
-
var Static$1 = $TS($S($EXPECT($
|
|
11360
|
+
var Static$1 = $TS($S($EXPECT($L117, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L117, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
11361
11361
|
return { $loc, token: "static " };
|
|
11362
11362
|
});
|
|
11363
11363
|
var Static$$ = [Static$0, Static$1];
|
|
11364
11364
|
function Static(ctx, state) {
|
|
11365
11365
|
return $EVENT_C(ctx, state, "Static", Static$$);
|
|
11366
11366
|
}
|
|
11367
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
11367
|
+
var SubstitutionStart$0 = $TV($EXPECT($L174, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
11368
11368
|
return { $loc, token: $1 };
|
|
11369
11369
|
});
|
|
11370
11370
|
function SubstitutionStart(ctx, state) {
|
|
11371
11371
|
return $EVENT(ctx, state, "SubstitutionStart", SubstitutionStart$0);
|
|
11372
11372
|
}
|
|
11373
|
-
var Super$0 = $TS($S($EXPECT($
|
|
11373
|
+
var Super$0 = $TS($S($EXPECT($L175, 'Super "super"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11374
11374
|
return { $loc, token: $1 };
|
|
11375
11375
|
});
|
|
11376
11376
|
function Super(ctx, state) {
|
|
11377
11377
|
return $EVENT(ctx, state, "Super", Super$0);
|
|
11378
11378
|
}
|
|
11379
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
11379
|
+
var Switch$0 = $TS($S($EXPECT($L176, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11380
11380
|
return { $loc, token: $1 };
|
|
11381
11381
|
});
|
|
11382
11382
|
function Switch(ctx, state) {
|
|
11383
11383
|
return $EVENT(ctx, state, "Switch", Switch$0);
|
|
11384
11384
|
}
|
|
11385
|
-
var Target$0 = $TS($S($EXPECT($
|
|
11385
|
+
var Target$0 = $TS($S($EXPECT($L177, 'Target "target"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11386
11386
|
return { $loc, token: $1 };
|
|
11387
11387
|
});
|
|
11388
11388
|
function Target(ctx, state) {
|
|
11389
11389
|
return $EVENT(ctx, state, "Target", Target$0);
|
|
11390
11390
|
}
|
|
11391
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
11391
|
+
var Then$0 = $TS($S(__, $EXPECT($L178, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
11392
11392
|
return { $loc, token: "" };
|
|
11393
11393
|
});
|
|
11394
11394
|
function Then(ctx, state) {
|
|
11395
11395
|
return $EVENT(ctx, state, "Then", Then$0);
|
|
11396
11396
|
}
|
|
11397
|
-
var This$0 = $TS($S($EXPECT($
|
|
11397
|
+
var This$0 = $TS($S($EXPECT($L179, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11398
11398
|
return { $loc, token: $1 };
|
|
11399
11399
|
});
|
|
11400
11400
|
function This(ctx, state) {
|
|
11401
11401
|
return $EVENT(ctx, state, "This", This$0);
|
|
11402
11402
|
}
|
|
11403
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
11403
|
+
var Throw$0 = $TS($S($EXPECT($L180, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11404
11404
|
return { $loc, token: $1 };
|
|
11405
11405
|
});
|
|
11406
11406
|
function Throw(ctx, state) {
|
|
11407
11407
|
return $EVENT(ctx, state, "Throw", Throw$0);
|
|
11408
11408
|
}
|
|
11409
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
11409
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L181, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
11410
11410
|
return { $loc, token: "`" };
|
|
11411
11411
|
});
|
|
11412
11412
|
function TripleDoubleQuote(ctx, state) {
|
|
11413
11413
|
return $EVENT(ctx, state, "TripleDoubleQuote", TripleDoubleQuote$0);
|
|
11414
11414
|
}
|
|
11415
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
11415
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L182, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
11416
11416
|
return { $loc, token: "`" };
|
|
11417
11417
|
});
|
|
11418
11418
|
function TripleSingleQuote(ctx, state) {
|
|
11419
11419
|
return $EVENT(ctx, state, "TripleSingleQuote", TripleSingleQuote$0);
|
|
11420
11420
|
}
|
|
11421
|
-
var TripleSlash$0 = $TV($EXPECT($
|
|
11421
|
+
var TripleSlash$0 = $TV($EXPECT($L183, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
|
|
11422
11422
|
return { $loc, token: "/" };
|
|
11423
11423
|
});
|
|
11424
11424
|
function TripleSlash(ctx, state) {
|
|
11425
11425
|
return $EVENT(ctx, state, "TripleSlash", TripleSlash$0);
|
|
11426
11426
|
}
|
|
11427
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
11427
|
+
var TripleTick$0 = $TV($EXPECT($L184, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
11428
11428
|
return { $loc, token: "`" };
|
|
11429
11429
|
});
|
|
11430
11430
|
function TripleTick(ctx, state) {
|
|
11431
11431
|
return $EVENT(ctx, state, "TripleTick", TripleTick$0);
|
|
11432
11432
|
}
|
|
11433
|
-
var Try$0 = $TS($S($EXPECT($
|
|
11433
|
+
var Try$0 = $TS($S($EXPECT($L185, 'Try "try"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11434
11434
|
return { $loc, token: $1 };
|
|
11435
11435
|
});
|
|
11436
11436
|
function Try(ctx, state) {
|
|
11437
11437
|
return $EVENT(ctx, state, "Try", Try$0);
|
|
11438
11438
|
}
|
|
11439
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
11439
|
+
var Typeof$0 = $TS($S($EXPECT($L186, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11440
11440
|
return { $loc, token: $1 };
|
|
11441
11441
|
});
|
|
11442
11442
|
function Typeof(ctx, state) {
|
|
11443
11443
|
return $EVENT(ctx, state, "Typeof", Typeof$0);
|
|
11444
11444
|
}
|
|
11445
|
-
var Unless$0 = $TS($S($EXPECT($
|
|
11445
|
+
var Unless$0 = $TS($S($EXPECT($L187, 'Unless "unless"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11446
11446
|
return { $loc, token: $1 };
|
|
11447
11447
|
});
|
|
11448
11448
|
function Unless(ctx, state) {
|
|
11449
11449
|
return $EVENT(ctx, state, "Unless", Unless$0);
|
|
11450
11450
|
}
|
|
11451
|
-
var Until$0 = $TS($S($EXPECT($
|
|
11451
|
+
var Until$0 = $TS($S($EXPECT($L188, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11452
11452
|
return { $loc, token: $1 };
|
|
11453
11453
|
});
|
|
11454
11454
|
function Until(ctx, state) {
|
|
11455
11455
|
return $EVENT(ctx, state, "Until", Until$0);
|
|
11456
11456
|
}
|
|
11457
|
-
var Using$0 = $TS($S($EXPECT($
|
|
11457
|
+
var Using$0 = $TS($S($EXPECT($L189, 'Using "using"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11458
11458
|
return { $loc, token: $1 };
|
|
11459
11459
|
});
|
|
11460
11460
|
function Using(ctx, state) {
|
|
11461
11461
|
return $EVENT(ctx, state, "Using", Using$0);
|
|
11462
11462
|
}
|
|
11463
|
-
var Var$0 = $TS($S($EXPECT($
|
|
11463
|
+
var Var$0 = $TS($S($EXPECT($L190, 'Var "var"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11464
11464
|
return { $loc, token: $1 };
|
|
11465
11465
|
});
|
|
11466
11466
|
function Var(ctx, state) {
|
|
11467
11467
|
return $EVENT(ctx, state, "Var", Var$0);
|
|
11468
11468
|
}
|
|
11469
|
-
var Void$0 = $TS($S($EXPECT($
|
|
11469
|
+
var Void$0 = $TS($S($EXPECT($L191, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11470
11470
|
return { $loc, token: $1 };
|
|
11471
11471
|
});
|
|
11472
11472
|
function Void(ctx, state) {
|
|
11473
11473
|
return $EVENT(ctx, state, "Void", Void$0);
|
|
11474
11474
|
}
|
|
11475
|
-
var When$0 = $TS($S($EXPECT($
|
|
11475
|
+
var When$0 = $TS($S($EXPECT($L192, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11476
11476
|
return { $loc, token: "case" };
|
|
11477
11477
|
});
|
|
11478
11478
|
function When(ctx, state) {
|
|
11479
11479
|
return $EVENT(ctx, state, "When", When$0);
|
|
11480
11480
|
}
|
|
11481
|
-
var While$0 = $TS($S($EXPECT($
|
|
11481
|
+
var While$0 = $TS($S($EXPECT($L193, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11482
11482
|
return { $loc, token: $1 };
|
|
11483
11483
|
});
|
|
11484
11484
|
function While(ctx, state) {
|
|
11485
11485
|
return $EVENT(ctx, state, "While", While$0);
|
|
11486
11486
|
}
|
|
11487
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
11487
|
+
var Yield$0 = $TS($S($EXPECT($L194, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11488
11488
|
return { $loc, token: $1, type: "Yield" };
|
|
11489
11489
|
});
|
|
11490
11490
|
function Yield(ctx, state) {
|
|
@@ -11563,7 +11563,7 @@ ${input.slice(result.pos)}
|
|
|
11563
11563
|
function JSXElement(ctx, state) {
|
|
11564
11564
|
return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
|
|
11565
11565
|
}
|
|
11566
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
11566
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L14, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L195, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
11567
11567
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
11568
11568
|
});
|
|
11569
11569
|
function JSXSelfClosingElement(ctx, state) {
|
|
@@ -11582,7 +11582,7 @@ ${input.slice(result.pos)}
|
|
|
11582
11582
|
function PopJSXStack(ctx, state) {
|
|
11583
11583
|
return $EVENT(ctx, state, "PopJSXStack", PopJSXStack$0);
|
|
11584
11584
|
}
|
|
11585
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
11585
|
+
var JSXOpeningElement$0 = $S($EXPECT($L14, 'JSXOpeningElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L35, 'JSXOpeningElement ">"'));
|
|
11586
11586
|
function JSXOpeningElement(ctx, state) {
|
|
11587
11587
|
return $EVENT(ctx, state, "JSXOpeningElement", JSXOpeningElement$0);
|
|
11588
11588
|
}
|
|
@@ -11597,7 +11597,7 @@ ${input.slice(result.pos)}
|
|
|
11597
11597
|
function JSXOptionalClosingElement(ctx, state) {
|
|
11598
11598
|
return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
|
|
11599
11599
|
}
|
|
11600
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
11600
|
+
var JSXClosingElement$0 = $S($EXPECT($L196, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L35, 'JSXClosingElement ">"'));
|
|
11601
11601
|
function JSXClosingElement(ctx, state) {
|
|
11602
11602
|
return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
|
|
11603
11603
|
}
|
|
@@ -11618,7 +11618,7 @@ ${input.slice(result.pos)}
|
|
|
11618
11618
|
];
|
|
11619
11619
|
return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
|
|
11620
11620
|
});
|
|
11621
|
-
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($
|
|
11621
|
+
var JSXFragment$1 = $TS($S(CoffeeJSXEnabled, $EXPECT($L197, 'JSXFragment "<>"'), $E(JSXChildren), $E(Whitespace), JSXClosingFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
11622
11622
|
var children = $3;
|
|
11623
11623
|
$0 = $0.slice(1);
|
|
11624
11624
|
return {
|
|
@@ -11631,7 +11631,7 @@ ${input.slice(result.pos)}
|
|
|
11631
11631
|
function JSXFragment(ctx, state) {
|
|
11632
11632
|
return $EVENT_C(ctx, state, "JSXFragment", JSXFragment$$);
|
|
11633
11633
|
}
|
|
11634
|
-
var PushJSXOpeningFragment$0 = $TV($EXPECT($
|
|
11634
|
+
var PushJSXOpeningFragment$0 = $TV($EXPECT($L197, 'PushJSXOpeningFragment "<>"'), function($skip, $loc, $0, $1) {
|
|
11635
11635
|
module.JSXTagStack.push("");
|
|
11636
11636
|
return $1;
|
|
11637
11637
|
});
|
|
@@ -11648,11 +11648,11 @@ ${input.slice(result.pos)}
|
|
|
11648
11648
|
function JSXOptionalClosingFragment(ctx, state) {
|
|
11649
11649
|
return $EVENT_C(ctx, state, "JSXOptionalClosingFragment", JSXOptionalClosingFragment$$);
|
|
11650
11650
|
}
|
|
11651
|
-
var JSXClosingFragment$0 = $EXPECT($
|
|
11651
|
+
var JSXClosingFragment$0 = $EXPECT($L198, 'JSXClosingFragment "</>"');
|
|
11652
11652
|
function JSXClosingFragment(ctx, state) {
|
|
11653
11653
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
11654
11654
|
}
|
|
11655
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
11655
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L147, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
11656
11656
|
return module.config.defaultElement;
|
|
11657
11657
|
});
|
|
11658
11658
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -11824,7 +11824,7 @@ ${input.slice(result.pos)}
|
|
|
11824
11824
|
}
|
|
11825
11825
|
return $skip;
|
|
11826
11826
|
});
|
|
11827
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
11827
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L147, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
11828
11828
|
return [" ", "id=", $2];
|
|
11829
11829
|
});
|
|
11830
11830
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -11833,7 +11833,7 @@ ${input.slice(result.pos)}
|
|
|
11833
11833
|
class: $2
|
|
11834
11834
|
};
|
|
11835
11835
|
});
|
|
11836
|
-
var JSXAttribute$7 = $TS($S($TEXT($EXPECT($
|
|
11836
|
+
var JSXAttribute$7 = $TS($S($TEXT($EXPECT($R14, "JSXAttribute /[!+-]/")), JSXAttributeName, $Y(JSXAttributeSpace)), function($skip, $loc, $0, $1, $2, $3) {
|
|
11837
11837
|
var toggle = $1;
|
|
11838
11838
|
var id = $2;
|
|
11839
11839
|
const value = toggle === "+" ? "true" : "false";
|
|
@@ -11943,7 +11943,7 @@ ${input.slice(result.pos)}
|
|
|
11943
11943
|
]
|
|
11944
11944
|
});
|
|
11945
11945
|
});
|
|
11946
|
-
var InlineJSXCallExpression$1 = $TS($S($EXPECT($
|
|
11946
|
+
var InlineJSXCallExpression$1 = $TS($S($EXPECT($L17, 'InlineJSXCallExpression "import"'), ExplicitArguments, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
11947
11947
|
var args = $2;
|
|
11948
11948
|
var rest = $3;
|
|
11949
11949
|
return processCallMemberExpression({
|
|
@@ -12062,7 +12062,7 @@ ${input.slice(result.pos)}
|
|
|
12062
12062
|
}
|
|
12063
12063
|
return $skip;
|
|
12064
12064
|
});
|
|
12065
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
12065
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L27, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
12066
12066
|
return { children: [], jsxChildren: [] };
|
|
12067
12067
|
});
|
|
12068
12068
|
var JSXNestedChildren$$ = [JSXNestedChildren$0, JSXNestedChildren$1];
|
|
@@ -12117,7 +12117,7 @@ ${input.slice(result.pos)}
|
|
|
12117
12117
|
function JSXChild(ctx, state) {
|
|
12118
12118
|
return $EVENT_C(ctx, state, "JSXChild", JSXChild$$);
|
|
12119
12119
|
}
|
|
12120
|
-
var JSXComment$0 = $TS($S($EXPECT($
|
|
12120
|
+
var JSXComment$0 = $TS($S($EXPECT($L199, 'JSXComment "<!--"'), JSXCommentContent, $EXPECT($L200, 'JSXComment "-->"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
12121
12121
|
return ["{/*", $2, "*/}"];
|
|
12122
12122
|
});
|
|
12123
12123
|
function JSXComment(ctx, state) {
|
|
@@ -12249,37 +12249,37 @@ ${input.slice(result.pos)}
|
|
|
12249
12249
|
function InterfaceExtendsTarget(ctx, state) {
|
|
12250
12250
|
return $EVENT(ctx, state, "InterfaceExtendsTarget", InterfaceExtendsTarget$0);
|
|
12251
12251
|
}
|
|
12252
|
-
var TypeKeyword$0 = $TS($S($EXPECT($
|
|
12252
|
+
var TypeKeyword$0 = $TS($S($EXPECT($L201, 'TypeKeyword "type"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12253
12253
|
return { $loc, token: $1 };
|
|
12254
12254
|
});
|
|
12255
12255
|
function TypeKeyword(ctx, state) {
|
|
12256
12256
|
return $EVENT(ctx, state, "TypeKeyword", TypeKeyword$0);
|
|
12257
12257
|
}
|
|
12258
|
-
var Enum$0 = $TS($S($EXPECT($
|
|
12258
|
+
var Enum$0 = $TS($S($EXPECT($L202, 'Enum "enum"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12259
12259
|
return { $loc, token: $1 };
|
|
12260
12260
|
});
|
|
12261
12261
|
function Enum(ctx, state) {
|
|
12262
12262
|
return $EVENT(ctx, state, "Enum", Enum$0);
|
|
12263
12263
|
}
|
|
12264
|
-
var Interface$0 = $TS($S($EXPECT($
|
|
12264
|
+
var Interface$0 = $TS($S($EXPECT($L203, 'Interface "interface"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12265
12265
|
return { $loc, token: $1 };
|
|
12266
12266
|
});
|
|
12267
12267
|
function Interface(ctx, state) {
|
|
12268
12268
|
return $EVENT(ctx, state, "Interface", Interface$0);
|
|
12269
12269
|
}
|
|
12270
|
-
var Global$0 = $TS($S($EXPECT($
|
|
12270
|
+
var Global$0 = $TS($S($EXPECT($L204, 'Global "global"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12271
12271
|
return { $loc, token: $1 };
|
|
12272
12272
|
});
|
|
12273
12273
|
function Global(ctx, state) {
|
|
12274
12274
|
return $EVENT(ctx, state, "Global", Global$0);
|
|
12275
12275
|
}
|
|
12276
|
-
var Module$0 = $TS($S($EXPECT($
|
|
12276
|
+
var Module$0 = $TS($S($EXPECT($L205, 'Module "module"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12277
12277
|
return { $loc, token: $1 };
|
|
12278
12278
|
});
|
|
12279
12279
|
function Module(ctx, state) {
|
|
12280
12280
|
return $EVENT(ctx, state, "Module", Module$0);
|
|
12281
12281
|
}
|
|
12282
|
-
var Namespace$0 = $TS($S($EXPECT($
|
|
12282
|
+
var Namespace$0 = $TS($S($EXPECT($L206, 'Namespace "namespace"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12283
12283
|
return { $loc, token: $1 };
|
|
12284
12284
|
});
|
|
12285
12285
|
function Namespace(ctx, state) {
|
|
@@ -12524,7 +12524,7 @@ ${input.slice(result.pos)}
|
|
|
12524
12524
|
function ReturnTypeSuffix(ctx, state) {
|
|
12525
12525
|
return $EVENT(ctx, state, "ReturnTypeSuffix", ReturnTypeSuffix$0);
|
|
12526
12526
|
}
|
|
12527
|
-
var ReturnType$0 = $TS($S($E($S(__, $EXPECT($
|
|
12527
|
+
var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L207, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
|
|
12528
12528
|
var asserts = $1;
|
|
12529
12529
|
var t = $2;
|
|
12530
12530
|
if (asserts) {
|
|
@@ -12545,7 +12545,7 @@ ${input.slice(result.pos)}
|
|
|
12545
12545
|
function ReturnType(ctx, state) {
|
|
12546
12546
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
12547
12547
|
}
|
|
12548
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
12548
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L152, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
12549
12549
|
var lhs = $1;
|
|
12550
12550
|
var rhs = $2;
|
|
12551
12551
|
if (!rhs)
|
|
@@ -12593,10 +12593,10 @@ ${input.slice(result.pos)}
|
|
|
12593
12593
|
function TypeUnarySuffix(ctx, state) {
|
|
12594
12594
|
return $EVENT_C(ctx, state, "TypeUnarySuffix", TypeUnarySuffix$$);
|
|
12595
12595
|
}
|
|
12596
|
-
var TypeUnaryOp$0 = $S($EXPECT($
|
|
12597
|
-
var TypeUnaryOp$1 = $S($EXPECT($
|
|
12598
|
-
var TypeUnaryOp$2 = $S($EXPECT($
|
|
12599
|
-
var TypeUnaryOp$3 = $S($EXPECT($
|
|
12596
|
+
var TypeUnaryOp$0 = $S($EXPECT($L208, 'TypeUnaryOp "keyof"'), NonIdContinue);
|
|
12597
|
+
var TypeUnaryOp$1 = $S($EXPECT($L186, 'TypeUnaryOp "typeof"'), NonIdContinue);
|
|
12598
|
+
var TypeUnaryOp$2 = $S($EXPECT($L209, 'TypeUnaryOp "infer"'), NonIdContinue);
|
|
12599
|
+
var TypeUnaryOp$3 = $S($EXPECT($L169, 'TypeUnaryOp "readonly"'), NonIdContinue);
|
|
12600
12600
|
var TypeUnaryOp$$ = [TypeUnaryOp$0, TypeUnaryOp$1, TypeUnaryOp$2, TypeUnaryOp$3];
|
|
12601
12601
|
function TypeUnaryOp(ctx, state) {
|
|
12602
12602
|
return $EVENT_C(ctx, state, "TypeUnaryOp", TypeUnaryOp$$);
|
|
@@ -12605,7 +12605,7 @@ ${input.slice(result.pos)}
|
|
|
12605
12605
|
function TypeIndexedAccess(ctx, state) {
|
|
12606
12606
|
return $EVENT(ctx, state, "TypeIndexedAccess", TypeIndexedAccess$0);
|
|
12607
12607
|
}
|
|
12608
|
-
var UnknownAlias$0 = $TV($EXPECT($
|
|
12608
|
+
var UnknownAlias$0 = $TV($EXPECT($L210, 'UnknownAlias "???"'), function($skip, $loc, $0, $1) {
|
|
12609
12609
|
return { $loc, token: "unknown" };
|
|
12610
12610
|
});
|
|
12611
12611
|
function UnknownAlias(ctx, state) {
|
|
@@ -12646,8 +12646,8 @@ ${input.slice(result.pos)}
|
|
|
12646
12646
|
function TypePrimary(ctx, state) {
|
|
12647
12647
|
return $EVENT_C(ctx, state, "TypePrimary", TypePrimary$$);
|
|
12648
12648
|
}
|
|
12649
|
-
var ImportType$0 = $S($EXPECT($
|
|
12650
|
-
var ImportType$1 = $S($EXPECT($
|
|
12649
|
+
var ImportType$0 = $S($EXPECT($L17, 'ImportType "import"'), OpenParen, __, StringLiteral, __, CloseParen, $E($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
12650
|
+
var ImportType$1 = $S($EXPECT($L17, 'ImportType "import"'), InsertOpenParen, Trimmed_, StringLiteral, InsertCloseParen);
|
|
12651
12651
|
var ImportType$$ = [ImportType$0, ImportType$1];
|
|
12652
12652
|
function ImportType(ctx, state) {
|
|
12653
12653
|
return $EVENT_C(ctx, state, "ImportType", ImportType$$);
|
|
@@ -12707,7 +12707,7 @@ ${input.slice(result.pos)}
|
|
|
12707
12707
|
function NestedType(ctx, state) {
|
|
12708
12708
|
return $EVENT(ctx, state, "NestedType", NestedType$0);
|
|
12709
12709
|
}
|
|
12710
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
12710
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L140, 'TypeConditional "extends"'), NonIdContinue, Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
12711
12711
|
if ($2)
|
|
12712
12712
|
return $0;
|
|
12713
12713
|
return $1;
|
|
@@ -12745,10 +12745,10 @@ ${input.slice(result.pos)}
|
|
|
12745
12745
|
}
|
|
12746
12746
|
var TypeLiteral$0 = TypeTemplateLiteral;
|
|
12747
12747
|
var TypeLiteral$1 = Literal;
|
|
12748
|
-
var TypeLiteral$2 = $TS($S($EXPECT($
|
|
12748
|
+
var TypeLiteral$2 = $TS($S($EXPECT($L191, 'TypeLiteral "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
12749
12749
|
return { type: "VoidType", $loc, token: $1 };
|
|
12750
12750
|
});
|
|
12751
|
-
var TypeLiteral$3 = $TV($EXPECT($
|
|
12751
|
+
var TypeLiteral$3 = $TV($EXPECT($L211, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
12752
12752
|
return { $loc, token: "[]" };
|
|
12753
12753
|
});
|
|
12754
12754
|
var TypeLiteral$$ = [TypeLiteral$0, TypeLiteral$1, TypeLiteral$2, TypeLiteral$3];
|
|
@@ -12767,16 +12767,16 @@ ${input.slice(result.pos)}
|
|
|
12767
12767
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
12768
12768
|
return value[1];
|
|
12769
12769
|
});
|
|
12770
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
12770
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L12, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L114, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L36, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L27, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
12771
12771
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
12772
12772
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
12773
12773
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
12774
12774
|
return $EVENT_C(ctx, state, "InlineInterfacePropertyDelimiter", InlineInterfacePropertyDelimiter$$);
|
|
12775
12775
|
}
|
|
12776
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
12776
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L100, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
12777
12777
|
return { $loc, token: "|" };
|
|
12778
12778
|
});
|
|
12779
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
12779
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L99, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
12780
12780
|
return { $loc, token: "&" };
|
|
12781
12781
|
});
|
|
12782
12782
|
var TypeBinaryOp$$ = [TypeBinaryOp$0, TypeBinaryOp$1];
|
|
@@ -12793,7 +12793,7 @@ ${input.slice(result.pos)}
|
|
|
12793
12793
|
function FunctionType(ctx, state) {
|
|
12794
12794
|
return $EVENT(ctx, state, "FunctionType", FunctionType$0);
|
|
12795
12795
|
}
|
|
12796
|
-
var TypeArrowFunction$0 = $TV($C($EXPECT($
|
|
12796
|
+
var TypeArrowFunction$0 = $TV($C($EXPECT($L10, 'TypeArrowFunction "=>"'), $EXPECT($L11, 'TypeArrowFunction "\u21D2"'), $EXPECT($L25, 'TypeArrowFunction "->"'), $EXPECT($L26, 'TypeArrowFunction "\u2192"')), function($skip, $loc, $0, $1) {
|
|
12797
12797
|
return { $loc, token: "=>" };
|
|
12798
12798
|
});
|
|
12799
12799
|
function TypeArrowFunction(ctx, state) {
|
|
@@ -12831,11 +12831,11 @@ ${input.slice(result.pos)}
|
|
|
12831
12831
|
function TypeParameters(ctx, state) {
|
|
12832
12832
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
12833
12833
|
}
|
|
12834
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
12834
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L151, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
12835
12835
|
function TypeParameter(ctx, state) {
|
|
12836
12836
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
12837
12837
|
}
|
|
12838
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
12838
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L140, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
12839
12839
|
function TypeConstraint(ctx, state) {
|
|
12840
12840
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
12841
12841
|
}
|
|
@@ -12844,7 +12844,7 @@ ${input.slice(result.pos)}
|
|
|
12844
12844
|
return $EVENT(ctx, state, "TypeInitializer", TypeInitializer$0);
|
|
12845
12845
|
}
|
|
12846
12846
|
var TypeParameterDelimiter$0 = $S($E(_), Comma);
|
|
12847
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
12847
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L35, 'TypeParameterDelimiter ">"')));
|
|
12848
12848
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
12849
12849
|
return value[1];
|
|
12850
12850
|
});
|
|
@@ -12874,7 +12874,7 @@ ${input.slice(result.pos)}
|
|
|
12874
12874
|
function CivetPrologue(ctx, state) {
|
|
12875
12875
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
12876
12876
|
}
|
|
12877
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
12877
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L212, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R82, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
12878
12878
|
var options = $3;
|
|
12879
12879
|
return {
|
|
12880
12880
|
type: "CivetPrologue",
|
|
@@ -13711,7 +13711,6 @@ ${input.slice(result.pos)}
|
|
|
13711
13711
|
exports.OperatorSignature = OperatorSignature;
|
|
13712
13712
|
exports.AmpersandBlockRHS = AmpersandBlockRHS;
|
|
13713
13713
|
exports.AmpersandBlockRHSBody = AmpersandBlockRHSBody;
|
|
13714
|
-
exports.AmpersandUnaryPrefix = AmpersandUnaryPrefix;
|
|
13715
13714
|
exports.ThinArrowFunction = ThinArrowFunction;
|
|
13716
13715
|
exports.Arrow = Arrow;
|
|
13717
13716
|
exports.ExplicitBlock = ExplicitBlock;
|
|
@@ -14357,7 +14356,6 @@ ${input.slice(result.pos)}
|
|
|
14357
14356
|
switch (node.type) {
|
|
14358
14357
|
case "Ref": {
|
|
14359
14358
|
throw new Error(`Unpopulated ref ${JSON.stringify(node)}`);
|
|
14360
|
-
break;
|
|
14361
14359
|
}
|
|
14362
14360
|
}
|
|
14363
14361
|
debugger;
|