@danielx/civet 0.6.51 → 0.6.53
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 +638 -498
- package/dist/esbuild.js +107 -69
- package/dist/main.js +638 -498
- package/dist/main.mjs +638 -498
- package/dist/rollup.js +107 -69
- package/dist/unplugin-shared.mjs +97 -59
- package/dist/unplugin.d.mts +8 -9
- package/dist/unplugin.d.ts +8 -9
- package/dist/unplugin.js +107 -69
- package/dist/vite.js +107 -69
- package/dist/webpack.js +107 -69
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -3838,6 +3838,7 @@ ${input.slice(result.pos)}
|
|
|
3838
3838
|
ClassHeritage,
|
|
3839
3839
|
ExtendsClause,
|
|
3840
3840
|
ExtendsToken,
|
|
3841
|
+
ExtendsShorthand,
|
|
3841
3842
|
ExtendsTarget,
|
|
3842
3843
|
ImplementsClause,
|
|
3843
3844
|
ImplementsToken,
|
|
@@ -3883,6 +3884,10 @@ ${input.slice(result.pos)}
|
|
|
3883
3884
|
ShortArrowParameters,
|
|
3884
3885
|
ArrowParameters,
|
|
3885
3886
|
NonEmptyParameters,
|
|
3887
|
+
ParameterList,
|
|
3888
|
+
NestedParameterList,
|
|
3889
|
+
NestedParameter,
|
|
3890
|
+
Parameter,
|
|
3886
3891
|
FunctionRestParameter,
|
|
3887
3892
|
ParameterElement,
|
|
3888
3893
|
ParameterElementDelimiter,
|
|
@@ -4074,6 +4079,7 @@ ${input.slice(result.pos)}
|
|
|
4074
4079
|
DeclarationCondition,
|
|
4075
4080
|
ExpressionWithIndentedApplicationForbidden,
|
|
4076
4081
|
ExpressionWithObjectApplicationForbidden,
|
|
4082
|
+
LeftHandSideExpressionWithObjectApplicationForbidden,
|
|
4077
4083
|
ForbidClassImplicitCall,
|
|
4078
4084
|
AllowClassImplicitCall,
|
|
4079
4085
|
RestoreClassImplicitCall,
|
|
@@ -4209,6 +4215,7 @@ ${input.slice(result.pos)}
|
|
|
4209
4215
|
Case,
|
|
4210
4216
|
Catch,
|
|
4211
4217
|
Class,
|
|
4218
|
+
CloseAngleBracket,
|
|
4212
4219
|
CloseBrace,
|
|
4213
4220
|
CloseBracket,
|
|
4214
4221
|
CloseParen,
|
|
@@ -4478,148 +4485,148 @@ ${input.slice(result.pos)}
|
|
|
4478
4485
|
var $L10 = $L("\u21D2");
|
|
4479
4486
|
var $L11 = $L(":");
|
|
4480
4487
|
var $L12 = $L(" ");
|
|
4481
|
-
var $L13 = $L("
|
|
4482
|
-
var $L14 = $L("
|
|
4483
|
-
var $L15 = $L("
|
|
4484
|
-
var $L16 = $L("
|
|
4485
|
-
var $L17 = $L("
|
|
4486
|
-
var $L18 = $L("
|
|
4487
|
-
var $L19 = $L("
|
|
4488
|
-
var $L20 = $L("
|
|
4489
|
-
var $L21 = $L("
|
|
4490
|
-
var $L22 = $L("
|
|
4491
|
-
var $L23 = $L("
|
|
4492
|
-
var $L24 = $L("
|
|
4493
|
-
var $L25 = $L("
|
|
4494
|
-
var $L26 = $L("
|
|
4495
|
-
var $L27 = $L("
|
|
4496
|
-
var $L28 = $L("
|
|
4497
|
-
var $L29 = $L("
|
|
4498
|
-
var $L30 = $L("
|
|
4499
|
-
var $L31 = $L("
|
|
4500
|
-
var $L32 = $L("
|
|
4501
|
-
var $L33 = $L("
|
|
4502
|
-
var $L34 = $L("
|
|
4503
|
-
var $L35 = $L("
|
|
4504
|
-
var $L36 = $L("
|
|
4505
|
-
var $L37 = $L("
|
|
4506
|
-
var $L38 = $L("
|
|
4507
|
-
var $L39 = $L("
|
|
4508
|
-
var $L40 = $L("
|
|
4509
|
-
var $L41 = $L("
|
|
4510
|
-
var $L42 = $L("
|
|
4511
|
-
var $L43 = $L("
|
|
4512
|
-
var $L44 = $L("
|
|
4513
|
-
var $L45 = $L("
|
|
4514
|
-
var $L46 = $L("
|
|
4515
|
-
var $L47 = $L("
|
|
4516
|
-
var $L48 = $L("
|
|
4517
|
-
var $L49 = $L("
|
|
4518
|
-
var $L50 = $L("
|
|
4519
|
-
var $L51 = $L("
|
|
4520
|
-
var $L52 = $L("
|
|
4521
|
-
var $L53 = $L("
|
|
4522
|
-
var $L54 = $L("
|
|
4523
|
-
var $L55 = $L("
|
|
4524
|
-
var $L56 = $L("
|
|
4525
|
-
var $L57 = $L("
|
|
4526
|
-
var $L58 = $L("
|
|
4527
|
-
var $L59 = $L("
|
|
4528
|
-
var $L60 = $L("
|
|
4529
|
-
var $L61 = $L("
|
|
4530
|
-
var $L62 = $L("
|
|
4531
|
-
var $L63 = $L("
|
|
4532
|
-
var $L64 = $L("
|
|
4533
|
-
var $L65 = $L("
|
|
4534
|
-
var $L66 = $L("
|
|
4535
|
-
var $L67 = $L("
|
|
4536
|
-
var $L68 = $L("
|
|
4537
|
-
var $L69 = $L("
|
|
4538
|
-
var $L70 = $L("
|
|
4539
|
-
var $L71 = $L("
|
|
4540
|
-
var $L72 = $L("
|
|
4541
|
-
var $L73 = $L("
|
|
4542
|
-
var $L74 = $L("
|
|
4543
|
-
var $L75 = $L("
|
|
4544
|
-
var $L76 = $L("
|
|
4545
|
-
var $L77 = $L("
|
|
4546
|
-
var $L78 = $L("\
|
|
4547
|
-
var $L79 = $L("
|
|
4548
|
-
var $L80 = $L("
|
|
4549
|
-
var $L81 = $L("\
|
|
4550
|
-
var $L82 = $L("
|
|
4551
|
-
var $L83 = $L("
|
|
4552
|
-
var $L84 = $L("
|
|
4553
|
-
var $L85 = $L("
|
|
4554
|
-
var $L86 = $L("
|
|
4555
|
-
var $L87 = $L("
|
|
4556
|
-
var $L88 = $L("
|
|
4557
|
-
var $L89 = $L("
|
|
4558
|
-
var $L90 = $L("
|
|
4559
|
-
var $L91 = $L("
|
|
4560
|
-
var $L92 = $L("
|
|
4561
|
-
var $L93 = $L("
|
|
4562
|
-
var $L94 = $L("\
|
|
4563
|
-
var $L95 = $L("\
|
|
4564
|
-
var $L96 = $L("\
|
|
4565
|
-
var $L97 = $L("
|
|
4566
|
-
var $L98 = $L("
|
|
4567
|
-
var $L99 = $L("
|
|
4568
|
-
var $L100 = $L("
|
|
4569
|
-
var $L101 = $L("
|
|
4570
|
-
var $L102 = $L("
|
|
4571
|
-
var $L103 = $L("
|
|
4572
|
-
var $L104 = $L("
|
|
4573
|
-
var $L105 = $L("
|
|
4574
|
-
var $L106 = $L("
|
|
4575
|
-
var $L107 = $L("
|
|
4576
|
-
var $L108 = $L("
|
|
4577
|
-
var $L109 = $L("
|
|
4578
|
-
var $L110 = $L("
|
|
4579
|
-
var $L111 = $L("
|
|
4580
|
-
var $L112 = $L("
|
|
4581
|
-
var $L113 = $L("
|
|
4582
|
-
var $L114 = $L("
|
|
4583
|
-
var $L115 = $L("
|
|
4584
|
-
var $L116 = $L("
|
|
4585
|
-
var $L117 = $L("
|
|
4586
|
-
var $L118 = $L("
|
|
4587
|
-
var $L119 = $L("
|
|
4588
|
-
var $L120 = $L("
|
|
4589
|
-
var $L121 = $L("
|
|
4590
|
-
var $L122 = $L("
|
|
4591
|
-
var $L123 = $L("
|
|
4592
|
-
var $L124 = $L("
|
|
4593
|
-
var $L125 = $L("
|
|
4594
|
-
var $L126 = $L("
|
|
4595
|
-
var $L127 = $L("
|
|
4596
|
-
var $L128 = $L("
|
|
4597
|
-
var $L129 = $L("
|
|
4598
|
-
var $L130 = $L("
|
|
4599
|
-
var $L131 = $L("
|
|
4600
|
-
var $L132 = $L("
|
|
4601
|
-
var $L133 = $L(
|
|
4602
|
-
var $L134 = $L("
|
|
4603
|
-
var $L135 = $L("
|
|
4604
|
-
var $L136 = $L("
|
|
4605
|
-
var $L137 = $L("
|
|
4606
|
-
var $L138 = $L("
|
|
4607
|
-
var $L139 = $L("
|
|
4608
|
-
var $L140 = $L("
|
|
4609
|
-
var $L141 = $L("
|
|
4610
|
-
var $L142 = $L("
|
|
4611
|
-
var $L143 = $L("
|
|
4612
|
-
var $L144 = $L("
|
|
4613
|
-
var $L145 = $L("
|
|
4614
|
-
var $L146 = $L("
|
|
4615
|
-
var $L147 = $L("
|
|
4616
|
-
var $L148 = $L("
|
|
4617
|
-
var $L149 = $L("
|
|
4618
|
-
var $L150 = $L("
|
|
4619
|
-
var $L151 = $L("
|
|
4620
|
-
var $L152 = $L("
|
|
4621
|
-
var $L153 = $L("
|
|
4622
|
-
var $L154 = $L("
|
|
4488
|
+
var $L13 = $L("<");
|
|
4489
|
+
var $L14 = $L("implements");
|
|
4490
|
+
var $L15 = $L("<:");
|
|
4491
|
+
var $L16 = $L("import");
|
|
4492
|
+
var $L17 = $L("!");
|
|
4493
|
+
var $L18 = $L("^");
|
|
4494
|
+
var $L19 = $L("-");
|
|
4495
|
+
var $L20 = $L("import.meta");
|
|
4496
|
+
var $L21 = $L("return.value");
|
|
4497
|
+
var $L22 = $L(",");
|
|
4498
|
+
var $L23 = $L("(&)");
|
|
4499
|
+
var $L24 = $L("->");
|
|
4500
|
+
var $L25 = $L("\u2192");
|
|
4501
|
+
var $L26 = $L("}");
|
|
4502
|
+
var $L27 = $L("null");
|
|
4503
|
+
var $L28 = $L("true");
|
|
4504
|
+
var $L29 = $L("false");
|
|
4505
|
+
var $L30 = $L("yes");
|
|
4506
|
+
var $L31 = $L("on");
|
|
4507
|
+
var $L32 = $L("no");
|
|
4508
|
+
var $L33 = $L("off");
|
|
4509
|
+
var $L34 = $L(">");
|
|
4510
|
+
var $L35 = $L("]");
|
|
4511
|
+
var $L36 = $L("**=");
|
|
4512
|
+
var $L37 = $L("*=");
|
|
4513
|
+
var $L38 = $L("/=");
|
|
4514
|
+
var $L39 = $L("%=");
|
|
4515
|
+
var $L40 = $L("+=");
|
|
4516
|
+
var $L41 = $L("-=");
|
|
4517
|
+
var $L42 = $L("<<=");
|
|
4518
|
+
var $L43 = $L(">>>=");
|
|
4519
|
+
var $L44 = $L(">>=");
|
|
4520
|
+
var $L45 = $L("&&=");
|
|
4521
|
+
var $L46 = $L("&=");
|
|
4522
|
+
var $L47 = $L("^=");
|
|
4523
|
+
var $L48 = $L("||=");
|
|
4524
|
+
var $L49 = $L("|=");
|
|
4525
|
+
var $L50 = $L("??=");
|
|
4526
|
+
var $L51 = $L("?=");
|
|
4527
|
+
var $L52 = $L("and=");
|
|
4528
|
+
var $L53 = $L("or=");
|
|
4529
|
+
var $L54 = $L("**");
|
|
4530
|
+
var $L55 = $L("*");
|
|
4531
|
+
var $L56 = $L("/");
|
|
4532
|
+
var $L57 = $L("%%");
|
|
4533
|
+
var $L58 = $L("%");
|
|
4534
|
+
var $L59 = $L("+");
|
|
4535
|
+
var $L60 = $L("<=");
|
|
4536
|
+
var $L61 = $L("\u2264");
|
|
4537
|
+
var $L62 = $L(">=");
|
|
4538
|
+
var $L63 = $L("\u2265");
|
|
4539
|
+
var $L64 = $L("<?");
|
|
4540
|
+
var $L65 = $L("!<?");
|
|
4541
|
+
var $L66 = $L("<<");
|
|
4542
|
+
var $L67 = $L("\xAB");
|
|
4543
|
+
var $L68 = $L(">>>");
|
|
4544
|
+
var $L69 = $L("\u22D9");
|
|
4545
|
+
var $L70 = $L(">>");
|
|
4546
|
+
var $L71 = $L("\xBB");
|
|
4547
|
+
var $L72 = $L("!==");
|
|
4548
|
+
var $L73 = $L("\u2262");
|
|
4549
|
+
var $L74 = $L("!=");
|
|
4550
|
+
var $L75 = $L("\u2260");
|
|
4551
|
+
var $L76 = $L("isnt");
|
|
4552
|
+
var $L77 = $L("===");
|
|
4553
|
+
var $L78 = $L("\u2263");
|
|
4554
|
+
var $L79 = $L("\u2A76");
|
|
4555
|
+
var $L80 = $L("==");
|
|
4556
|
+
var $L81 = $L("\u2261");
|
|
4557
|
+
var $L82 = $L("\u2A75");
|
|
4558
|
+
var $L83 = $L("and");
|
|
4559
|
+
var $L84 = $L("&&");
|
|
4560
|
+
var $L85 = $L("or");
|
|
4561
|
+
var $L86 = $L("||");
|
|
4562
|
+
var $L87 = $L("\u2016");
|
|
4563
|
+
var $L88 = $L("^^");
|
|
4564
|
+
var $L89 = $L("xor");
|
|
4565
|
+
var $L90 = $L("xnor");
|
|
4566
|
+
var $L91 = $L("??");
|
|
4567
|
+
var $L92 = $L("\u2047");
|
|
4568
|
+
var $L93 = $L("instanceof");
|
|
4569
|
+
var $L94 = $L("\u2208");
|
|
4570
|
+
var $L95 = $L("\u220B");
|
|
4571
|
+
var $L96 = $L("\u220C");
|
|
4572
|
+
var $L97 = $L("\u2209");
|
|
4573
|
+
var $L98 = $L("&");
|
|
4574
|
+
var $L99 = $L("|");
|
|
4575
|
+
var $L100 = $L(";");
|
|
4576
|
+
var $L101 = $L("$:");
|
|
4577
|
+
var $L102 = $L("break");
|
|
4578
|
+
var $L103 = $L("continue");
|
|
4579
|
+
var $L104 = $L("debugger");
|
|
4580
|
+
var $L105 = $L("assert");
|
|
4581
|
+
var $L106 = $L(":=");
|
|
4582
|
+
var $L107 = $L("\u2254");
|
|
4583
|
+
var $L108 = $L(".=");
|
|
4584
|
+
var $L109 = $L("/*");
|
|
4585
|
+
var $L110 = $L("*/");
|
|
4586
|
+
var $L111 = $L("\\");
|
|
4587
|
+
var $L112 = $L(")");
|
|
4588
|
+
var $L113 = $L("abstract");
|
|
4589
|
+
var $L114 = $L("as");
|
|
4590
|
+
var $L115 = $L("@");
|
|
4591
|
+
var $L116 = $L("@@");
|
|
4592
|
+
var $L117 = $L("async");
|
|
4593
|
+
var $L118 = $L("await");
|
|
4594
|
+
var $L119 = $L("`");
|
|
4595
|
+
var $L120 = $L("by");
|
|
4596
|
+
var $L121 = $L("case");
|
|
4597
|
+
var $L122 = $L("catch");
|
|
4598
|
+
var $L123 = $L("class");
|
|
4599
|
+
var $L124 = $L("#{");
|
|
4600
|
+
var $L125 = $L("declare");
|
|
4601
|
+
var $L126 = $L("default");
|
|
4602
|
+
var $L127 = $L("delete");
|
|
4603
|
+
var $L128 = $L("do");
|
|
4604
|
+
var $L129 = $L("..");
|
|
4605
|
+
var $L130 = $L("\u2025");
|
|
4606
|
+
var $L131 = $L("...");
|
|
4607
|
+
var $L132 = $L("\u2026");
|
|
4608
|
+
var $L133 = $L("::");
|
|
4609
|
+
var $L134 = $L('"');
|
|
4610
|
+
var $L135 = $L("each");
|
|
4611
|
+
var $L136 = $L("else");
|
|
4612
|
+
var $L137 = $L("export");
|
|
4613
|
+
var $L138 = $L("extends");
|
|
4614
|
+
var $L139 = $L("finally");
|
|
4615
|
+
var $L140 = $L("for");
|
|
4616
|
+
var $L141 = $L("from");
|
|
4617
|
+
var $L142 = $L("function");
|
|
4618
|
+
var $L143 = $L("get");
|
|
4619
|
+
var $L144 = $L("set");
|
|
4620
|
+
var $L145 = $L("#");
|
|
4621
|
+
var $L146 = $L("if");
|
|
4622
|
+
var $L147 = $L("in");
|
|
4623
|
+
var $L148 = $L("let");
|
|
4624
|
+
var $L149 = $L("const");
|
|
4625
|
+
var $L150 = $L("is");
|
|
4626
|
+
var $L151 = $L("loop");
|
|
4627
|
+
var $L152 = $L("new");
|
|
4628
|
+
var $L153 = $L("not");
|
|
4629
|
+
var $L154 = $L("of");
|
|
4623
4630
|
var $L155 = $L("[");
|
|
4624
4631
|
var $L156 = $L("operator");
|
|
4625
4632
|
var $L157 = $L("own");
|
|
@@ -4680,7 +4687,7 @@ ${input.slice(result.pos)}
|
|
|
4680
4687
|
var $R1 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
4681
4688
|
var $R2 = $R(new RegExp("[0-9]", "suy"));
|
|
4682
4689
|
var $R3 = $R(new RegExp("[ \\t]", "suy"));
|
|
4683
|
-
var $R4 = $R(new RegExp("(?=['\"
|
|
4690
|
+
var $R4 = $R(new RegExp("(?=['\"`<])", "suy"));
|
|
4684
4691
|
var $R5 = $R(new RegExp("(?=[\\/?])", "suy"));
|
|
4685
4692
|
var $R6 = $R(new RegExp("(?=[\\/\\[{?.!@'\u2019:])", "suy"));
|
|
4686
4693
|
var $R7 = $R(new RegExp("[)}]", "suy"));
|
|
@@ -4693,77 +4700,76 @@ ${input.slice(result.pos)}
|
|
|
4693
4700
|
var $R14 = $R(new RegExp("(?=\\[)", "suy"));
|
|
4694
4701
|
var $R15 = $R(new RegExp("[!+-]", "suy"));
|
|
4695
4702
|
var $R16 = $R(new RegExp("(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>+-])", "suy"));
|
|
4696
|
-
var $R17 = $R(new RegExp("
|
|
4697
|
-
var $R18 = $R(new RegExp("
|
|
4698
|
-
var $R19 = $R(new RegExp("(
|
|
4699
|
-
var $R20 = $R(new RegExp("(?=
|
|
4700
|
-
var $R21 = $R(new RegExp("(?=
|
|
4701
|
-
var $R22 = $R(new RegExp("
|
|
4702
|
-
var $R23 = $R(new RegExp(
|
|
4703
|
-
var $R24 = $R(new RegExp("(
|
|
4704
|
-
var $R25 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)
|
|
4705
|
-
var $R26 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(
|
|
4706
|
-
var $R27 = $R(new RegExp("(
|
|
4707
|
-
var $R28 = $R(new RegExp("(
|
|
4708
|
-
var $R29 = $R(new RegExp("
|
|
4709
|
-
var $R30 = $R(new RegExp("0[
|
|
4710
|
-
var $R31 = $R(new RegExp("0[
|
|
4711
|
-
var $R32 = $R(new RegExp("
|
|
4712
|
-
var $R33 = $R(new RegExp("(
|
|
4713
|
-
var $R34 = $R(new RegExp(
|
|
4714
|
-
var $R35 = $R(new RegExp(
|
|
4715
|
-
var $R36 = $R(new RegExp("(
|
|
4716
|
-
var $R37 = $R(new RegExp(
|
|
4717
|
-
var $R38 = $R(new RegExp(
|
|
4718
|
-
var $R39 = $R(new RegExp(
|
|
4719
|
-
var $R40 = $R(new RegExp("(
|
|
4720
|
-
var $R41 = $R(new RegExp("
|
|
4721
|
-
var $R42 = $R(new RegExp("
|
|
4722
|
-
var $R43 = $R(new RegExp("
|
|
4723
|
-
var $R44 = $R(new RegExp("[
|
|
4724
|
-
var $R45 = $R(new RegExp("[
|
|
4725
|
-
var $R46 = $R(new RegExp("(
|
|
4726
|
-
var $R47 = $R(new RegExp("(
|
|
4727
|
-
var $R48 = $R(new RegExp("(
|
|
4728
|
-
var $R49 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
4729
|
-
var $R50 = $R(new RegExp("(
|
|
4730
|
-
var $R51 = $R(new RegExp("(?:
|
|
4731
|
-
var $R52 = $R(new RegExp("(?:
|
|
4732
|
-
var $R53 = $R(new RegExp("(?:
|
|
4733
|
-
var $R54 = $R(new RegExp("(?:
|
|
4734
|
-
var $R55 = $R(new RegExp("(
|
|
4735
|
-
var $R56 = $R(new RegExp("(
|
|
4736
|
-
var $R57 = $R(new RegExp("
|
|
4737
|
-
var $R58 = $R(new RegExp("
|
|
4738
|
-
var $R59 = $R(new RegExp("
|
|
4739
|
-
var $R60 = $R(new RegExp("
|
|
4740
|
-
var $R61 = $R(new RegExp("
|
|
4741
|
-
var $R62 = $R(new RegExp("
|
|
4742
|
-
var $R63 = $R(new RegExp("
|
|
4743
|
-
var $R64 = $R(new RegExp("
|
|
4744
|
-
var $R65 = $R(new RegExp("(
|
|
4745
|
-
var $R66 = $R(new RegExp("
|
|
4746
|
-
var $R67 = $R(new RegExp("
|
|
4747
|
-
var $R68 = $R(new RegExp("
|
|
4748
|
-
var $R69 = $R(new RegExp("(
|
|
4749
|
-
var $R70 = $R(new RegExp("
|
|
4750
|
-
var $R71 = $R(new RegExp("[\\
|
|
4751
|
-
var $R72 = $R(new RegExp("
|
|
4752
|
-
var $R73 = $R(new RegExp(
|
|
4753
|
-
var $R74 = $R(new RegExp("[
|
|
4754
|
-
var $R75 = $R(new RegExp("[
|
|
4755
|
-
var $R76 = $R(new RegExp("
|
|
4756
|
-
var $R77 = $R(new RegExp("[
|
|
4757
|
-
var $R78 = $R(new RegExp("[+-]
|
|
4758
|
-
var $R79 = $R(new RegExp("[
|
|
4759
|
-
var $R80 = $R(new RegExp("
|
|
4760
|
-
var $R81 = $R(new RegExp("[\\t
|
|
4761
|
-
var $R82 = $R(new RegExp("[
|
|
4762
|
-
var $R83 = $R(new RegExp("[\\s]*", "suy"));
|
|
4763
|
-
var $R84 = $R(new RegExp("
|
|
4764
|
-
var $R85 = $R(new RegExp("
|
|
4765
|
-
var $R86 = $R(new RegExp("
|
|
4766
|
-
var $R87 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
4703
|
+
var $R17 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
4704
|
+
var $R18 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*(&|\\.[^0-9]))", "suy"));
|
|
4705
|
+
var $R19 = $R(new RegExp("(?=for|if|loop|unless|until|while)", "suy"));
|
|
4706
|
+
var $R20 = $R(new RegExp("(?=loop|do|for|until|while)", "suy"));
|
|
4707
|
+
var $R21 = $R(new RegExp("(?=[\\s\\),])", "suy"));
|
|
4708
|
+
var $R22 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
4709
|
+
var $R23 = $R(new RegExp("(?=[0-9.])", "suy"));
|
|
4710
|
+
var $R24 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
4711
|
+
var $R25 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
4712
|
+
var $R26 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
4713
|
+
var $R27 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4714
|
+
var $R28 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
4715
|
+
var $R29 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
4716
|
+
var $R30 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
4717
|
+
var $R31 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
4718
|
+
var $R32 = $R(new RegExp("(?=[0-9])", "suy"));
|
|
4719
|
+
var $R33 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4720
|
+
var $R34 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
4721
|
+
var $R35 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
4722
|
+
var $R36 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
4723
|
+
var $R37 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
4724
|
+
var $R38 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
4725
|
+
var $R39 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
4726
|
+
var $R40 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
4727
|
+
var $R41 = $R(new RegExp("[\\s]+", "suy"));
|
|
4728
|
+
var $R42 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
4729
|
+
var $R43 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
4730
|
+
var $R44 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
4731
|
+
var $R45 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
4732
|
+
var $R46 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
4733
|
+
var $R47 = $R(new RegExp("(?=[`'\"])", "suy"));
|
|
4734
|
+
var $R48 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
4735
|
+
var $R49 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
4736
|
+
var $R50 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
4737
|
+
var $R51 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
4738
|
+
var $R52 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
4739
|
+
var $R53 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
4740
|
+
var $R54 = $R(new RegExp("(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
4741
|
+
var $R55 = $R(new RegExp("(?=\\/|#)", "suy"));
|
|
4742
|
+
var $R56 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
4743
|
+
var $R57 = $R(new RegExp(".", "suy"));
|
|
4744
|
+
var $R58 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
4745
|
+
var $R59 = $R(new RegExp("[^]*?###", "suy"));
|
|
4746
|
+
var $R60 = $R(new RegExp("###(?!#)", "suy"));
|
|
4747
|
+
var $R61 = $R(new RegExp("\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\/", "suy"));
|
|
4748
|
+
var $R62 = $R(new RegExp("(?=[ \\t\\/\\\\])", "suy"));
|
|
4749
|
+
var $R63 = $R(new RegExp("[ \\t]+", "suy"));
|
|
4750
|
+
var $R64 = $R(new RegExp("(?=\\s|\\/|#)", "suy"));
|
|
4751
|
+
var $R65 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
4752
|
+
var $R66 = $R(new RegExp("['\u2019]s", "suy"));
|
|
4753
|
+
var $R67 = $R(new RegExp("\\s", "suy"));
|
|
4754
|
+
var $R68 = $R(new RegExp("(?=[<])", "suy"));
|
|
4755
|
+
var $R69 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
4756
|
+
var $R70 = $R(new RegExp("[\\s>]|\\/>", "suy"));
|
|
4757
|
+
var $R71 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
4758
|
+
var $R72 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
|
|
4759
|
+
var $R73 = $R(new RegExp("[<>]", "suy"));
|
|
4760
|
+
var $R74 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
4761
|
+
var $R75 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
4762
|
+
var $R76 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
4763
|
+
var $R77 = $R(new RegExp("[+-]?", "suy"));
|
|
4764
|
+
var $R78 = $R(new RegExp("[+-]", "suy"));
|
|
4765
|
+
var $R79 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
4766
|
+
var $R80 = $R(new RegExp("[\\t ]*", "suy"));
|
|
4767
|
+
var $R81 = $R(new RegExp("[ \\t]*", "suy"));
|
|
4768
|
+
var $R82 = $R(new RegExp("[\\s]*", "suy"));
|
|
4769
|
+
var $R83 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
4770
|
+
var $R84 = $R(new RegExp("\\/\\/\\/[^\\r\\n]*", "suy"));
|
|
4771
|
+
var $R85 = $R(new RegExp("(?=[ \\t\\r\\n\\/#]|$)", "suy"));
|
|
4772
|
+
var $R86 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
4767
4773
|
var Program$0 = $TS($S(Reset, Init, $E(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
4768
4774
|
var statements = $4;
|
|
4769
4775
|
processProgram({
|
|
@@ -5498,14 +5504,11 @@ ${input.slice(result.pos)}
|
|
|
5498
5504
|
function ExtendsClause(ctx, state) {
|
|
5499
5505
|
return $EVENT(ctx, state, "ExtendsClause", ExtendsClause$0);
|
|
5500
5506
|
}
|
|
5501
|
-
var ExtendsToken$0 = $TS($S(Loc, __,
|
|
5507
|
+
var ExtendsToken$0 = $TS($S(Loc, __, ExtendsShorthand, $E($EXPECT($L12, 'ExtendsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5502
5508
|
var l = $1;
|
|
5503
5509
|
var ws = $2;
|
|
5504
|
-
var
|
|
5505
|
-
const children = [
|
|
5506
|
-
...ws,
|
|
5507
|
-
{ ...lt, token: "extends " }
|
|
5508
|
-
];
|
|
5510
|
+
var t = $3;
|
|
5511
|
+
const children = [...ws, t];
|
|
5509
5512
|
if (!ws.length) {
|
|
5510
5513
|
children.unshift({ $loc: l.$loc, token: " " });
|
|
5511
5514
|
}
|
|
@@ -5516,7 +5519,13 @@ ${input.slice(result.pos)}
|
|
|
5516
5519
|
function ExtendsToken(ctx, state) {
|
|
5517
5520
|
return $EVENT_C(ctx, state, "ExtendsToken", ExtendsToken$$);
|
|
5518
5521
|
}
|
|
5519
|
-
var
|
|
5522
|
+
var ExtendsShorthand$0 = $TV($EXPECT($L13, 'ExtendsShorthand "<"'), function($skip, $loc, $0, $1) {
|
|
5523
|
+
return { $loc, token: "extends " };
|
|
5524
|
+
});
|
|
5525
|
+
function ExtendsShorthand(ctx, state) {
|
|
5526
|
+
return $EVENT(ctx, state, "ExtendsShorthand", ExtendsShorthand$0);
|
|
5527
|
+
}
|
|
5528
|
+
var ExtendsTarget$0 = $TS($S(LeftHandSideExpressionWithObjectApplicationForbidden, $E(TypeArguments)), function($skip, $loc, $0, $1, $2) {
|
|
5520
5529
|
var exp = $1;
|
|
5521
5530
|
var ta = $2;
|
|
5522
5531
|
exp = makeLeftHandSideExpression(exp);
|
|
@@ -5546,7 +5555,7 @@ ${input.slice(result.pos)}
|
|
|
5546
5555
|
}
|
|
5547
5556
|
return { children };
|
|
5548
5557
|
});
|
|
5549
|
-
var ImplementsToken$1 = $TS($S(__, $EXPECT($
|
|
5558
|
+
var ImplementsToken$1 = $TS($S(__, $EXPECT($L14, 'ImplementsToken "implements"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
5550
5559
|
$2 = { $loc, token: $2 };
|
|
5551
5560
|
return [$1, $2];
|
|
5552
5561
|
});
|
|
@@ -5554,7 +5563,7 @@ ${input.slice(result.pos)}
|
|
|
5554
5563
|
function ImplementsToken(ctx, state) {
|
|
5555
5564
|
return $EVENT_C(ctx, state, "ImplementsToken", ImplementsToken$$);
|
|
5556
5565
|
}
|
|
5557
|
-
var ImplementsShorthand$0 = $TV($EXPECT($
|
|
5566
|
+
var ImplementsShorthand$0 = $TV($EXPECT($L15, 'ImplementsShorthand "<:"'), function($skip, $loc, $0, $1) {
|
|
5558
5567
|
return { $loc, token: "implements " };
|
|
5559
5568
|
});
|
|
5560
5569
|
function ImplementsShorthand(ctx, state) {
|
|
@@ -5779,7 +5788,7 @@ ${input.slice(result.pos)}
|
|
|
5779
5788
|
children: [$1, ...$2, ...rest.flat()]
|
|
5780
5789
|
});
|
|
5781
5790
|
});
|
|
5782
|
-
var CallExpression$1 = $TS($S($EXPECT($
|
|
5791
|
+
var CallExpression$1 = $TS($S($EXPECT($L16, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5783
5792
|
var rest = $3;
|
|
5784
5793
|
return processCallMemberExpression({
|
|
5785
5794
|
type: "CallExpression",
|
|
@@ -5804,12 +5813,15 @@ ${input.slice(result.pos)}
|
|
|
5804
5813
|
return $EVENT_C(ctx, state, "CallExpression", CallExpression$$);
|
|
5805
5814
|
}
|
|
5806
5815
|
var CallExpressionRest$0 = MemberExpressionRest;
|
|
5807
|
-
var CallExpressionRest$1 = $TS($S($EXPECT($R4, "CallExpressionRest /(?=['\"
|
|
5808
|
-
var
|
|
5816
|
+
var CallExpressionRest$1 = $TS($S($EXPECT($R4, "CallExpressionRest /(?=['\"`<])/"), $E(TypeArguments), $C(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5817
|
+
var args = $2;
|
|
5818
|
+
var literal = $3;
|
|
5809
5819
|
if (literal.type === "StringLiteral") {
|
|
5810
|
-
|
|
5820
|
+
literal = "`" + literal.token.slice(1, -1).replace(/(`|\$\{)/g, "\\$1") + "`";
|
|
5811
5821
|
}
|
|
5812
|
-
|
|
5822
|
+
if (!args)
|
|
5823
|
+
return literal;
|
|
5824
|
+
return [args, literal];
|
|
5813
5825
|
});
|
|
5814
5826
|
var CallExpressionRest$2 = $TS($S($E(OptionalShorthand), ArgumentsWithTrailingMemberExpressions), function($skip, $loc, $0, $1, $2) {
|
|
5815
5827
|
if (!$1)
|
|
@@ -5837,7 +5849,7 @@ ${input.slice(result.pos)}
|
|
|
5837
5849
|
function OptionalDot(ctx, state) {
|
|
5838
5850
|
return $EVENT_C(ctx, state, "OptionalDot", OptionalDot$$);
|
|
5839
5851
|
}
|
|
5840
|
-
var NonNullAssertion$0 = $T($S($EXPECT($
|
|
5852
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L17, 'NonNullAssertion "!"'), $N($EXPECT($L18, 'NonNullAssertion "^"'))), function(value) {
|
|
5841
5853
|
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
5842
5854
|
});
|
|
5843
5855
|
function NonNullAssertion(ctx, state) {
|
|
@@ -5934,7 +5946,7 @@ ${input.slice(result.pos)}
|
|
|
5934
5946
|
]
|
|
5935
5947
|
};
|
|
5936
5948
|
});
|
|
5937
|
-
var MemberBracketContent$2 = $TS($S(Dot, $EXPECT($
|
|
5949
|
+
var MemberBracketContent$2 = $TS($S(Dot, $EXPECT($L19, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
5938
5950
|
var dot = $1;
|
|
5939
5951
|
var neg = $2;
|
|
5940
5952
|
var num = $3;
|
|
@@ -6092,7 +6104,7 @@ ${input.slice(result.pos)}
|
|
|
6092
6104
|
return $EVENT_C(ctx, state, "SuperProperty", SuperProperty$$);
|
|
6093
6105
|
}
|
|
6094
6106
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
6095
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
6107
|
+
var MetaProperty$1 = $TS($S($EXPECT($L20, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6096
6108
|
return { $loc, token: $1 };
|
|
6097
6109
|
});
|
|
6098
6110
|
var MetaProperty$2 = ReturnValue;
|
|
@@ -6100,7 +6112,7 @@ ${input.slice(result.pos)}
|
|
|
6100
6112
|
function MetaProperty(ctx, state) {
|
|
6101
6113
|
return $EVENT_C(ctx, state, "MetaProperty", MetaProperty$$);
|
|
6102
6114
|
}
|
|
6103
|
-
var ReturnValue$0 = $TV($C($S($EXPECT($
|
|
6115
|
+
var ReturnValue$0 = $TV($C($S($EXPECT($L21, 'ReturnValue "return.value"'), NonIdContinue), $S(Return, $Y(AfterReturnShorthand))), function($skip, $loc, $0, $1) {
|
|
6104
6116
|
return { type: "ReturnValue", children: [$1[0]] };
|
|
6105
6117
|
});
|
|
6106
6118
|
function ReturnValue(ctx, state) {
|
|
@@ -6149,15 +6161,55 @@ ${input.slice(result.pos)}
|
|
|
6149
6161
|
function ArrowParameters(ctx, state) {
|
|
6150
6162
|
return $EVENT_C(ctx, state, "ArrowParameters", ArrowParameters$$);
|
|
6151
6163
|
}
|
|
6152
|
-
var NonEmptyParameters$0 = $TS($S($E(TypeParameters), OpenParen,
|
|
6164
|
+
var NonEmptyParameters$0 = $TS($S($E(TypeParameters), OpenParen, ParameterList, $S(__, CloseParen)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6153
6165
|
var tp = $1;
|
|
6154
6166
|
var open = $2;
|
|
6155
|
-
var
|
|
6156
|
-
var
|
|
6157
|
-
|
|
6158
|
-
|
|
6159
|
-
|
|
6160
|
-
|
|
6167
|
+
var params = $3;
|
|
6168
|
+
var close = $4;
|
|
6169
|
+
let tt, before = [], rest, after = [], errors = [];
|
|
6170
|
+
function append(p) {
|
|
6171
|
+
(rest ? after : before).push(p);
|
|
6172
|
+
}
|
|
6173
|
+
for (const param of params) {
|
|
6174
|
+
switch (param.type) {
|
|
6175
|
+
case "ThisType":
|
|
6176
|
+
if (tt) {
|
|
6177
|
+
append({
|
|
6178
|
+
type: "Error",
|
|
6179
|
+
message: "Only one typed this parameter is allowed"
|
|
6180
|
+
});
|
|
6181
|
+
append(param);
|
|
6182
|
+
} else {
|
|
6183
|
+
tt = insertTrimmingSpace(param, "");
|
|
6184
|
+
if (before.length || rest) {
|
|
6185
|
+
let delim = tt.children.at(-1);
|
|
6186
|
+
if (Array.isArray(delim))
|
|
6187
|
+
delim = delim.at(-1);
|
|
6188
|
+
if (delim?.token !== ",") {
|
|
6189
|
+
tt = {
|
|
6190
|
+
...tt,
|
|
6191
|
+
children: [...tt.children, ", "]
|
|
6192
|
+
};
|
|
6193
|
+
}
|
|
6194
|
+
}
|
|
6195
|
+
}
|
|
6196
|
+
break;
|
|
6197
|
+
case "FunctionRestParameter":
|
|
6198
|
+
if (rest) {
|
|
6199
|
+
append({
|
|
6200
|
+
type: "Error",
|
|
6201
|
+
message: "Only one rest parameter is allowed"
|
|
6202
|
+
});
|
|
6203
|
+
append(param);
|
|
6204
|
+
} else {
|
|
6205
|
+
rest = param;
|
|
6206
|
+
}
|
|
6207
|
+
break;
|
|
6208
|
+
default:
|
|
6209
|
+
append(param);
|
|
6210
|
+
}
|
|
6211
|
+
}
|
|
6212
|
+
const names = before.flatMap((p) => p.names);
|
|
6161
6213
|
if (rest) {
|
|
6162
6214
|
const restIdentifier = rest.binding.ref || rest.binding;
|
|
6163
6215
|
names.push(...rest.names || []);
|
|
@@ -6174,7 +6226,7 @@ ${input.slice(result.pos)}
|
|
|
6174
6226
|
tp,
|
|
6175
6227
|
open,
|
|
6176
6228
|
tt,
|
|
6177
|
-
...
|
|
6229
|
+
...before,
|
|
6178
6230
|
// Remove delimiter
|
|
6179
6231
|
{ ...rest, children: rest.children.slice(0, -1) },
|
|
6180
6232
|
close
|
|
@@ -6186,19 +6238,61 @@ ${input.slice(result.pos)}
|
|
|
6186
6238
|
}
|
|
6187
6239
|
return {
|
|
6188
6240
|
type: "Parameters",
|
|
6189
|
-
children: [tp, open, tt, ...
|
|
6190
|
-
names
|
|
6241
|
+
children: [tp, open, tt, ...before, close],
|
|
6242
|
+
names,
|
|
6191
6243
|
tp
|
|
6192
6244
|
};
|
|
6193
6245
|
});
|
|
6194
6246
|
function NonEmptyParameters(ctx, state) {
|
|
6195
6247
|
return $EVENT(ctx, state, "NonEmptyParameters", NonEmptyParameters$0);
|
|
6196
6248
|
}
|
|
6197
|
-
var
|
|
6249
|
+
var ParameterList$0 = $TS($S($Q(Parameter), NestedParameterList), function($skip, $loc, $0, $1, $2) {
|
|
6250
|
+
return [...$1, ...$2];
|
|
6251
|
+
});
|
|
6252
|
+
var ParameterList$1 = $TV($Q($S(__, Parameter)), function($skip, $loc, $0, $1) {
|
|
6253
|
+
return $1.map(([eos, p]) => ({
|
|
6254
|
+
...p,
|
|
6255
|
+
children: [eos, ...p.children]
|
|
6256
|
+
}));
|
|
6257
|
+
});
|
|
6258
|
+
var ParameterList$$ = [ParameterList$0, ParameterList$1];
|
|
6259
|
+
function ParameterList(ctx, state) {
|
|
6260
|
+
return $EVENT_C(ctx, state, "ParameterList", ParameterList$$);
|
|
6261
|
+
}
|
|
6262
|
+
var NestedParameterList$0 = $TS($S(PushIndent, $Q(NestedParameter), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
6263
|
+
var params = $2;
|
|
6264
|
+
if (!params.length)
|
|
6265
|
+
return $skip;
|
|
6266
|
+
return params;
|
|
6267
|
+
});
|
|
6268
|
+
function NestedParameterList(ctx, state) {
|
|
6269
|
+
return $EVENT(ctx, state, "NestedParameterList", NestedParameterList$0);
|
|
6270
|
+
}
|
|
6271
|
+
var NestedParameter$0 = $TS($S(Nested, $P(Parameter)), function($skip, $loc, $0, $1, $2) {
|
|
6272
|
+
var ws = $1;
|
|
6273
|
+
var params = $2;
|
|
6274
|
+
params = [...params];
|
|
6275
|
+
params[0] = {
|
|
6276
|
+
...params[0],
|
|
6277
|
+
children: [ws, ...params[0].children]
|
|
6278
|
+
};
|
|
6279
|
+
return params;
|
|
6280
|
+
});
|
|
6281
|
+
function NestedParameter(ctx, state) {
|
|
6282
|
+
return $EVENT(ctx, state, "NestedParameter", NestedParameter$0);
|
|
6283
|
+
}
|
|
6284
|
+
var Parameter$0 = ThisType;
|
|
6285
|
+
var Parameter$1 = ParameterElement;
|
|
6286
|
+
var Parameter$2 = FunctionRestParameter;
|
|
6287
|
+
var Parameter$$ = [Parameter$0, Parameter$1, Parameter$2];
|
|
6288
|
+
function Parameter(ctx, state) {
|
|
6289
|
+
return $EVENT_C(ctx, state, "Parameter", Parameter$$);
|
|
6290
|
+
}
|
|
6291
|
+
var FunctionRestParameter$0 = $TS($S($N(EOS), BindingRestElement, $E(TypeSuffix), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6198
6292
|
var id = $2;
|
|
6199
6293
|
return {
|
|
6200
6294
|
type: "FunctionRestParameter",
|
|
6201
|
-
children: $0,
|
|
6295
|
+
children: $0.slice(1),
|
|
6202
6296
|
names: id.names,
|
|
6203
6297
|
binding: id.binding
|
|
6204
6298
|
};
|
|
@@ -6206,12 +6300,14 @@ ${input.slice(result.pos)}
|
|
|
6206
6300
|
function FunctionRestParameter(ctx, state) {
|
|
6207
6301
|
return $EVENT(ctx, state, "FunctionRestParameter", FunctionRestParameter$0);
|
|
6208
6302
|
}
|
|
6209
|
-
var ParameterElement$0 = $TS($S(
|
|
6303
|
+
var ParameterElement$0 = $TS($S($E(_), $E(AccessModifier), $E(_), $C(NWBindingIdentifier, BindingPattern), $E(TypeSuffix), $E(Initializer), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
6304
|
+
var accessModifier = $2;
|
|
6305
|
+
var binding = $4;
|
|
6210
6306
|
return {
|
|
6211
6307
|
type: "Parameter",
|
|
6212
6308
|
children: $0,
|
|
6213
|
-
names:
|
|
6214
|
-
accessModifier
|
|
6309
|
+
names: binding.names,
|
|
6310
|
+
accessModifier
|
|
6215
6311
|
};
|
|
6216
6312
|
});
|
|
6217
6313
|
function ParameterElement(ctx, state) {
|
|
@@ -6271,7 +6367,7 @@ ${input.slice(result.pos)}
|
|
|
6271
6367
|
function AtIdentifierRef(ctx, state) {
|
|
6272
6368
|
return $EVENT_C(ctx, state, "AtIdentifierRef", AtIdentifierRef$$);
|
|
6273
6369
|
}
|
|
6274
|
-
var PinPattern$0 = $TS($S($EXPECT($
|
|
6370
|
+
var PinPattern$0 = $TS($S($EXPECT($L18, 'PinPattern "^"'), Identifier), function($skip, $loc, $0, $1, $2) {
|
|
6275
6371
|
var identifier = $2;
|
|
6276
6372
|
return {
|
|
6277
6373
|
type: "PinPattern",
|
|
@@ -6430,7 +6526,7 @@ ${input.slice(result.pos)}
|
|
|
6430
6526
|
names: value.names
|
|
6431
6527
|
};
|
|
6432
6528
|
});
|
|
6433
|
-
var BindingProperty$2 = $TS($S($E(_), $E($EXPECT($
|
|
6529
|
+
var BindingProperty$2 = $TS($S($E(_), $E($EXPECT($L18, 'BindingProperty "^"')), BindingIdentifier, $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6434
6530
|
var ws = $1;
|
|
6435
6531
|
var pin = $2;
|
|
6436
6532
|
var binding = $3;
|
|
@@ -6520,7 +6616,7 @@ ${input.slice(result.pos)}
|
|
|
6520
6616
|
children: [ws, binding]
|
|
6521
6617
|
};
|
|
6522
6618
|
});
|
|
6523
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
6619
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L22, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
6524
6620
|
return {
|
|
6525
6621
|
children: [{
|
|
6526
6622
|
type: "ElisionElement",
|
|
@@ -6606,8 +6702,8 @@ ${input.slice(result.pos)}
|
|
|
6606
6702
|
async,
|
|
6607
6703
|
generator,
|
|
6608
6704
|
modifier: {
|
|
6609
|
-
async:
|
|
6610
|
-
generator:
|
|
6705
|
+
async: !!async.length,
|
|
6706
|
+
generator: !!generator.length
|
|
6611
6707
|
},
|
|
6612
6708
|
block: null,
|
|
6613
6709
|
children: !parameters.implicit ? [async, func, generator, wid, w, parameters, suffix] : [async, func, generator, wid, parameters, w, suffix]
|
|
@@ -6630,9 +6726,11 @@ ${input.slice(result.pos)}
|
|
|
6630
6726
|
}
|
|
6631
6727
|
if (hasAwait(block) && !signature.async.length) {
|
|
6632
6728
|
signature.async.push("async ");
|
|
6729
|
+
signature.modifier.async = true;
|
|
6633
6730
|
}
|
|
6634
6731
|
if (hasYield(block) && !signature.generator.length) {
|
|
6635
6732
|
signature.generator.push("*");
|
|
6733
|
+
signature.modifier.generator = true;
|
|
6636
6734
|
}
|
|
6637
6735
|
return {
|
|
6638
6736
|
...signature,
|
|
@@ -6642,7 +6740,7 @@ ${input.slice(result.pos)}
|
|
|
6642
6740
|
block
|
|
6643
6741
|
};
|
|
6644
6742
|
});
|
|
6645
|
-
var FunctionExpression$1 = $TV($EXPECT($
|
|
6743
|
+
var FunctionExpression$1 = $TV($EXPECT($L23, 'FunctionExpression "(&)"'), function($skip, $loc, $0, $1) {
|
|
6646
6744
|
const ref = makeRef("$"), body = [ref];
|
|
6647
6745
|
const parameters = {
|
|
6648
6746
|
type: "Parameters",
|
|
@@ -6807,10 +6905,11 @@ ${input.slice(result.pos)}
|
|
|
6807
6905
|
function AmpersandBlockRHS(ctx, state) {
|
|
6808
6906
|
return $EVENT(ctx, state, "AmpersandBlockRHS", AmpersandBlockRHS$0);
|
|
6809
6907
|
}
|
|
6810
|
-
var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S($N($EXPECT($R8, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2, $3) {
|
|
6908
|
+
var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S(WAssignmentOp, $Q($S(NotDedented, UpdateExpression, WAssignmentOp)), NonPipelineExtendedExpression)), $E($S($N($EXPECT($R8, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6811
6909
|
var callExpRest = $1;
|
|
6812
6910
|
var unaryPostfix = $2;
|
|
6813
|
-
var
|
|
6911
|
+
var assign = $3;
|
|
6912
|
+
var binopRHS = $4;
|
|
6814
6913
|
if (!callExpRest && !binopRHS && !unaryPostfix)
|
|
6815
6914
|
return $skip;
|
|
6816
6915
|
const ref = makeRef("$");
|
|
@@ -6826,8 +6925,24 @@ ${input.slice(result.pos)}
|
|
|
6826
6925
|
if (unaryPostfix) {
|
|
6827
6926
|
exp = processUnaryExpression([], exp, unaryPostfix);
|
|
6828
6927
|
}
|
|
6928
|
+
if (assign) {
|
|
6929
|
+
const [op1, more, rhs] = assign;
|
|
6930
|
+
const lhs = [
|
|
6931
|
+
[void 0, exp, ...op1],
|
|
6932
|
+
...more.map((x) => [x[0], x[1], ...x[2]])
|
|
6933
|
+
];
|
|
6934
|
+
exp = {
|
|
6935
|
+
type: "AssignmentExpression",
|
|
6936
|
+
children: [lhs, rhs],
|
|
6937
|
+
names: null,
|
|
6938
|
+
lhs,
|
|
6939
|
+
assigned: exp,
|
|
6940
|
+
exp: rhs,
|
|
6941
|
+
ref
|
|
6942
|
+
};
|
|
6943
|
+
}
|
|
6829
6944
|
if (binopRHS) {
|
|
6830
|
-
|
|
6945
|
+
exp = {
|
|
6831
6946
|
children: processBinaryOpExpression([exp, binopRHS[1]]),
|
|
6832
6947
|
ref
|
|
6833
6948
|
};
|
|
@@ -6884,7 +6999,7 @@ ${input.slice(result.pos)}
|
|
|
6884
6999
|
function ThinArrowFunction(ctx, state) {
|
|
6885
7000
|
return $EVENT(ctx, state, "ThinArrowFunction", ThinArrowFunction$0);
|
|
6886
7001
|
}
|
|
6887
|
-
var Arrow$0 = $TV($C($EXPECT($
|
|
7002
|
+
var Arrow$0 = $TV($C($EXPECT($L24, 'Arrow "->"'), $EXPECT($L25, 'Arrow "\u2192"')), function($skip, $loc, $0, $1) {
|
|
6888
7003
|
return { $loc, token: "->" };
|
|
6889
7004
|
});
|
|
6890
7005
|
function Arrow(ctx, state) {
|
|
@@ -7162,7 +7277,7 @@ ${input.slice(result.pos)}
|
|
|
7162
7277
|
}
|
|
7163
7278
|
var BracedContent$0 = NestedBlockStatements;
|
|
7164
7279
|
var BracedContent$1 = SingleLineStatements;
|
|
7165
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
7280
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L26, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
7166
7281
|
const expressions = [];
|
|
7167
7282
|
return {
|
|
7168
7283
|
type: "BlockStatement",
|
|
@@ -7232,7 +7347,7 @@ ${input.slice(result.pos)}
|
|
|
7232
7347
|
function LiteralContent(ctx, state) {
|
|
7233
7348
|
return $EVENT_C(ctx, state, "LiteralContent", LiteralContent$$);
|
|
7234
7349
|
}
|
|
7235
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
7350
|
+
var NullLiteral$0 = $TS($S($EXPECT($L27, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7236
7351
|
return { $loc, token: $1 };
|
|
7237
7352
|
});
|
|
7238
7353
|
function NullLiteral(ctx, state) {
|
|
@@ -7247,17 +7362,17 @@ ${input.slice(result.pos)}
|
|
|
7247
7362
|
var _BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
7248
7363
|
return value[1];
|
|
7249
7364
|
});
|
|
7250
|
-
var _BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
7365
|
+
var _BooleanLiteral$1 = $TS($S($C($EXPECT($L28, '_BooleanLiteral "true"'), $EXPECT($L29, '_BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7251
7366
|
return { $loc, token: $1 };
|
|
7252
7367
|
});
|
|
7253
7368
|
var _BooleanLiteral$$ = [_BooleanLiteral$0, _BooleanLiteral$1];
|
|
7254
7369
|
function _BooleanLiteral(ctx, state) {
|
|
7255
7370
|
return $EVENT_C(ctx, state, "_BooleanLiteral", _BooleanLiteral$$);
|
|
7256
7371
|
}
|
|
7257
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
7372
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L30, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L31, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7258
7373
|
return { $loc, token: "true" };
|
|
7259
7374
|
});
|
|
7260
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
7375
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L32, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L33, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7261
7376
|
return { $loc, token: "false" };
|
|
7262
7377
|
});
|
|
7263
7378
|
var CoffeeScriptBooleanLiteral$$ = [CoffeeScriptBooleanLiteral$0, CoffeeScriptBooleanLiteral$1];
|
|
@@ -7289,7 +7404,7 @@ ${input.slice(result.pos)}
|
|
|
7289
7404
|
function IdentifierReference(ctx, state) {
|
|
7290
7405
|
return $EVENT(ctx, state, "IdentifierReference", IdentifierReference$0);
|
|
7291
7406
|
}
|
|
7292
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L3, 'UpcomingAssignment "="'), $N($C($EXPECT($L3, 'UpcomingAssignment "="'), $EXPECT($
|
|
7407
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L3, 'UpcomingAssignment "="'), $N($C($EXPECT($L3, 'UpcomingAssignment "="'), $EXPECT($L34, 'UpcomingAssignment ">"')))));
|
|
7293
7408
|
function UpcomingAssignment(ctx, state) {
|
|
7294
7409
|
return $EVENT(ctx, state, "UpcomingAssignment", UpcomingAssignment$0);
|
|
7295
7410
|
}
|
|
@@ -7447,7 +7562,7 @@ ${input.slice(result.pos)}
|
|
|
7447
7562
|
return $EVENT(ctx, state, "NestedElement", NestedElement$0);
|
|
7448
7563
|
}
|
|
7449
7564
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
7450
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7565
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L35, 'ArrayElementDelimiter "]"')));
|
|
7451
7566
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7452
7567
|
return value[1];
|
|
7453
7568
|
});
|
|
@@ -7677,7 +7792,7 @@ ${input.slice(result.pos)}
|
|
|
7677
7792
|
return $EVENT_C(ctx, state, "ImplicitInlineObjectPropertyDelimiter", ImplicitInlineObjectPropertyDelimiter$$);
|
|
7678
7793
|
}
|
|
7679
7794
|
var ObjectPropertyDelimiter$0 = $S($E(_), Comma);
|
|
7680
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7795
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L26, 'ObjectPropertyDelimiter "}"')));
|
|
7681
7796
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7682
7797
|
return value[1];
|
|
7683
7798
|
});
|
|
@@ -7860,7 +7975,7 @@ ${input.slice(result.pos)}
|
|
|
7860
7975
|
implicit: true
|
|
7861
7976
|
};
|
|
7862
7977
|
});
|
|
7863
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7978
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L19, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7864
7979
|
const expression = [$2, $3];
|
|
7865
7980
|
return {
|
|
7866
7981
|
type: "ComputedPropertyName",
|
|
@@ -8109,7 +8224,7 @@ ${input.slice(result.pos)}
|
|
|
8109
8224
|
return $EVENT(ctx, state, "PrivateIdentifier", PrivateIdentifier$0);
|
|
8110
8225
|
}
|
|
8111
8226
|
var WAssignmentOp$0 = $S(__, AssignmentOp);
|
|
8112
|
-
var WAssignmentOp$1 = $S(_, OperatorAssignmentOp);
|
|
8227
|
+
var WAssignmentOp$1 = $S($E(_), OperatorAssignmentOp);
|
|
8113
8228
|
var WAssignmentOp$$ = [WAssignmentOp$0, WAssignmentOp$1];
|
|
8114
8229
|
function WAssignmentOp(ctx, state) {
|
|
8115
8230
|
return $EVENT_C(ctx, state, "WAssignmentOp", WAssignmentOp$$);
|
|
@@ -8126,47 +8241,47 @@ ${input.slice(result.pos)}
|
|
|
8126
8241
|
function AssignmentOp(ctx, state) {
|
|
8127
8242
|
return $EVENT(ctx, state, "AssignmentOp", AssignmentOp$0);
|
|
8128
8243
|
}
|
|
8129
|
-
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $
|
|
8244
|
+
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8130
8245
|
return {
|
|
8131
8246
|
special: true,
|
|
8132
8247
|
call: module.getRef("xor"),
|
|
8133
|
-
children: [$2, ...$
|
|
8248
|
+
children: [$2, ...$3 || []]
|
|
8134
8249
|
};
|
|
8135
8250
|
});
|
|
8136
|
-
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $
|
|
8251
|
+
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8137
8252
|
return {
|
|
8138
8253
|
special: true,
|
|
8139
8254
|
call: module.getRef("xnor"),
|
|
8140
|
-
children: [$2, ...$
|
|
8255
|
+
children: [$2, ...$3 || []]
|
|
8141
8256
|
};
|
|
8142
8257
|
});
|
|
8143
|
-
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L3, 'OperatorAssignmentOp "="'), $
|
|
8258
|
+
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L3, 'OperatorAssignmentOp "="'), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8144
8259
|
return {
|
|
8145
8260
|
special: true,
|
|
8146
8261
|
call: $1,
|
|
8147
|
-
children: [$2, ...$
|
|
8262
|
+
children: [$2, ...$3 || []]
|
|
8148
8263
|
};
|
|
8149
8264
|
});
|
|
8150
8265
|
var OperatorAssignmentOp$$ = [OperatorAssignmentOp$0, OperatorAssignmentOp$1, OperatorAssignmentOp$2];
|
|
8151
8266
|
function OperatorAssignmentOp(ctx, state) {
|
|
8152
8267
|
return $EVENT_C(ctx, state, "OperatorAssignmentOp", OperatorAssignmentOp$$);
|
|
8153
8268
|
}
|
|
8154
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
8155
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
8156
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
8157
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
8158
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
8159
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
8160
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
8161
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
8162
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
8163
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
8164
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
8165
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
8166
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
8167
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
8168
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
8169
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
8269
|
+
var AssignmentOpSymbol$0 = $EXPECT($L36, 'AssignmentOpSymbol "**="');
|
|
8270
|
+
var AssignmentOpSymbol$1 = $EXPECT($L37, 'AssignmentOpSymbol "*="');
|
|
8271
|
+
var AssignmentOpSymbol$2 = $EXPECT($L38, 'AssignmentOpSymbol "/="');
|
|
8272
|
+
var AssignmentOpSymbol$3 = $EXPECT($L39, 'AssignmentOpSymbol "%="');
|
|
8273
|
+
var AssignmentOpSymbol$4 = $EXPECT($L40, 'AssignmentOpSymbol "+="');
|
|
8274
|
+
var AssignmentOpSymbol$5 = $EXPECT($L41, 'AssignmentOpSymbol "-="');
|
|
8275
|
+
var AssignmentOpSymbol$6 = $EXPECT($L42, 'AssignmentOpSymbol "<<="');
|
|
8276
|
+
var AssignmentOpSymbol$7 = $EXPECT($L43, 'AssignmentOpSymbol ">>>="');
|
|
8277
|
+
var AssignmentOpSymbol$8 = $EXPECT($L44, 'AssignmentOpSymbol ">>="');
|
|
8278
|
+
var AssignmentOpSymbol$9 = $EXPECT($L45, 'AssignmentOpSymbol "&&="');
|
|
8279
|
+
var AssignmentOpSymbol$10 = $EXPECT($L46, 'AssignmentOpSymbol "&="');
|
|
8280
|
+
var AssignmentOpSymbol$11 = $EXPECT($L47, 'AssignmentOpSymbol "^="');
|
|
8281
|
+
var AssignmentOpSymbol$12 = $EXPECT($L48, 'AssignmentOpSymbol "||="');
|
|
8282
|
+
var AssignmentOpSymbol$13 = $EXPECT($L49, 'AssignmentOpSymbol "|="');
|
|
8283
|
+
var AssignmentOpSymbol$14 = $EXPECT($L50, 'AssignmentOpSymbol "??="');
|
|
8284
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L51, 'AssignmentOpSymbol "?="'), function(value) {
|
|
8170
8285
|
return "??=";
|
|
8171
8286
|
});
|
|
8172
8287
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L3, 'AssignmentOpSymbol "="'), $N($EXPECT($L3, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -8179,10 +8294,10 @@ ${input.slice(result.pos)}
|
|
|
8179
8294
|
function AssignmentOpSymbol(ctx, state) {
|
|
8180
8295
|
return $EVENT_C(ctx, state, "AssignmentOpSymbol", AssignmentOpSymbol$$);
|
|
8181
8296
|
}
|
|
8182
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
8297
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L52, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
8183
8298
|
return "&&=";
|
|
8184
8299
|
});
|
|
8185
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
8300
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L53, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
8186
8301
|
return "||=";
|
|
8187
8302
|
});
|
|
8188
8303
|
var CoffeeWordAssignmentOp$$ = [CoffeeWordAssignmentOp$0, CoffeeWordAssignmentOp$1];
|
|
@@ -8251,27 +8366,27 @@ ${input.slice(result.pos)}
|
|
|
8251
8366
|
function _BinaryOp(ctx, state) {
|
|
8252
8367
|
return $EVENT_C(ctx, state, "_BinaryOp", _BinaryOp$$);
|
|
8253
8368
|
}
|
|
8254
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
8255
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
8256
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
8257
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
8369
|
+
var BinaryOpSymbol$0 = $EXPECT($L54, 'BinaryOpSymbol "**"');
|
|
8370
|
+
var BinaryOpSymbol$1 = $EXPECT($L55, 'BinaryOpSymbol "*"');
|
|
8371
|
+
var BinaryOpSymbol$2 = $EXPECT($L56, 'BinaryOpSymbol "/"');
|
|
8372
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L57, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
8258
8373
|
return {
|
|
8259
8374
|
call: module.getRef("modulo"),
|
|
8260
8375
|
special: true
|
|
8261
8376
|
};
|
|
8262
8377
|
});
|
|
8263
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
8264
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
8265
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
8266
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
8267
|
-
var BinaryOpSymbol$8 = $T($EXPECT($
|
|
8378
|
+
var BinaryOpSymbol$4 = $EXPECT($L58, 'BinaryOpSymbol "%"');
|
|
8379
|
+
var BinaryOpSymbol$5 = $EXPECT($L59, 'BinaryOpSymbol "+"');
|
|
8380
|
+
var BinaryOpSymbol$6 = $EXPECT($L19, 'BinaryOpSymbol "-"');
|
|
8381
|
+
var BinaryOpSymbol$7 = $EXPECT($L60, 'BinaryOpSymbol "<="');
|
|
8382
|
+
var BinaryOpSymbol$8 = $T($EXPECT($L61, 'BinaryOpSymbol "\u2264"'), function(value) {
|
|
8268
8383
|
return "<=";
|
|
8269
8384
|
});
|
|
8270
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
8271
|
-
var BinaryOpSymbol$10 = $T($EXPECT($
|
|
8385
|
+
var BinaryOpSymbol$9 = $EXPECT($L62, 'BinaryOpSymbol ">="');
|
|
8386
|
+
var BinaryOpSymbol$10 = $T($EXPECT($L63, 'BinaryOpSymbol "\u2265"'), function(value) {
|
|
8272
8387
|
return ">=";
|
|
8273
8388
|
});
|
|
8274
|
-
var BinaryOpSymbol$11 = $TV($EXPECT($
|
|
8389
|
+
var BinaryOpSymbol$11 = $TV($EXPECT($L64, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
8275
8390
|
return {
|
|
8276
8391
|
$loc,
|
|
8277
8392
|
token: "instanceof",
|
|
@@ -8279,7 +8394,7 @@ ${input.slice(result.pos)}
|
|
|
8279
8394
|
special: true
|
|
8280
8395
|
};
|
|
8281
8396
|
});
|
|
8282
|
-
var BinaryOpSymbol$12 = $TV($EXPECT($
|
|
8397
|
+
var BinaryOpSymbol$12 = $TV($EXPECT($L65, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
8283
8398
|
return {
|
|
8284
8399
|
$loc,
|
|
8285
8400
|
token: "instanceof",
|
|
@@ -8288,76 +8403,74 @@ ${input.slice(result.pos)}
|
|
|
8288
8403
|
negated: true
|
|
8289
8404
|
};
|
|
8290
8405
|
});
|
|
8291
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
8292
|
-
var BinaryOpSymbol$14 = $T($EXPECT($
|
|
8406
|
+
var BinaryOpSymbol$13 = $EXPECT($L66, 'BinaryOpSymbol "<<"');
|
|
8407
|
+
var BinaryOpSymbol$14 = $T($EXPECT($L67, 'BinaryOpSymbol "\xAB"'), function(value) {
|
|
8293
8408
|
return "<<";
|
|
8294
8409
|
});
|
|
8295
|
-
var BinaryOpSymbol$15 = $
|
|
8296
|
-
|
|
8297
|
-
|
|
8298
|
-
var BinaryOpSymbol$16 = $EXPECT($L67, 'BinaryOpSymbol ">>>"');
|
|
8299
|
-
var BinaryOpSymbol$17 = $T($EXPECT($L68, 'BinaryOpSymbol "\u22D9"'), function(value) {
|
|
8410
|
+
var BinaryOpSymbol$15 = $EXPECT($L13, 'BinaryOpSymbol "<"');
|
|
8411
|
+
var BinaryOpSymbol$16 = $EXPECT($L68, 'BinaryOpSymbol ">>>"');
|
|
8412
|
+
var BinaryOpSymbol$17 = $T($EXPECT($L69, 'BinaryOpSymbol "\u22D9"'), function(value) {
|
|
8300
8413
|
return ">>>";
|
|
8301
8414
|
});
|
|
8302
|
-
var BinaryOpSymbol$18 = $EXPECT($
|
|
8303
|
-
var BinaryOpSymbol$19 = $T($EXPECT($
|
|
8415
|
+
var BinaryOpSymbol$18 = $EXPECT($L70, 'BinaryOpSymbol ">>"');
|
|
8416
|
+
var BinaryOpSymbol$19 = $T($EXPECT($L71, 'BinaryOpSymbol "\xBB"'), function(value) {
|
|
8304
8417
|
return ">>";
|
|
8305
8418
|
});
|
|
8306
|
-
var BinaryOpSymbol$20 = $EXPECT($
|
|
8307
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
8308
|
-
var BinaryOpSymbol$22 = $T($EXPECT($
|
|
8419
|
+
var BinaryOpSymbol$20 = $EXPECT($L34, 'BinaryOpSymbol ">"');
|
|
8420
|
+
var BinaryOpSymbol$21 = $EXPECT($L72, 'BinaryOpSymbol "!=="');
|
|
8421
|
+
var BinaryOpSymbol$22 = $T($EXPECT($L73, 'BinaryOpSymbol "\u2262"'), function(value) {
|
|
8309
8422
|
return "!==";
|
|
8310
8423
|
});
|
|
8311
|
-
var BinaryOpSymbol$23 = $TV($C($EXPECT($
|
|
8424
|
+
var BinaryOpSymbol$23 = $TV($C($EXPECT($L74, 'BinaryOpSymbol "!="'), $EXPECT($L75, 'BinaryOpSymbol "\u2260"')), function($skip, $loc, $0, $1) {
|
|
8312
8425
|
if (module.config.coffeeEq)
|
|
8313
8426
|
return "!==";
|
|
8314
8427
|
return "!=";
|
|
8315
8428
|
});
|
|
8316
|
-
var BinaryOpSymbol$24 = $TS($S($EXPECT($
|
|
8429
|
+
var BinaryOpSymbol$24 = $TS($S($EXPECT($L76, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8317
8430
|
if (module.config.coffeeIsnt)
|
|
8318
8431
|
return "!==";
|
|
8319
8432
|
return $skip;
|
|
8320
8433
|
});
|
|
8321
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
8322
|
-
var BinaryOpSymbol$26 = $T($C($EXPECT($
|
|
8434
|
+
var BinaryOpSymbol$25 = $EXPECT($L77, 'BinaryOpSymbol "==="');
|
|
8435
|
+
var BinaryOpSymbol$26 = $T($C($EXPECT($L78, 'BinaryOpSymbol "\u2263"'), $EXPECT($L79, 'BinaryOpSymbol "\u2A76"')), function(value) {
|
|
8323
8436
|
return "===";
|
|
8324
8437
|
});
|
|
8325
|
-
var BinaryOpSymbol$27 = $TV($C($EXPECT($
|
|
8438
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($L80, 'BinaryOpSymbol "=="'), $EXPECT($L81, 'BinaryOpSymbol "\u2261"'), $EXPECT($L82, 'BinaryOpSymbol "\u2A75"')), function($skip, $loc, $0, $1) {
|
|
8326
8439
|
if (module.config.coffeeEq)
|
|
8327
8440
|
return "===";
|
|
8328
8441
|
return "==";
|
|
8329
8442
|
});
|
|
8330
|
-
var BinaryOpSymbol$28 = $T($S($EXPECT($
|
|
8443
|
+
var BinaryOpSymbol$28 = $T($S($EXPECT($L83, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
8331
8444
|
return "&&";
|
|
8332
8445
|
});
|
|
8333
|
-
var BinaryOpSymbol$29 = $EXPECT($
|
|
8334
|
-
var BinaryOpSymbol$30 = $T($S($EXPECT($
|
|
8446
|
+
var BinaryOpSymbol$29 = $EXPECT($L84, 'BinaryOpSymbol "&&"');
|
|
8447
|
+
var BinaryOpSymbol$30 = $T($S($EXPECT($L85, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
8335
8448
|
return "||";
|
|
8336
8449
|
});
|
|
8337
|
-
var BinaryOpSymbol$31 = $EXPECT($
|
|
8338
|
-
var BinaryOpSymbol$32 = $T($EXPECT($
|
|
8450
|
+
var BinaryOpSymbol$31 = $EXPECT($L86, 'BinaryOpSymbol "||"');
|
|
8451
|
+
var BinaryOpSymbol$32 = $T($EXPECT($L87, 'BinaryOpSymbol "\u2016"'), function(value) {
|
|
8339
8452
|
return "||";
|
|
8340
8453
|
});
|
|
8341
|
-
var BinaryOpSymbol$33 = $TV($C($EXPECT($
|
|
8454
|
+
var BinaryOpSymbol$33 = $TV($C($EXPECT($L88, 'BinaryOpSymbol "^^"'), $S($EXPECT($L89, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8342
8455
|
return {
|
|
8343
8456
|
call: module.getRef("xor"),
|
|
8344
8457
|
special: true
|
|
8345
8458
|
};
|
|
8346
8459
|
});
|
|
8347
|
-
var BinaryOpSymbol$34 = $TV($C($EXPECT($
|
|
8460
|
+
var BinaryOpSymbol$34 = $TV($C($EXPECT($R17, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L90, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8348
8461
|
return {
|
|
8349
8462
|
call: module.getRef("xnor"),
|
|
8350
8463
|
special: true
|
|
8351
8464
|
};
|
|
8352
8465
|
});
|
|
8353
|
-
var BinaryOpSymbol$35 = $EXPECT($
|
|
8354
|
-
var BinaryOpSymbol$36 = $T($EXPECT($
|
|
8466
|
+
var BinaryOpSymbol$35 = $EXPECT($L91, 'BinaryOpSymbol "??"');
|
|
8467
|
+
var BinaryOpSymbol$36 = $T($EXPECT($L92, 'BinaryOpSymbol "\u2047"'), function(value) {
|
|
8355
8468
|
return "??";
|
|
8356
8469
|
});
|
|
8357
8470
|
var BinaryOpSymbol$37 = $T($S($EXPECT($L5, 'BinaryOpSymbol "?"'), CoffeeBinaryExistentialEnabled), function(value) {
|
|
8358
8471
|
return "??";
|
|
8359
8472
|
});
|
|
8360
|
-
var BinaryOpSymbol$38 = $TS($S($EXPECT($
|
|
8473
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L93, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8361
8474
|
return {
|
|
8362
8475
|
$loc,
|
|
8363
8476
|
token: $1,
|
|
@@ -8374,7 +8487,7 @@ ${input.slice(result.pos)}
|
|
|
8374
8487
|
var op = $3;
|
|
8375
8488
|
return { ...op, $loc };
|
|
8376
8489
|
});
|
|
8377
|
-
var BinaryOpSymbol$41 = $TV($C($S(Is, __, In), $EXPECT($
|
|
8490
|
+
var BinaryOpSymbol$41 = $TV($C($S(Is, __, In), $EXPECT($L94, 'BinaryOpSymbol "\u2208"')), function($skip, $loc, $0, $1) {
|
|
8378
8491
|
return {
|
|
8379
8492
|
method: "includes",
|
|
8380
8493
|
relational: true,
|
|
@@ -8382,14 +8495,14 @@ ${input.slice(result.pos)}
|
|
|
8382
8495
|
special: true
|
|
8383
8496
|
};
|
|
8384
8497
|
});
|
|
8385
|
-
var BinaryOpSymbol$42 = $TV($EXPECT($
|
|
8498
|
+
var BinaryOpSymbol$42 = $TV($EXPECT($L95, 'BinaryOpSymbol "\u220B"'), function($skip, $loc, $0, $1) {
|
|
8386
8499
|
return {
|
|
8387
8500
|
method: "includes",
|
|
8388
8501
|
relational: true,
|
|
8389
8502
|
special: true
|
|
8390
8503
|
};
|
|
8391
8504
|
});
|
|
8392
|
-
var BinaryOpSymbol$43 = $TV($EXPECT($
|
|
8505
|
+
var BinaryOpSymbol$43 = $TV($EXPECT($L96, 'BinaryOpSymbol "\u220C"'), function($skip, $loc, $0, $1) {
|
|
8393
8506
|
return {
|
|
8394
8507
|
method: "includes",
|
|
8395
8508
|
relational: true,
|
|
@@ -8397,7 +8510,7 @@ ${input.slice(result.pos)}
|
|
|
8397
8510
|
negated: true
|
|
8398
8511
|
};
|
|
8399
8512
|
});
|
|
8400
|
-
var BinaryOpSymbol$44 = $TV($C($S(Is, __, Not, __, In), $EXPECT($
|
|
8513
|
+
var BinaryOpSymbol$44 = $TV($C($S(Is, __, Not, __, In), $EXPECT($L97, 'BinaryOpSymbol "\u2209"')), function($skip, $loc, $0, $1) {
|
|
8401
8514
|
return {
|
|
8402
8515
|
method: "includes",
|
|
8403
8516
|
relational: true,
|
|
@@ -8430,9 +8543,9 @@ ${input.slice(result.pos)}
|
|
|
8430
8543
|
return "===";
|
|
8431
8544
|
});
|
|
8432
8545
|
var BinaryOpSymbol$47 = In;
|
|
8433
|
-
var BinaryOpSymbol$48 = $EXPECT($
|
|
8434
|
-
var BinaryOpSymbol$49 = $EXPECT($
|
|
8435
|
-
var BinaryOpSymbol$50 = $EXPECT($
|
|
8546
|
+
var BinaryOpSymbol$48 = $EXPECT($L98, 'BinaryOpSymbol "&"');
|
|
8547
|
+
var BinaryOpSymbol$49 = $EXPECT($L18, 'BinaryOpSymbol "^"');
|
|
8548
|
+
var BinaryOpSymbol$50 = $EXPECT($L99, 'BinaryOpSymbol "|"');
|
|
8436
8549
|
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];
|
|
8437
8550
|
function BinaryOpSymbol(ctx, state) {
|
|
8438
8551
|
return $EVENT_C(ctx, state, "BinaryOpSymbol", BinaryOpSymbol$$);
|
|
@@ -8470,7 +8583,7 @@ ${input.slice(result.pos)}
|
|
|
8470
8583
|
function CoffeeOfOp(ctx, state) {
|
|
8471
8584
|
return $EVENT_C(ctx, state, "CoffeeOfOp", CoffeeOfOp$$);
|
|
8472
8585
|
}
|
|
8473
|
-
var NotOp$0 = $TS($S($EXPECT($
|
|
8586
|
+
var NotOp$0 = $TS($S($EXPECT($L93, 'NotOp "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8474
8587
|
return {
|
|
8475
8588
|
$loc,
|
|
8476
8589
|
token: "instanceof",
|
|
@@ -8491,19 +8604,19 @@ ${input.slice(result.pos)}
|
|
|
8491
8604
|
function NotOp(ctx, state) {
|
|
8492
8605
|
return $EVENT_C(ctx, state, "NotOp", NotOp$$);
|
|
8493
8606
|
}
|
|
8494
|
-
var Xor$0 = $EXPECT($
|
|
8495
|
-
var Xor$1 = $S($EXPECT($
|
|
8607
|
+
var Xor$0 = $EXPECT($L88, 'Xor "^^"');
|
|
8608
|
+
var Xor$1 = $S($EXPECT($L89, 'Xor "xor"'), NonIdContinue);
|
|
8496
8609
|
var Xor$$ = [Xor$0, Xor$1];
|
|
8497
8610
|
function Xor(ctx, state) {
|
|
8498
8611
|
return $EVENT_C(ctx, state, "Xor", Xor$$);
|
|
8499
8612
|
}
|
|
8500
|
-
var Xnor$0 = $R$0($EXPECT($
|
|
8501
|
-
var Xnor$1 = $EXPECT($
|
|
8613
|
+
var Xnor$0 = $R$0($EXPECT($R17, "Xnor /!\\^\\^?/"));
|
|
8614
|
+
var Xnor$1 = $EXPECT($L90, 'Xnor "xnor"');
|
|
8502
8615
|
var Xnor$$ = [Xnor$0, Xnor$1];
|
|
8503
8616
|
function Xnor(ctx, state) {
|
|
8504
8617
|
return $EVENT_C(ctx, state, "Xnor", Xnor$$);
|
|
8505
8618
|
}
|
|
8506
|
-
var UnaryOp$0 = $TR($EXPECT($
|
|
8619
|
+
var UnaryOp$0 = $TR($EXPECT($R18, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*(&|\\.[^0-9]))/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8507
8620
|
return { $loc, token: $0 };
|
|
8508
8621
|
});
|
|
8509
8622
|
var UnaryOp$1 = AwaitOp;
|
|
@@ -8603,7 +8716,7 @@ ${input.slice(result.pos)}
|
|
|
8603
8716
|
function NonPipelinePostfixedExpression(ctx, state) {
|
|
8604
8717
|
return $EVENT(ctx, state, "NonPipelinePostfixedExpression", NonPipelinePostfixedExpression$0);
|
|
8605
8718
|
}
|
|
8606
|
-
var PostfixStatement$0 = $T($S($EXPECT($
|
|
8719
|
+
var PostfixStatement$0 = $T($S($EXPECT($R19, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
|
|
8607
8720
|
return value[1];
|
|
8608
8721
|
});
|
|
8609
8722
|
function PostfixStatement(ctx, state) {
|
|
@@ -8646,7 +8759,7 @@ ${input.slice(result.pos)}
|
|
|
8646
8759
|
function NoCommaStatement(ctx, state) {
|
|
8647
8760
|
return $EVENT_C(ctx, state, "NoCommaStatement", NoCommaStatement$$);
|
|
8648
8761
|
}
|
|
8649
|
-
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($
|
|
8762
|
+
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L100, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
|
|
8650
8763
|
return { type: "EmptyStatement", children: $1 || [] };
|
|
8651
8764
|
});
|
|
8652
8765
|
function EmptyStatement(ctx, state) {
|
|
@@ -8668,7 +8781,7 @@ ${input.slice(result.pos)}
|
|
|
8668
8781
|
var w = $3;
|
|
8669
8782
|
return [id, colon, w];
|
|
8670
8783
|
});
|
|
8671
|
-
var Label$1 = $S($EXPECT($
|
|
8784
|
+
var Label$1 = $S($EXPECT($L101, 'Label "$:"'), Whitespace);
|
|
8672
8785
|
var Label$$ = [Label$0, Label$1];
|
|
8673
8786
|
function Label(ctx, state) {
|
|
8674
8787
|
return $EVENT_C(ctx, state, "Label", Label$$);
|
|
@@ -8841,7 +8954,7 @@ ${input.slice(result.pos)}
|
|
|
8841
8954
|
function BlockExpressionPart(ctx, state) {
|
|
8842
8955
|
return $EVENT(ctx, state, "BlockExpressionPart", BlockExpressionPart$0);
|
|
8843
8956
|
}
|
|
8844
|
-
var IterationStatement$0 = $T($S($EXPECT($
|
|
8957
|
+
var IterationStatement$0 = $T($S($EXPECT($R20, "IterationStatement /(?=loop|do|for|until|while)/"), _IterationStatement), function(value) {
|
|
8845
8958
|
return value[1];
|
|
8846
8959
|
});
|
|
8847
8960
|
function IterationStatement(ctx, state) {
|
|
@@ -9194,7 +9307,7 @@ ${input.slice(result.pos)}
|
|
|
9194
9307
|
names: binding.names
|
|
9195
9308
|
};
|
|
9196
9309
|
});
|
|
9197
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
9310
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R21, "ForDeclaration /(?=[\\s\\),])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
9198
9311
|
var c = $1;
|
|
9199
9312
|
var binding = $2;
|
|
9200
9313
|
return {
|
|
@@ -9559,6 +9672,15 @@ ${input.slice(result.pos)}
|
|
|
9559
9672
|
function ExpressionWithObjectApplicationForbidden(ctx, state) {
|
|
9560
9673
|
return $EVENT(ctx, state, "ExpressionWithObjectApplicationForbidden", ExpressionWithObjectApplicationForbidden$0);
|
|
9561
9674
|
}
|
|
9675
|
+
var LeftHandSideExpressionWithObjectApplicationForbidden$0 = $TS($S(ForbidBracedApplication, ForbidIndentedApplication, ForbidNewlineBinaryOp, $E(LeftHandSideExpression), RestoreNewlineBinaryOp, RestoreBracedApplication, RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
9676
|
+
var exp = $4;
|
|
9677
|
+
if (exp)
|
|
9678
|
+
return exp;
|
|
9679
|
+
return $skip;
|
|
9680
|
+
});
|
|
9681
|
+
function LeftHandSideExpressionWithObjectApplicationForbidden(ctx, state) {
|
|
9682
|
+
return $EVENT(ctx, state, "LeftHandSideExpressionWithObjectApplicationForbidden", LeftHandSideExpressionWithObjectApplicationForbidden$0);
|
|
9683
|
+
}
|
|
9562
9684
|
var ForbidClassImplicitCall$0 = $TV($EXPECT($L0, 'ForbidClassImplicitCall ""'), function($skip, $loc, $0, $1) {
|
|
9563
9685
|
module.forbidClassImplicitCall.push(true);
|
|
9564
9686
|
});
|
|
@@ -9759,19 +9881,19 @@ ${input.slice(result.pos)}
|
|
|
9759
9881
|
function ThrowStatement(ctx, state) {
|
|
9760
9882
|
return $EVENT(ctx, state, "ThrowStatement", ThrowStatement$0);
|
|
9761
9883
|
}
|
|
9762
|
-
var Break$0 = $TS($S($EXPECT($
|
|
9884
|
+
var Break$0 = $TS($S($EXPECT($L102, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9763
9885
|
return { $loc, token: $1 };
|
|
9764
9886
|
});
|
|
9765
9887
|
function Break(ctx, state) {
|
|
9766
9888
|
return $EVENT(ctx, state, "Break", Break$0);
|
|
9767
9889
|
}
|
|
9768
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
9890
|
+
var Continue$0 = $TS($S($EXPECT($L103, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9769
9891
|
return { $loc, token: $1 };
|
|
9770
9892
|
});
|
|
9771
9893
|
function Continue(ctx, state) {
|
|
9772
9894
|
return $EVENT(ctx, state, "Continue", Continue$0);
|
|
9773
9895
|
}
|
|
9774
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
9896
|
+
var Debugger$0 = $TS($S($EXPECT($L104, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9775
9897
|
return { $loc, token: $1 };
|
|
9776
9898
|
});
|
|
9777
9899
|
function Debugger(ctx, state) {
|
|
@@ -9892,7 +10014,7 @@ ${input.slice(result.pos)}
|
|
|
9892
10014
|
function FromClause(ctx, state) {
|
|
9893
10015
|
return $EVENT(ctx, state, "FromClause", FromClause$0);
|
|
9894
10016
|
}
|
|
9895
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10017
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L105, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
9896
10018
|
function ImportAssertion(ctx, state) {
|
|
9897
10019
|
return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
|
|
9898
10020
|
}
|
|
@@ -9980,7 +10102,7 @@ ${input.slice(result.pos)}
|
|
|
9980
10102
|
function UnprocessedModuleSpecifier(ctx, state) {
|
|
9981
10103
|
return $EVENT_C(ctx, state, "UnprocessedModuleSpecifier", UnprocessedModuleSpecifier$$);
|
|
9982
10104
|
}
|
|
9983
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
10105
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R22, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
9984
10106
|
var spec = $0;
|
|
9985
10107
|
return { $loc, token: `"${spec}"` };
|
|
9986
10108
|
});
|
|
@@ -10112,13 +10234,13 @@ ${input.slice(result.pos)}
|
|
|
10112
10234
|
function LexicalDeclaration(ctx, state) {
|
|
10113
10235
|
return $EVENT_C(ctx, state, "LexicalDeclaration", LexicalDeclaration$$);
|
|
10114
10236
|
}
|
|
10115
|
-
var ConstAssignment$0 = $TV($C($EXPECT($
|
|
10237
|
+
var ConstAssignment$0 = $TV($C($EXPECT($L106, 'ConstAssignment ":="'), $EXPECT($L107, 'ConstAssignment "\u2254"')), function($skip, $loc, $0, $1) {
|
|
10116
10238
|
return { $loc, token: "=" };
|
|
10117
10239
|
});
|
|
10118
10240
|
function ConstAssignment(ctx, state) {
|
|
10119
10241
|
return $EVENT(ctx, state, "ConstAssignment", ConstAssignment$0);
|
|
10120
10242
|
}
|
|
10121
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
10243
|
+
var LetAssignment$0 = $TV($EXPECT($L108, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10122
10244
|
return { $loc, token: "=" };
|
|
10123
10245
|
});
|
|
10124
10246
|
function LetAssignment(ctx, state) {
|
|
@@ -10186,7 +10308,7 @@ ${input.slice(result.pos)}
|
|
|
10186
10308
|
function VariableDeclarationList(ctx, state) {
|
|
10187
10309
|
return $EVENT(ctx, state, "VariableDeclarationList", VariableDeclarationList$0);
|
|
10188
10310
|
}
|
|
10189
|
-
var NumericLiteral$0 = $TS($S($EXPECT($
|
|
10311
|
+
var NumericLiteral$0 = $TS($S($EXPECT($R23, "NumericLiteral /(?=[0-9.])/"), NumericLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
10190
10312
|
var token = $2;
|
|
10191
10313
|
return { type: "NumericLiteral", $loc, token };
|
|
10192
10314
|
});
|
|
@@ -10202,36 +10324,36 @@ ${input.slice(result.pos)}
|
|
|
10202
10324
|
function NumericLiteralKind(ctx, state) {
|
|
10203
10325
|
return $EVENT_C(ctx, state, "NumericLiteralKind", NumericLiteralKind$$);
|
|
10204
10326
|
}
|
|
10205
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
10327
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R24, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
10206
10328
|
function DecimalBigIntegerLiteral(ctx, state) {
|
|
10207
10329
|
return $EVENT(ctx, state, "DecimalBigIntegerLiteral", DecimalBigIntegerLiteral$0);
|
|
10208
10330
|
}
|
|
10209
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
10331
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R25, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
10210
10332
|
return $1 + ".";
|
|
10211
10333
|
});
|
|
10212
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
10213
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
10334
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R26, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
10335
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R27, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
10214
10336
|
var DecimalLiteral$$ = [DecimalLiteral$0, DecimalLiteral$1, DecimalLiteral$2];
|
|
10215
10337
|
function DecimalLiteral(ctx, state) {
|
|
10216
10338
|
return $EVENT_C(ctx, state, "DecimalLiteral", DecimalLiteral$$);
|
|
10217
10339
|
}
|
|
10218
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
10340
|
+
var ExponentPart$0 = $R$0($EXPECT($R28, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
10219
10341
|
function ExponentPart(ctx, state) {
|
|
10220
10342
|
return $EVENT(ctx, state, "ExponentPart", ExponentPart$0);
|
|
10221
10343
|
}
|
|
10222
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
10344
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R29, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
10223
10345
|
function BinaryIntegerLiteral(ctx, state) {
|
|
10224
10346
|
return $EVENT(ctx, state, "BinaryIntegerLiteral", BinaryIntegerLiteral$0);
|
|
10225
10347
|
}
|
|
10226
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
10348
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R30, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
10227
10349
|
function OctalIntegerLiteral(ctx, state) {
|
|
10228
10350
|
return $EVENT(ctx, state, "OctalIntegerLiteral", OctalIntegerLiteral$0);
|
|
10229
10351
|
}
|
|
10230
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
10352
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R31, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
10231
10353
|
function HexIntegerLiteral(ctx, state) {
|
|
10232
10354
|
return $EVENT(ctx, state, "HexIntegerLiteral", HexIntegerLiteral$0);
|
|
10233
10355
|
}
|
|
10234
|
-
var IntegerLiteral$0 = $TS($S($EXPECT($
|
|
10356
|
+
var IntegerLiteral$0 = $TS($S($EXPECT($R32, "IntegerLiteral /(?=[0-9])/"), IntegerLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
10235
10357
|
var token = $2;
|
|
10236
10358
|
return { $loc, token };
|
|
10237
10359
|
});
|
|
@@ -10247,7 +10369,7 @@ ${input.slice(result.pos)}
|
|
|
10247
10369
|
function IntegerLiteralKind(ctx, state) {
|
|
10248
10370
|
return $EVENT_C(ctx, state, "IntegerLiteralKind", IntegerLiteralKind$$);
|
|
10249
10371
|
}
|
|
10250
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
10372
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R33, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
10251
10373
|
function DecimalIntegerLiteral(ctx, state) {
|
|
10252
10374
|
return $EVENT(ctx, state, "DecimalIntegerLiteral", DecimalIntegerLiteral$0);
|
|
10253
10375
|
}
|
|
@@ -10271,25 +10393,25 @@ ${input.slice(result.pos)}
|
|
|
10271
10393
|
function StringLiteral(ctx, state) {
|
|
10272
10394
|
return $EVENT_C(ctx, state, "StringLiteral", StringLiteral$$);
|
|
10273
10395
|
}
|
|
10274
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
10396
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R34, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10275
10397
|
return { $loc, token: $0 };
|
|
10276
10398
|
});
|
|
10277
10399
|
function DoubleStringCharacters(ctx, state) {
|
|
10278
10400
|
return $EVENT(ctx, state, "DoubleStringCharacters", DoubleStringCharacters$0);
|
|
10279
10401
|
}
|
|
10280
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
10402
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R35, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10281
10403
|
return { $loc, token: $0 };
|
|
10282
10404
|
});
|
|
10283
10405
|
function SingleStringCharacters(ctx, state) {
|
|
10284
10406
|
return $EVENT(ctx, state, "SingleStringCharacters", SingleStringCharacters$0);
|
|
10285
10407
|
}
|
|
10286
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
10408
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R36, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10287
10409
|
return { $loc, token: $0 };
|
|
10288
10410
|
});
|
|
10289
10411
|
function TripleDoubleStringCharacters(ctx, state) {
|
|
10290
10412
|
return $EVENT(ctx, state, "TripleDoubleStringCharacters", TripleDoubleStringCharacters$0);
|
|
10291
10413
|
}
|
|
10292
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
10414
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R37, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10293
10415
|
return { $loc, token: $0 };
|
|
10294
10416
|
});
|
|
10295
10417
|
function TripleSingleStringCharacters(ctx, state) {
|
|
@@ -10308,14 +10430,14 @@ ${input.slice(result.pos)}
|
|
|
10308
10430
|
function CoffeeInterpolatedDoubleQuotedString(ctx, state) {
|
|
10309
10431
|
return $EVENT(ctx, state, "CoffeeInterpolatedDoubleQuotedString", CoffeeInterpolatedDoubleQuotedString$0);
|
|
10310
10432
|
}
|
|
10311
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
10433
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R38, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10312
10434
|
return { $loc, token: $0 };
|
|
10313
10435
|
});
|
|
10314
10436
|
function CoffeeDoubleQuotedStringCharacters(ctx, state) {
|
|
10315
10437
|
return $EVENT(ctx, state, "CoffeeDoubleQuotedStringCharacters", CoffeeDoubleQuotedStringCharacters$0);
|
|
10316
10438
|
}
|
|
10317
10439
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
10318
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
10440
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L56, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L56, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
10319
10441
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
10320
10442
|
});
|
|
10321
10443
|
var RegularExpressionLiteral$$ = [RegularExpressionLiteral$0, RegularExpressionLiteral$1];
|
|
@@ -10328,7 +10450,7 @@ ${input.slice(result.pos)}
|
|
|
10328
10450
|
function RegularExpressionClass(ctx, state) {
|
|
10329
10451
|
return $EVENT(ctx, state, "RegularExpressionClass", RegularExpressionClass$0);
|
|
10330
10452
|
}
|
|
10331
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
10453
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R39, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10332
10454
|
return { $loc, token: $0 };
|
|
10333
10455
|
});
|
|
10334
10456
|
function RegularExpressionClassCharacters(ctx, state) {
|
|
@@ -10382,7 +10504,7 @@ ${input.slice(result.pos)}
|
|
|
10382
10504
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
10383
10505
|
return { "type": "Substitution", "children": value[0] };
|
|
10384
10506
|
});
|
|
10385
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
10507
|
+
var HeregexPart$3 = $TR($EXPECT($R40, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10386
10508
|
let token = $0;
|
|
10387
10509
|
switch ($0[1]) {
|
|
10388
10510
|
case "\n":
|
|
@@ -10400,13 +10522,13 @@ ${input.slice(result.pos)}
|
|
|
10400
10522
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
10401
10523
|
return { $loc, token: "" };
|
|
10402
10524
|
});
|
|
10403
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
10525
|
+
var HeregexPart$5 = $TR($EXPECT($R41, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10404
10526
|
return { $loc, token: "" };
|
|
10405
10527
|
});
|
|
10406
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
10528
|
+
var HeregexPart$6 = $TR($EXPECT($R42, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10407
10529
|
return { $loc, token: "\\/" };
|
|
10408
10530
|
});
|
|
10409
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
10531
|
+
var HeregexPart$7 = $TR($EXPECT($R43, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10410
10532
|
return { $loc, token: $0 };
|
|
10411
10533
|
});
|
|
10412
10534
|
var HeregexPart$$ = [HeregexPart$0, HeregexPart$1, HeregexPart$2, HeregexPart$3, HeregexPart$4, HeregexPart$5, HeregexPart$6, HeregexPart$7];
|
|
@@ -10419,7 +10541,7 @@ ${input.slice(result.pos)}
|
|
|
10419
10541
|
function HeregexComment(ctx, state) {
|
|
10420
10542
|
return $EVENT_C(ctx, state, "HeregexComment", HeregexComment$$);
|
|
10421
10543
|
}
|
|
10422
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
10544
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R44, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
10423
10545
|
function RegularExpressionBody(ctx, state) {
|
|
10424
10546
|
return $EVENT(ctx, state, "RegularExpressionBody", RegularExpressionBody$0);
|
|
10425
10547
|
}
|
|
@@ -10429,15 +10551,15 @@ ${input.slice(result.pos)}
|
|
|
10429
10551
|
function RegExpPart(ctx, state) {
|
|
10430
10552
|
return $EVENT_C(ctx, state, "RegExpPart", RegExpPart$$);
|
|
10431
10553
|
}
|
|
10432
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
10554
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R45, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
10433
10555
|
function RegExpCharacter(ctx, state) {
|
|
10434
10556
|
return $EVENT(ctx, state, "RegExpCharacter", RegExpCharacter$0);
|
|
10435
10557
|
}
|
|
10436
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
10558
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R46, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
10437
10559
|
function RegularExpressionFlags(ctx, state) {
|
|
10438
10560
|
return $EVENT(ctx, state, "RegularExpressionFlags", RegularExpressionFlags$0);
|
|
10439
10561
|
}
|
|
10440
|
-
var TemplateLiteral$0 = $T($S($EXPECT($
|
|
10562
|
+
var TemplateLiteral$0 = $T($S($EXPECT($R47, "TemplateLiteral /(?=[`'\"])/"), _TemplateLiteral), function(value) {
|
|
10441
10563
|
return value[1];
|
|
10442
10564
|
});
|
|
10443
10565
|
function TemplateLiteral(ctx, state) {
|
|
@@ -10473,28 +10595,28 @@ ${input.slice(result.pos)}
|
|
|
10473
10595
|
function TemplateSubstitution(ctx, state) {
|
|
10474
10596
|
return $EVENT(ctx, state, "TemplateSubstitution", TemplateSubstitution$0);
|
|
10475
10597
|
}
|
|
10476
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
10598
|
+
var TemplateCharacters$0 = $TR($EXPECT($R48, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10477
10599
|
return { $loc, token: $0 };
|
|
10478
10600
|
});
|
|
10479
10601
|
function TemplateCharacters(ctx, state) {
|
|
10480
10602
|
return $EVENT(ctx, state, "TemplateCharacters", TemplateCharacters$0);
|
|
10481
10603
|
}
|
|
10482
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
10604
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R49, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10483
10605
|
return { $loc, token: $0 };
|
|
10484
10606
|
});
|
|
10485
10607
|
function TemplateBlockCharacters(ctx, state) {
|
|
10486
10608
|
return $EVENT(ctx, state, "TemplateBlockCharacters", TemplateBlockCharacters$0);
|
|
10487
10609
|
}
|
|
10488
|
-
var ReservedWord$0 = $S($R$0($EXPECT($
|
|
10489
|
-
var ReservedWord$1 = $S($R$0($EXPECT($
|
|
10490
|
-
var ReservedWord$2 = $S($R$0($EXPECT($
|
|
10491
|
-
var ReservedWord$3 = $S($R$0($EXPECT($
|
|
10492
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
10610
|
+
var ReservedWord$0 = $S($R$0($EXPECT($R50, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")), CoffeeBooleansEnabled);
|
|
10611
|
+
var ReservedWord$1 = $S($R$0($EXPECT($R51, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")), CoffeeIsntEnabled);
|
|
10612
|
+
var ReservedWord$2 = $S($R$0($EXPECT($R52, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")), CoffeeForLoopsEnabled);
|
|
10613
|
+
var ReservedWord$3 = $S($R$0($EXPECT($R53, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")), CoffeeOfEnabled);
|
|
10614
|
+
var ReservedWord$4 = $R$0($EXPECT($R54, "ReservedWord /(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
10493
10615
|
var ReservedWord$$ = [ReservedWord$0, ReservedWord$1, ReservedWord$2, ReservedWord$3, ReservedWord$4];
|
|
10494
10616
|
function ReservedWord(ctx, state) {
|
|
10495
10617
|
return $EVENT_C(ctx, state, "ReservedWord", ReservedWord$$);
|
|
10496
10618
|
}
|
|
10497
|
-
var Comment$0 = $T($S($EXPECT($
|
|
10619
|
+
var Comment$0 = $T($S($EXPECT($R55, "Comment /(?=\\/|#)/"), _Comment), function(value) {
|
|
10498
10620
|
return value[1];
|
|
10499
10621
|
});
|
|
10500
10622
|
function Comment(ctx, state) {
|
|
@@ -10512,7 +10634,7 @@ ${input.slice(result.pos)}
|
|
|
10512
10634
|
function SingleLineComment(ctx, state) {
|
|
10513
10635
|
return $EVENT_C(ctx, state, "SingleLineComment", SingleLineComment$$);
|
|
10514
10636
|
}
|
|
10515
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
10637
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R56, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10516
10638
|
return { type: "Comment", $loc, token: $0 };
|
|
10517
10639
|
});
|
|
10518
10640
|
function JSSingleLineComment(ctx, state) {
|
|
@@ -10524,30 +10646,30 @@ ${input.slice(result.pos)}
|
|
|
10524
10646
|
function MultiLineComment(ctx, state) {
|
|
10525
10647
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
10526
10648
|
}
|
|
10527
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
10649
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L109, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L110, 'JSMultiLineComment "*/"')), $EXPECT($R57, "JSMultiLineComment /./"))), $EXPECT($L110, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
10528
10650
|
return { type: "Comment", $loc, token: $1 };
|
|
10529
10651
|
});
|
|
10530
10652
|
function JSMultiLineComment(ctx, state) {
|
|
10531
10653
|
return $EVENT(ctx, state, "JSMultiLineComment", JSMultiLineComment$0);
|
|
10532
10654
|
}
|
|
10533
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
10655
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R58, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10534
10656
|
return { type: "Comment", $loc, token: `//${$1}` };
|
|
10535
10657
|
});
|
|
10536
10658
|
function CoffeeSingleLineComment(ctx, state) {
|
|
10537
10659
|
return $EVENT(ctx, state, "CoffeeSingleLineComment", CoffeeSingleLineComment$0);
|
|
10538
10660
|
}
|
|
10539
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
10661
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R59, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
10540
10662
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
10541
10663
|
return { type: "Comment", $loc, token: `/*${$2}*/` };
|
|
10542
10664
|
});
|
|
10543
10665
|
function CoffeeMultiLineComment(ctx, state) {
|
|
10544
10666
|
return $EVENT(ctx, state, "CoffeeMultiLineComment", CoffeeMultiLineComment$0);
|
|
10545
10667
|
}
|
|
10546
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
10668
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R60, "CoffeeHereCommentStart /###(?!#)/"));
|
|
10547
10669
|
function CoffeeHereCommentStart(ctx, state) {
|
|
10548
10670
|
return $EVENT(ctx, state, "CoffeeHereCommentStart", CoffeeHereCommentStart$0);
|
|
10549
10671
|
}
|
|
10550
|
-
var InlineComment$0 = $TR($EXPECT($
|
|
10672
|
+
var InlineComment$0 = $TR($EXPECT($R61, "InlineComment /\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\//"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10551
10673
|
return { $loc, token: $0 };
|
|
10552
10674
|
});
|
|
10553
10675
|
function InlineComment(ctx, state) {
|
|
@@ -10561,16 +10683,16 @@ ${input.slice(result.pos)}
|
|
|
10561
10683
|
function TrailingComment(ctx, state) {
|
|
10562
10684
|
return $EVENT(ctx, state, "TrailingComment", TrailingComment$0);
|
|
10563
10685
|
}
|
|
10564
|
-
var _$0 = $T($S($EXPECT($
|
|
10686
|
+
var _$0 = $T($S($EXPECT($R62, "_ /(?=[ \\t\\/\\\\])/"), $P($C(NonNewlineWhitespace, InlineComment))), function(value) {
|
|
10565
10687
|
return value[1];
|
|
10566
10688
|
});
|
|
10567
10689
|
function _(ctx, state) {
|
|
10568
10690
|
return $EVENT(ctx, state, "_", _$0);
|
|
10569
10691
|
}
|
|
10570
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
10692
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R63, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10571
10693
|
return { $loc, token: $0 };
|
|
10572
10694
|
});
|
|
10573
|
-
var NonNewlineWhitespace$1 = $T($S($EXPECT($
|
|
10695
|
+
var NonNewlineWhitespace$1 = $T($S($EXPECT($L111, 'NonNewlineWhitespace "\\\\\\\\"'), CoffeeLineContinuationEnabled, EOL), function(value) {
|
|
10574
10696
|
return " ";
|
|
10575
10697
|
});
|
|
10576
10698
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
@@ -10584,7 +10706,7 @@ ${input.slice(result.pos)}
|
|
|
10584
10706
|
function Trimmed_(ctx, state) {
|
|
10585
10707
|
return $EVENT(ctx, state, "Trimmed_", Trimmed_$0);
|
|
10586
10708
|
}
|
|
10587
|
-
var __$0 = $T($S($EXPECT($
|
|
10709
|
+
var __$0 = $T($S($EXPECT($R64, "__ /(?=\\s|\\/|#)/"), $Q($C(Whitespace, Comment))), function(value) {
|
|
10588
10710
|
return value[1];
|
|
10589
10711
|
});
|
|
10590
10712
|
var __$1 = $EXPECT($L0, '__ ""');
|
|
@@ -10592,7 +10714,7 @@ ${input.slice(result.pos)}
|
|
|
10592
10714
|
function __(ctx, state) {
|
|
10593
10715
|
return $EVENT_C(ctx, state, "__", __$$);
|
|
10594
10716
|
}
|
|
10595
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
10717
|
+
var Whitespace$0 = $TR($EXPECT($R41, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10596
10718
|
return { $loc, token: $0 };
|
|
10597
10719
|
});
|
|
10598
10720
|
function Whitespace(ctx, state) {
|
|
@@ -10616,7 +10738,7 @@ ${input.slice(result.pos)}
|
|
|
10616
10738
|
}
|
|
10617
10739
|
var StatementDelimiter$0 = $Y(EOS);
|
|
10618
10740
|
var StatementDelimiter$1 = SemicolonDelimiter;
|
|
10619
|
-
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($
|
|
10741
|
+
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L26, 'StatementDelimiter "}"'), $EXPECT($L112, 'StatementDelimiter ")"'), $EXPECT($L35, 'StatementDelimiter "]"'))));
|
|
10620
10742
|
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2];
|
|
10621
10743
|
function StatementDelimiter(ctx, state) {
|
|
10622
10744
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
@@ -10630,7 +10752,7 @@ ${input.slice(result.pos)}
|
|
|
10630
10752
|
function SemicolonDelimiter(ctx, state) {
|
|
10631
10753
|
return $EVENT(ctx, state, "SemicolonDelimiter", SemicolonDelimiter$0);
|
|
10632
10754
|
}
|
|
10633
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
10755
|
+
var NonIdContinue$0 = $R$0($EXPECT($R65, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
10634
10756
|
function NonIdContinue(ctx, state) {
|
|
10635
10757
|
return $EVENT(ctx, state, "NonIdContinue", NonIdContinue$0);
|
|
10636
10758
|
}
|
|
@@ -10640,97 +10762,103 @@ ${input.slice(result.pos)}
|
|
|
10640
10762
|
function Loc(ctx, state) {
|
|
10641
10763
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
10642
10764
|
}
|
|
10643
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
10765
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L113, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L12, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
10644
10766
|
return { $loc, token: $1, ts: true };
|
|
10645
10767
|
});
|
|
10646
10768
|
function Abstract(ctx, state) {
|
|
10647
10769
|
return $EVENT(ctx, state, "Abstract", Abstract$0);
|
|
10648
10770
|
}
|
|
10649
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
10771
|
+
var Ampersand$0 = $TV($EXPECT($L98, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
10650
10772
|
return { $loc, token: $1 };
|
|
10651
10773
|
});
|
|
10652
10774
|
function Ampersand(ctx, state) {
|
|
10653
10775
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
10654
10776
|
}
|
|
10655
|
-
var As$0 = $TS($S($EXPECT($
|
|
10777
|
+
var As$0 = $TS($S($EXPECT($L114, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10656
10778
|
return { $loc, token: $1 };
|
|
10657
10779
|
});
|
|
10658
10780
|
function As(ctx, state) {
|
|
10659
10781
|
return $EVENT(ctx, state, "As", As$0);
|
|
10660
10782
|
}
|
|
10661
|
-
var At$0 = $TV($EXPECT($
|
|
10783
|
+
var At$0 = $TV($EXPECT($L115, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
10662
10784
|
return { $loc, token: $1 };
|
|
10663
10785
|
});
|
|
10664
10786
|
function At(ctx, state) {
|
|
10665
10787
|
return $EVENT(ctx, state, "At", At$0);
|
|
10666
10788
|
}
|
|
10667
|
-
var AtAt$0 = $TV($EXPECT($
|
|
10789
|
+
var AtAt$0 = $TV($EXPECT($L116, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
10668
10790
|
return { $loc, token: "@" };
|
|
10669
10791
|
});
|
|
10670
10792
|
function AtAt(ctx, state) {
|
|
10671
10793
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
10672
10794
|
}
|
|
10673
|
-
var Async$0 = $TS($S($EXPECT($
|
|
10795
|
+
var Async$0 = $TS($S($EXPECT($L117, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10674
10796
|
return { $loc, token: $1, type: "Async" };
|
|
10675
10797
|
});
|
|
10676
10798
|
function Async(ctx, state) {
|
|
10677
10799
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
10678
10800
|
}
|
|
10679
|
-
var Await$0 = $TS($S($EXPECT($
|
|
10801
|
+
var Await$0 = $TS($S($EXPECT($L118, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10680
10802
|
return { $loc, token: $1, type: "Await" };
|
|
10681
10803
|
});
|
|
10682
10804
|
function Await(ctx, state) {
|
|
10683
10805
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
10684
10806
|
}
|
|
10685
|
-
var Backtick$0 = $TV($EXPECT($
|
|
10807
|
+
var Backtick$0 = $TV($EXPECT($L119, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
10686
10808
|
return { $loc, token: $1 };
|
|
10687
10809
|
});
|
|
10688
10810
|
function Backtick(ctx, state) {
|
|
10689
10811
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
10690
10812
|
}
|
|
10691
|
-
var By$0 = $TS($S($EXPECT($
|
|
10813
|
+
var By$0 = $TS($S($EXPECT($L120, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10692
10814
|
return { $loc, token: $1 };
|
|
10693
10815
|
});
|
|
10694
10816
|
function By(ctx, state) {
|
|
10695
10817
|
return $EVENT(ctx, state, "By", By$0);
|
|
10696
10818
|
}
|
|
10697
|
-
var Case$0 = $TS($S($EXPECT($
|
|
10819
|
+
var Case$0 = $TS($S($EXPECT($L121, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10698
10820
|
return { $loc, token: $1 };
|
|
10699
10821
|
});
|
|
10700
10822
|
function Case(ctx, state) {
|
|
10701
10823
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
10702
10824
|
}
|
|
10703
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
10825
|
+
var Catch$0 = $TS($S($EXPECT($L122, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10704
10826
|
return { $loc, token: $1 };
|
|
10705
10827
|
});
|
|
10706
10828
|
function Catch(ctx, state) {
|
|
10707
10829
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
10708
10830
|
}
|
|
10709
|
-
var Class$0 = $TS($S($EXPECT($
|
|
10831
|
+
var Class$0 = $TS($S($EXPECT($L123, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10710
10832
|
return { $loc, token: $1 };
|
|
10711
10833
|
});
|
|
10712
10834
|
function Class(ctx, state) {
|
|
10713
10835
|
return $EVENT(ctx, state, "Class", Class$0);
|
|
10714
10836
|
}
|
|
10715
|
-
var
|
|
10837
|
+
var CloseAngleBracket$0 = $TV($EXPECT($L34, 'CloseAngleBracket ">"'), function($skip, $loc, $0, $1) {
|
|
10838
|
+
return { $loc, token: $1 };
|
|
10839
|
+
});
|
|
10840
|
+
function CloseAngleBracket(ctx, state) {
|
|
10841
|
+
return $EVENT(ctx, state, "CloseAngleBracket", CloseAngleBracket$0);
|
|
10842
|
+
}
|
|
10843
|
+
var CloseBrace$0 = $TV($EXPECT($L26, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
10716
10844
|
return { $loc, token: $1 };
|
|
10717
10845
|
});
|
|
10718
10846
|
function CloseBrace(ctx, state) {
|
|
10719
10847
|
return $EVENT(ctx, state, "CloseBrace", CloseBrace$0);
|
|
10720
10848
|
}
|
|
10721
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
10849
|
+
var CloseBracket$0 = $TV($EXPECT($L35, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
10722
10850
|
return { $loc, token: $1 };
|
|
10723
10851
|
});
|
|
10724
10852
|
function CloseBracket(ctx, state) {
|
|
10725
10853
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
10726
10854
|
}
|
|
10727
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
10855
|
+
var CloseParen$0 = $TV($EXPECT($L112, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
10728
10856
|
return { $loc, token: $1 };
|
|
10729
10857
|
});
|
|
10730
10858
|
function CloseParen(ctx, state) {
|
|
10731
10859
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
10732
10860
|
}
|
|
10733
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
10861
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L124, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
10734
10862
|
return { $loc, token: "${" };
|
|
10735
10863
|
});
|
|
10736
10864
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
@@ -10742,37 +10870,37 @@ ${input.slice(result.pos)}
|
|
|
10742
10870
|
function Colon(ctx, state) {
|
|
10743
10871
|
return $EVENT(ctx, state, "Colon", Colon$0);
|
|
10744
10872
|
}
|
|
10745
|
-
var Comma$0 = $TV($EXPECT($
|
|
10873
|
+
var Comma$0 = $TV($EXPECT($L22, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
10746
10874
|
return { $loc, token: $1 };
|
|
10747
10875
|
});
|
|
10748
10876
|
function Comma(ctx, state) {
|
|
10749
10877
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
10750
10878
|
}
|
|
10751
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
10879
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L115, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
10752
10880
|
return { $loc, token: "constructor" };
|
|
10753
10881
|
});
|
|
10754
10882
|
function ConstructorShorthand(ctx, state) {
|
|
10755
10883
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
10756
10884
|
}
|
|
10757
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
10885
|
+
var Declare$0 = $TS($S($EXPECT($L125, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10758
10886
|
return { $loc, token: $1 };
|
|
10759
10887
|
});
|
|
10760
10888
|
function Declare(ctx, state) {
|
|
10761
10889
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
10762
10890
|
}
|
|
10763
|
-
var Default$0 = $TS($S($EXPECT($
|
|
10891
|
+
var Default$0 = $TS($S($EXPECT($L126, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10764
10892
|
return { $loc, token: $1 };
|
|
10765
10893
|
});
|
|
10766
10894
|
function Default(ctx, state) {
|
|
10767
10895
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
10768
10896
|
}
|
|
10769
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
10897
|
+
var Delete$0 = $TS($S($EXPECT($L127, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10770
10898
|
return { $loc, token: $1 };
|
|
10771
10899
|
});
|
|
10772
10900
|
function Delete(ctx, state) {
|
|
10773
10901
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
10774
10902
|
}
|
|
10775
|
-
var Do$0 = $TS($S($EXPECT($
|
|
10903
|
+
var Do$0 = $TS($S($EXPECT($L128, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10776
10904
|
return { $loc, token: $1 };
|
|
10777
10905
|
});
|
|
10778
10906
|
function Do(ctx, state) {
|
|
@@ -10781,7 +10909,7 @@ ${input.slice(result.pos)}
|
|
|
10781
10909
|
var Dot$0 = $TV($EXPECT($L6, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
10782
10910
|
return { $loc, token: $1 };
|
|
10783
10911
|
});
|
|
10784
|
-
var Dot$1 = $TS($S($EXPECT($
|
|
10912
|
+
var Dot$1 = $TS($S($EXPECT($R66, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
|
|
10785
10913
|
var ws = $2;
|
|
10786
10914
|
return [
|
|
10787
10915
|
{ $loc, token: "." },
|
|
@@ -10792,45 +10920,45 @@ ${input.slice(result.pos)}
|
|
|
10792
10920
|
function Dot(ctx, state) {
|
|
10793
10921
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
10794
10922
|
}
|
|
10795
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
10923
|
+
var DotDot$0 = $TS($S($EXPECT($L129, 'DotDot ".."'), $N($EXPECT($L6, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
10796
10924
|
return { $loc, token: $1 };
|
|
10797
10925
|
});
|
|
10798
|
-
var DotDot$1 = $TV($EXPECT($
|
|
10926
|
+
var DotDot$1 = $TV($EXPECT($L130, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
10799
10927
|
return { $loc, token: ".." };
|
|
10800
10928
|
});
|
|
10801
10929
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
10802
10930
|
function DotDot(ctx, state) {
|
|
10803
10931
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
10804
10932
|
}
|
|
10805
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
10933
|
+
var DotDotDot$0 = $TV($EXPECT($L131, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
10806
10934
|
return { $loc, token: $1 };
|
|
10807
10935
|
});
|
|
10808
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
10936
|
+
var DotDotDot$1 = $TV($EXPECT($L132, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
10809
10937
|
return { $loc, token: "..." };
|
|
10810
10938
|
});
|
|
10811
10939
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
10812
10940
|
function DotDotDot(ctx, state) {
|
|
10813
10941
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
10814
10942
|
}
|
|
10815
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
10943
|
+
var DoubleColon$0 = $TV($EXPECT($L133, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
10816
10944
|
return { $loc, token: $1 };
|
|
10817
10945
|
});
|
|
10818
10946
|
function DoubleColon(ctx, state) {
|
|
10819
10947
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
10820
10948
|
}
|
|
10821
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
10949
|
+
var DoubleQuote$0 = $TV($EXPECT($L134, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
10822
10950
|
return { $loc, token: $1 };
|
|
10823
10951
|
});
|
|
10824
10952
|
function DoubleQuote(ctx, state) {
|
|
10825
10953
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
10826
10954
|
}
|
|
10827
|
-
var Each$0 = $TS($S($EXPECT($
|
|
10955
|
+
var Each$0 = $TS($S($EXPECT($L135, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10828
10956
|
return { $loc, token: $1 };
|
|
10829
10957
|
});
|
|
10830
10958
|
function Each(ctx, state) {
|
|
10831
10959
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
10832
10960
|
}
|
|
10833
|
-
var Else$0 = $TS($S($EXPECT($
|
|
10961
|
+
var Else$0 = $TS($S($EXPECT($L136, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10834
10962
|
return { $loc, token: $1 };
|
|
10835
10963
|
});
|
|
10836
10964
|
function Else(ctx, state) {
|
|
@@ -10842,85 +10970,85 @@ ${input.slice(result.pos)}
|
|
|
10842
10970
|
function Equals(ctx, state) {
|
|
10843
10971
|
return $EVENT(ctx, state, "Equals", Equals$0);
|
|
10844
10972
|
}
|
|
10845
|
-
var Export$0 = $TS($S($EXPECT($
|
|
10973
|
+
var Export$0 = $TS($S($EXPECT($L137, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10846
10974
|
return { $loc, token: $1 };
|
|
10847
10975
|
});
|
|
10848
10976
|
function Export(ctx, state) {
|
|
10849
10977
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
10850
10978
|
}
|
|
10851
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
10979
|
+
var Extends$0 = $TS($S($EXPECT($L138, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10852
10980
|
return { $loc, token: $1 };
|
|
10853
10981
|
});
|
|
10854
10982
|
function Extends(ctx, state) {
|
|
10855
10983
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
10856
10984
|
}
|
|
10857
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
10985
|
+
var Finally$0 = $TS($S($EXPECT($L139, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10858
10986
|
return { $loc, token: $1 };
|
|
10859
10987
|
});
|
|
10860
10988
|
function Finally(ctx, state) {
|
|
10861
10989
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
10862
10990
|
}
|
|
10863
|
-
var For$0 = $TS($S($EXPECT($
|
|
10991
|
+
var For$0 = $TS($S($EXPECT($L140, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10864
10992
|
return { $loc, token: $1 };
|
|
10865
10993
|
});
|
|
10866
10994
|
function For(ctx, state) {
|
|
10867
10995
|
return $EVENT(ctx, state, "For", For$0);
|
|
10868
10996
|
}
|
|
10869
|
-
var From$0 = $TS($S($EXPECT($
|
|
10997
|
+
var From$0 = $TS($S($EXPECT($L141, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10870
10998
|
return { $loc, token: $1 };
|
|
10871
10999
|
});
|
|
10872
11000
|
function From(ctx, state) {
|
|
10873
11001
|
return $EVENT(ctx, state, "From", From$0);
|
|
10874
11002
|
}
|
|
10875
|
-
var Function$0 = $TS($S($EXPECT($
|
|
11003
|
+
var Function$0 = $TS($S($EXPECT($L142, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10876
11004
|
return { $loc, token: $1 };
|
|
10877
11005
|
});
|
|
10878
11006
|
function Function(ctx, state) {
|
|
10879
11007
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
10880
11008
|
}
|
|
10881
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
11009
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L143, 'GetOrSet "get"'), $EXPECT($L144, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10882
11010
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
10883
11011
|
});
|
|
10884
11012
|
function GetOrSet(ctx, state) {
|
|
10885
11013
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
10886
11014
|
}
|
|
10887
|
-
var Hash$0 = $TV($EXPECT($
|
|
11015
|
+
var Hash$0 = $TV($EXPECT($L145, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
10888
11016
|
return { $loc, token: $1 };
|
|
10889
11017
|
});
|
|
10890
11018
|
function Hash(ctx, state) {
|
|
10891
11019
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
10892
11020
|
}
|
|
10893
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
11021
|
+
var If$0 = $TV($TEXT($S($EXPECT($L146, 'If "if"'), NonIdContinue, $E($EXPECT($L12, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
10894
11022
|
return { $loc, token: $1 };
|
|
10895
11023
|
});
|
|
10896
11024
|
function If(ctx, state) {
|
|
10897
11025
|
return $EVENT(ctx, state, "If", If$0);
|
|
10898
11026
|
}
|
|
10899
|
-
var Import$0 = $TS($S($EXPECT($
|
|
11027
|
+
var Import$0 = $TS($S($EXPECT($L16, 'Import "import"'), $Y($EXPECT($R67, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
10900
11028
|
return { $loc, token: $1 };
|
|
10901
11029
|
});
|
|
10902
11030
|
function Import(ctx, state) {
|
|
10903
11031
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
10904
11032
|
}
|
|
10905
|
-
var In$0 = $TS($S($EXPECT($
|
|
11033
|
+
var In$0 = $TS($S($EXPECT($L147, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10906
11034
|
return { $loc, token: $1 };
|
|
10907
11035
|
});
|
|
10908
11036
|
function In(ctx, state) {
|
|
10909
11037
|
return $EVENT(ctx, state, "In", In$0);
|
|
10910
11038
|
}
|
|
10911
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
11039
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L148, 'LetOrConst "let"'), $EXPECT($L149, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10912
11040
|
return { $loc, token: $1 };
|
|
10913
11041
|
});
|
|
10914
11042
|
function LetOrConst(ctx, state) {
|
|
10915
11043
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
10916
11044
|
}
|
|
10917
|
-
var Const$0 = $TS($S($EXPECT($
|
|
11045
|
+
var Const$0 = $TS($S($EXPECT($L149, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10918
11046
|
return { $loc, token: $1 };
|
|
10919
11047
|
});
|
|
10920
11048
|
function Const(ctx, state) {
|
|
10921
11049
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
10922
11050
|
}
|
|
10923
|
-
var Is$0 = $TS($S($EXPECT($
|
|
11051
|
+
var Is$0 = $TS($S($EXPECT($L150, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10924
11052
|
return { $loc, token: $1 };
|
|
10925
11053
|
});
|
|
10926
11054
|
function Is(ctx, state) {
|
|
@@ -10932,31 +11060,31 @@ ${input.slice(result.pos)}
|
|
|
10932
11060
|
function LetOrConstOrVar(ctx, state) {
|
|
10933
11061
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
10934
11062
|
}
|
|
10935
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
11063
|
+
var Loop$0 = $TS($S($EXPECT($L151, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10936
11064
|
return { $loc, token: "while(true)" };
|
|
10937
11065
|
});
|
|
10938
11066
|
function Loop(ctx, state) {
|
|
10939
11067
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
10940
11068
|
}
|
|
10941
|
-
var New$0 = $TS($S($EXPECT($
|
|
11069
|
+
var New$0 = $TS($S($EXPECT($L152, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10942
11070
|
return { $loc, token: $1 };
|
|
10943
11071
|
});
|
|
10944
11072
|
function New(ctx, state) {
|
|
10945
11073
|
return $EVENT(ctx, state, "New", New$0);
|
|
10946
11074
|
}
|
|
10947
|
-
var Not$0 = $TS($S($EXPECT($
|
|
11075
|
+
var Not$0 = $TS($S($EXPECT($L153, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L11, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
10948
11076
|
return { $loc, token: "!" };
|
|
10949
11077
|
});
|
|
10950
11078
|
function Not(ctx, state) {
|
|
10951
11079
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
10952
11080
|
}
|
|
10953
|
-
var Of$0 = $TS($S($EXPECT($
|
|
11081
|
+
var Of$0 = $TS($S($EXPECT($L154, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10954
11082
|
return { $loc, token: $1 };
|
|
10955
11083
|
});
|
|
10956
11084
|
function Of(ctx, state) {
|
|
10957
11085
|
return $EVENT(ctx, state, "Of", Of$0);
|
|
10958
11086
|
}
|
|
10959
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
11087
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L13, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
10960
11088
|
return { $loc, token: $1 };
|
|
10961
11089
|
});
|
|
10962
11090
|
function OpenAngleBracket(ctx, state) {
|
|
@@ -11047,7 +11175,7 @@ ${input.slice(result.pos)}
|
|
|
11047
11175
|
function Satisfies(ctx, state) {
|
|
11048
11176
|
return $EVENT(ctx, state, "Satisfies", Satisfies$0);
|
|
11049
11177
|
}
|
|
11050
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
11178
|
+
var Semicolon$0 = $TV($EXPECT($L100, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
11051
11179
|
return { $loc, token: $1 };
|
|
11052
11180
|
});
|
|
11053
11181
|
function Semicolon(ctx, state) {
|
|
@@ -11059,7 +11187,7 @@ ${input.slice(result.pos)}
|
|
|
11059
11187
|
function SingleQuote(ctx, state) {
|
|
11060
11188
|
return $EVENT(ctx, state, "SingleQuote", SingleQuote$0);
|
|
11061
11189
|
}
|
|
11062
|
-
var Star$0 = $TV($EXPECT($
|
|
11190
|
+
var Star$0 = $TV($EXPECT($L55, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
11063
11191
|
return { $loc, token: $1 };
|
|
11064
11192
|
});
|
|
11065
11193
|
function Star(ctx, state) {
|
|
@@ -11068,7 +11196,7 @@ ${input.slice(result.pos)}
|
|
|
11068
11196
|
var Static$0 = $TS($S($EXPECT($L171, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11069
11197
|
return { $loc, token: $1 };
|
|
11070
11198
|
});
|
|
11071
|
-
var Static$1 = $TS($S($EXPECT($
|
|
11199
|
+
var Static$1 = $TS($S($EXPECT($L115, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L115, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
11072
11200
|
return { $loc, token: "static " };
|
|
11073
11201
|
});
|
|
11074
11202
|
var Static$$ = [Static$0, Static$1];
|
|
@@ -11224,7 +11352,7 @@ ${input.slice(result.pos)}
|
|
|
11224
11352
|
function JSXImplicitFragment(ctx, state) {
|
|
11225
11353
|
return $EVENT(ctx, state, "JSXImplicitFragment", JSXImplicitFragment$0);
|
|
11226
11354
|
}
|
|
11227
|
-
var JSXTag$0 = $T($S($EXPECT($
|
|
11355
|
+
var JSXTag$0 = $T($S($EXPECT($R68, "JSXTag /(?=[<])/"), _JSXTag), function(value) {
|
|
11228
11356
|
return value[1];
|
|
11229
11357
|
});
|
|
11230
11358
|
function JSXTag(ctx, state) {
|
|
@@ -11274,7 +11402,7 @@ ${input.slice(result.pos)}
|
|
|
11274
11402
|
function JSXElement(ctx, state) {
|
|
11275
11403
|
return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
|
|
11276
11404
|
}
|
|
11277
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
11405
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L13, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L193, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
11278
11406
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
11279
11407
|
});
|
|
11280
11408
|
function JSXSelfClosingElement(ctx, state) {
|
|
@@ -11293,7 +11421,7 @@ ${input.slice(result.pos)}
|
|
|
11293
11421
|
function PopJSXStack(ctx, state) {
|
|
11294
11422
|
return $EVENT(ctx, state, "PopJSXStack", PopJSXStack$0);
|
|
11295
11423
|
}
|
|
11296
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
11424
|
+
var JSXOpeningElement$0 = $S($EXPECT($L13, 'JSXOpeningElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L34, 'JSXOpeningElement ">"'));
|
|
11297
11425
|
function JSXOpeningElement(ctx, state) {
|
|
11298
11426
|
return $EVENT(ctx, state, "JSXOpeningElement", JSXOpeningElement$0);
|
|
11299
11427
|
}
|
|
@@ -11308,7 +11436,7 @@ ${input.slice(result.pos)}
|
|
|
11308
11436
|
function JSXOptionalClosingElement(ctx, state) {
|
|
11309
11437
|
return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
|
|
11310
11438
|
}
|
|
11311
|
-
var JSXClosingElement$0 = $S($EXPECT($L194, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($
|
|
11439
|
+
var JSXClosingElement$0 = $S($EXPECT($L194, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L34, 'JSXClosingElement ">"'));
|
|
11312
11440
|
function JSXClosingElement(ctx, state) {
|
|
11313
11441
|
return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
|
|
11314
11442
|
}
|
|
@@ -11363,7 +11491,7 @@ ${input.slice(result.pos)}
|
|
|
11363
11491
|
function JSXClosingFragment(ctx, state) {
|
|
11364
11492
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
11365
11493
|
}
|
|
11366
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
11494
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L145, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
11367
11495
|
return module.config.defaultElement;
|
|
11368
11496
|
});
|
|
11369
11497
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -11371,7 +11499,7 @@ ${input.slice(result.pos)}
|
|
|
11371
11499
|
function JSXElementName(ctx, state) {
|
|
11372
11500
|
return $EVENT_C(ctx, state, "JSXElementName", JSXElementName$$);
|
|
11373
11501
|
}
|
|
11374
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
11502
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R69, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
11375
11503
|
function JSXIdentifierName(ctx, state) {
|
|
11376
11504
|
return $EVENT(ctx, state, "JSXIdentifierName", JSXIdentifierName$0);
|
|
11377
11505
|
}
|
|
@@ -11535,7 +11663,7 @@ ${input.slice(result.pos)}
|
|
|
11535
11663
|
}
|
|
11536
11664
|
return $skip;
|
|
11537
11665
|
});
|
|
11538
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
11666
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L145, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
11539
11667
|
return [" ", "id=", $2];
|
|
11540
11668
|
});
|
|
11541
11669
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -11554,11 +11682,11 @@ ${input.slice(result.pos)}
|
|
|
11554
11682
|
function JSXAttribute(ctx, state) {
|
|
11555
11683
|
return $EVENT_C(ctx, state, "JSXAttribute", JSXAttribute$$);
|
|
11556
11684
|
}
|
|
11557
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
11685
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R70, "JSXAttributeSpace /[\\s>]|\\/>/"));
|
|
11558
11686
|
function JSXAttributeSpace(ctx, state) {
|
|
11559
11687
|
return $EVENT(ctx, state, "JSXAttributeSpace", JSXAttributeSpace$0);
|
|
11560
11688
|
}
|
|
11561
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
11689
|
+
var JSXShorthandString$0 = $TR($EXPECT($R71, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11562
11690
|
return quoteString($0);
|
|
11563
11691
|
});
|
|
11564
11692
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -11592,7 +11720,7 @@ ${input.slice(result.pos)}
|
|
|
11592
11720
|
}
|
|
11593
11721
|
return [open, value, close];
|
|
11594
11722
|
});
|
|
11595
|
-
var JSXAttributeValue$4 = $R$0($EXPECT($
|
|
11723
|
+
var JSXAttributeValue$4 = $R$0($EXPECT($R72, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
|
|
11596
11724
|
var JSXAttributeValue$$ = [JSXAttributeValue$0, JSXAttributeValue$1, JSXAttributeValue$2, JSXAttributeValue$3, JSXAttributeValue$4];
|
|
11597
11725
|
function JSXAttributeValue(ctx, state) {
|
|
11598
11726
|
return $EVENT_C(ctx, state, "JSXAttributeValue", JSXAttributeValue$$);
|
|
@@ -11605,7 +11733,7 @@ ${input.slice(result.pos)}
|
|
|
11605
11733
|
function InlineJSXAttributeValue(ctx, state) {
|
|
11606
11734
|
return $EVENT(ctx, state, "InlineJSXAttributeValue", InlineJSXAttributeValue$0);
|
|
11607
11735
|
}
|
|
11608
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
11736
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R73, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
11609
11737
|
var op = $2;
|
|
11610
11738
|
var rhs = $3;
|
|
11611
11739
|
return [[], op, [], rhs];
|
|
@@ -11622,7 +11750,7 @@ ${input.slice(result.pos)}
|
|
|
11622
11750
|
function InlineJSXUnaryExpression(ctx, state) {
|
|
11623
11751
|
return $EVENT(ctx, state, "InlineJSXUnaryExpression", InlineJSXUnaryExpression$0);
|
|
11624
11752
|
}
|
|
11625
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
11753
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R74, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11626
11754
|
return { $loc, token: $0 };
|
|
11627
11755
|
});
|
|
11628
11756
|
function InlineJSXUnaryOp(ctx, state) {
|
|
@@ -11654,7 +11782,7 @@ ${input.slice(result.pos)}
|
|
|
11654
11782
|
]
|
|
11655
11783
|
});
|
|
11656
11784
|
});
|
|
11657
|
-
var InlineJSXCallExpression$1 = $TS($S($EXPECT($
|
|
11785
|
+
var InlineJSXCallExpression$1 = $TS($S($EXPECT($L16, 'InlineJSXCallExpression "import"'), ExplicitArguments, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
11658
11786
|
var args = $2;
|
|
11659
11787
|
var rest = $3;
|
|
11660
11788
|
return processCallMemberExpression({
|
|
@@ -11773,7 +11901,7 @@ ${input.slice(result.pos)}
|
|
|
11773
11901
|
}
|
|
11774
11902
|
return $skip;
|
|
11775
11903
|
});
|
|
11776
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
11904
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L26, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
11777
11905
|
return { children: [], jsxChildren: [] };
|
|
11778
11906
|
});
|
|
11779
11907
|
var JSXNestedChildren$$ = [JSXNestedChildren$0, JSXNestedChildren$1];
|
|
@@ -11834,13 +11962,13 @@ ${input.slice(result.pos)}
|
|
|
11834
11962
|
function JSXComment(ctx, state) {
|
|
11835
11963
|
return $EVENT(ctx, state, "JSXComment", JSXComment$0);
|
|
11836
11964
|
}
|
|
11837
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
11965
|
+
var JSXCommentContent$0 = $TR($EXPECT($R75, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11838
11966
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
11839
11967
|
});
|
|
11840
11968
|
function JSXCommentContent(ctx, state) {
|
|
11841
11969
|
return $EVENT(ctx, state, "JSXCommentContent", JSXCommentContent$0);
|
|
11842
11970
|
}
|
|
11843
|
-
var JSXText$0 = $TR($EXPECT($
|
|
11971
|
+
var JSXText$0 = $TR($EXPECT($R76, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11844
11972
|
return {
|
|
11845
11973
|
type: "JSXText",
|
|
11846
11974
|
token: $0,
|
|
@@ -12205,7 +12333,7 @@ ${input.slice(result.pos)}
|
|
|
12205
12333
|
function TypeProperty(ctx, state) {
|
|
12206
12334
|
return $EVENT(ctx, state, "TypeProperty", TypeProperty$0);
|
|
12207
12335
|
}
|
|
12208
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
12336
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R77, "TypeIndexSignature /[+-]?/")), Readonly, NotDedented)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R78, "TypeIndexSignature /[+-]/")), $Y($S($E(_), QuestionMark)))));
|
|
12209
12337
|
function TypeIndexSignature(ctx, state) {
|
|
12210
12338
|
return $EVENT(ctx, state, "TypeIndexSignature", TypeIndexSignature$0);
|
|
12211
12339
|
}
|
|
@@ -12256,7 +12384,7 @@ ${input.slice(result.pos)}
|
|
|
12256
12384
|
function ReturnType(ctx, state) {
|
|
12257
12385
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
12258
12386
|
}
|
|
12259
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
12387
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L150, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
12260
12388
|
var lhs = $1;
|
|
12261
12389
|
var rhs = $2;
|
|
12262
12390
|
if (!rhs)
|
|
@@ -12357,8 +12485,8 @@ ${input.slice(result.pos)}
|
|
|
12357
12485
|
function TypePrimary(ctx, state) {
|
|
12358
12486
|
return $EVENT_C(ctx, state, "TypePrimary", TypePrimary$$);
|
|
12359
12487
|
}
|
|
12360
|
-
var ImportType$0 = $S($EXPECT($
|
|
12361
|
-
var ImportType$1 = $S($EXPECT($
|
|
12488
|
+
var ImportType$0 = $S($EXPECT($L16, 'ImportType "import"'), OpenParen, __, StringLiteral, __, CloseParen, $E($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
12489
|
+
var ImportType$1 = $S($EXPECT($L16, 'ImportType "import"'), InsertOpenParen, Trimmed_, StringLiteral, InsertCloseParen);
|
|
12362
12490
|
var ImportType$$ = [ImportType$0, ImportType$1];
|
|
12363
12491
|
function ImportType(ctx, state) {
|
|
12364
12492
|
return $EVENT_C(ctx, state, "ImportType", ImportType$$);
|
|
@@ -12418,7 +12546,7 @@ ${input.slice(result.pos)}
|
|
|
12418
12546
|
function NestedType(ctx, state) {
|
|
12419
12547
|
return $EVENT(ctx, state, "NestedType", NestedType$0);
|
|
12420
12548
|
}
|
|
12421
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
12549
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L138, 'TypeConditional "extends"'), NonIdContinue, Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
12422
12550
|
if ($2)
|
|
12423
12551
|
return $0;
|
|
12424
12552
|
return $1;
|
|
@@ -12478,16 +12606,16 @@ ${input.slice(result.pos)}
|
|
|
12478
12606
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
12479
12607
|
return value[1];
|
|
12480
12608
|
});
|
|
12481
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($
|
|
12609
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L112, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L35, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L26, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
12482
12610
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
12483
12611
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
12484
12612
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
12485
12613
|
return $EVENT_C(ctx, state, "InlineInterfacePropertyDelimiter", InlineInterfacePropertyDelimiter$$);
|
|
12486
12614
|
}
|
|
12487
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
12615
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L99, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
12488
12616
|
return { $loc, token: "|" };
|
|
12489
12617
|
});
|
|
12490
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
12618
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L98, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
12491
12619
|
return { $loc, token: "&" };
|
|
12492
12620
|
});
|
|
12493
12621
|
var TypeBinaryOp$$ = [TypeBinaryOp$0, TypeBinaryOp$1];
|
|
@@ -12504,15 +12632,20 @@ ${input.slice(result.pos)}
|
|
|
12504
12632
|
function FunctionType(ctx, state) {
|
|
12505
12633
|
return $EVENT(ctx, state, "FunctionType", FunctionType$0);
|
|
12506
12634
|
}
|
|
12507
|
-
var TypeArrowFunction$0 = $TV($C($EXPECT($L9, 'TypeArrowFunction "=>"'), $EXPECT($L10, 'TypeArrowFunction "\u21D2"'), $EXPECT($
|
|
12635
|
+
var TypeArrowFunction$0 = $TV($C($EXPECT($L9, 'TypeArrowFunction "=>"'), $EXPECT($L10, 'TypeArrowFunction "\u21D2"'), $EXPECT($L24, 'TypeArrowFunction "->"'), $EXPECT($L25, 'TypeArrowFunction "\u2192"')), function($skip, $loc, $0, $1) {
|
|
12508
12636
|
return { $loc, token: "=>" };
|
|
12509
12637
|
});
|
|
12510
12638
|
function TypeArrowFunction(ctx, state) {
|
|
12511
12639
|
return $EVENT(ctx, state, "TypeArrowFunction", TypeArrowFunction$0);
|
|
12512
12640
|
}
|
|
12513
|
-
var TypeArguments$0 = $TS($S(
|
|
12641
|
+
var TypeArguments$0 = $TS($S(OpenAngleBracket, $P(TypeArgument), __, CloseAngleBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
12514
12642
|
var args = $2;
|
|
12515
|
-
return {
|
|
12643
|
+
return {
|
|
12644
|
+
type: "TypeArguments",
|
|
12645
|
+
ts: true,
|
|
12646
|
+
types: args.map(([, t]) => t),
|
|
12647
|
+
children: $0
|
|
12648
|
+
};
|
|
12516
12649
|
});
|
|
12517
12650
|
function TypeArguments(ctx, state) {
|
|
12518
12651
|
return $EVENT(ctx, state, "TypeArguments", TypeArguments$0);
|
|
@@ -12525,7 +12658,7 @@ ${input.slice(result.pos)}
|
|
|
12525
12658
|
function TypeArgumentDelimiter(ctx, state) {
|
|
12526
12659
|
return $EVENT(ctx, state, "TypeArgumentDelimiter", TypeArgumentDelimiter$0);
|
|
12527
12660
|
}
|
|
12528
|
-
var TypeParameters$0 = $TS($S($E(_),
|
|
12661
|
+
var TypeParameters$0 = $TS($S($E(_), OpenAngleBracket, $P(TypeParameter), __, CloseAngleBracket), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
12529
12662
|
var parameters = $3;
|
|
12530
12663
|
return {
|
|
12531
12664
|
type: "TypeParameters",
|
|
@@ -12537,11 +12670,11 @@ ${input.slice(result.pos)}
|
|
|
12537
12670
|
function TypeParameters(ctx, state) {
|
|
12538
12671
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
12539
12672
|
}
|
|
12540
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
12673
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L149, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
12541
12674
|
function TypeParameter(ctx, state) {
|
|
12542
12675
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
12543
12676
|
}
|
|
12544
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
12677
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L138, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
12545
12678
|
function TypeConstraint(ctx, state) {
|
|
12546
12679
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
12547
12680
|
}
|
|
@@ -12550,7 +12683,7 @@ ${input.slice(result.pos)}
|
|
|
12550
12683
|
return $EVENT(ctx, state, "TypeInitializer", TypeInitializer$0);
|
|
12551
12684
|
}
|
|
12552
12685
|
var TypeParameterDelimiter$0 = $S($E(_), Comma);
|
|
12553
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
12686
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L34, 'TypeParameterDelimiter ">"')));
|
|
12554
12687
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
12555
12688
|
return value[1];
|
|
12556
12689
|
});
|
|
@@ -12558,21 +12691,21 @@ ${input.slice(result.pos)}
|
|
|
12558
12691
|
function TypeParameterDelimiter(ctx, state) {
|
|
12559
12692
|
return $EVENT_C(ctx, state, "TypeParameterDelimiter", TypeParameterDelimiter$$);
|
|
12560
12693
|
}
|
|
12561
|
-
var ThisType$0 = $T($S($C(This, AtThis), Colon, Type, ParameterElementDelimiter), function(value) {
|
|
12694
|
+
var ThisType$0 = $T($S($E(_), $C(This, AtThis), Colon, Type, ParameterElementDelimiter), function(value) {
|
|
12562
12695
|
return { "type": "ThisType", "ts": true, "children": value };
|
|
12563
12696
|
});
|
|
12564
12697
|
function ThisType(ctx, state) {
|
|
12565
12698
|
return $EVENT(ctx, state, "ThisType", ThisType$0);
|
|
12566
12699
|
}
|
|
12567
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
12700
|
+
var Shebang$0 = $S($R$0($EXPECT($R79, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
12568
12701
|
function Shebang(ctx, state) {
|
|
12569
12702
|
return $EVENT(ctx, state, "Shebang", Shebang$0);
|
|
12570
12703
|
}
|
|
12571
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
12704
|
+
var CivetPrologue$0 = $T($S($EXPECT($R80, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, SimpleStatementDelimiter, $EXPECT($R81, "CivetPrologue /[ \\t]*/"), $C(EOL, $Y(RestOfLine))), function(value) {
|
|
12572
12705
|
var content = value[2];
|
|
12573
12706
|
return content;
|
|
12574
12707
|
});
|
|
12575
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
12708
|
+
var CivetPrologue$1 = $T($S($EXPECT($R80, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, SimpleStatementDelimiter, $EXPECT($R81, "CivetPrologue /[ \\t]*/"), $C(EOL, $Y(RestOfLine))), function(value) {
|
|
12576
12709
|
var content = value[2];
|
|
12577
12710
|
return content;
|
|
12578
12711
|
});
|
|
@@ -12580,7 +12713,7 @@ ${input.slice(result.pos)}
|
|
|
12580
12713
|
function CivetPrologue(ctx, state) {
|
|
12581
12714
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
12582
12715
|
}
|
|
12583
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($
|
|
12716
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R82, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
12584
12717
|
var options = $3;
|
|
12585
12718
|
return {
|
|
12586
12719
|
type: "CivetPrologue",
|
|
@@ -12591,7 +12724,7 @@ ${input.slice(result.pos)}
|
|
|
12591
12724
|
function CivetPrologueContent(ctx, state) {
|
|
12592
12725
|
return $EVENT(ctx, state, "CivetPrologueContent", CivetPrologueContent$0);
|
|
12593
12726
|
}
|
|
12594
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
12727
|
+
var CivetOption$0 = $TR($EXPECT($R83, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12595
12728
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
12596
12729
|
if (l)
|
|
12597
12730
|
return l.toUpperCase();
|
|
@@ -12608,11 +12741,11 @@ ${input.slice(result.pos)}
|
|
|
12608
12741
|
function CivetOption(ctx, state) {
|
|
12609
12742
|
return $EVENT(ctx, state, "CivetOption", CivetOption$0);
|
|
12610
12743
|
}
|
|
12611
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
12744
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R80, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
12612
12745
|
function UnknownPrologue(ctx, state) {
|
|
12613
12746
|
return $EVENT(ctx, state, "UnknownPrologue", UnknownPrologue$0);
|
|
12614
12747
|
}
|
|
12615
|
-
var TripleSlashDirective$0 = $S($R$0($EXPECT($
|
|
12748
|
+
var TripleSlashDirective$0 = $S($R$0($EXPECT($R84, "TripleSlashDirective /\\/\\/\\/[^\\r\\n]*/")), $E(EOS));
|
|
12616
12749
|
function TripleSlashDirective(ctx, state) {
|
|
12617
12750
|
return $EVENT(ctx, state, "TripleSlashDirective", TripleSlashDirective$0);
|
|
12618
12751
|
}
|
|
@@ -12626,13 +12759,13 @@ ${input.slice(result.pos)}
|
|
|
12626
12759
|
function PrologueString(ctx, state) {
|
|
12627
12760
|
return $EVENT_C(ctx, state, "PrologueString", PrologueString$$);
|
|
12628
12761
|
}
|
|
12629
|
-
var EOS$0 = $T($S($EXPECT($
|
|
12762
|
+
var EOS$0 = $T($S($EXPECT($R85, "EOS /(?=[ \\t\\r\\n\\/#]|$)/"), $P(RestOfLine)), function(value) {
|
|
12630
12763
|
return value[1];
|
|
12631
12764
|
});
|
|
12632
12765
|
function EOS(ctx, state) {
|
|
12633
12766
|
return $EVENT(ctx, state, "EOS", EOS$0);
|
|
12634
12767
|
}
|
|
12635
|
-
var EOL$0 = $TR($EXPECT($
|
|
12768
|
+
var EOL$0 = $TR($EXPECT($R86, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12636
12769
|
return { $loc, token: $0 };
|
|
12637
12770
|
});
|
|
12638
12771
|
function EOL(ctx, state) {
|
|
@@ -13152,7 +13285,7 @@ ${input.slice(result.pos)}
|
|
|
13152
13285
|
function Init(ctx, state) {
|
|
13153
13286
|
return $EVENT(ctx, state, "Init", Init$0);
|
|
13154
13287
|
}
|
|
13155
|
-
var Indent$0 = $TR($EXPECT($
|
|
13288
|
+
var Indent$0 = $TR($EXPECT($R81, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
13156
13289
|
const level = getIndentLevel($0, module.config.tab);
|
|
13157
13290
|
return {
|
|
13158
13291
|
$loc,
|
|
@@ -13334,6 +13467,7 @@ ${input.slice(result.pos)}
|
|
|
13334
13467
|
exports.ClassHeritage = ClassHeritage;
|
|
13335
13468
|
exports.ExtendsClause = ExtendsClause;
|
|
13336
13469
|
exports.ExtendsToken = ExtendsToken;
|
|
13470
|
+
exports.ExtendsShorthand = ExtendsShorthand;
|
|
13337
13471
|
exports.ExtendsTarget = ExtendsTarget;
|
|
13338
13472
|
exports.ImplementsClause = ImplementsClause;
|
|
13339
13473
|
exports.ImplementsToken = ImplementsToken;
|
|
@@ -13379,6 +13513,10 @@ ${input.slice(result.pos)}
|
|
|
13379
13513
|
exports.ShortArrowParameters = ShortArrowParameters;
|
|
13380
13514
|
exports.ArrowParameters = ArrowParameters;
|
|
13381
13515
|
exports.NonEmptyParameters = NonEmptyParameters;
|
|
13516
|
+
exports.ParameterList = ParameterList;
|
|
13517
|
+
exports.NestedParameterList = NestedParameterList;
|
|
13518
|
+
exports.NestedParameter = NestedParameter;
|
|
13519
|
+
exports.Parameter = Parameter;
|
|
13382
13520
|
exports.FunctionRestParameter = FunctionRestParameter;
|
|
13383
13521
|
exports.ParameterElement = ParameterElement;
|
|
13384
13522
|
exports.ParameterElementDelimiter = ParameterElementDelimiter;
|
|
@@ -13570,6 +13708,7 @@ ${input.slice(result.pos)}
|
|
|
13570
13708
|
exports.DeclarationCondition = DeclarationCondition;
|
|
13571
13709
|
exports.ExpressionWithIndentedApplicationForbidden = ExpressionWithIndentedApplicationForbidden;
|
|
13572
13710
|
exports.ExpressionWithObjectApplicationForbidden = ExpressionWithObjectApplicationForbidden;
|
|
13711
|
+
exports.LeftHandSideExpressionWithObjectApplicationForbidden = LeftHandSideExpressionWithObjectApplicationForbidden;
|
|
13573
13712
|
exports.ForbidClassImplicitCall = ForbidClassImplicitCall;
|
|
13574
13713
|
exports.AllowClassImplicitCall = AllowClassImplicitCall;
|
|
13575
13714
|
exports.RestoreClassImplicitCall = RestoreClassImplicitCall;
|
|
@@ -13705,6 +13844,7 @@ ${input.slice(result.pos)}
|
|
|
13705
13844
|
exports.Case = Case;
|
|
13706
13845
|
exports.Catch = Catch;
|
|
13707
13846
|
exports.Class = Class;
|
|
13847
|
+
exports.CloseAngleBracket = CloseAngleBracket;
|
|
13708
13848
|
exports.CloseBrace = CloseBrace;
|
|
13709
13849
|
exports.CloseBracket = CloseBracket;
|
|
13710
13850
|
exports.CloseParen = CloseParen;
|