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