@danielx/civet 0.6.52 → 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 +483 -470
- package/dist/esbuild.js +107 -69
- package/dist/main.js +483 -470
- package/dist/main.mjs +483 -470
- 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/main.js
CHANGED
|
@@ -3830,6 +3830,7 @@ var require_parser = __commonJS({
|
|
|
3830
3830
|
ClassHeritage,
|
|
3831
3831
|
ExtendsClause,
|
|
3832
3832
|
ExtendsToken,
|
|
3833
|
+
ExtendsShorthand,
|
|
3833
3834
|
ExtendsTarget,
|
|
3834
3835
|
ImplementsClause,
|
|
3835
3836
|
ImplementsToken,
|
|
@@ -4070,6 +4071,7 @@ var require_parser = __commonJS({
|
|
|
4070
4071
|
DeclarationCondition,
|
|
4071
4072
|
ExpressionWithIndentedApplicationForbidden,
|
|
4072
4073
|
ExpressionWithObjectApplicationForbidden,
|
|
4074
|
+
LeftHandSideExpressionWithObjectApplicationForbidden,
|
|
4073
4075
|
ForbidClassImplicitCall,
|
|
4074
4076
|
AllowClassImplicitCall,
|
|
4075
4077
|
RestoreClassImplicitCall,
|
|
@@ -4475,148 +4477,148 @@ var require_parser = __commonJS({
|
|
|
4475
4477
|
var $L10 = $L("\u21D2");
|
|
4476
4478
|
var $L11 = $L(":");
|
|
4477
4479
|
var $L12 = $L(" ");
|
|
4478
|
-
var $L13 = $L("
|
|
4479
|
-
var $L14 = $L("
|
|
4480
|
-
var $L15 = $L("
|
|
4481
|
-
var $L16 = $L("
|
|
4482
|
-
var $L17 = $L("
|
|
4483
|
-
var $L18 = $L("
|
|
4484
|
-
var $L19 = $L("
|
|
4485
|
-
var $L20 = $L("
|
|
4486
|
-
var $L21 = $L("
|
|
4487
|
-
var $L22 = $L("
|
|
4488
|
-
var $L23 = $L("
|
|
4489
|
-
var $L24 = $L("
|
|
4490
|
-
var $L25 = $L("
|
|
4491
|
-
var $L26 = $L("
|
|
4492
|
-
var $L27 = $L("
|
|
4493
|
-
var $L28 = $L("
|
|
4494
|
-
var $L29 = $L("
|
|
4495
|
-
var $L30 = $L("
|
|
4496
|
-
var $L31 = $L("
|
|
4497
|
-
var $L32 = $L("
|
|
4498
|
-
var $L33 = $L("
|
|
4499
|
-
var $L34 = $L("
|
|
4500
|
-
var $L35 = $L("
|
|
4501
|
-
var $L36 = $L("
|
|
4502
|
-
var $L37 = $L("
|
|
4503
|
-
var $L38 = $L("
|
|
4504
|
-
var $L39 = $L("
|
|
4505
|
-
var $L40 = $L("
|
|
4506
|
-
var $L41 = $L("
|
|
4507
|
-
var $L42 = $L("
|
|
4508
|
-
var $L43 = $L("
|
|
4509
|
-
var $L44 = $L("
|
|
4510
|
-
var $L45 = $L("
|
|
4511
|
-
var $L46 = $L("
|
|
4512
|
-
var $L47 = $L("
|
|
4513
|
-
var $L48 = $L("
|
|
4514
|
-
var $L49 = $L("
|
|
4515
|
-
var $L50 = $L("
|
|
4516
|
-
var $L51 = $L("
|
|
4517
|
-
var $L52 = $L("
|
|
4518
|
-
var $L53 = $L("
|
|
4519
|
-
var $L54 = $L("
|
|
4520
|
-
var $L55 = $L("
|
|
4521
|
-
var $L56 = $L("
|
|
4522
|
-
var $L57 = $L("
|
|
4523
|
-
var $L58 = $L("
|
|
4524
|
-
var $L59 = $L("
|
|
4525
|
-
var $L60 = $L("
|
|
4526
|
-
var $L61 = $L("
|
|
4527
|
-
var $L62 = $L("
|
|
4528
|
-
var $L63 = $L("
|
|
4529
|
-
var $L64 = $L("
|
|
4530
|
-
var $L65 = $L("
|
|
4531
|
-
var $L66 = $L("
|
|
4532
|
-
var $L67 = $L("
|
|
4533
|
-
var $L68 = $L("
|
|
4534
|
-
var $L69 = $L("
|
|
4535
|
-
var $L70 = $L("
|
|
4536
|
-
var $L71 = $L("
|
|
4537
|
-
var $L72 = $L("
|
|
4538
|
-
var $L73 = $L("
|
|
4539
|
-
var $L74 = $L("
|
|
4540
|
-
var $L75 = $L("
|
|
4541
|
-
var $L76 = $L("
|
|
4542
|
-
var $L77 = $L("
|
|
4543
|
-
var $L78 = $L("\
|
|
4544
|
-
var $L79 = $L("
|
|
4545
|
-
var $L80 = $L("
|
|
4546
|
-
var $L81 = $L("\
|
|
4547
|
-
var $L82 = $L("
|
|
4548
|
-
var $L83 = $L("
|
|
4549
|
-
var $L84 = $L("
|
|
4550
|
-
var $L85 = $L("
|
|
4551
|
-
var $L86 = $L("
|
|
4552
|
-
var $L87 = $L("
|
|
4553
|
-
var $L88 = $L("
|
|
4554
|
-
var $L89 = $L("
|
|
4555
|
-
var $L90 = $L("
|
|
4556
|
-
var $L91 = $L("
|
|
4557
|
-
var $L92 = $L("
|
|
4558
|
-
var $L93 = $L("
|
|
4559
|
-
var $L94 = $L("\
|
|
4560
|
-
var $L95 = $L("\
|
|
4561
|
-
var $L96 = $L("\
|
|
4562
|
-
var $L97 = $L("
|
|
4563
|
-
var $L98 = $L("
|
|
4564
|
-
var $L99 = $L("
|
|
4565
|
-
var $L100 = $L("
|
|
4566
|
-
var $L101 = $L("
|
|
4567
|
-
var $L102 = $L("
|
|
4568
|
-
var $L103 = $L("
|
|
4569
|
-
var $L104 = $L("
|
|
4570
|
-
var $L105 = $L("
|
|
4571
|
-
var $L106 = $L("
|
|
4572
|
-
var $L107 = $L("
|
|
4573
|
-
var $L108 = $L("
|
|
4574
|
-
var $L109 = $L("
|
|
4575
|
-
var $L110 = $L("
|
|
4576
|
-
var $L111 = $L("
|
|
4577
|
-
var $L112 = $L("
|
|
4578
|
-
var $L113 = $L("
|
|
4579
|
-
var $L114 = $L("
|
|
4580
|
-
var $L115 = $L("
|
|
4581
|
-
var $L116 = $L("
|
|
4582
|
-
var $L117 = $L("
|
|
4583
|
-
var $L118 = $L("
|
|
4584
|
-
var $L119 = $L("
|
|
4585
|
-
var $L120 = $L("
|
|
4586
|
-
var $L121 = $L("
|
|
4587
|
-
var $L122 = $L("
|
|
4588
|
-
var $L123 = $L("
|
|
4589
|
-
var $L124 = $L("
|
|
4590
|
-
var $L125 = $L("
|
|
4591
|
-
var $L126 = $L("
|
|
4592
|
-
var $L127 = $L("
|
|
4593
|
-
var $L128 = $L("
|
|
4594
|
-
var $L129 = $L("
|
|
4595
|
-
var $L130 = $L("
|
|
4596
|
-
var $L131 = $L("
|
|
4597
|
-
var $L132 = $L("
|
|
4598
|
-
var $L133 = $L(
|
|
4599
|
-
var $L134 = $L("
|
|
4600
|
-
var $L135 = $L("
|
|
4601
|
-
var $L136 = $L("
|
|
4602
|
-
var $L137 = $L("
|
|
4603
|
-
var $L138 = $L("
|
|
4604
|
-
var $L139 = $L("
|
|
4605
|
-
var $L140 = $L("
|
|
4606
|
-
var $L141 = $L("
|
|
4607
|
-
var $L142 = $L("
|
|
4608
|
-
var $L143 = $L("
|
|
4609
|
-
var $L144 = $L("
|
|
4610
|
-
var $L145 = $L("
|
|
4611
|
-
var $L146 = $L("
|
|
4612
|
-
var $L147 = $L("
|
|
4613
|
-
var $L148 = $L("
|
|
4614
|
-
var $L149 = $L("
|
|
4615
|
-
var $L150 = $L("
|
|
4616
|
-
var $L151 = $L("
|
|
4617
|
-
var $L152 = $L("
|
|
4618
|
-
var $L153 = $L("
|
|
4619
|
-
var $L154 = $L("
|
|
4480
|
+
var $L13 = $L("<");
|
|
4481
|
+
var $L14 = $L("implements");
|
|
4482
|
+
var $L15 = $L("<:");
|
|
4483
|
+
var $L16 = $L("import");
|
|
4484
|
+
var $L17 = $L("!");
|
|
4485
|
+
var $L18 = $L("^");
|
|
4486
|
+
var $L19 = $L("-");
|
|
4487
|
+
var $L20 = $L("import.meta");
|
|
4488
|
+
var $L21 = $L("return.value");
|
|
4489
|
+
var $L22 = $L(",");
|
|
4490
|
+
var $L23 = $L("(&)");
|
|
4491
|
+
var $L24 = $L("->");
|
|
4492
|
+
var $L25 = $L("\u2192");
|
|
4493
|
+
var $L26 = $L("}");
|
|
4494
|
+
var $L27 = $L("null");
|
|
4495
|
+
var $L28 = $L("true");
|
|
4496
|
+
var $L29 = $L("false");
|
|
4497
|
+
var $L30 = $L("yes");
|
|
4498
|
+
var $L31 = $L("on");
|
|
4499
|
+
var $L32 = $L("no");
|
|
4500
|
+
var $L33 = $L("off");
|
|
4501
|
+
var $L34 = $L(">");
|
|
4502
|
+
var $L35 = $L("]");
|
|
4503
|
+
var $L36 = $L("**=");
|
|
4504
|
+
var $L37 = $L("*=");
|
|
4505
|
+
var $L38 = $L("/=");
|
|
4506
|
+
var $L39 = $L("%=");
|
|
4507
|
+
var $L40 = $L("+=");
|
|
4508
|
+
var $L41 = $L("-=");
|
|
4509
|
+
var $L42 = $L("<<=");
|
|
4510
|
+
var $L43 = $L(">>>=");
|
|
4511
|
+
var $L44 = $L(">>=");
|
|
4512
|
+
var $L45 = $L("&&=");
|
|
4513
|
+
var $L46 = $L("&=");
|
|
4514
|
+
var $L47 = $L("^=");
|
|
4515
|
+
var $L48 = $L("||=");
|
|
4516
|
+
var $L49 = $L("|=");
|
|
4517
|
+
var $L50 = $L("??=");
|
|
4518
|
+
var $L51 = $L("?=");
|
|
4519
|
+
var $L52 = $L("and=");
|
|
4520
|
+
var $L53 = $L("or=");
|
|
4521
|
+
var $L54 = $L("**");
|
|
4522
|
+
var $L55 = $L("*");
|
|
4523
|
+
var $L56 = $L("/");
|
|
4524
|
+
var $L57 = $L("%%");
|
|
4525
|
+
var $L58 = $L("%");
|
|
4526
|
+
var $L59 = $L("+");
|
|
4527
|
+
var $L60 = $L("<=");
|
|
4528
|
+
var $L61 = $L("\u2264");
|
|
4529
|
+
var $L62 = $L(">=");
|
|
4530
|
+
var $L63 = $L("\u2265");
|
|
4531
|
+
var $L64 = $L("<?");
|
|
4532
|
+
var $L65 = $L("!<?");
|
|
4533
|
+
var $L66 = $L("<<");
|
|
4534
|
+
var $L67 = $L("\xAB");
|
|
4535
|
+
var $L68 = $L(">>>");
|
|
4536
|
+
var $L69 = $L("\u22D9");
|
|
4537
|
+
var $L70 = $L(">>");
|
|
4538
|
+
var $L71 = $L("\xBB");
|
|
4539
|
+
var $L72 = $L("!==");
|
|
4540
|
+
var $L73 = $L("\u2262");
|
|
4541
|
+
var $L74 = $L("!=");
|
|
4542
|
+
var $L75 = $L("\u2260");
|
|
4543
|
+
var $L76 = $L("isnt");
|
|
4544
|
+
var $L77 = $L("===");
|
|
4545
|
+
var $L78 = $L("\u2263");
|
|
4546
|
+
var $L79 = $L("\u2A76");
|
|
4547
|
+
var $L80 = $L("==");
|
|
4548
|
+
var $L81 = $L("\u2261");
|
|
4549
|
+
var $L82 = $L("\u2A75");
|
|
4550
|
+
var $L83 = $L("and");
|
|
4551
|
+
var $L84 = $L("&&");
|
|
4552
|
+
var $L85 = $L("or");
|
|
4553
|
+
var $L86 = $L("||");
|
|
4554
|
+
var $L87 = $L("\u2016");
|
|
4555
|
+
var $L88 = $L("^^");
|
|
4556
|
+
var $L89 = $L("xor");
|
|
4557
|
+
var $L90 = $L("xnor");
|
|
4558
|
+
var $L91 = $L("??");
|
|
4559
|
+
var $L92 = $L("\u2047");
|
|
4560
|
+
var $L93 = $L("instanceof");
|
|
4561
|
+
var $L94 = $L("\u2208");
|
|
4562
|
+
var $L95 = $L("\u220B");
|
|
4563
|
+
var $L96 = $L("\u220C");
|
|
4564
|
+
var $L97 = $L("\u2209");
|
|
4565
|
+
var $L98 = $L("&");
|
|
4566
|
+
var $L99 = $L("|");
|
|
4567
|
+
var $L100 = $L(";");
|
|
4568
|
+
var $L101 = $L("$:");
|
|
4569
|
+
var $L102 = $L("break");
|
|
4570
|
+
var $L103 = $L("continue");
|
|
4571
|
+
var $L104 = $L("debugger");
|
|
4572
|
+
var $L105 = $L("assert");
|
|
4573
|
+
var $L106 = $L(":=");
|
|
4574
|
+
var $L107 = $L("\u2254");
|
|
4575
|
+
var $L108 = $L(".=");
|
|
4576
|
+
var $L109 = $L("/*");
|
|
4577
|
+
var $L110 = $L("*/");
|
|
4578
|
+
var $L111 = $L("\\");
|
|
4579
|
+
var $L112 = $L(")");
|
|
4580
|
+
var $L113 = $L("abstract");
|
|
4581
|
+
var $L114 = $L("as");
|
|
4582
|
+
var $L115 = $L("@");
|
|
4583
|
+
var $L116 = $L("@@");
|
|
4584
|
+
var $L117 = $L("async");
|
|
4585
|
+
var $L118 = $L("await");
|
|
4586
|
+
var $L119 = $L("`");
|
|
4587
|
+
var $L120 = $L("by");
|
|
4588
|
+
var $L121 = $L("case");
|
|
4589
|
+
var $L122 = $L("catch");
|
|
4590
|
+
var $L123 = $L("class");
|
|
4591
|
+
var $L124 = $L("#{");
|
|
4592
|
+
var $L125 = $L("declare");
|
|
4593
|
+
var $L126 = $L("default");
|
|
4594
|
+
var $L127 = $L("delete");
|
|
4595
|
+
var $L128 = $L("do");
|
|
4596
|
+
var $L129 = $L("..");
|
|
4597
|
+
var $L130 = $L("\u2025");
|
|
4598
|
+
var $L131 = $L("...");
|
|
4599
|
+
var $L132 = $L("\u2026");
|
|
4600
|
+
var $L133 = $L("::");
|
|
4601
|
+
var $L134 = $L('"');
|
|
4602
|
+
var $L135 = $L("each");
|
|
4603
|
+
var $L136 = $L("else");
|
|
4604
|
+
var $L137 = $L("export");
|
|
4605
|
+
var $L138 = $L("extends");
|
|
4606
|
+
var $L139 = $L("finally");
|
|
4607
|
+
var $L140 = $L("for");
|
|
4608
|
+
var $L141 = $L("from");
|
|
4609
|
+
var $L142 = $L("function");
|
|
4610
|
+
var $L143 = $L("get");
|
|
4611
|
+
var $L144 = $L("set");
|
|
4612
|
+
var $L145 = $L("#");
|
|
4613
|
+
var $L146 = $L("if");
|
|
4614
|
+
var $L147 = $L("in");
|
|
4615
|
+
var $L148 = $L("let");
|
|
4616
|
+
var $L149 = $L("const");
|
|
4617
|
+
var $L150 = $L("is");
|
|
4618
|
+
var $L151 = $L("loop");
|
|
4619
|
+
var $L152 = $L("new");
|
|
4620
|
+
var $L153 = $L("not");
|
|
4621
|
+
var $L154 = $L("of");
|
|
4620
4622
|
var $L155 = $L("[");
|
|
4621
4623
|
var $L156 = $L("operator");
|
|
4622
4624
|
var $L157 = $L("own");
|
|
@@ -4690,77 +4692,76 @@ var require_parser = __commonJS({
|
|
|
4690
4692
|
var $R14 = $R(new RegExp("(?=\\[)", "suy"));
|
|
4691
4693
|
var $R15 = $R(new RegExp("[!+-]", "suy"));
|
|
4692
4694
|
var $R16 = $R(new RegExp("(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>+-])", "suy"));
|
|
4693
|
-
var $R17 = $R(new RegExp("
|
|
4694
|
-
var $R18 = $R(new RegExp("
|
|
4695
|
-
var $R19 = $R(new RegExp("(
|
|
4696
|
-
var $R20 = $R(new RegExp("(?=
|
|
4697
|
-
var $R21 = $R(new RegExp("(?=
|
|
4698
|
-
var $R22 = $R(new RegExp("
|
|
4699
|
-
var $R23 = $R(new RegExp(
|
|
4700
|
-
var $R24 = $R(new RegExp("(
|
|
4701
|
-
var $R25 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)
|
|
4702
|
-
var $R26 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(
|
|
4703
|
-
var $R27 = $R(new RegExp("(
|
|
4704
|
-
var $R28 = $R(new RegExp("(
|
|
4705
|
-
var $R29 = $R(new RegExp("
|
|
4706
|
-
var $R30 = $R(new RegExp("0[
|
|
4707
|
-
var $R31 = $R(new RegExp("0[
|
|
4708
|
-
var $R32 = $R(new RegExp("
|
|
4709
|
-
var $R33 = $R(new RegExp("(
|
|
4710
|
-
var $R34 = $R(new RegExp(
|
|
4711
|
-
var $R35 = $R(new RegExp(
|
|
4712
|
-
var $R36 = $R(new RegExp("(
|
|
4713
|
-
var $R37 = $R(new RegExp(
|
|
4714
|
-
var $R38 = $R(new RegExp(
|
|
4715
|
-
var $R39 = $R(new RegExp(
|
|
4716
|
-
var $R40 = $R(new RegExp("(
|
|
4717
|
-
var $R41 = $R(new RegExp("
|
|
4718
|
-
var $R42 = $R(new RegExp("
|
|
4719
|
-
var $R43 = $R(new RegExp("
|
|
4720
|
-
var $R44 = $R(new RegExp("[
|
|
4721
|
-
var $R45 = $R(new RegExp("[
|
|
4722
|
-
var $R46 = $R(new RegExp("(
|
|
4723
|
-
var $R47 = $R(new RegExp("(
|
|
4724
|
-
var $R48 = $R(new RegExp("(
|
|
4725
|
-
var $R49 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
4726
|
-
var $R50 = $R(new RegExp("(
|
|
4727
|
-
var $R51 = $R(new RegExp("(?:
|
|
4728
|
-
var $R52 = $R(new RegExp("(?:
|
|
4729
|
-
var $R53 = $R(new RegExp("(?:
|
|
4730
|
-
var $R54 = $R(new RegExp("(?:
|
|
4731
|
-
var $R55 = $R(new RegExp("(
|
|
4732
|
-
var $R56 = $R(new RegExp("(
|
|
4733
|
-
var $R57 = $R(new RegExp("
|
|
4734
|
-
var $R58 = $R(new RegExp("
|
|
4735
|
-
var $R59 = $R(new RegExp("
|
|
4736
|
-
var $R60 = $R(new RegExp("
|
|
4737
|
-
var $R61 = $R(new RegExp("
|
|
4738
|
-
var $R62 = $R(new RegExp("
|
|
4739
|
-
var $R63 = $R(new RegExp("
|
|
4740
|
-
var $R64 = $R(new RegExp("
|
|
4741
|
-
var $R65 = $R(new RegExp("(
|
|
4742
|
-
var $R66 = $R(new RegExp("
|
|
4743
|
-
var $R67 = $R(new RegExp("
|
|
4744
|
-
var $R68 = $R(new RegExp("
|
|
4745
|
-
var $R69 = $R(new RegExp("(
|
|
4746
|
-
var $R70 = $R(new RegExp("
|
|
4747
|
-
var $R71 = $R(new RegExp("[\\
|
|
4748
|
-
var $R72 = $R(new RegExp("
|
|
4749
|
-
var $R73 = $R(new RegExp(
|
|
4750
|
-
var $R74 = $R(new RegExp("[
|
|
4751
|
-
var $R75 = $R(new RegExp("[
|
|
4752
|
-
var $R76 = $R(new RegExp("
|
|
4753
|
-
var $R77 = $R(new RegExp("[
|
|
4754
|
-
var $R78 = $R(new RegExp("[+-]
|
|
4755
|
-
var $R79 = $R(new RegExp("[
|
|
4756
|
-
var $R80 = $R(new RegExp("
|
|
4757
|
-
var $R81 = $R(new RegExp("[\\t
|
|
4758
|
-
var $R82 = $R(new RegExp("[
|
|
4759
|
-
var $R83 = $R(new RegExp("[\\s]*", "suy"));
|
|
4760
|
-
var $R84 = $R(new RegExp("
|
|
4761
|
-
var $R85 = $R(new RegExp("
|
|
4762
|
-
var $R86 = $R(new RegExp("
|
|
4763
|
-
var $R87 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
4695
|
+
var $R17 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
4696
|
+
var $R18 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*(&|\\.[^0-9]))", "suy"));
|
|
4697
|
+
var $R19 = $R(new RegExp("(?=for|if|loop|unless|until|while)", "suy"));
|
|
4698
|
+
var $R20 = $R(new RegExp("(?=loop|do|for|until|while)", "suy"));
|
|
4699
|
+
var $R21 = $R(new RegExp("(?=[\\s\\),])", "suy"));
|
|
4700
|
+
var $R22 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
4701
|
+
var $R23 = $R(new RegExp("(?=[0-9.])", "suy"));
|
|
4702
|
+
var $R24 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
4703
|
+
var $R25 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
4704
|
+
var $R26 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
4705
|
+
var $R27 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4706
|
+
var $R28 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
4707
|
+
var $R29 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
4708
|
+
var $R30 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
4709
|
+
var $R31 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
4710
|
+
var $R32 = $R(new RegExp("(?=[0-9])", "suy"));
|
|
4711
|
+
var $R33 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4712
|
+
var $R34 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
4713
|
+
var $R35 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
4714
|
+
var $R36 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
4715
|
+
var $R37 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
4716
|
+
var $R38 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
4717
|
+
var $R39 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
4718
|
+
var $R40 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
4719
|
+
var $R41 = $R(new RegExp("[\\s]+", "suy"));
|
|
4720
|
+
var $R42 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
4721
|
+
var $R43 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
4722
|
+
var $R44 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
4723
|
+
var $R45 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
4724
|
+
var $R46 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
4725
|
+
var $R47 = $R(new RegExp("(?=[`'\"])", "suy"));
|
|
4726
|
+
var $R48 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
4727
|
+
var $R49 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
4728
|
+
var $R50 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
4729
|
+
var $R51 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
4730
|
+
var $R52 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
4731
|
+
var $R53 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
4732
|
+
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"));
|
|
4733
|
+
var $R55 = $R(new RegExp("(?=\\/|#)", "suy"));
|
|
4734
|
+
var $R56 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
4735
|
+
var $R57 = $R(new RegExp(".", "suy"));
|
|
4736
|
+
var $R58 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
4737
|
+
var $R59 = $R(new RegExp("[^]*?###", "suy"));
|
|
4738
|
+
var $R60 = $R(new RegExp("###(?!#)", "suy"));
|
|
4739
|
+
var $R61 = $R(new RegExp("\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\/", "suy"));
|
|
4740
|
+
var $R62 = $R(new RegExp("(?=[ \\t\\/\\\\])", "suy"));
|
|
4741
|
+
var $R63 = $R(new RegExp("[ \\t]+", "suy"));
|
|
4742
|
+
var $R64 = $R(new RegExp("(?=\\s|\\/|#)", "suy"));
|
|
4743
|
+
var $R65 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
4744
|
+
var $R66 = $R(new RegExp("['\u2019]s", "suy"));
|
|
4745
|
+
var $R67 = $R(new RegExp("\\s", "suy"));
|
|
4746
|
+
var $R68 = $R(new RegExp("(?=[<])", "suy"));
|
|
4747
|
+
var $R69 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
4748
|
+
var $R70 = $R(new RegExp("[\\s>]|\\/>", "suy"));
|
|
4749
|
+
var $R71 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
4750
|
+
var $R72 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
|
|
4751
|
+
var $R73 = $R(new RegExp("[<>]", "suy"));
|
|
4752
|
+
var $R74 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
4753
|
+
var $R75 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
4754
|
+
var $R76 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
4755
|
+
var $R77 = $R(new RegExp("[+-]?", "suy"));
|
|
4756
|
+
var $R78 = $R(new RegExp("[+-]", "suy"));
|
|
4757
|
+
var $R79 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
4758
|
+
var $R80 = $R(new RegExp("[\\t ]*", "suy"));
|
|
4759
|
+
var $R81 = $R(new RegExp("[ \\t]*", "suy"));
|
|
4760
|
+
var $R82 = $R(new RegExp("[\\s]*", "suy"));
|
|
4761
|
+
var $R83 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
4762
|
+
var $R84 = $R(new RegExp("\\/\\/\\/[^\\r\\n]*", "suy"));
|
|
4763
|
+
var $R85 = $R(new RegExp("(?=[ \\t\\r\\n\\/#]|$)", "suy"));
|
|
4764
|
+
var $R86 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
4764
4765
|
var Program$0 = $TS($S(Reset, Init, $E(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
4765
4766
|
var statements = $4;
|
|
4766
4767
|
processProgram({
|
|
@@ -5495,14 +5496,11 @@ var require_parser = __commonJS({
|
|
|
5495
5496
|
function ExtendsClause(ctx, state) {
|
|
5496
5497
|
return $EVENT(ctx, state, "ExtendsClause", ExtendsClause$0);
|
|
5497
5498
|
}
|
|
5498
|
-
var ExtendsToken$0 = $TS($S(Loc, __,
|
|
5499
|
+
var ExtendsToken$0 = $TS($S(Loc, __, ExtendsShorthand, $E($EXPECT($L12, 'ExtendsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5499
5500
|
var l = $1;
|
|
5500
5501
|
var ws = $2;
|
|
5501
|
-
var
|
|
5502
|
-
const children = [
|
|
5503
|
-
...ws,
|
|
5504
|
-
{ ...lt, token: "extends " }
|
|
5505
|
-
];
|
|
5502
|
+
var t = $3;
|
|
5503
|
+
const children = [...ws, t];
|
|
5506
5504
|
if (!ws.length) {
|
|
5507
5505
|
children.unshift({ $loc: l.$loc, token: " " });
|
|
5508
5506
|
}
|
|
@@ -5513,7 +5511,13 @@ var require_parser = __commonJS({
|
|
|
5513
5511
|
function ExtendsToken(ctx, state) {
|
|
5514
5512
|
return $EVENT_C(ctx, state, "ExtendsToken", ExtendsToken$$);
|
|
5515
5513
|
}
|
|
5516
|
-
var
|
|
5514
|
+
var ExtendsShorthand$0 = $TV($EXPECT($L13, 'ExtendsShorthand "<"'), function($skip, $loc, $0, $1) {
|
|
5515
|
+
return { $loc, token: "extends " };
|
|
5516
|
+
});
|
|
5517
|
+
function ExtendsShorthand(ctx, state) {
|
|
5518
|
+
return $EVENT(ctx, state, "ExtendsShorthand", ExtendsShorthand$0);
|
|
5519
|
+
}
|
|
5520
|
+
var ExtendsTarget$0 = $TS($S(LeftHandSideExpressionWithObjectApplicationForbidden, $E(TypeArguments)), function($skip, $loc, $0, $1, $2) {
|
|
5517
5521
|
var exp = $1;
|
|
5518
5522
|
var ta = $2;
|
|
5519
5523
|
exp = makeLeftHandSideExpression(exp);
|
|
@@ -5543,7 +5547,7 @@ var require_parser = __commonJS({
|
|
|
5543
5547
|
}
|
|
5544
5548
|
return { children };
|
|
5545
5549
|
});
|
|
5546
|
-
var ImplementsToken$1 = $TS($S(__, $EXPECT($
|
|
5550
|
+
var ImplementsToken$1 = $TS($S(__, $EXPECT($L14, 'ImplementsToken "implements"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
5547
5551
|
$2 = { $loc, token: $2 };
|
|
5548
5552
|
return [$1, $2];
|
|
5549
5553
|
});
|
|
@@ -5551,7 +5555,7 @@ var require_parser = __commonJS({
|
|
|
5551
5555
|
function ImplementsToken(ctx, state) {
|
|
5552
5556
|
return $EVENT_C(ctx, state, "ImplementsToken", ImplementsToken$$);
|
|
5553
5557
|
}
|
|
5554
|
-
var ImplementsShorthand$0 = $TV($EXPECT($
|
|
5558
|
+
var ImplementsShorthand$0 = $TV($EXPECT($L15, 'ImplementsShorthand "<:"'), function($skip, $loc, $0, $1) {
|
|
5555
5559
|
return { $loc, token: "implements " };
|
|
5556
5560
|
});
|
|
5557
5561
|
function ImplementsShorthand(ctx, state) {
|
|
@@ -5776,7 +5780,7 @@ var require_parser = __commonJS({
|
|
|
5776
5780
|
children: [$1, ...$2, ...rest.flat()]
|
|
5777
5781
|
});
|
|
5778
5782
|
});
|
|
5779
|
-
var CallExpression$1 = $TS($S($EXPECT($
|
|
5783
|
+
var CallExpression$1 = $TS($S($EXPECT($L16, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5780
5784
|
var rest = $3;
|
|
5781
5785
|
return processCallMemberExpression({
|
|
5782
5786
|
type: "CallExpression",
|
|
@@ -5837,7 +5841,7 @@ var require_parser = __commonJS({
|
|
|
5837
5841
|
function OptionalDot(ctx, state) {
|
|
5838
5842
|
return $EVENT_C(ctx, state, "OptionalDot", OptionalDot$$);
|
|
5839
5843
|
}
|
|
5840
|
-
var NonNullAssertion$0 = $T($S($EXPECT($
|
|
5844
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L17, 'NonNullAssertion "!"'), $N($EXPECT($L18, 'NonNullAssertion "^"'))), function(value) {
|
|
5841
5845
|
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
5842
5846
|
});
|
|
5843
5847
|
function NonNullAssertion(ctx, state) {
|
|
@@ -5934,7 +5938,7 @@ var require_parser = __commonJS({
|
|
|
5934
5938
|
]
|
|
5935
5939
|
};
|
|
5936
5940
|
});
|
|
5937
|
-
var MemberBracketContent$2 = $TS($S(Dot, $EXPECT($
|
|
5941
|
+
var MemberBracketContent$2 = $TS($S(Dot, $EXPECT($L19, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
5938
5942
|
var dot = $1;
|
|
5939
5943
|
var neg = $2;
|
|
5940
5944
|
var num = $3;
|
|
@@ -6092,7 +6096,7 @@ var require_parser = __commonJS({
|
|
|
6092
6096
|
return $EVENT_C(ctx, state, "SuperProperty", SuperProperty$$);
|
|
6093
6097
|
}
|
|
6094
6098
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
6095
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
6099
|
+
var MetaProperty$1 = $TS($S($EXPECT($L20, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6096
6100
|
return { $loc, token: $1 };
|
|
6097
6101
|
});
|
|
6098
6102
|
var MetaProperty$2 = ReturnValue;
|
|
@@ -6100,7 +6104,7 @@ var require_parser = __commonJS({
|
|
|
6100
6104
|
function MetaProperty(ctx, state) {
|
|
6101
6105
|
return $EVENT_C(ctx, state, "MetaProperty", MetaProperty$$);
|
|
6102
6106
|
}
|
|
6103
|
-
var ReturnValue$0 = $TV($C($S($EXPECT($
|
|
6107
|
+
var ReturnValue$0 = $TV($C($S($EXPECT($L21, 'ReturnValue "return.value"'), NonIdContinue), $S(Return, $Y(AfterReturnShorthand))), function($skip, $loc, $0, $1) {
|
|
6104
6108
|
return { type: "ReturnValue", children: [$1[0]] };
|
|
6105
6109
|
});
|
|
6106
6110
|
function ReturnValue(ctx, state) {
|
|
@@ -6355,7 +6359,7 @@ var require_parser = __commonJS({
|
|
|
6355
6359
|
function AtIdentifierRef(ctx, state) {
|
|
6356
6360
|
return $EVENT_C(ctx, state, "AtIdentifierRef", AtIdentifierRef$$);
|
|
6357
6361
|
}
|
|
6358
|
-
var PinPattern$0 = $TS($S($EXPECT($
|
|
6362
|
+
var PinPattern$0 = $TS($S($EXPECT($L18, 'PinPattern "^"'), Identifier), function($skip, $loc, $0, $1, $2) {
|
|
6359
6363
|
var identifier = $2;
|
|
6360
6364
|
return {
|
|
6361
6365
|
type: "PinPattern",
|
|
@@ -6514,7 +6518,7 @@ var require_parser = __commonJS({
|
|
|
6514
6518
|
names: value.names
|
|
6515
6519
|
};
|
|
6516
6520
|
});
|
|
6517
|
-
var BindingProperty$2 = $TS($S($E(_), $E($EXPECT($
|
|
6521
|
+
var BindingProperty$2 = $TS($S($E(_), $E($EXPECT($L18, 'BindingProperty "^"')), BindingIdentifier, $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6518
6522
|
var ws = $1;
|
|
6519
6523
|
var pin = $2;
|
|
6520
6524
|
var binding = $3;
|
|
@@ -6604,7 +6608,7 @@ var require_parser = __commonJS({
|
|
|
6604
6608
|
children: [ws, binding]
|
|
6605
6609
|
};
|
|
6606
6610
|
});
|
|
6607
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
6611
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L22, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
6608
6612
|
return {
|
|
6609
6613
|
children: [{
|
|
6610
6614
|
type: "ElisionElement",
|
|
@@ -6728,7 +6732,7 @@ var require_parser = __commonJS({
|
|
|
6728
6732
|
block
|
|
6729
6733
|
};
|
|
6730
6734
|
});
|
|
6731
|
-
var FunctionExpression$1 = $TV($EXPECT($
|
|
6735
|
+
var FunctionExpression$1 = $TV($EXPECT($L23, 'FunctionExpression "(&)"'), function($skip, $loc, $0, $1) {
|
|
6732
6736
|
const ref = makeRef("$"), body = [ref];
|
|
6733
6737
|
const parameters = {
|
|
6734
6738
|
type: "Parameters",
|
|
@@ -6987,7 +6991,7 @@ var require_parser = __commonJS({
|
|
|
6987
6991
|
function ThinArrowFunction(ctx, state) {
|
|
6988
6992
|
return $EVENT(ctx, state, "ThinArrowFunction", ThinArrowFunction$0);
|
|
6989
6993
|
}
|
|
6990
|
-
var Arrow$0 = $TV($C($EXPECT($
|
|
6994
|
+
var Arrow$0 = $TV($C($EXPECT($L24, 'Arrow "->"'), $EXPECT($L25, 'Arrow "\u2192"')), function($skip, $loc, $0, $1) {
|
|
6991
6995
|
return { $loc, token: "->" };
|
|
6992
6996
|
});
|
|
6993
6997
|
function Arrow(ctx, state) {
|
|
@@ -7265,7 +7269,7 @@ var require_parser = __commonJS({
|
|
|
7265
7269
|
}
|
|
7266
7270
|
var BracedContent$0 = NestedBlockStatements;
|
|
7267
7271
|
var BracedContent$1 = SingleLineStatements;
|
|
7268
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
7272
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L26, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
7269
7273
|
const expressions = [];
|
|
7270
7274
|
return {
|
|
7271
7275
|
type: "BlockStatement",
|
|
@@ -7335,7 +7339,7 @@ var require_parser = __commonJS({
|
|
|
7335
7339
|
function LiteralContent(ctx, state) {
|
|
7336
7340
|
return $EVENT_C(ctx, state, "LiteralContent", LiteralContent$$);
|
|
7337
7341
|
}
|
|
7338
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
7342
|
+
var NullLiteral$0 = $TS($S($EXPECT($L27, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7339
7343
|
return { $loc, token: $1 };
|
|
7340
7344
|
});
|
|
7341
7345
|
function NullLiteral(ctx, state) {
|
|
@@ -7350,17 +7354,17 @@ var require_parser = __commonJS({
|
|
|
7350
7354
|
var _BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
7351
7355
|
return value[1];
|
|
7352
7356
|
});
|
|
7353
|
-
var _BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
7357
|
+
var _BooleanLiteral$1 = $TS($S($C($EXPECT($L28, '_BooleanLiteral "true"'), $EXPECT($L29, '_BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7354
7358
|
return { $loc, token: $1 };
|
|
7355
7359
|
});
|
|
7356
7360
|
var _BooleanLiteral$$ = [_BooleanLiteral$0, _BooleanLiteral$1];
|
|
7357
7361
|
function _BooleanLiteral(ctx, state) {
|
|
7358
7362
|
return $EVENT_C(ctx, state, "_BooleanLiteral", _BooleanLiteral$$);
|
|
7359
7363
|
}
|
|
7360
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
7364
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L30, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L31, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7361
7365
|
return { $loc, token: "true" };
|
|
7362
7366
|
});
|
|
7363
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
7367
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L32, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L33, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7364
7368
|
return { $loc, token: "false" };
|
|
7365
7369
|
});
|
|
7366
7370
|
var CoffeeScriptBooleanLiteral$$ = [CoffeeScriptBooleanLiteral$0, CoffeeScriptBooleanLiteral$1];
|
|
@@ -7392,7 +7396,7 @@ var require_parser = __commonJS({
|
|
|
7392
7396
|
function IdentifierReference(ctx, state) {
|
|
7393
7397
|
return $EVENT(ctx, state, "IdentifierReference", IdentifierReference$0);
|
|
7394
7398
|
}
|
|
7395
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L3, 'UpcomingAssignment "="'), $N($C($EXPECT($L3, 'UpcomingAssignment "="'), $EXPECT($
|
|
7399
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L3, 'UpcomingAssignment "="'), $N($C($EXPECT($L3, 'UpcomingAssignment "="'), $EXPECT($L34, 'UpcomingAssignment ">"')))));
|
|
7396
7400
|
function UpcomingAssignment(ctx, state) {
|
|
7397
7401
|
return $EVENT(ctx, state, "UpcomingAssignment", UpcomingAssignment$0);
|
|
7398
7402
|
}
|
|
@@ -7550,7 +7554,7 @@ var require_parser = __commonJS({
|
|
|
7550
7554
|
return $EVENT(ctx, state, "NestedElement", NestedElement$0);
|
|
7551
7555
|
}
|
|
7552
7556
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
7553
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7557
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L35, 'ArrayElementDelimiter "]"')));
|
|
7554
7558
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7555
7559
|
return value[1];
|
|
7556
7560
|
});
|
|
@@ -7780,7 +7784,7 @@ var require_parser = __commonJS({
|
|
|
7780
7784
|
return $EVENT_C(ctx, state, "ImplicitInlineObjectPropertyDelimiter", ImplicitInlineObjectPropertyDelimiter$$);
|
|
7781
7785
|
}
|
|
7782
7786
|
var ObjectPropertyDelimiter$0 = $S($E(_), Comma);
|
|
7783
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7787
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L26, 'ObjectPropertyDelimiter "}"')));
|
|
7784
7788
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7785
7789
|
return value[1];
|
|
7786
7790
|
});
|
|
@@ -7963,7 +7967,7 @@ var require_parser = __commonJS({
|
|
|
7963
7967
|
implicit: true
|
|
7964
7968
|
};
|
|
7965
7969
|
});
|
|
7966
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7970
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L19, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7967
7971
|
const expression = [$2, $3];
|
|
7968
7972
|
return {
|
|
7969
7973
|
type: "ComputedPropertyName",
|
|
@@ -8212,7 +8216,7 @@ var require_parser = __commonJS({
|
|
|
8212
8216
|
return $EVENT(ctx, state, "PrivateIdentifier", PrivateIdentifier$0);
|
|
8213
8217
|
}
|
|
8214
8218
|
var WAssignmentOp$0 = $S(__, AssignmentOp);
|
|
8215
|
-
var WAssignmentOp$1 = $S(_, OperatorAssignmentOp);
|
|
8219
|
+
var WAssignmentOp$1 = $S($E(_), OperatorAssignmentOp);
|
|
8216
8220
|
var WAssignmentOp$$ = [WAssignmentOp$0, WAssignmentOp$1];
|
|
8217
8221
|
function WAssignmentOp(ctx, state) {
|
|
8218
8222
|
return $EVENT_C(ctx, state, "WAssignmentOp", WAssignmentOp$$);
|
|
@@ -8229,47 +8233,47 @@ var require_parser = __commonJS({
|
|
|
8229
8233
|
function AssignmentOp(ctx, state) {
|
|
8230
8234
|
return $EVENT(ctx, state, "AssignmentOp", AssignmentOp$0);
|
|
8231
8235
|
}
|
|
8232
|
-
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $
|
|
8236
|
+
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8233
8237
|
return {
|
|
8234
8238
|
special: true,
|
|
8235
8239
|
call: module2.getRef("xor"),
|
|
8236
|
-
children: [$2, ...$
|
|
8240
|
+
children: [$2, ...$3 || []]
|
|
8237
8241
|
};
|
|
8238
8242
|
});
|
|
8239
|
-
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $
|
|
8243
|
+
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8240
8244
|
return {
|
|
8241
8245
|
special: true,
|
|
8242
8246
|
call: module2.getRef("xnor"),
|
|
8243
|
-
children: [$2, ...$
|
|
8247
|
+
children: [$2, ...$3 || []]
|
|
8244
8248
|
};
|
|
8245
8249
|
});
|
|
8246
|
-
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L3, 'OperatorAssignmentOp "="'), $
|
|
8250
|
+
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L3, 'OperatorAssignmentOp "="'), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8247
8251
|
return {
|
|
8248
8252
|
special: true,
|
|
8249
8253
|
call: $1,
|
|
8250
|
-
children: [$2, ...$
|
|
8254
|
+
children: [$2, ...$3 || []]
|
|
8251
8255
|
};
|
|
8252
8256
|
});
|
|
8253
8257
|
var OperatorAssignmentOp$$ = [OperatorAssignmentOp$0, OperatorAssignmentOp$1, OperatorAssignmentOp$2];
|
|
8254
8258
|
function OperatorAssignmentOp(ctx, state) {
|
|
8255
8259
|
return $EVENT_C(ctx, state, "OperatorAssignmentOp", OperatorAssignmentOp$$);
|
|
8256
8260
|
}
|
|
8257
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
8258
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
8259
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
8260
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
8261
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
8262
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
8263
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
8264
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
8265
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
8266
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
8267
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
8268
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
8269
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
8270
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
8271
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
8272
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
8261
|
+
var AssignmentOpSymbol$0 = $EXPECT($L36, 'AssignmentOpSymbol "**="');
|
|
8262
|
+
var AssignmentOpSymbol$1 = $EXPECT($L37, 'AssignmentOpSymbol "*="');
|
|
8263
|
+
var AssignmentOpSymbol$2 = $EXPECT($L38, 'AssignmentOpSymbol "/="');
|
|
8264
|
+
var AssignmentOpSymbol$3 = $EXPECT($L39, 'AssignmentOpSymbol "%="');
|
|
8265
|
+
var AssignmentOpSymbol$4 = $EXPECT($L40, 'AssignmentOpSymbol "+="');
|
|
8266
|
+
var AssignmentOpSymbol$5 = $EXPECT($L41, 'AssignmentOpSymbol "-="');
|
|
8267
|
+
var AssignmentOpSymbol$6 = $EXPECT($L42, 'AssignmentOpSymbol "<<="');
|
|
8268
|
+
var AssignmentOpSymbol$7 = $EXPECT($L43, 'AssignmentOpSymbol ">>>="');
|
|
8269
|
+
var AssignmentOpSymbol$8 = $EXPECT($L44, 'AssignmentOpSymbol ">>="');
|
|
8270
|
+
var AssignmentOpSymbol$9 = $EXPECT($L45, 'AssignmentOpSymbol "&&="');
|
|
8271
|
+
var AssignmentOpSymbol$10 = $EXPECT($L46, 'AssignmentOpSymbol "&="');
|
|
8272
|
+
var AssignmentOpSymbol$11 = $EXPECT($L47, 'AssignmentOpSymbol "^="');
|
|
8273
|
+
var AssignmentOpSymbol$12 = $EXPECT($L48, 'AssignmentOpSymbol "||="');
|
|
8274
|
+
var AssignmentOpSymbol$13 = $EXPECT($L49, 'AssignmentOpSymbol "|="');
|
|
8275
|
+
var AssignmentOpSymbol$14 = $EXPECT($L50, 'AssignmentOpSymbol "??="');
|
|
8276
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L51, 'AssignmentOpSymbol "?="'), function(value) {
|
|
8273
8277
|
return "??=";
|
|
8274
8278
|
});
|
|
8275
8279
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L3, 'AssignmentOpSymbol "="'), $N($EXPECT($L3, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -8282,10 +8286,10 @@ var require_parser = __commonJS({
|
|
|
8282
8286
|
function AssignmentOpSymbol(ctx, state) {
|
|
8283
8287
|
return $EVENT_C(ctx, state, "AssignmentOpSymbol", AssignmentOpSymbol$$);
|
|
8284
8288
|
}
|
|
8285
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
8289
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L52, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
8286
8290
|
return "&&=";
|
|
8287
8291
|
});
|
|
8288
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
8292
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L53, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
8289
8293
|
return "||=";
|
|
8290
8294
|
});
|
|
8291
8295
|
var CoffeeWordAssignmentOp$$ = [CoffeeWordAssignmentOp$0, CoffeeWordAssignmentOp$1];
|
|
@@ -8354,27 +8358,27 @@ var require_parser = __commonJS({
|
|
|
8354
8358
|
function _BinaryOp(ctx, state) {
|
|
8355
8359
|
return $EVENT_C(ctx, state, "_BinaryOp", _BinaryOp$$);
|
|
8356
8360
|
}
|
|
8357
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
8358
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
8359
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
8360
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
8361
|
+
var BinaryOpSymbol$0 = $EXPECT($L54, 'BinaryOpSymbol "**"');
|
|
8362
|
+
var BinaryOpSymbol$1 = $EXPECT($L55, 'BinaryOpSymbol "*"');
|
|
8363
|
+
var BinaryOpSymbol$2 = $EXPECT($L56, 'BinaryOpSymbol "/"');
|
|
8364
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L57, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
8361
8365
|
return {
|
|
8362
8366
|
call: module2.getRef("modulo"),
|
|
8363
8367
|
special: true
|
|
8364
8368
|
};
|
|
8365
8369
|
});
|
|
8366
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
8367
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
8368
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
8369
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
8370
|
-
var BinaryOpSymbol$8 = $T($EXPECT($
|
|
8370
|
+
var BinaryOpSymbol$4 = $EXPECT($L58, 'BinaryOpSymbol "%"');
|
|
8371
|
+
var BinaryOpSymbol$5 = $EXPECT($L59, 'BinaryOpSymbol "+"');
|
|
8372
|
+
var BinaryOpSymbol$6 = $EXPECT($L19, 'BinaryOpSymbol "-"');
|
|
8373
|
+
var BinaryOpSymbol$7 = $EXPECT($L60, 'BinaryOpSymbol "<="');
|
|
8374
|
+
var BinaryOpSymbol$8 = $T($EXPECT($L61, 'BinaryOpSymbol "\u2264"'), function(value) {
|
|
8371
8375
|
return "<=";
|
|
8372
8376
|
});
|
|
8373
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
8374
|
-
var BinaryOpSymbol$10 = $T($EXPECT($
|
|
8377
|
+
var BinaryOpSymbol$9 = $EXPECT($L62, 'BinaryOpSymbol ">="');
|
|
8378
|
+
var BinaryOpSymbol$10 = $T($EXPECT($L63, 'BinaryOpSymbol "\u2265"'), function(value) {
|
|
8375
8379
|
return ">=";
|
|
8376
8380
|
});
|
|
8377
|
-
var BinaryOpSymbol$11 = $TV($EXPECT($
|
|
8381
|
+
var BinaryOpSymbol$11 = $TV($EXPECT($L64, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
8378
8382
|
return {
|
|
8379
8383
|
$loc,
|
|
8380
8384
|
token: "instanceof",
|
|
@@ -8382,7 +8386,7 @@ var require_parser = __commonJS({
|
|
|
8382
8386
|
special: true
|
|
8383
8387
|
};
|
|
8384
8388
|
});
|
|
8385
|
-
var BinaryOpSymbol$12 = $TV($EXPECT($
|
|
8389
|
+
var BinaryOpSymbol$12 = $TV($EXPECT($L65, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
8386
8390
|
return {
|
|
8387
8391
|
$loc,
|
|
8388
8392
|
token: "instanceof",
|
|
@@ -8391,76 +8395,74 @@ var require_parser = __commonJS({
|
|
|
8391
8395
|
negated: true
|
|
8392
8396
|
};
|
|
8393
8397
|
});
|
|
8394
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
8395
|
-
var BinaryOpSymbol$14 = $T($EXPECT($
|
|
8398
|
+
var BinaryOpSymbol$13 = $EXPECT($L66, 'BinaryOpSymbol "<<"');
|
|
8399
|
+
var BinaryOpSymbol$14 = $T($EXPECT($L67, 'BinaryOpSymbol "\xAB"'), function(value) {
|
|
8396
8400
|
return "<<";
|
|
8397
8401
|
});
|
|
8398
|
-
var BinaryOpSymbol$15 = $
|
|
8399
|
-
|
|
8400
|
-
|
|
8401
|
-
var BinaryOpSymbol$16 = $EXPECT($L67, 'BinaryOpSymbol ">>>"');
|
|
8402
|
-
var BinaryOpSymbol$17 = $T($EXPECT($L68, 'BinaryOpSymbol "\u22D9"'), function(value) {
|
|
8402
|
+
var BinaryOpSymbol$15 = $EXPECT($L13, 'BinaryOpSymbol "<"');
|
|
8403
|
+
var BinaryOpSymbol$16 = $EXPECT($L68, 'BinaryOpSymbol ">>>"');
|
|
8404
|
+
var BinaryOpSymbol$17 = $T($EXPECT($L69, 'BinaryOpSymbol "\u22D9"'), function(value) {
|
|
8403
8405
|
return ">>>";
|
|
8404
8406
|
});
|
|
8405
|
-
var BinaryOpSymbol$18 = $EXPECT($
|
|
8406
|
-
var BinaryOpSymbol$19 = $T($EXPECT($
|
|
8407
|
+
var BinaryOpSymbol$18 = $EXPECT($L70, 'BinaryOpSymbol ">>"');
|
|
8408
|
+
var BinaryOpSymbol$19 = $T($EXPECT($L71, 'BinaryOpSymbol "\xBB"'), function(value) {
|
|
8407
8409
|
return ">>";
|
|
8408
8410
|
});
|
|
8409
|
-
var BinaryOpSymbol$20 = $EXPECT($
|
|
8410
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
8411
|
-
var BinaryOpSymbol$22 = $T($EXPECT($
|
|
8411
|
+
var BinaryOpSymbol$20 = $EXPECT($L34, 'BinaryOpSymbol ">"');
|
|
8412
|
+
var BinaryOpSymbol$21 = $EXPECT($L72, 'BinaryOpSymbol "!=="');
|
|
8413
|
+
var BinaryOpSymbol$22 = $T($EXPECT($L73, 'BinaryOpSymbol "\u2262"'), function(value) {
|
|
8412
8414
|
return "!==";
|
|
8413
8415
|
});
|
|
8414
|
-
var BinaryOpSymbol$23 = $TV($C($EXPECT($
|
|
8416
|
+
var BinaryOpSymbol$23 = $TV($C($EXPECT($L74, 'BinaryOpSymbol "!="'), $EXPECT($L75, 'BinaryOpSymbol "\u2260"')), function($skip, $loc, $0, $1) {
|
|
8415
8417
|
if (module2.config.coffeeEq)
|
|
8416
8418
|
return "!==";
|
|
8417
8419
|
return "!=";
|
|
8418
8420
|
});
|
|
8419
|
-
var BinaryOpSymbol$24 = $TS($S($EXPECT($
|
|
8421
|
+
var BinaryOpSymbol$24 = $TS($S($EXPECT($L76, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8420
8422
|
if (module2.config.coffeeIsnt)
|
|
8421
8423
|
return "!==";
|
|
8422
8424
|
return $skip;
|
|
8423
8425
|
});
|
|
8424
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
8425
|
-
var BinaryOpSymbol$26 = $T($C($EXPECT($
|
|
8426
|
+
var BinaryOpSymbol$25 = $EXPECT($L77, 'BinaryOpSymbol "==="');
|
|
8427
|
+
var BinaryOpSymbol$26 = $T($C($EXPECT($L78, 'BinaryOpSymbol "\u2263"'), $EXPECT($L79, 'BinaryOpSymbol "\u2A76"')), function(value) {
|
|
8426
8428
|
return "===";
|
|
8427
8429
|
});
|
|
8428
|
-
var BinaryOpSymbol$27 = $TV($C($EXPECT($
|
|
8430
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($L80, 'BinaryOpSymbol "=="'), $EXPECT($L81, 'BinaryOpSymbol "\u2261"'), $EXPECT($L82, 'BinaryOpSymbol "\u2A75"')), function($skip, $loc, $0, $1) {
|
|
8429
8431
|
if (module2.config.coffeeEq)
|
|
8430
8432
|
return "===";
|
|
8431
8433
|
return "==";
|
|
8432
8434
|
});
|
|
8433
|
-
var BinaryOpSymbol$28 = $T($S($EXPECT($
|
|
8435
|
+
var BinaryOpSymbol$28 = $T($S($EXPECT($L83, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
8434
8436
|
return "&&";
|
|
8435
8437
|
});
|
|
8436
|
-
var BinaryOpSymbol$29 = $EXPECT($
|
|
8437
|
-
var BinaryOpSymbol$30 = $T($S($EXPECT($
|
|
8438
|
+
var BinaryOpSymbol$29 = $EXPECT($L84, 'BinaryOpSymbol "&&"');
|
|
8439
|
+
var BinaryOpSymbol$30 = $T($S($EXPECT($L85, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
8438
8440
|
return "||";
|
|
8439
8441
|
});
|
|
8440
|
-
var BinaryOpSymbol$31 = $EXPECT($
|
|
8441
|
-
var BinaryOpSymbol$32 = $T($EXPECT($
|
|
8442
|
+
var BinaryOpSymbol$31 = $EXPECT($L86, 'BinaryOpSymbol "||"');
|
|
8443
|
+
var BinaryOpSymbol$32 = $T($EXPECT($L87, 'BinaryOpSymbol "\u2016"'), function(value) {
|
|
8442
8444
|
return "||";
|
|
8443
8445
|
});
|
|
8444
|
-
var BinaryOpSymbol$33 = $TV($C($EXPECT($
|
|
8446
|
+
var BinaryOpSymbol$33 = $TV($C($EXPECT($L88, 'BinaryOpSymbol "^^"'), $S($EXPECT($L89, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8445
8447
|
return {
|
|
8446
8448
|
call: module2.getRef("xor"),
|
|
8447
8449
|
special: true
|
|
8448
8450
|
};
|
|
8449
8451
|
});
|
|
8450
|
-
var BinaryOpSymbol$34 = $TV($C($EXPECT($
|
|
8452
|
+
var BinaryOpSymbol$34 = $TV($C($EXPECT($R17, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L90, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8451
8453
|
return {
|
|
8452
8454
|
call: module2.getRef("xnor"),
|
|
8453
8455
|
special: true
|
|
8454
8456
|
};
|
|
8455
8457
|
});
|
|
8456
|
-
var BinaryOpSymbol$35 = $EXPECT($
|
|
8457
|
-
var BinaryOpSymbol$36 = $T($EXPECT($
|
|
8458
|
+
var BinaryOpSymbol$35 = $EXPECT($L91, 'BinaryOpSymbol "??"');
|
|
8459
|
+
var BinaryOpSymbol$36 = $T($EXPECT($L92, 'BinaryOpSymbol "\u2047"'), function(value) {
|
|
8458
8460
|
return "??";
|
|
8459
8461
|
});
|
|
8460
8462
|
var BinaryOpSymbol$37 = $T($S($EXPECT($L5, 'BinaryOpSymbol "?"'), CoffeeBinaryExistentialEnabled), function(value) {
|
|
8461
8463
|
return "??";
|
|
8462
8464
|
});
|
|
8463
|
-
var BinaryOpSymbol$38 = $TS($S($EXPECT($
|
|
8465
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L93, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8464
8466
|
return {
|
|
8465
8467
|
$loc,
|
|
8466
8468
|
token: $1,
|
|
@@ -8477,7 +8479,7 @@ var require_parser = __commonJS({
|
|
|
8477
8479
|
var op = $3;
|
|
8478
8480
|
return { ...op, $loc };
|
|
8479
8481
|
});
|
|
8480
|
-
var BinaryOpSymbol$41 = $TV($C($S(Is, __, In), $EXPECT($
|
|
8482
|
+
var BinaryOpSymbol$41 = $TV($C($S(Is, __, In), $EXPECT($L94, 'BinaryOpSymbol "\u2208"')), function($skip, $loc, $0, $1) {
|
|
8481
8483
|
return {
|
|
8482
8484
|
method: "includes",
|
|
8483
8485
|
relational: true,
|
|
@@ -8485,14 +8487,14 @@ var require_parser = __commonJS({
|
|
|
8485
8487
|
special: true
|
|
8486
8488
|
};
|
|
8487
8489
|
});
|
|
8488
|
-
var BinaryOpSymbol$42 = $TV($EXPECT($
|
|
8490
|
+
var BinaryOpSymbol$42 = $TV($EXPECT($L95, 'BinaryOpSymbol "\u220B"'), function($skip, $loc, $0, $1) {
|
|
8489
8491
|
return {
|
|
8490
8492
|
method: "includes",
|
|
8491
8493
|
relational: true,
|
|
8492
8494
|
special: true
|
|
8493
8495
|
};
|
|
8494
8496
|
});
|
|
8495
|
-
var BinaryOpSymbol$43 = $TV($EXPECT($
|
|
8497
|
+
var BinaryOpSymbol$43 = $TV($EXPECT($L96, 'BinaryOpSymbol "\u220C"'), function($skip, $loc, $0, $1) {
|
|
8496
8498
|
return {
|
|
8497
8499
|
method: "includes",
|
|
8498
8500
|
relational: true,
|
|
@@ -8500,7 +8502,7 @@ var require_parser = __commonJS({
|
|
|
8500
8502
|
negated: true
|
|
8501
8503
|
};
|
|
8502
8504
|
});
|
|
8503
|
-
var BinaryOpSymbol$44 = $TV($C($S(Is, __, Not, __, In), $EXPECT($
|
|
8505
|
+
var BinaryOpSymbol$44 = $TV($C($S(Is, __, Not, __, In), $EXPECT($L97, 'BinaryOpSymbol "\u2209"')), function($skip, $loc, $0, $1) {
|
|
8504
8506
|
return {
|
|
8505
8507
|
method: "includes",
|
|
8506
8508
|
relational: true,
|
|
@@ -8533,9 +8535,9 @@ var require_parser = __commonJS({
|
|
|
8533
8535
|
return "===";
|
|
8534
8536
|
});
|
|
8535
8537
|
var BinaryOpSymbol$47 = In;
|
|
8536
|
-
var BinaryOpSymbol$48 = $EXPECT($
|
|
8537
|
-
var BinaryOpSymbol$49 = $EXPECT($
|
|
8538
|
-
var BinaryOpSymbol$50 = $EXPECT($
|
|
8538
|
+
var BinaryOpSymbol$48 = $EXPECT($L98, 'BinaryOpSymbol "&"');
|
|
8539
|
+
var BinaryOpSymbol$49 = $EXPECT($L18, 'BinaryOpSymbol "^"');
|
|
8540
|
+
var BinaryOpSymbol$50 = $EXPECT($L99, 'BinaryOpSymbol "|"');
|
|
8539
8541
|
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];
|
|
8540
8542
|
function BinaryOpSymbol(ctx, state) {
|
|
8541
8543
|
return $EVENT_C(ctx, state, "BinaryOpSymbol", BinaryOpSymbol$$);
|
|
@@ -8573,7 +8575,7 @@ var require_parser = __commonJS({
|
|
|
8573
8575
|
function CoffeeOfOp(ctx, state) {
|
|
8574
8576
|
return $EVENT_C(ctx, state, "CoffeeOfOp", CoffeeOfOp$$);
|
|
8575
8577
|
}
|
|
8576
|
-
var NotOp$0 = $TS($S($EXPECT($
|
|
8578
|
+
var NotOp$0 = $TS($S($EXPECT($L93, 'NotOp "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8577
8579
|
return {
|
|
8578
8580
|
$loc,
|
|
8579
8581
|
token: "instanceof",
|
|
@@ -8594,19 +8596,19 @@ var require_parser = __commonJS({
|
|
|
8594
8596
|
function NotOp(ctx, state) {
|
|
8595
8597
|
return $EVENT_C(ctx, state, "NotOp", NotOp$$);
|
|
8596
8598
|
}
|
|
8597
|
-
var Xor$0 = $EXPECT($
|
|
8598
|
-
var Xor$1 = $S($EXPECT($
|
|
8599
|
+
var Xor$0 = $EXPECT($L88, 'Xor "^^"');
|
|
8600
|
+
var Xor$1 = $S($EXPECT($L89, 'Xor "xor"'), NonIdContinue);
|
|
8599
8601
|
var Xor$$ = [Xor$0, Xor$1];
|
|
8600
8602
|
function Xor(ctx, state) {
|
|
8601
8603
|
return $EVENT_C(ctx, state, "Xor", Xor$$);
|
|
8602
8604
|
}
|
|
8603
|
-
var Xnor$0 = $R$0($EXPECT($
|
|
8604
|
-
var Xnor$1 = $EXPECT($
|
|
8605
|
+
var Xnor$0 = $R$0($EXPECT($R17, "Xnor /!\\^\\^?/"));
|
|
8606
|
+
var Xnor$1 = $EXPECT($L90, 'Xnor "xnor"');
|
|
8605
8607
|
var Xnor$$ = [Xnor$0, Xnor$1];
|
|
8606
8608
|
function Xnor(ctx, state) {
|
|
8607
8609
|
return $EVENT_C(ctx, state, "Xnor", Xnor$$);
|
|
8608
8610
|
}
|
|
8609
|
-
var UnaryOp$0 = $TR($EXPECT($
|
|
8611
|
+
var UnaryOp$0 = $TR($EXPECT($R18, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*(&|\\.[^0-9]))/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8610
8612
|
return { $loc, token: $0 };
|
|
8611
8613
|
});
|
|
8612
8614
|
var UnaryOp$1 = AwaitOp;
|
|
@@ -8706,7 +8708,7 @@ var require_parser = __commonJS({
|
|
|
8706
8708
|
function NonPipelinePostfixedExpression(ctx, state) {
|
|
8707
8709
|
return $EVENT(ctx, state, "NonPipelinePostfixedExpression", NonPipelinePostfixedExpression$0);
|
|
8708
8710
|
}
|
|
8709
|
-
var PostfixStatement$0 = $T($S($EXPECT($
|
|
8711
|
+
var PostfixStatement$0 = $T($S($EXPECT($R19, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
|
|
8710
8712
|
return value[1];
|
|
8711
8713
|
});
|
|
8712
8714
|
function PostfixStatement(ctx, state) {
|
|
@@ -8749,7 +8751,7 @@ var require_parser = __commonJS({
|
|
|
8749
8751
|
function NoCommaStatement(ctx, state) {
|
|
8750
8752
|
return $EVENT_C(ctx, state, "NoCommaStatement", NoCommaStatement$$);
|
|
8751
8753
|
}
|
|
8752
|
-
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($
|
|
8754
|
+
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L100, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
|
|
8753
8755
|
return { type: "EmptyStatement", children: $1 || [] };
|
|
8754
8756
|
});
|
|
8755
8757
|
function EmptyStatement(ctx, state) {
|
|
@@ -8771,7 +8773,7 @@ var require_parser = __commonJS({
|
|
|
8771
8773
|
var w = $3;
|
|
8772
8774
|
return [id, colon, w];
|
|
8773
8775
|
});
|
|
8774
|
-
var Label$1 = $S($EXPECT($
|
|
8776
|
+
var Label$1 = $S($EXPECT($L101, 'Label "$:"'), Whitespace);
|
|
8775
8777
|
var Label$$ = [Label$0, Label$1];
|
|
8776
8778
|
function Label(ctx, state) {
|
|
8777
8779
|
return $EVENT_C(ctx, state, "Label", Label$$);
|
|
@@ -8944,7 +8946,7 @@ var require_parser = __commonJS({
|
|
|
8944
8946
|
function BlockExpressionPart(ctx, state) {
|
|
8945
8947
|
return $EVENT(ctx, state, "BlockExpressionPart", BlockExpressionPart$0);
|
|
8946
8948
|
}
|
|
8947
|
-
var IterationStatement$0 = $T($S($EXPECT($
|
|
8949
|
+
var IterationStatement$0 = $T($S($EXPECT($R20, "IterationStatement /(?=loop|do|for|until|while)/"), _IterationStatement), function(value) {
|
|
8948
8950
|
return value[1];
|
|
8949
8951
|
});
|
|
8950
8952
|
function IterationStatement(ctx, state) {
|
|
@@ -9297,7 +9299,7 @@ var require_parser = __commonJS({
|
|
|
9297
9299
|
names: binding.names
|
|
9298
9300
|
};
|
|
9299
9301
|
});
|
|
9300
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
9302
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R21, "ForDeclaration /(?=[\\s\\),])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
9301
9303
|
var c = $1;
|
|
9302
9304
|
var binding = $2;
|
|
9303
9305
|
return {
|
|
@@ -9662,6 +9664,15 @@ var require_parser = __commonJS({
|
|
|
9662
9664
|
function ExpressionWithObjectApplicationForbidden(ctx, state) {
|
|
9663
9665
|
return $EVENT(ctx, state, "ExpressionWithObjectApplicationForbidden", ExpressionWithObjectApplicationForbidden$0);
|
|
9664
9666
|
}
|
|
9667
|
+
var LeftHandSideExpressionWithObjectApplicationForbidden$0 = $TS($S(ForbidBracedApplication, ForbidIndentedApplication, ForbidNewlineBinaryOp, $E(LeftHandSideExpression), RestoreNewlineBinaryOp, RestoreBracedApplication, RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
9668
|
+
var exp = $4;
|
|
9669
|
+
if (exp)
|
|
9670
|
+
return exp;
|
|
9671
|
+
return $skip;
|
|
9672
|
+
});
|
|
9673
|
+
function LeftHandSideExpressionWithObjectApplicationForbidden(ctx, state) {
|
|
9674
|
+
return $EVENT(ctx, state, "LeftHandSideExpressionWithObjectApplicationForbidden", LeftHandSideExpressionWithObjectApplicationForbidden$0);
|
|
9675
|
+
}
|
|
9665
9676
|
var ForbidClassImplicitCall$0 = $TV($EXPECT($L0, 'ForbidClassImplicitCall ""'), function($skip, $loc, $0, $1) {
|
|
9666
9677
|
module2.forbidClassImplicitCall.push(true);
|
|
9667
9678
|
});
|
|
@@ -9862,19 +9873,19 @@ var require_parser = __commonJS({
|
|
|
9862
9873
|
function ThrowStatement(ctx, state) {
|
|
9863
9874
|
return $EVENT(ctx, state, "ThrowStatement", ThrowStatement$0);
|
|
9864
9875
|
}
|
|
9865
|
-
var Break$0 = $TS($S($EXPECT($
|
|
9876
|
+
var Break$0 = $TS($S($EXPECT($L102, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9866
9877
|
return { $loc, token: $1 };
|
|
9867
9878
|
});
|
|
9868
9879
|
function Break(ctx, state) {
|
|
9869
9880
|
return $EVENT(ctx, state, "Break", Break$0);
|
|
9870
9881
|
}
|
|
9871
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
9882
|
+
var Continue$0 = $TS($S($EXPECT($L103, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9872
9883
|
return { $loc, token: $1 };
|
|
9873
9884
|
});
|
|
9874
9885
|
function Continue(ctx, state) {
|
|
9875
9886
|
return $EVENT(ctx, state, "Continue", Continue$0);
|
|
9876
9887
|
}
|
|
9877
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
9888
|
+
var Debugger$0 = $TS($S($EXPECT($L104, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9878
9889
|
return { $loc, token: $1 };
|
|
9879
9890
|
});
|
|
9880
9891
|
function Debugger(ctx, state) {
|
|
@@ -9995,7 +10006,7 @@ var require_parser = __commonJS({
|
|
|
9995
10006
|
function FromClause(ctx, state) {
|
|
9996
10007
|
return $EVENT(ctx, state, "FromClause", FromClause$0);
|
|
9997
10008
|
}
|
|
9998
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10009
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L105, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
9999
10010
|
function ImportAssertion(ctx, state) {
|
|
10000
10011
|
return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
|
|
10001
10012
|
}
|
|
@@ -10083,7 +10094,7 @@ var require_parser = __commonJS({
|
|
|
10083
10094
|
function UnprocessedModuleSpecifier(ctx, state) {
|
|
10084
10095
|
return $EVENT_C(ctx, state, "UnprocessedModuleSpecifier", UnprocessedModuleSpecifier$$);
|
|
10085
10096
|
}
|
|
10086
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
10097
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R22, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
10087
10098
|
var spec = $0;
|
|
10088
10099
|
return { $loc, token: `"${spec}"` };
|
|
10089
10100
|
});
|
|
@@ -10215,13 +10226,13 @@ var require_parser = __commonJS({
|
|
|
10215
10226
|
function LexicalDeclaration(ctx, state) {
|
|
10216
10227
|
return $EVENT_C(ctx, state, "LexicalDeclaration", LexicalDeclaration$$);
|
|
10217
10228
|
}
|
|
10218
|
-
var ConstAssignment$0 = $TV($C($EXPECT($
|
|
10229
|
+
var ConstAssignment$0 = $TV($C($EXPECT($L106, 'ConstAssignment ":="'), $EXPECT($L107, 'ConstAssignment "\u2254"')), function($skip, $loc, $0, $1) {
|
|
10219
10230
|
return { $loc, token: "=" };
|
|
10220
10231
|
});
|
|
10221
10232
|
function ConstAssignment(ctx, state) {
|
|
10222
10233
|
return $EVENT(ctx, state, "ConstAssignment", ConstAssignment$0);
|
|
10223
10234
|
}
|
|
10224
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
10235
|
+
var LetAssignment$0 = $TV($EXPECT($L108, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10225
10236
|
return { $loc, token: "=" };
|
|
10226
10237
|
});
|
|
10227
10238
|
function LetAssignment(ctx, state) {
|
|
@@ -10289,7 +10300,7 @@ var require_parser = __commonJS({
|
|
|
10289
10300
|
function VariableDeclarationList(ctx, state) {
|
|
10290
10301
|
return $EVENT(ctx, state, "VariableDeclarationList", VariableDeclarationList$0);
|
|
10291
10302
|
}
|
|
10292
|
-
var NumericLiteral$0 = $TS($S($EXPECT($
|
|
10303
|
+
var NumericLiteral$0 = $TS($S($EXPECT($R23, "NumericLiteral /(?=[0-9.])/"), NumericLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
10293
10304
|
var token = $2;
|
|
10294
10305
|
return { type: "NumericLiteral", $loc, token };
|
|
10295
10306
|
});
|
|
@@ -10305,36 +10316,36 @@ var require_parser = __commonJS({
|
|
|
10305
10316
|
function NumericLiteralKind(ctx, state) {
|
|
10306
10317
|
return $EVENT_C(ctx, state, "NumericLiteralKind", NumericLiteralKind$$);
|
|
10307
10318
|
}
|
|
10308
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
10319
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R24, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
10309
10320
|
function DecimalBigIntegerLiteral(ctx, state) {
|
|
10310
10321
|
return $EVENT(ctx, state, "DecimalBigIntegerLiteral", DecimalBigIntegerLiteral$0);
|
|
10311
10322
|
}
|
|
10312
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
10323
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R25, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
10313
10324
|
return $1 + ".";
|
|
10314
10325
|
});
|
|
10315
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
10316
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
10326
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R26, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
10327
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R27, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
10317
10328
|
var DecimalLiteral$$ = [DecimalLiteral$0, DecimalLiteral$1, DecimalLiteral$2];
|
|
10318
10329
|
function DecimalLiteral(ctx, state) {
|
|
10319
10330
|
return $EVENT_C(ctx, state, "DecimalLiteral", DecimalLiteral$$);
|
|
10320
10331
|
}
|
|
10321
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
10332
|
+
var ExponentPart$0 = $R$0($EXPECT($R28, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
10322
10333
|
function ExponentPart(ctx, state) {
|
|
10323
10334
|
return $EVENT(ctx, state, "ExponentPart", ExponentPart$0);
|
|
10324
10335
|
}
|
|
10325
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
10336
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R29, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
10326
10337
|
function BinaryIntegerLiteral(ctx, state) {
|
|
10327
10338
|
return $EVENT(ctx, state, "BinaryIntegerLiteral", BinaryIntegerLiteral$0);
|
|
10328
10339
|
}
|
|
10329
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
10340
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R30, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
10330
10341
|
function OctalIntegerLiteral(ctx, state) {
|
|
10331
10342
|
return $EVENT(ctx, state, "OctalIntegerLiteral", OctalIntegerLiteral$0);
|
|
10332
10343
|
}
|
|
10333
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
10344
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R31, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
10334
10345
|
function HexIntegerLiteral(ctx, state) {
|
|
10335
10346
|
return $EVENT(ctx, state, "HexIntegerLiteral", HexIntegerLiteral$0);
|
|
10336
10347
|
}
|
|
10337
|
-
var IntegerLiteral$0 = $TS($S($EXPECT($
|
|
10348
|
+
var IntegerLiteral$0 = $TS($S($EXPECT($R32, "IntegerLiteral /(?=[0-9])/"), IntegerLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
10338
10349
|
var token = $2;
|
|
10339
10350
|
return { $loc, token };
|
|
10340
10351
|
});
|
|
@@ -10350,7 +10361,7 @@ var require_parser = __commonJS({
|
|
|
10350
10361
|
function IntegerLiteralKind(ctx, state) {
|
|
10351
10362
|
return $EVENT_C(ctx, state, "IntegerLiteralKind", IntegerLiteralKind$$);
|
|
10352
10363
|
}
|
|
10353
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
10364
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R33, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
10354
10365
|
function DecimalIntegerLiteral(ctx, state) {
|
|
10355
10366
|
return $EVENT(ctx, state, "DecimalIntegerLiteral", DecimalIntegerLiteral$0);
|
|
10356
10367
|
}
|
|
@@ -10374,25 +10385,25 @@ var require_parser = __commonJS({
|
|
|
10374
10385
|
function StringLiteral(ctx, state) {
|
|
10375
10386
|
return $EVENT_C(ctx, state, "StringLiteral", StringLiteral$$);
|
|
10376
10387
|
}
|
|
10377
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
10388
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R34, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10378
10389
|
return { $loc, token: $0 };
|
|
10379
10390
|
});
|
|
10380
10391
|
function DoubleStringCharacters(ctx, state) {
|
|
10381
10392
|
return $EVENT(ctx, state, "DoubleStringCharacters", DoubleStringCharacters$0);
|
|
10382
10393
|
}
|
|
10383
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
10394
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R35, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10384
10395
|
return { $loc, token: $0 };
|
|
10385
10396
|
});
|
|
10386
10397
|
function SingleStringCharacters(ctx, state) {
|
|
10387
10398
|
return $EVENT(ctx, state, "SingleStringCharacters", SingleStringCharacters$0);
|
|
10388
10399
|
}
|
|
10389
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
10400
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R36, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10390
10401
|
return { $loc, token: $0 };
|
|
10391
10402
|
});
|
|
10392
10403
|
function TripleDoubleStringCharacters(ctx, state) {
|
|
10393
10404
|
return $EVENT(ctx, state, "TripleDoubleStringCharacters", TripleDoubleStringCharacters$0);
|
|
10394
10405
|
}
|
|
10395
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
10406
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R37, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10396
10407
|
return { $loc, token: $0 };
|
|
10397
10408
|
});
|
|
10398
10409
|
function TripleSingleStringCharacters(ctx, state) {
|
|
@@ -10411,14 +10422,14 @@ var require_parser = __commonJS({
|
|
|
10411
10422
|
function CoffeeInterpolatedDoubleQuotedString(ctx, state) {
|
|
10412
10423
|
return $EVENT(ctx, state, "CoffeeInterpolatedDoubleQuotedString", CoffeeInterpolatedDoubleQuotedString$0);
|
|
10413
10424
|
}
|
|
10414
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
10425
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R38, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10415
10426
|
return { $loc, token: $0 };
|
|
10416
10427
|
});
|
|
10417
10428
|
function CoffeeDoubleQuotedStringCharacters(ctx, state) {
|
|
10418
10429
|
return $EVENT(ctx, state, "CoffeeDoubleQuotedStringCharacters", CoffeeDoubleQuotedStringCharacters$0);
|
|
10419
10430
|
}
|
|
10420
10431
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
10421
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
10432
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L56, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L56, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
10422
10433
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
10423
10434
|
});
|
|
10424
10435
|
var RegularExpressionLiteral$$ = [RegularExpressionLiteral$0, RegularExpressionLiteral$1];
|
|
@@ -10431,7 +10442,7 @@ var require_parser = __commonJS({
|
|
|
10431
10442
|
function RegularExpressionClass(ctx, state) {
|
|
10432
10443
|
return $EVENT(ctx, state, "RegularExpressionClass", RegularExpressionClass$0);
|
|
10433
10444
|
}
|
|
10434
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
10445
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R39, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10435
10446
|
return { $loc, token: $0 };
|
|
10436
10447
|
});
|
|
10437
10448
|
function RegularExpressionClassCharacters(ctx, state) {
|
|
@@ -10485,7 +10496,7 @@ var require_parser = __commonJS({
|
|
|
10485
10496
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
10486
10497
|
return { "type": "Substitution", "children": value[0] };
|
|
10487
10498
|
});
|
|
10488
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
10499
|
+
var HeregexPart$3 = $TR($EXPECT($R40, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10489
10500
|
let token = $0;
|
|
10490
10501
|
switch ($0[1]) {
|
|
10491
10502
|
case "\n":
|
|
@@ -10503,13 +10514,13 @@ var require_parser = __commonJS({
|
|
|
10503
10514
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
10504
10515
|
return { $loc, token: "" };
|
|
10505
10516
|
});
|
|
10506
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
10517
|
+
var HeregexPart$5 = $TR($EXPECT($R41, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10507
10518
|
return { $loc, token: "" };
|
|
10508
10519
|
});
|
|
10509
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
10520
|
+
var HeregexPart$6 = $TR($EXPECT($R42, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10510
10521
|
return { $loc, token: "\\/" };
|
|
10511
10522
|
});
|
|
10512
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
10523
|
+
var HeregexPart$7 = $TR($EXPECT($R43, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10513
10524
|
return { $loc, token: $0 };
|
|
10514
10525
|
});
|
|
10515
10526
|
var HeregexPart$$ = [HeregexPart$0, HeregexPart$1, HeregexPart$2, HeregexPart$3, HeregexPart$4, HeregexPart$5, HeregexPart$6, HeregexPart$7];
|
|
@@ -10522,7 +10533,7 @@ var require_parser = __commonJS({
|
|
|
10522
10533
|
function HeregexComment(ctx, state) {
|
|
10523
10534
|
return $EVENT_C(ctx, state, "HeregexComment", HeregexComment$$);
|
|
10524
10535
|
}
|
|
10525
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
10536
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R44, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
10526
10537
|
function RegularExpressionBody(ctx, state) {
|
|
10527
10538
|
return $EVENT(ctx, state, "RegularExpressionBody", RegularExpressionBody$0);
|
|
10528
10539
|
}
|
|
@@ -10532,15 +10543,15 @@ var require_parser = __commonJS({
|
|
|
10532
10543
|
function RegExpPart(ctx, state) {
|
|
10533
10544
|
return $EVENT_C(ctx, state, "RegExpPart", RegExpPart$$);
|
|
10534
10545
|
}
|
|
10535
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
10546
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R45, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
10536
10547
|
function RegExpCharacter(ctx, state) {
|
|
10537
10548
|
return $EVENT(ctx, state, "RegExpCharacter", RegExpCharacter$0);
|
|
10538
10549
|
}
|
|
10539
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
10550
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R46, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
10540
10551
|
function RegularExpressionFlags(ctx, state) {
|
|
10541
10552
|
return $EVENT(ctx, state, "RegularExpressionFlags", RegularExpressionFlags$0);
|
|
10542
10553
|
}
|
|
10543
|
-
var TemplateLiteral$0 = $T($S($EXPECT($
|
|
10554
|
+
var TemplateLiteral$0 = $T($S($EXPECT($R47, "TemplateLiteral /(?=[`'\"])/"), _TemplateLiteral), function(value) {
|
|
10544
10555
|
return value[1];
|
|
10545
10556
|
});
|
|
10546
10557
|
function TemplateLiteral(ctx, state) {
|
|
@@ -10576,28 +10587,28 @@ var require_parser = __commonJS({
|
|
|
10576
10587
|
function TemplateSubstitution(ctx, state) {
|
|
10577
10588
|
return $EVENT(ctx, state, "TemplateSubstitution", TemplateSubstitution$0);
|
|
10578
10589
|
}
|
|
10579
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
10590
|
+
var TemplateCharacters$0 = $TR($EXPECT($R48, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10580
10591
|
return { $loc, token: $0 };
|
|
10581
10592
|
});
|
|
10582
10593
|
function TemplateCharacters(ctx, state) {
|
|
10583
10594
|
return $EVENT(ctx, state, "TemplateCharacters", TemplateCharacters$0);
|
|
10584
10595
|
}
|
|
10585
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
10596
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R49, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10586
10597
|
return { $loc, token: $0 };
|
|
10587
10598
|
});
|
|
10588
10599
|
function TemplateBlockCharacters(ctx, state) {
|
|
10589
10600
|
return $EVENT(ctx, state, "TemplateBlockCharacters", TemplateBlockCharacters$0);
|
|
10590
10601
|
}
|
|
10591
|
-
var ReservedWord$0 = $S($R$0($EXPECT($
|
|
10592
|
-
var ReservedWord$1 = $S($R$0($EXPECT($
|
|
10593
|
-
var ReservedWord$2 = $S($R$0($EXPECT($
|
|
10594
|
-
var ReservedWord$3 = $S($R$0($EXPECT($
|
|
10595
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
10602
|
+
var ReservedWord$0 = $S($R$0($EXPECT($R50, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")), CoffeeBooleansEnabled);
|
|
10603
|
+
var ReservedWord$1 = $S($R$0($EXPECT($R51, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")), CoffeeIsntEnabled);
|
|
10604
|
+
var ReservedWord$2 = $S($R$0($EXPECT($R52, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")), CoffeeForLoopsEnabled);
|
|
10605
|
+
var ReservedWord$3 = $S($R$0($EXPECT($R53, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")), CoffeeOfEnabled);
|
|
10606
|
+
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})/"));
|
|
10596
10607
|
var ReservedWord$$ = [ReservedWord$0, ReservedWord$1, ReservedWord$2, ReservedWord$3, ReservedWord$4];
|
|
10597
10608
|
function ReservedWord(ctx, state) {
|
|
10598
10609
|
return $EVENT_C(ctx, state, "ReservedWord", ReservedWord$$);
|
|
10599
10610
|
}
|
|
10600
|
-
var Comment$0 = $T($S($EXPECT($
|
|
10611
|
+
var Comment$0 = $T($S($EXPECT($R55, "Comment /(?=\\/|#)/"), _Comment), function(value) {
|
|
10601
10612
|
return value[1];
|
|
10602
10613
|
});
|
|
10603
10614
|
function Comment(ctx, state) {
|
|
@@ -10615,7 +10626,7 @@ var require_parser = __commonJS({
|
|
|
10615
10626
|
function SingleLineComment(ctx, state) {
|
|
10616
10627
|
return $EVENT_C(ctx, state, "SingleLineComment", SingleLineComment$$);
|
|
10617
10628
|
}
|
|
10618
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
10629
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R56, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10619
10630
|
return { type: "Comment", $loc, token: $0 };
|
|
10620
10631
|
});
|
|
10621
10632
|
function JSSingleLineComment(ctx, state) {
|
|
@@ -10627,30 +10638,30 @@ var require_parser = __commonJS({
|
|
|
10627
10638
|
function MultiLineComment(ctx, state) {
|
|
10628
10639
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
10629
10640
|
}
|
|
10630
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
10641
|
+
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) {
|
|
10631
10642
|
return { type: "Comment", $loc, token: $1 };
|
|
10632
10643
|
});
|
|
10633
10644
|
function JSMultiLineComment(ctx, state) {
|
|
10634
10645
|
return $EVENT(ctx, state, "JSMultiLineComment", JSMultiLineComment$0);
|
|
10635
10646
|
}
|
|
10636
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
10647
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R58, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10637
10648
|
return { type: "Comment", $loc, token: `//${$1}` };
|
|
10638
10649
|
});
|
|
10639
10650
|
function CoffeeSingleLineComment(ctx, state) {
|
|
10640
10651
|
return $EVENT(ctx, state, "CoffeeSingleLineComment", CoffeeSingleLineComment$0);
|
|
10641
10652
|
}
|
|
10642
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
10653
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R59, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
10643
10654
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
10644
10655
|
return { type: "Comment", $loc, token: `/*${$2}*/` };
|
|
10645
10656
|
});
|
|
10646
10657
|
function CoffeeMultiLineComment(ctx, state) {
|
|
10647
10658
|
return $EVENT(ctx, state, "CoffeeMultiLineComment", CoffeeMultiLineComment$0);
|
|
10648
10659
|
}
|
|
10649
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
10660
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R60, "CoffeeHereCommentStart /###(?!#)/"));
|
|
10650
10661
|
function CoffeeHereCommentStart(ctx, state) {
|
|
10651
10662
|
return $EVENT(ctx, state, "CoffeeHereCommentStart", CoffeeHereCommentStart$0);
|
|
10652
10663
|
}
|
|
10653
|
-
var InlineComment$0 = $TR($EXPECT($
|
|
10664
|
+
var InlineComment$0 = $TR($EXPECT($R61, "InlineComment /\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\//"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10654
10665
|
return { $loc, token: $0 };
|
|
10655
10666
|
});
|
|
10656
10667
|
function InlineComment(ctx, state) {
|
|
@@ -10664,16 +10675,16 @@ var require_parser = __commonJS({
|
|
|
10664
10675
|
function TrailingComment(ctx, state) {
|
|
10665
10676
|
return $EVENT(ctx, state, "TrailingComment", TrailingComment$0);
|
|
10666
10677
|
}
|
|
10667
|
-
var _$0 = $T($S($EXPECT($
|
|
10678
|
+
var _$0 = $T($S($EXPECT($R62, "_ /(?=[ \\t\\/\\\\])/"), $P($C(NonNewlineWhitespace, InlineComment))), function(value) {
|
|
10668
10679
|
return value[1];
|
|
10669
10680
|
});
|
|
10670
10681
|
function _(ctx, state) {
|
|
10671
10682
|
return $EVENT(ctx, state, "_", _$0);
|
|
10672
10683
|
}
|
|
10673
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
10684
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R63, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10674
10685
|
return { $loc, token: $0 };
|
|
10675
10686
|
});
|
|
10676
|
-
var NonNewlineWhitespace$1 = $T($S($EXPECT($
|
|
10687
|
+
var NonNewlineWhitespace$1 = $T($S($EXPECT($L111, 'NonNewlineWhitespace "\\\\\\\\"'), CoffeeLineContinuationEnabled, EOL), function(value) {
|
|
10677
10688
|
return " ";
|
|
10678
10689
|
});
|
|
10679
10690
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
@@ -10687,7 +10698,7 @@ var require_parser = __commonJS({
|
|
|
10687
10698
|
function Trimmed_(ctx, state) {
|
|
10688
10699
|
return $EVENT(ctx, state, "Trimmed_", Trimmed_$0);
|
|
10689
10700
|
}
|
|
10690
|
-
var __$0 = $T($S($EXPECT($
|
|
10701
|
+
var __$0 = $T($S($EXPECT($R64, "__ /(?=\\s|\\/|#)/"), $Q($C(Whitespace, Comment))), function(value) {
|
|
10691
10702
|
return value[1];
|
|
10692
10703
|
});
|
|
10693
10704
|
var __$1 = $EXPECT($L0, '__ ""');
|
|
@@ -10695,7 +10706,7 @@ var require_parser = __commonJS({
|
|
|
10695
10706
|
function __(ctx, state) {
|
|
10696
10707
|
return $EVENT_C(ctx, state, "__", __$$);
|
|
10697
10708
|
}
|
|
10698
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
10709
|
+
var Whitespace$0 = $TR($EXPECT($R41, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10699
10710
|
return { $loc, token: $0 };
|
|
10700
10711
|
});
|
|
10701
10712
|
function Whitespace(ctx, state) {
|
|
@@ -10719,7 +10730,7 @@ var require_parser = __commonJS({
|
|
|
10719
10730
|
}
|
|
10720
10731
|
var StatementDelimiter$0 = $Y(EOS);
|
|
10721
10732
|
var StatementDelimiter$1 = SemicolonDelimiter;
|
|
10722
|
-
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($
|
|
10733
|
+
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L26, 'StatementDelimiter "}"'), $EXPECT($L112, 'StatementDelimiter ")"'), $EXPECT($L35, 'StatementDelimiter "]"'))));
|
|
10723
10734
|
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2];
|
|
10724
10735
|
function StatementDelimiter(ctx, state) {
|
|
10725
10736
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
@@ -10733,7 +10744,7 @@ var require_parser = __commonJS({
|
|
|
10733
10744
|
function SemicolonDelimiter(ctx, state) {
|
|
10734
10745
|
return $EVENT(ctx, state, "SemicolonDelimiter", SemicolonDelimiter$0);
|
|
10735
10746
|
}
|
|
10736
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
10747
|
+
var NonIdContinue$0 = $R$0($EXPECT($R65, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
10737
10748
|
function NonIdContinue(ctx, state) {
|
|
10738
10749
|
return $EVENT(ctx, state, "NonIdContinue", NonIdContinue$0);
|
|
10739
10750
|
}
|
|
@@ -10743,103 +10754,103 @@ var require_parser = __commonJS({
|
|
|
10743
10754
|
function Loc(ctx, state) {
|
|
10744
10755
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
10745
10756
|
}
|
|
10746
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
10757
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L113, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L12, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
10747
10758
|
return { $loc, token: $1, ts: true };
|
|
10748
10759
|
});
|
|
10749
10760
|
function Abstract(ctx, state) {
|
|
10750
10761
|
return $EVENT(ctx, state, "Abstract", Abstract$0);
|
|
10751
10762
|
}
|
|
10752
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
10763
|
+
var Ampersand$0 = $TV($EXPECT($L98, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
10753
10764
|
return { $loc, token: $1 };
|
|
10754
10765
|
});
|
|
10755
10766
|
function Ampersand(ctx, state) {
|
|
10756
10767
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
10757
10768
|
}
|
|
10758
|
-
var As$0 = $TS($S($EXPECT($
|
|
10769
|
+
var As$0 = $TS($S($EXPECT($L114, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10759
10770
|
return { $loc, token: $1 };
|
|
10760
10771
|
});
|
|
10761
10772
|
function As(ctx, state) {
|
|
10762
10773
|
return $EVENT(ctx, state, "As", As$0);
|
|
10763
10774
|
}
|
|
10764
|
-
var At$0 = $TV($EXPECT($
|
|
10775
|
+
var At$0 = $TV($EXPECT($L115, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
10765
10776
|
return { $loc, token: $1 };
|
|
10766
10777
|
});
|
|
10767
10778
|
function At(ctx, state) {
|
|
10768
10779
|
return $EVENT(ctx, state, "At", At$0);
|
|
10769
10780
|
}
|
|
10770
|
-
var AtAt$0 = $TV($EXPECT($
|
|
10781
|
+
var AtAt$0 = $TV($EXPECT($L116, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
10771
10782
|
return { $loc, token: "@" };
|
|
10772
10783
|
});
|
|
10773
10784
|
function AtAt(ctx, state) {
|
|
10774
10785
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
10775
10786
|
}
|
|
10776
|
-
var Async$0 = $TS($S($EXPECT($
|
|
10787
|
+
var Async$0 = $TS($S($EXPECT($L117, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10777
10788
|
return { $loc, token: $1, type: "Async" };
|
|
10778
10789
|
});
|
|
10779
10790
|
function Async(ctx, state) {
|
|
10780
10791
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
10781
10792
|
}
|
|
10782
|
-
var Await$0 = $TS($S($EXPECT($
|
|
10793
|
+
var Await$0 = $TS($S($EXPECT($L118, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10783
10794
|
return { $loc, token: $1, type: "Await" };
|
|
10784
10795
|
});
|
|
10785
10796
|
function Await(ctx, state) {
|
|
10786
10797
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
10787
10798
|
}
|
|
10788
|
-
var Backtick$0 = $TV($EXPECT($
|
|
10799
|
+
var Backtick$0 = $TV($EXPECT($L119, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
10789
10800
|
return { $loc, token: $1 };
|
|
10790
10801
|
});
|
|
10791
10802
|
function Backtick(ctx, state) {
|
|
10792
10803
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
10793
10804
|
}
|
|
10794
|
-
var By$0 = $TS($S($EXPECT($
|
|
10805
|
+
var By$0 = $TS($S($EXPECT($L120, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10795
10806
|
return { $loc, token: $1 };
|
|
10796
10807
|
});
|
|
10797
10808
|
function By(ctx, state) {
|
|
10798
10809
|
return $EVENT(ctx, state, "By", By$0);
|
|
10799
10810
|
}
|
|
10800
|
-
var Case$0 = $TS($S($EXPECT($
|
|
10811
|
+
var Case$0 = $TS($S($EXPECT($L121, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10801
10812
|
return { $loc, token: $1 };
|
|
10802
10813
|
});
|
|
10803
10814
|
function Case(ctx, state) {
|
|
10804
10815
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
10805
10816
|
}
|
|
10806
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
10817
|
+
var Catch$0 = $TS($S($EXPECT($L122, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10807
10818
|
return { $loc, token: $1 };
|
|
10808
10819
|
});
|
|
10809
10820
|
function Catch(ctx, state) {
|
|
10810
10821
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
10811
10822
|
}
|
|
10812
|
-
var Class$0 = $TS($S($EXPECT($
|
|
10823
|
+
var Class$0 = $TS($S($EXPECT($L123, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10813
10824
|
return { $loc, token: $1 };
|
|
10814
10825
|
});
|
|
10815
10826
|
function Class(ctx, state) {
|
|
10816
10827
|
return $EVENT(ctx, state, "Class", Class$0);
|
|
10817
10828
|
}
|
|
10818
|
-
var CloseAngleBracket$0 = $TV($EXPECT($
|
|
10829
|
+
var CloseAngleBracket$0 = $TV($EXPECT($L34, 'CloseAngleBracket ">"'), function($skip, $loc, $0, $1) {
|
|
10819
10830
|
return { $loc, token: $1 };
|
|
10820
10831
|
});
|
|
10821
10832
|
function CloseAngleBracket(ctx, state) {
|
|
10822
10833
|
return $EVENT(ctx, state, "CloseAngleBracket", CloseAngleBracket$0);
|
|
10823
10834
|
}
|
|
10824
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
10835
|
+
var CloseBrace$0 = $TV($EXPECT($L26, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
10825
10836
|
return { $loc, token: $1 };
|
|
10826
10837
|
});
|
|
10827
10838
|
function CloseBrace(ctx, state) {
|
|
10828
10839
|
return $EVENT(ctx, state, "CloseBrace", CloseBrace$0);
|
|
10829
10840
|
}
|
|
10830
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
10841
|
+
var CloseBracket$0 = $TV($EXPECT($L35, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
10831
10842
|
return { $loc, token: $1 };
|
|
10832
10843
|
});
|
|
10833
10844
|
function CloseBracket(ctx, state) {
|
|
10834
10845
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
10835
10846
|
}
|
|
10836
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
10847
|
+
var CloseParen$0 = $TV($EXPECT($L112, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
10837
10848
|
return { $loc, token: $1 };
|
|
10838
10849
|
});
|
|
10839
10850
|
function CloseParen(ctx, state) {
|
|
10840
10851
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
10841
10852
|
}
|
|
10842
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
10853
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L124, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
10843
10854
|
return { $loc, token: "${" };
|
|
10844
10855
|
});
|
|
10845
10856
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
@@ -10851,37 +10862,37 @@ var require_parser = __commonJS({
|
|
|
10851
10862
|
function Colon(ctx, state) {
|
|
10852
10863
|
return $EVENT(ctx, state, "Colon", Colon$0);
|
|
10853
10864
|
}
|
|
10854
|
-
var Comma$0 = $TV($EXPECT($
|
|
10865
|
+
var Comma$0 = $TV($EXPECT($L22, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
10855
10866
|
return { $loc, token: $1 };
|
|
10856
10867
|
});
|
|
10857
10868
|
function Comma(ctx, state) {
|
|
10858
10869
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
10859
10870
|
}
|
|
10860
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
10871
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L115, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
10861
10872
|
return { $loc, token: "constructor" };
|
|
10862
10873
|
});
|
|
10863
10874
|
function ConstructorShorthand(ctx, state) {
|
|
10864
10875
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
10865
10876
|
}
|
|
10866
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
10877
|
+
var Declare$0 = $TS($S($EXPECT($L125, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10867
10878
|
return { $loc, token: $1 };
|
|
10868
10879
|
});
|
|
10869
10880
|
function Declare(ctx, state) {
|
|
10870
10881
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
10871
10882
|
}
|
|
10872
|
-
var Default$0 = $TS($S($EXPECT($
|
|
10883
|
+
var Default$0 = $TS($S($EXPECT($L126, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10873
10884
|
return { $loc, token: $1 };
|
|
10874
10885
|
});
|
|
10875
10886
|
function Default(ctx, state) {
|
|
10876
10887
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
10877
10888
|
}
|
|
10878
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
10889
|
+
var Delete$0 = $TS($S($EXPECT($L127, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10879
10890
|
return { $loc, token: $1 };
|
|
10880
10891
|
});
|
|
10881
10892
|
function Delete(ctx, state) {
|
|
10882
10893
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
10883
10894
|
}
|
|
10884
|
-
var Do$0 = $TS($S($EXPECT($
|
|
10895
|
+
var Do$0 = $TS($S($EXPECT($L128, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10885
10896
|
return { $loc, token: $1 };
|
|
10886
10897
|
});
|
|
10887
10898
|
function Do(ctx, state) {
|
|
@@ -10890,7 +10901,7 @@ var require_parser = __commonJS({
|
|
|
10890
10901
|
var Dot$0 = $TV($EXPECT($L6, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
10891
10902
|
return { $loc, token: $1 };
|
|
10892
10903
|
});
|
|
10893
|
-
var Dot$1 = $TS($S($EXPECT($
|
|
10904
|
+
var Dot$1 = $TS($S($EXPECT($R66, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
|
|
10894
10905
|
var ws = $2;
|
|
10895
10906
|
return [
|
|
10896
10907
|
{ $loc, token: "." },
|
|
@@ -10901,45 +10912,45 @@ var require_parser = __commonJS({
|
|
|
10901
10912
|
function Dot(ctx, state) {
|
|
10902
10913
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
10903
10914
|
}
|
|
10904
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
10915
|
+
var DotDot$0 = $TS($S($EXPECT($L129, 'DotDot ".."'), $N($EXPECT($L6, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
10905
10916
|
return { $loc, token: $1 };
|
|
10906
10917
|
});
|
|
10907
|
-
var DotDot$1 = $TV($EXPECT($
|
|
10918
|
+
var DotDot$1 = $TV($EXPECT($L130, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
10908
10919
|
return { $loc, token: ".." };
|
|
10909
10920
|
});
|
|
10910
10921
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
10911
10922
|
function DotDot(ctx, state) {
|
|
10912
10923
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
10913
10924
|
}
|
|
10914
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
10925
|
+
var DotDotDot$0 = $TV($EXPECT($L131, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
10915
10926
|
return { $loc, token: $1 };
|
|
10916
10927
|
});
|
|
10917
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
10928
|
+
var DotDotDot$1 = $TV($EXPECT($L132, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
10918
10929
|
return { $loc, token: "..." };
|
|
10919
10930
|
});
|
|
10920
10931
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
10921
10932
|
function DotDotDot(ctx, state) {
|
|
10922
10933
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
10923
10934
|
}
|
|
10924
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
10935
|
+
var DoubleColon$0 = $TV($EXPECT($L133, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
10925
10936
|
return { $loc, token: $1 };
|
|
10926
10937
|
});
|
|
10927
10938
|
function DoubleColon(ctx, state) {
|
|
10928
10939
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
10929
10940
|
}
|
|
10930
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
10941
|
+
var DoubleQuote$0 = $TV($EXPECT($L134, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
10931
10942
|
return { $loc, token: $1 };
|
|
10932
10943
|
});
|
|
10933
10944
|
function DoubleQuote(ctx, state) {
|
|
10934
10945
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
10935
10946
|
}
|
|
10936
|
-
var Each$0 = $TS($S($EXPECT($
|
|
10947
|
+
var Each$0 = $TS($S($EXPECT($L135, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10937
10948
|
return { $loc, token: $1 };
|
|
10938
10949
|
});
|
|
10939
10950
|
function Each(ctx, state) {
|
|
10940
10951
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
10941
10952
|
}
|
|
10942
|
-
var Else$0 = $TS($S($EXPECT($
|
|
10953
|
+
var Else$0 = $TS($S($EXPECT($L136, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10943
10954
|
return { $loc, token: $1 };
|
|
10944
10955
|
});
|
|
10945
10956
|
function Else(ctx, state) {
|
|
@@ -10951,85 +10962,85 @@ var require_parser = __commonJS({
|
|
|
10951
10962
|
function Equals(ctx, state) {
|
|
10952
10963
|
return $EVENT(ctx, state, "Equals", Equals$0);
|
|
10953
10964
|
}
|
|
10954
|
-
var Export$0 = $TS($S($EXPECT($
|
|
10965
|
+
var Export$0 = $TS($S($EXPECT($L137, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10955
10966
|
return { $loc, token: $1 };
|
|
10956
10967
|
});
|
|
10957
10968
|
function Export(ctx, state) {
|
|
10958
10969
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
10959
10970
|
}
|
|
10960
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
10971
|
+
var Extends$0 = $TS($S($EXPECT($L138, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10961
10972
|
return { $loc, token: $1 };
|
|
10962
10973
|
});
|
|
10963
10974
|
function Extends(ctx, state) {
|
|
10964
10975
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
10965
10976
|
}
|
|
10966
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
10977
|
+
var Finally$0 = $TS($S($EXPECT($L139, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10967
10978
|
return { $loc, token: $1 };
|
|
10968
10979
|
});
|
|
10969
10980
|
function Finally(ctx, state) {
|
|
10970
10981
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
10971
10982
|
}
|
|
10972
|
-
var For$0 = $TS($S($EXPECT($
|
|
10983
|
+
var For$0 = $TS($S($EXPECT($L140, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10973
10984
|
return { $loc, token: $1 };
|
|
10974
10985
|
});
|
|
10975
10986
|
function For(ctx, state) {
|
|
10976
10987
|
return $EVENT(ctx, state, "For", For$0);
|
|
10977
10988
|
}
|
|
10978
|
-
var From$0 = $TS($S($EXPECT($
|
|
10989
|
+
var From$0 = $TS($S($EXPECT($L141, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10979
10990
|
return { $loc, token: $1 };
|
|
10980
10991
|
});
|
|
10981
10992
|
function From(ctx, state) {
|
|
10982
10993
|
return $EVENT(ctx, state, "From", From$0);
|
|
10983
10994
|
}
|
|
10984
|
-
var Function$0 = $TS($S($EXPECT($
|
|
10995
|
+
var Function$0 = $TS($S($EXPECT($L142, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10985
10996
|
return { $loc, token: $1 };
|
|
10986
10997
|
});
|
|
10987
10998
|
function Function(ctx, state) {
|
|
10988
10999
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
10989
11000
|
}
|
|
10990
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
11001
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L143, 'GetOrSet "get"'), $EXPECT($L144, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10991
11002
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
10992
11003
|
});
|
|
10993
11004
|
function GetOrSet(ctx, state) {
|
|
10994
11005
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
10995
11006
|
}
|
|
10996
|
-
var Hash$0 = $TV($EXPECT($
|
|
11007
|
+
var Hash$0 = $TV($EXPECT($L145, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
10997
11008
|
return { $loc, token: $1 };
|
|
10998
11009
|
});
|
|
10999
11010
|
function Hash(ctx, state) {
|
|
11000
11011
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
11001
11012
|
}
|
|
11002
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
11013
|
+
var If$0 = $TV($TEXT($S($EXPECT($L146, 'If "if"'), NonIdContinue, $E($EXPECT($L12, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
11003
11014
|
return { $loc, token: $1 };
|
|
11004
11015
|
});
|
|
11005
11016
|
function If(ctx, state) {
|
|
11006
11017
|
return $EVENT(ctx, state, "If", If$0);
|
|
11007
11018
|
}
|
|
11008
|
-
var Import$0 = $TS($S($EXPECT($
|
|
11019
|
+
var Import$0 = $TS($S($EXPECT($L16, 'Import "import"'), $Y($EXPECT($R67, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
11009
11020
|
return { $loc, token: $1 };
|
|
11010
11021
|
});
|
|
11011
11022
|
function Import(ctx, state) {
|
|
11012
11023
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
11013
11024
|
}
|
|
11014
|
-
var In$0 = $TS($S($EXPECT($
|
|
11025
|
+
var In$0 = $TS($S($EXPECT($L147, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11015
11026
|
return { $loc, token: $1 };
|
|
11016
11027
|
});
|
|
11017
11028
|
function In(ctx, state) {
|
|
11018
11029
|
return $EVENT(ctx, state, "In", In$0);
|
|
11019
11030
|
}
|
|
11020
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
11031
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L148, 'LetOrConst "let"'), $EXPECT($L149, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11021
11032
|
return { $loc, token: $1 };
|
|
11022
11033
|
});
|
|
11023
11034
|
function LetOrConst(ctx, state) {
|
|
11024
11035
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
11025
11036
|
}
|
|
11026
|
-
var Const$0 = $TS($S($EXPECT($
|
|
11037
|
+
var Const$0 = $TS($S($EXPECT($L149, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11027
11038
|
return { $loc, token: $1 };
|
|
11028
11039
|
});
|
|
11029
11040
|
function Const(ctx, state) {
|
|
11030
11041
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
11031
11042
|
}
|
|
11032
|
-
var Is$0 = $TS($S($EXPECT($
|
|
11043
|
+
var Is$0 = $TS($S($EXPECT($L150, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11033
11044
|
return { $loc, token: $1 };
|
|
11034
11045
|
});
|
|
11035
11046
|
function Is(ctx, state) {
|
|
@@ -11041,31 +11052,31 @@ var require_parser = __commonJS({
|
|
|
11041
11052
|
function LetOrConstOrVar(ctx, state) {
|
|
11042
11053
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
11043
11054
|
}
|
|
11044
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
11055
|
+
var Loop$0 = $TS($S($EXPECT($L151, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11045
11056
|
return { $loc, token: "while(true)" };
|
|
11046
11057
|
});
|
|
11047
11058
|
function Loop(ctx, state) {
|
|
11048
11059
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
11049
11060
|
}
|
|
11050
|
-
var New$0 = $TS($S($EXPECT($
|
|
11061
|
+
var New$0 = $TS($S($EXPECT($L152, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11051
11062
|
return { $loc, token: $1 };
|
|
11052
11063
|
});
|
|
11053
11064
|
function New(ctx, state) {
|
|
11054
11065
|
return $EVENT(ctx, state, "New", New$0);
|
|
11055
11066
|
}
|
|
11056
|
-
var Not$0 = $TS($S($EXPECT($
|
|
11067
|
+
var Not$0 = $TS($S($EXPECT($L153, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L11, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
11057
11068
|
return { $loc, token: "!" };
|
|
11058
11069
|
});
|
|
11059
11070
|
function Not(ctx, state) {
|
|
11060
11071
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
11061
11072
|
}
|
|
11062
|
-
var Of$0 = $TS($S($EXPECT($
|
|
11073
|
+
var Of$0 = $TS($S($EXPECT($L154, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11063
11074
|
return { $loc, token: $1 };
|
|
11064
11075
|
});
|
|
11065
11076
|
function Of(ctx, state) {
|
|
11066
11077
|
return $EVENT(ctx, state, "Of", Of$0);
|
|
11067
11078
|
}
|
|
11068
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
11079
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L13, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
11069
11080
|
return { $loc, token: $1 };
|
|
11070
11081
|
});
|
|
11071
11082
|
function OpenAngleBracket(ctx, state) {
|
|
@@ -11156,7 +11167,7 @@ var require_parser = __commonJS({
|
|
|
11156
11167
|
function Satisfies(ctx, state) {
|
|
11157
11168
|
return $EVENT(ctx, state, "Satisfies", Satisfies$0);
|
|
11158
11169
|
}
|
|
11159
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
11170
|
+
var Semicolon$0 = $TV($EXPECT($L100, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
11160
11171
|
return { $loc, token: $1 };
|
|
11161
11172
|
});
|
|
11162
11173
|
function Semicolon(ctx, state) {
|
|
@@ -11168,7 +11179,7 @@ var require_parser = __commonJS({
|
|
|
11168
11179
|
function SingleQuote(ctx, state) {
|
|
11169
11180
|
return $EVENT(ctx, state, "SingleQuote", SingleQuote$0);
|
|
11170
11181
|
}
|
|
11171
|
-
var Star$0 = $TV($EXPECT($
|
|
11182
|
+
var Star$0 = $TV($EXPECT($L55, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
11172
11183
|
return { $loc, token: $1 };
|
|
11173
11184
|
});
|
|
11174
11185
|
function Star(ctx, state) {
|
|
@@ -11177,7 +11188,7 @@ var require_parser = __commonJS({
|
|
|
11177
11188
|
var Static$0 = $TS($S($EXPECT($L171, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11178
11189
|
return { $loc, token: $1 };
|
|
11179
11190
|
});
|
|
11180
|
-
var Static$1 = $TS($S($EXPECT($
|
|
11191
|
+
var Static$1 = $TS($S($EXPECT($L115, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L115, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
11181
11192
|
return { $loc, token: "static " };
|
|
11182
11193
|
});
|
|
11183
11194
|
var Static$$ = [Static$0, Static$1];
|
|
@@ -11333,7 +11344,7 @@ var require_parser = __commonJS({
|
|
|
11333
11344
|
function JSXImplicitFragment(ctx, state) {
|
|
11334
11345
|
return $EVENT(ctx, state, "JSXImplicitFragment", JSXImplicitFragment$0);
|
|
11335
11346
|
}
|
|
11336
|
-
var JSXTag$0 = $T($S($EXPECT($
|
|
11347
|
+
var JSXTag$0 = $T($S($EXPECT($R68, "JSXTag /(?=[<])/"), _JSXTag), function(value) {
|
|
11337
11348
|
return value[1];
|
|
11338
11349
|
});
|
|
11339
11350
|
function JSXTag(ctx, state) {
|
|
@@ -11383,7 +11394,7 @@ var require_parser = __commonJS({
|
|
|
11383
11394
|
function JSXElement(ctx, state) {
|
|
11384
11395
|
return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
|
|
11385
11396
|
}
|
|
11386
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
11397
|
+
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) {
|
|
11387
11398
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
11388
11399
|
});
|
|
11389
11400
|
function JSXSelfClosingElement(ctx, state) {
|
|
@@ -11402,7 +11413,7 @@ var require_parser = __commonJS({
|
|
|
11402
11413
|
function PopJSXStack(ctx, state) {
|
|
11403
11414
|
return $EVENT(ctx, state, "PopJSXStack", PopJSXStack$0);
|
|
11404
11415
|
}
|
|
11405
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
11416
|
+
var JSXOpeningElement$0 = $S($EXPECT($L13, 'JSXOpeningElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L34, 'JSXOpeningElement ">"'));
|
|
11406
11417
|
function JSXOpeningElement(ctx, state) {
|
|
11407
11418
|
return $EVENT(ctx, state, "JSXOpeningElement", JSXOpeningElement$0);
|
|
11408
11419
|
}
|
|
@@ -11417,7 +11428,7 @@ var require_parser = __commonJS({
|
|
|
11417
11428
|
function JSXOptionalClosingElement(ctx, state) {
|
|
11418
11429
|
return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
|
|
11419
11430
|
}
|
|
11420
|
-
var JSXClosingElement$0 = $S($EXPECT($L194, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($
|
|
11431
|
+
var JSXClosingElement$0 = $S($EXPECT($L194, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L34, 'JSXClosingElement ">"'));
|
|
11421
11432
|
function JSXClosingElement(ctx, state) {
|
|
11422
11433
|
return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
|
|
11423
11434
|
}
|
|
@@ -11472,7 +11483,7 @@ var require_parser = __commonJS({
|
|
|
11472
11483
|
function JSXClosingFragment(ctx, state) {
|
|
11473
11484
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
11474
11485
|
}
|
|
11475
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
11486
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L145, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
11476
11487
|
return module2.config.defaultElement;
|
|
11477
11488
|
});
|
|
11478
11489
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -11480,7 +11491,7 @@ var require_parser = __commonJS({
|
|
|
11480
11491
|
function JSXElementName(ctx, state) {
|
|
11481
11492
|
return $EVENT_C(ctx, state, "JSXElementName", JSXElementName$$);
|
|
11482
11493
|
}
|
|
11483
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
11494
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R69, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
11484
11495
|
function JSXIdentifierName(ctx, state) {
|
|
11485
11496
|
return $EVENT(ctx, state, "JSXIdentifierName", JSXIdentifierName$0);
|
|
11486
11497
|
}
|
|
@@ -11644,7 +11655,7 @@ var require_parser = __commonJS({
|
|
|
11644
11655
|
}
|
|
11645
11656
|
return $skip;
|
|
11646
11657
|
});
|
|
11647
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
11658
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L145, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
11648
11659
|
return [" ", "id=", $2];
|
|
11649
11660
|
});
|
|
11650
11661
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -11663,11 +11674,11 @@ var require_parser = __commonJS({
|
|
|
11663
11674
|
function JSXAttribute(ctx, state) {
|
|
11664
11675
|
return $EVENT_C(ctx, state, "JSXAttribute", JSXAttribute$$);
|
|
11665
11676
|
}
|
|
11666
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
11677
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R70, "JSXAttributeSpace /[\\s>]|\\/>/"));
|
|
11667
11678
|
function JSXAttributeSpace(ctx, state) {
|
|
11668
11679
|
return $EVENT(ctx, state, "JSXAttributeSpace", JSXAttributeSpace$0);
|
|
11669
11680
|
}
|
|
11670
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
11681
|
+
var JSXShorthandString$0 = $TR($EXPECT($R71, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11671
11682
|
return quoteString($0);
|
|
11672
11683
|
});
|
|
11673
11684
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -11701,7 +11712,7 @@ var require_parser = __commonJS({
|
|
|
11701
11712
|
}
|
|
11702
11713
|
return [open, value, close];
|
|
11703
11714
|
});
|
|
11704
|
-
var JSXAttributeValue$4 = $R$0($EXPECT($
|
|
11715
|
+
var JSXAttributeValue$4 = $R$0($EXPECT($R72, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
|
|
11705
11716
|
var JSXAttributeValue$$ = [JSXAttributeValue$0, JSXAttributeValue$1, JSXAttributeValue$2, JSXAttributeValue$3, JSXAttributeValue$4];
|
|
11706
11717
|
function JSXAttributeValue(ctx, state) {
|
|
11707
11718
|
return $EVENT_C(ctx, state, "JSXAttributeValue", JSXAttributeValue$$);
|
|
@@ -11714,7 +11725,7 @@ var require_parser = __commonJS({
|
|
|
11714
11725
|
function InlineJSXAttributeValue(ctx, state) {
|
|
11715
11726
|
return $EVENT(ctx, state, "InlineJSXAttributeValue", InlineJSXAttributeValue$0);
|
|
11716
11727
|
}
|
|
11717
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
11728
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R73, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
11718
11729
|
var op = $2;
|
|
11719
11730
|
var rhs = $3;
|
|
11720
11731
|
return [[], op, [], rhs];
|
|
@@ -11731,7 +11742,7 @@ var require_parser = __commonJS({
|
|
|
11731
11742
|
function InlineJSXUnaryExpression(ctx, state) {
|
|
11732
11743
|
return $EVENT(ctx, state, "InlineJSXUnaryExpression", InlineJSXUnaryExpression$0);
|
|
11733
11744
|
}
|
|
11734
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
11745
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R74, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11735
11746
|
return { $loc, token: $0 };
|
|
11736
11747
|
});
|
|
11737
11748
|
function InlineJSXUnaryOp(ctx, state) {
|
|
@@ -11763,7 +11774,7 @@ var require_parser = __commonJS({
|
|
|
11763
11774
|
]
|
|
11764
11775
|
});
|
|
11765
11776
|
});
|
|
11766
|
-
var InlineJSXCallExpression$1 = $TS($S($EXPECT($
|
|
11777
|
+
var InlineJSXCallExpression$1 = $TS($S($EXPECT($L16, 'InlineJSXCallExpression "import"'), ExplicitArguments, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
11767
11778
|
var args = $2;
|
|
11768
11779
|
var rest = $3;
|
|
11769
11780
|
return processCallMemberExpression({
|
|
@@ -11882,7 +11893,7 @@ var require_parser = __commonJS({
|
|
|
11882
11893
|
}
|
|
11883
11894
|
return $skip;
|
|
11884
11895
|
});
|
|
11885
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
11896
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L26, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
11886
11897
|
return { children: [], jsxChildren: [] };
|
|
11887
11898
|
});
|
|
11888
11899
|
var JSXNestedChildren$$ = [JSXNestedChildren$0, JSXNestedChildren$1];
|
|
@@ -11943,13 +11954,13 @@ var require_parser = __commonJS({
|
|
|
11943
11954
|
function JSXComment(ctx, state) {
|
|
11944
11955
|
return $EVENT(ctx, state, "JSXComment", JSXComment$0);
|
|
11945
11956
|
}
|
|
11946
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
11957
|
+
var JSXCommentContent$0 = $TR($EXPECT($R75, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11947
11958
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
11948
11959
|
});
|
|
11949
11960
|
function JSXCommentContent(ctx, state) {
|
|
11950
11961
|
return $EVENT(ctx, state, "JSXCommentContent", JSXCommentContent$0);
|
|
11951
11962
|
}
|
|
11952
|
-
var JSXText$0 = $TR($EXPECT($
|
|
11963
|
+
var JSXText$0 = $TR($EXPECT($R76, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11953
11964
|
return {
|
|
11954
11965
|
type: "JSXText",
|
|
11955
11966
|
token: $0,
|
|
@@ -12314,7 +12325,7 @@ var require_parser = __commonJS({
|
|
|
12314
12325
|
function TypeProperty(ctx, state) {
|
|
12315
12326
|
return $EVENT(ctx, state, "TypeProperty", TypeProperty$0);
|
|
12316
12327
|
}
|
|
12317
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
12328
|
+
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)))));
|
|
12318
12329
|
function TypeIndexSignature(ctx, state) {
|
|
12319
12330
|
return $EVENT(ctx, state, "TypeIndexSignature", TypeIndexSignature$0);
|
|
12320
12331
|
}
|
|
@@ -12365,7 +12376,7 @@ var require_parser = __commonJS({
|
|
|
12365
12376
|
function ReturnType(ctx, state) {
|
|
12366
12377
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
12367
12378
|
}
|
|
12368
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
12379
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L150, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
12369
12380
|
var lhs = $1;
|
|
12370
12381
|
var rhs = $2;
|
|
12371
12382
|
if (!rhs)
|
|
@@ -12466,8 +12477,8 @@ var require_parser = __commonJS({
|
|
|
12466
12477
|
function TypePrimary(ctx, state) {
|
|
12467
12478
|
return $EVENT_C(ctx, state, "TypePrimary", TypePrimary$$);
|
|
12468
12479
|
}
|
|
12469
|
-
var ImportType$0 = $S($EXPECT($
|
|
12470
|
-
var ImportType$1 = $S($EXPECT($
|
|
12480
|
+
var ImportType$0 = $S($EXPECT($L16, 'ImportType "import"'), OpenParen, __, StringLiteral, __, CloseParen, $E($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
12481
|
+
var ImportType$1 = $S($EXPECT($L16, 'ImportType "import"'), InsertOpenParen, Trimmed_, StringLiteral, InsertCloseParen);
|
|
12471
12482
|
var ImportType$$ = [ImportType$0, ImportType$1];
|
|
12472
12483
|
function ImportType(ctx, state) {
|
|
12473
12484
|
return $EVENT_C(ctx, state, "ImportType", ImportType$$);
|
|
@@ -12527,7 +12538,7 @@ var require_parser = __commonJS({
|
|
|
12527
12538
|
function NestedType(ctx, state) {
|
|
12528
12539
|
return $EVENT(ctx, state, "NestedType", NestedType$0);
|
|
12529
12540
|
}
|
|
12530
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
12541
|
+
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) {
|
|
12531
12542
|
if ($2)
|
|
12532
12543
|
return $0;
|
|
12533
12544
|
return $1;
|
|
@@ -12587,16 +12598,16 @@ var require_parser = __commonJS({
|
|
|
12587
12598
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
12588
12599
|
return value[1];
|
|
12589
12600
|
});
|
|
12590
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($
|
|
12601
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L112, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L35, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L26, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
12591
12602
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
12592
12603
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
12593
12604
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
12594
12605
|
return $EVENT_C(ctx, state, "InlineInterfacePropertyDelimiter", InlineInterfacePropertyDelimiter$$);
|
|
12595
12606
|
}
|
|
12596
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
12607
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L99, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
12597
12608
|
return { $loc, token: "|" };
|
|
12598
12609
|
});
|
|
12599
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
12610
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L98, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
12600
12611
|
return { $loc, token: "&" };
|
|
12601
12612
|
});
|
|
12602
12613
|
var TypeBinaryOp$$ = [TypeBinaryOp$0, TypeBinaryOp$1];
|
|
@@ -12613,7 +12624,7 @@ var require_parser = __commonJS({
|
|
|
12613
12624
|
function FunctionType(ctx, state) {
|
|
12614
12625
|
return $EVENT(ctx, state, "FunctionType", FunctionType$0);
|
|
12615
12626
|
}
|
|
12616
|
-
var TypeArrowFunction$0 = $TV($C($EXPECT($L9, 'TypeArrowFunction "=>"'), $EXPECT($L10, 'TypeArrowFunction "\u21D2"'), $EXPECT($
|
|
12627
|
+
var TypeArrowFunction$0 = $TV($C($EXPECT($L9, 'TypeArrowFunction "=>"'), $EXPECT($L10, 'TypeArrowFunction "\u21D2"'), $EXPECT($L24, 'TypeArrowFunction "->"'), $EXPECT($L25, 'TypeArrowFunction "\u2192"')), function($skip, $loc, $0, $1) {
|
|
12617
12628
|
return { $loc, token: "=>" };
|
|
12618
12629
|
});
|
|
12619
12630
|
function TypeArrowFunction(ctx, state) {
|
|
@@ -12651,11 +12662,11 @@ var require_parser = __commonJS({
|
|
|
12651
12662
|
function TypeParameters(ctx, state) {
|
|
12652
12663
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
12653
12664
|
}
|
|
12654
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
12665
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L149, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
12655
12666
|
function TypeParameter(ctx, state) {
|
|
12656
12667
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
12657
12668
|
}
|
|
12658
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
12669
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L138, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
12659
12670
|
function TypeConstraint(ctx, state) {
|
|
12660
12671
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
12661
12672
|
}
|
|
@@ -12664,7 +12675,7 @@ var require_parser = __commonJS({
|
|
|
12664
12675
|
return $EVENT(ctx, state, "TypeInitializer", TypeInitializer$0);
|
|
12665
12676
|
}
|
|
12666
12677
|
var TypeParameterDelimiter$0 = $S($E(_), Comma);
|
|
12667
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
12678
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L34, 'TypeParameterDelimiter ">"')));
|
|
12668
12679
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
12669
12680
|
return value[1];
|
|
12670
12681
|
});
|
|
@@ -12678,15 +12689,15 @@ var require_parser = __commonJS({
|
|
|
12678
12689
|
function ThisType(ctx, state) {
|
|
12679
12690
|
return $EVENT(ctx, state, "ThisType", ThisType$0);
|
|
12680
12691
|
}
|
|
12681
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
12692
|
+
var Shebang$0 = $S($R$0($EXPECT($R79, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
12682
12693
|
function Shebang(ctx, state) {
|
|
12683
12694
|
return $EVENT(ctx, state, "Shebang", Shebang$0);
|
|
12684
12695
|
}
|
|
12685
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
12696
|
+
var CivetPrologue$0 = $T($S($EXPECT($R80, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, SimpleStatementDelimiter, $EXPECT($R81, "CivetPrologue /[ \\t]*/"), $C(EOL, $Y(RestOfLine))), function(value) {
|
|
12686
12697
|
var content = value[2];
|
|
12687
12698
|
return content;
|
|
12688
12699
|
});
|
|
12689
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
12700
|
+
var CivetPrologue$1 = $T($S($EXPECT($R80, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, SimpleStatementDelimiter, $EXPECT($R81, "CivetPrologue /[ \\t]*/"), $C(EOL, $Y(RestOfLine))), function(value) {
|
|
12690
12701
|
var content = value[2];
|
|
12691
12702
|
return content;
|
|
12692
12703
|
});
|
|
@@ -12694,7 +12705,7 @@ var require_parser = __commonJS({
|
|
|
12694
12705
|
function CivetPrologue(ctx, state) {
|
|
12695
12706
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
12696
12707
|
}
|
|
12697
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($
|
|
12708
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R82, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
12698
12709
|
var options = $3;
|
|
12699
12710
|
return {
|
|
12700
12711
|
type: "CivetPrologue",
|
|
@@ -12705,7 +12716,7 @@ var require_parser = __commonJS({
|
|
|
12705
12716
|
function CivetPrologueContent(ctx, state) {
|
|
12706
12717
|
return $EVENT(ctx, state, "CivetPrologueContent", CivetPrologueContent$0);
|
|
12707
12718
|
}
|
|
12708
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
12719
|
+
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) {
|
|
12709
12720
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
12710
12721
|
if (l)
|
|
12711
12722
|
return l.toUpperCase();
|
|
@@ -12722,11 +12733,11 @@ var require_parser = __commonJS({
|
|
|
12722
12733
|
function CivetOption(ctx, state) {
|
|
12723
12734
|
return $EVENT(ctx, state, "CivetOption", CivetOption$0);
|
|
12724
12735
|
}
|
|
12725
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
12736
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R80, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
12726
12737
|
function UnknownPrologue(ctx, state) {
|
|
12727
12738
|
return $EVENT(ctx, state, "UnknownPrologue", UnknownPrologue$0);
|
|
12728
12739
|
}
|
|
12729
|
-
var TripleSlashDirective$0 = $S($R$0($EXPECT($
|
|
12740
|
+
var TripleSlashDirective$0 = $S($R$0($EXPECT($R84, "TripleSlashDirective /\\/\\/\\/[^\\r\\n]*/")), $E(EOS));
|
|
12730
12741
|
function TripleSlashDirective(ctx, state) {
|
|
12731
12742
|
return $EVENT(ctx, state, "TripleSlashDirective", TripleSlashDirective$0);
|
|
12732
12743
|
}
|
|
@@ -12740,13 +12751,13 @@ var require_parser = __commonJS({
|
|
|
12740
12751
|
function PrologueString(ctx, state) {
|
|
12741
12752
|
return $EVENT_C(ctx, state, "PrologueString", PrologueString$$);
|
|
12742
12753
|
}
|
|
12743
|
-
var EOS$0 = $T($S($EXPECT($
|
|
12754
|
+
var EOS$0 = $T($S($EXPECT($R85, "EOS /(?=[ \\t\\r\\n\\/#]|$)/"), $P(RestOfLine)), function(value) {
|
|
12744
12755
|
return value[1];
|
|
12745
12756
|
});
|
|
12746
12757
|
function EOS(ctx, state) {
|
|
12747
12758
|
return $EVENT(ctx, state, "EOS", EOS$0);
|
|
12748
12759
|
}
|
|
12749
|
-
var EOL$0 = $TR($EXPECT($
|
|
12760
|
+
var EOL$0 = $TR($EXPECT($R86, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12750
12761
|
return { $loc, token: $0 };
|
|
12751
12762
|
});
|
|
12752
12763
|
function EOL(ctx, state) {
|
|
@@ -13266,7 +13277,7 @@ var require_parser = __commonJS({
|
|
|
13266
13277
|
function Init(ctx, state) {
|
|
13267
13278
|
return $EVENT(ctx, state, "Init", Init$0);
|
|
13268
13279
|
}
|
|
13269
|
-
var Indent$0 = $TR($EXPECT($
|
|
13280
|
+
var Indent$0 = $TR($EXPECT($R81, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
13270
13281
|
const level = getIndentLevel($0, module2.config.tab);
|
|
13271
13282
|
return {
|
|
13272
13283
|
$loc,
|
|
@@ -13448,6 +13459,7 @@ var require_parser = __commonJS({
|
|
|
13448
13459
|
exports.ClassHeritage = ClassHeritage;
|
|
13449
13460
|
exports.ExtendsClause = ExtendsClause;
|
|
13450
13461
|
exports.ExtendsToken = ExtendsToken;
|
|
13462
|
+
exports.ExtendsShorthand = ExtendsShorthand;
|
|
13451
13463
|
exports.ExtendsTarget = ExtendsTarget;
|
|
13452
13464
|
exports.ImplementsClause = ImplementsClause;
|
|
13453
13465
|
exports.ImplementsToken = ImplementsToken;
|
|
@@ -13688,6 +13700,7 @@ var require_parser = __commonJS({
|
|
|
13688
13700
|
exports.DeclarationCondition = DeclarationCondition;
|
|
13689
13701
|
exports.ExpressionWithIndentedApplicationForbidden = ExpressionWithIndentedApplicationForbidden;
|
|
13690
13702
|
exports.ExpressionWithObjectApplicationForbidden = ExpressionWithObjectApplicationForbidden;
|
|
13703
|
+
exports.LeftHandSideExpressionWithObjectApplicationForbidden = LeftHandSideExpressionWithObjectApplicationForbidden;
|
|
13691
13704
|
exports.ForbidClassImplicitCall = ForbidClassImplicitCall;
|
|
13692
13705
|
exports.AllowClassImplicitCall = AllowClassImplicitCall;
|
|
13693
13706
|
exports.RestoreClassImplicitCall = RestoreClassImplicitCall;
|