@danielx/civet 0.6.52 → 0.6.54
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 +528 -475
- package/dist/esbuild.js +107 -69
- package/dist/main.js +528 -475
- package/dist/main.mjs +528 -475
- 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
|
@@ -2734,7 +2734,7 @@ var require_lib = __commonJS({
|
|
|
2734
2734
|
conditions.push([
|
|
2735
2735
|
ref,
|
|
2736
2736
|
" === ",
|
|
2737
|
-
pattern.
|
|
2737
|
+
pattern.expression
|
|
2738
2738
|
]);
|
|
2739
2739
|
break;
|
|
2740
2740
|
case "Literal":
|
|
@@ -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,
|
|
@@ -3855,6 +3856,7 @@ var require_parser = __commonJS({
|
|
|
3855
3856
|
OptionalDot,
|
|
3856
3857
|
NonNullAssertion,
|
|
3857
3858
|
MemberExpression,
|
|
3859
|
+
ActualMemberExpression,
|
|
3858
3860
|
MemberBase,
|
|
3859
3861
|
MemberExpressionRest,
|
|
3860
3862
|
MemberExpressionRestBody,
|
|
@@ -4067,7 +4069,9 @@ var require_parser = __commonJS({
|
|
|
4067
4069
|
Condition,
|
|
4068
4070
|
DeclarationCondition,
|
|
4069
4071
|
ExpressionWithIndentedApplicationForbidden,
|
|
4072
|
+
SingleLineExpressionWithIndentedApplicationForbidden,
|
|
4070
4073
|
ExpressionWithObjectApplicationForbidden,
|
|
4074
|
+
LeftHandSideExpressionWithObjectApplicationForbidden,
|
|
4071
4075
|
ForbidClassImplicitCall,
|
|
4072
4076
|
AllowClassImplicitCall,
|
|
4073
4077
|
RestoreClassImplicitCall,
|
|
@@ -4200,6 +4204,7 @@ var require_parser = __commonJS({
|
|
|
4200
4204
|
Await,
|
|
4201
4205
|
Backtick,
|
|
4202
4206
|
By,
|
|
4207
|
+
Caret,
|
|
4203
4208
|
Case,
|
|
4204
4209
|
Catch,
|
|
4205
4210
|
Class,
|
|
@@ -4473,148 +4478,148 @@ var require_parser = __commonJS({
|
|
|
4473
4478
|
var $L10 = $L("\u21D2");
|
|
4474
4479
|
var $L11 = $L(":");
|
|
4475
4480
|
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("
|
|
4481
|
+
var $L13 = $L("<");
|
|
4482
|
+
var $L14 = $L("implements");
|
|
4483
|
+
var $L15 = $L("<:");
|
|
4484
|
+
var $L16 = $L("import");
|
|
4485
|
+
var $L17 = $L("!");
|
|
4486
|
+
var $L18 = $L("^");
|
|
4487
|
+
var $L19 = $L("-");
|
|
4488
|
+
var $L20 = $L("import.meta");
|
|
4489
|
+
var $L21 = $L("return.value");
|
|
4490
|
+
var $L22 = $L(",");
|
|
4491
|
+
var $L23 = $L("(&)");
|
|
4492
|
+
var $L24 = $L("->");
|
|
4493
|
+
var $L25 = $L("\u2192");
|
|
4494
|
+
var $L26 = $L("}");
|
|
4495
|
+
var $L27 = $L("null");
|
|
4496
|
+
var $L28 = $L("true");
|
|
4497
|
+
var $L29 = $L("false");
|
|
4498
|
+
var $L30 = $L("yes");
|
|
4499
|
+
var $L31 = $L("on");
|
|
4500
|
+
var $L32 = $L("no");
|
|
4501
|
+
var $L33 = $L("off");
|
|
4502
|
+
var $L34 = $L(">");
|
|
4503
|
+
var $L35 = $L("]");
|
|
4504
|
+
var $L36 = $L("**=");
|
|
4505
|
+
var $L37 = $L("*=");
|
|
4506
|
+
var $L38 = $L("/=");
|
|
4507
|
+
var $L39 = $L("%=");
|
|
4508
|
+
var $L40 = $L("+=");
|
|
4509
|
+
var $L41 = $L("-=");
|
|
4510
|
+
var $L42 = $L("<<=");
|
|
4511
|
+
var $L43 = $L(">>>=");
|
|
4512
|
+
var $L44 = $L(">>=");
|
|
4513
|
+
var $L45 = $L("&&=");
|
|
4514
|
+
var $L46 = $L("&=");
|
|
4515
|
+
var $L47 = $L("^=");
|
|
4516
|
+
var $L48 = $L("||=");
|
|
4517
|
+
var $L49 = $L("|=");
|
|
4518
|
+
var $L50 = $L("??=");
|
|
4519
|
+
var $L51 = $L("?=");
|
|
4520
|
+
var $L52 = $L("and=");
|
|
4521
|
+
var $L53 = $L("or=");
|
|
4522
|
+
var $L54 = $L("**");
|
|
4523
|
+
var $L55 = $L("*");
|
|
4524
|
+
var $L56 = $L("/");
|
|
4525
|
+
var $L57 = $L("%%");
|
|
4526
|
+
var $L58 = $L("%");
|
|
4527
|
+
var $L59 = $L("+");
|
|
4528
|
+
var $L60 = $L("<=");
|
|
4529
|
+
var $L61 = $L("\u2264");
|
|
4530
|
+
var $L62 = $L(">=");
|
|
4531
|
+
var $L63 = $L("\u2265");
|
|
4532
|
+
var $L64 = $L("<?");
|
|
4533
|
+
var $L65 = $L("!<?");
|
|
4534
|
+
var $L66 = $L("<<");
|
|
4535
|
+
var $L67 = $L("\xAB");
|
|
4536
|
+
var $L68 = $L(">>>");
|
|
4537
|
+
var $L69 = $L("\u22D9");
|
|
4538
|
+
var $L70 = $L(">>");
|
|
4539
|
+
var $L71 = $L("\xBB");
|
|
4540
|
+
var $L72 = $L("!==");
|
|
4541
|
+
var $L73 = $L("\u2262");
|
|
4542
|
+
var $L74 = $L("!=");
|
|
4543
|
+
var $L75 = $L("\u2260");
|
|
4544
|
+
var $L76 = $L("isnt");
|
|
4545
|
+
var $L77 = $L("===");
|
|
4546
|
+
var $L78 = $L("\u2263");
|
|
4547
|
+
var $L79 = $L("\u2A76");
|
|
4548
|
+
var $L80 = $L("==");
|
|
4549
|
+
var $L81 = $L("\u2261");
|
|
4550
|
+
var $L82 = $L("\u2A75");
|
|
4551
|
+
var $L83 = $L("and");
|
|
4552
|
+
var $L84 = $L("&&");
|
|
4553
|
+
var $L85 = $L("or");
|
|
4554
|
+
var $L86 = $L("||");
|
|
4555
|
+
var $L87 = $L("\u2016");
|
|
4556
|
+
var $L88 = $L("^^");
|
|
4557
|
+
var $L89 = $L("xor");
|
|
4558
|
+
var $L90 = $L("xnor");
|
|
4559
|
+
var $L91 = $L("??");
|
|
4560
|
+
var $L92 = $L("\u2047");
|
|
4561
|
+
var $L93 = $L("instanceof");
|
|
4562
|
+
var $L94 = $L("\u2208");
|
|
4563
|
+
var $L95 = $L("\u220B");
|
|
4564
|
+
var $L96 = $L("\u220C");
|
|
4565
|
+
var $L97 = $L("\u2209");
|
|
4566
|
+
var $L98 = $L("&");
|
|
4567
|
+
var $L99 = $L("|");
|
|
4568
|
+
var $L100 = $L(";");
|
|
4569
|
+
var $L101 = $L("$:");
|
|
4570
|
+
var $L102 = $L("break");
|
|
4571
|
+
var $L103 = $L("continue");
|
|
4572
|
+
var $L104 = $L("debugger");
|
|
4573
|
+
var $L105 = $L("assert");
|
|
4574
|
+
var $L106 = $L(":=");
|
|
4575
|
+
var $L107 = $L("\u2254");
|
|
4576
|
+
var $L108 = $L(".=");
|
|
4577
|
+
var $L109 = $L("/*");
|
|
4578
|
+
var $L110 = $L("*/");
|
|
4579
|
+
var $L111 = $L("\\");
|
|
4580
|
+
var $L112 = $L(")");
|
|
4581
|
+
var $L113 = $L("abstract");
|
|
4582
|
+
var $L114 = $L("as");
|
|
4583
|
+
var $L115 = $L("@");
|
|
4584
|
+
var $L116 = $L("@@");
|
|
4585
|
+
var $L117 = $L("async");
|
|
4586
|
+
var $L118 = $L("await");
|
|
4587
|
+
var $L119 = $L("`");
|
|
4588
|
+
var $L120 = $L("by");
|
|
4589
|
+
var $L121 = $L("case");
|
|
4590
|
+
var $L122 = $L("catch");
|
|
4591
|
+
var $L123 = $L("class");
|
|
4592
|
+
var $L124 = $L("#{");
|
|
4593
|
+
var $L125 = $L("declare");
|
|
4594
|
+
var $L126 = $L("default");
|
|
4595
|
+
var $L127 = $L("delete");
|
|
4596
|
+
var $L128 = $L("do");
|
|
4597
|
+
var $L129 = $L("..");
|
|
4598
|
+
var $L130 = $L("\u2025");
|
|
4599
|
+
var $L131 = $L("...");
|
|
4600
|
+
var $L132 = $L("\u2026");
|
|
4601
|
+
var $L133 = $L("::");
|
|
4602
|
+
var $L134 = $L('"');
|
|
4603
|
+
var $L135 = $L("each");
|
|
4604
|
+
var $L136 = $L("else");
|
|
4605
|
+
var $L137 = $L("export");
|
|
4606
|
+
var $L138 = $L("extends");
|
|
4607
|
+
var $L139 = $L("finally");
|
|
4608
|
+
var $L140 = $L("for");
|
|
4609
|
+
var $L141 = $L("from");
|
|
4610
|
+
var $L142 = $L("function");
|
|
4611
|
+
var $L143 = $L("get");
|
|
4612
|
+
var $L144 = $L("set");
|
|
4613
|
+
var $L145 = $L("#");
|
|
4614
|
+
var $L146 = $L("if");
|
|
4615
|
+
var $L147 = $L("in");
|
|
4616
|
+
var $L148 = $L("let");
|
|
4617
|
+
var $L149 = $L("const");
|
|
4618
|
+
var $L150 = $L("is");
|
|
4619
|
+
var $L151 = $L("loop");
|
|
4620
|
+
var $L152 = $L("new");
|
|
4621
|
+
var $L153 = $L("not");
|
|
4622
|
+
var $L154 = $L("of");
|
|
4618
4623
|
var $L155 = $L("[");
|
|
4619
4624
|
var $L156 = $L("operator");
|
|
4620
4625
|
var $L157 = $L("own");
|
|
@@ -4688,77 +4693,76 @@ var require_parser = __commonJS({
|
|
|
4688
4693
|
var $R14 = $R(new RegExp("(?=\\[)", "suy"));
|
|
4689
4694
|
var $R15 = $R(new RegExp("[!+-]", "suy"));
|
|
4690
4695
|
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"));
|
|
4696
|
+
var $R17 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
4697
|
+
var $R18 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*(&|\\.[^0-9]))", "suy"));
|
|
4698
|
+
var $R19 = $R(new RegExp("(?=for|if|loop|unless|until|while)", "suy"));
|
|
4699
|
+
var $R20 = $R(new RegExp("(?=loop|do|for|until|while)", "suy"));
|
|
4700
|
+
var $R21 = $R(new RegExp("(?=[\\s\\),])", "suy"));
|
|
4701
|
+
var $R22 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
4702
|
+
var $R23 = $R(new RegExp("(?=[0-9.])", "suy"));
|
|
4703
|
+
var $R24 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
4704
|
+
var $R25 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
4705
|
+
var $R26 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
4706
|
+
var $R27 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4707
|
+
var $R28 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
4708
|
+
var $R29 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
4709
|
+
var $R30 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
4710
|
+
var $R31 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
4711
|
+
var $R32 = $R(new RegExp("(?=[0-9])", "suy"));
|
|
4712
|
+
var $R33 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4713
|
+
var $R34 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
4714
|
+
var $R35 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
4715
|
+
var $R36 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
4716
|
+
var $R37 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
4717
|
+
var $R38 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
4718
|
+
var $R39 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
4719
|
+
var $R40 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
4720
|
+
var $R41 = $R(new RegExp("[\\s]+", "suy"));
|
|
4721
|
+
var $R42 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
4722
|
+
var $R43 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
4723
|
+
var $R44 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
4724
|
+
var $R45 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
4725
|
+
var $R46 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
4726
|
+
var $R47 = $R(new RegExp("(?=[`'\"])", "suy"));
|
|
4727
|
+
var $R48 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
4728
|
+
var $R49 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
4729
|
+
var $R50 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
4730
|
+
var $R51 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
4731
|
+
var $R52 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
4732
|
+
var $R53 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
4733
|
+
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"));
|
|
4734
|
+
var $R55 = $R(new RegExp("(?=\\/|#)", "suy"));
|
|
4735
|
+
var $R56 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
4736
|
+
var $R57 = $R(new RegExp(".", "suy"));
|
|
4737
|
+
var $R58 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
4738
|
+
var $R59 = $R(new RegExp("[^]*?###", "suy"));
|
|
4739
|
+
var $R60 = $R(new RegExp("###(?!#)", "suy"));
|
|
4740
|
+
var $R61 = $R(new RegExp("\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\/", "suy"));
|
|
4741
|
+
var $R62 = $R(new RegExp("(?=[ \\t\\/\\\\])", "suy"));
|
|
4742
|
+
var $R63 = $R(new RegExp("[ \\t]+", "suy"));
|
|
4743
|
+
var $R64 = $R(new RegExp("(?=\\s|\\/|#)", "suy"));
|
|
4744
|
+
var $R65 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
4745
|
+
var $R66 = $R(new RegExp("['\u2019]s", "suy"));
|
|
4746
|
+
var $R67 = $R(new RegExp("\\s", "suy"));
|
|
4747
|
+
var $R68 = $R(new RegExp("(?=[<])", "suy"));
|
|
4748
|
+
var $R69 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
4749
|
+
var $R70 = $R(new RegExp("[\\s>]|\\/>", "suy"));
|
|
4750
|
+
var $R71 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
4751
|
+
var $R72 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
|
|
4752
|
+
var $R73 = $R(new RegExp("[<>]", "suy"));
|
|
4753
|
+
var $R74 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
4754
|
+
var $R75 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
4755
|
+
var $R76 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
4756
|
+
var $R77 = $R(new RegExp("[+-]?", "suy"));
|
|
4757
|
+
var $R78 = $R(new RegExp("[+-]", "suy"));
|
|
4758
|
+
var $R79 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
4759
|
+
var $R80 = $R(new RegExp("[\\t ]*", "suy"));
|
|
4760
|
+
var $R81 = $R(new RegExp("[ \\t]*", "suy"));
|
|
4761
|
+
var $R82 = $R(new RegExp("[\\s]*", "suy"));
|
|
4762
|
+
var $R83 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
4763
|
+
var $R84 = $R(new RegExp("\\/\\/\\/[^\\r\\n]*", "suy"));
|
|
4764
|
+
var $R85 = $R(new RegExp("(?=[ \\t\\r\\n\\/#]|$)", "suy"));
|
|
4765
|
+
var $R86 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
4762
4766
|
var Program$0 = $TS($S(Reset, Init, $E(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
4763
4767
|
var statements = $4;
|
|
4764
4768
|
processProgram({
|
|
@@ -5493,14 +5497,11 @@ var require_parser = __commonJS({
|
|
|
5493
5497
|
function ExtendsClause(ctx, state) {
|
|
5494
5498
|
return $EVENT(ctx, state, "ExtendsClause", ExtendsClause$0);
|
|
5495
5499
|
}
|
|
5496
|
-
var ExtendsToken$0 = $TS($S(Loc, __,
|
|
5500
|
+
var ExtendsToken$0 = $TS($S(Loc, __, ExtendsShorthand, $E($EXPECT($L12, 'ExtendsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5497
5501
|
var l = $1;
|
|
5498
5502
|
var ws = $2;
|
|
5499
|
-
var
|
|
5500
|
-
const children = [
|
|
5501
|
-
...ws,
|
|
5502
|
-
{ ...lt, token: "extends " }
|
|
5503
|
-
];
|
|
5503
|
+
var t = $3;
|
|
5504
|
+
const children = [...ws, t];
|
|
5504
5505
|
if (!ws.length) {
|
|
5505
5506
|
children.unshift({ $loc: l.$loc, token: " " });
|
|
5506
5507
|
}
|
|
@@ -5511,7 +5512,13 @@ var require_parser = __commonJS({
|
|
|
5511
5512
|
function ExtendsToken(ctx, state) {
|
|
5512
5513
|
return $EVENT_C(ctx, state, "ExtendsToken", ExtendsToken$$);
|
|
5513
5514
|
}
|
|
5514
|
-
var
|
|
5515
|
+
var ExtendsShorthand$0 = $TV($EXPECT($L13, 'ExtendsShorthand "<"'), function($skip, $loc, $0, $1) {
|
|
5516
|
+
return { $loc, token: "extends " };
|
|
5517
|
+
});
|
|
5518
|
+
function ExtendsShorthand(ctx, state) {
|
|
5519
|
+
return $EVENT(ctx, state, "ExtendsShorthand", ExtendsShorthand$0);
|
|
5520
|
+
}
|
|
5521
|
+
var ExtendsTarget$0 = $TS($S(LeftHandSideExpressionWithObjectApplicationForbidden, $E(TypeArguments)), function($skip, $loc, $0, $1, $2) {
|
|
5515
5522
|
var exp = $1;
|
|
5516
5523
|
var ta = $2;
|
|
5517
5524
|
exp = makeLeftHandSideExpression(exp);
|
|
@@ -5541,7 +5548,7 @@ var require_parser = __commonJS({
|
|
|
5541
5548
|
}
|
|
5542
5549
|
return { children };
|
|
5543
5550
|
});
|
|
5544
|
-
var ImplementsToken$1 = $TS($S(__, $EXPECT($
|
|
5551
|
+
var ImplementsToken$1 = $TS($S(__, $EXPECT($L14, 'ImplementsToken "implements"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
5545
5552
|
$2 = { $loc, token: $2 };
|
|
5546
5553
|
return [$1, $2];
|
|
5547
5554
|
});
|
|
@@ -5549,7 +5556,7 @@ var require_parser = __commonJS({
|
|
|
5549
5556
|
function ImplementsToken(ctx, state) {
|
|
5550
5557
|
return $EVENT_C(ctx, state, "ImplementsToken", ImplementsToken$$);
|
|
5551
5558
|
}
|
|
5552
|
-
var ImplementsShorthand$0 = $TV($EXPECT($
|
|
5559
|
+
var ImplementsShorthand$0 = $TV($EXPECT($L15, 'ImplementsShorthand "<:"'), function($skip, $loc, $0, $1) {
|
|
5553
5560
|
return { $loc, token: "implements " };
|
|
5554
5561
|
});
|
|
5555
5562
|
function ImplementsShorthand(ctx, state) {
|
|
@@ -5774,7 +5781,7 @@ var require_parser = __commonJS({
|
|
|
5774
5781
|
children: [$1, ...$2, ...rest.flat()]
|
|
5775
5782
|
});
|
|
5776
5783
|
});
|
|
5777
|
-
var CallExpression$1 = $TS($S($EXPECT($
|
|
5784
|
+
var CallExpression$1 = $TS($S($EXPECT($L16, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5778
5785
|
var rest = $3;
|
|
5779
5786
|
return processCallMemberExpression({
|
|
5780
5787
|
type: "CallExpression",
|
|
@@ -5835,7 +5842,7 @@ var require_parser = __commonJS({
|
|
|
5835
5842
|
function OptionalDot(ctx, state) {
|
|
5836
5843
|
return $EVENT_C(ctx, state, "OptionalDot", OptionalDot$$);
|
|
5837
5844
|
}
|
|
5838
|
-
var NonNullAssertion$0 = $T($S($EXPECT($
|
|
5845
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L17, 'NonNullAssertion "!"'), $N($EXPECT($L18, 'NonNullAssertion "^"'))), function(value) {
|
|
5839
5846
|
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
5840
5847
|
});
|
|
5841
5848
|
function NonNullAssertion(ctx, state) {
|
|
@@ -5854,6 +5861,16 @@ var require_parser = __commonJS({
|
|
|
5854
5861
|
function MemberExpression(ctx, state) {
|
|
5855
5862
|
return $EVENT(ctx, state, "MemberExpression", MemberExpression$0);
|
|
5856
5863
|
}
|
|
5864
|
+
var ActualMemberExpression$0 = $TS($S(MemberBase, $P(MemberExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
5865
|
+
var rest = $2;
|
|
5866
|
+
return processCallMemberExpression({
|
|
5867
|
+
type: "MemberExpression",
|
|
5868
|
+
children: [$1, ...rest].flat()
|
|
5869
|
+
});
|
|
5870
|
+
});
|
|
5871
|
+
function ActualMemberExpression(ctx, state) {
|
|
5872
|
+
return $EVENT(ctx, state, "ActualMemberExpression", ActualMemberExpression$0);
|
|
5873
|
+
}
|
|
5857
5874
|
var MemberBase$0 = PrimaryExpression;
|
|
5858
5875
|
var MemberBase$1 = SuperProperty;
|
|
5859
5876
|
var MemberBase$2 = MetaProperty;
|
|
@@ -5932,7 +5949,7 @@ var require_parser = __commonJS({
|
|
|
5932
5949
|
]
|
|
5933
5950
|
};
|
|
5934
5951
|
});
|
|
5935
|
-
var MemberBracketContent$2 = $TS($S(Dot, $EXPECT($
|
|
5952
|
+
var MemberBracketContent$2 = $TS($S(Dot, $EXPECT($L19, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
5936
5953
|
var dot = $1;
|
|
5937
5954
|
var neg = $2;
|
|
5938
5955
|
var num = $3;
|
|
@@ -6090,7 +6107,7 @@ var require_parser = __commonJS({
|
|
|
6090
6107
|
return $EVENT_C(ctx, state, "SuperProperty", SuperProperty$$);
|
|
6091
6108
|
}
|
|
6092
6109
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
6093
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
6110
|
+
var MetaProperty$1 = $TS($S($EXPECT($L20, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6094
6111
|
return { $loc, token: $1 };
|
|
6095
6112
|
});
|
|
6096
6113
|
var MetaProperty$2 = ReturnValue;
|
|
@@ -6098,7 +6115,7 @@ var require_parser = __commonJS({
|
|
|
6098
6115
|
function MetaProperty(ctx, state) {
|
|
6099
6116
|
return $EVENT_C(ctx, state, "MetaProperty", MetaProperty$$);
|
|
6100
6117
|
}
|
|
6101
|
-
var ReturnValue$0 = $TV($C($S($EXPECT($
|
|
6118
|
+
var ReturnValue$0 = $TV($C($S($EXPECT($L21, 'ReturnValue "return.value"'), NonIdContinue), $S(Return, $Y(AfterReturnShorthand))), function($skip, $loc, $0, $1) {
|
|
6102
6119
|
return { type: "ReturnValue", children: [$1[0]] };
|
|
6103
6120
|
});
|
|
6104
6121
|
function ReturnValue(ctx, state) {
|
|
@@ -6353,16 +6370,25 @@ var require_parser = __commonJS({
|
|
|
6353
6370
|
function AtIdentifierRef(ctx, state) {
|
|
6354
6371
|
return $EVENT_C(ctx, state, "AtIdentifierRef", AtIdentifierRef$$);
|
|
6355
6372
|
}
|
|
6356
|
-
var PinPattern$0 = $TS($S(
|
|
6357
|
-
var
|
|
6373
|
+
var PinPattern$0 = $TS($S(Caret, SingleLineExpressionWithIndentedApplicationForbidden), function($skip, $loc, $0, $1, $2) {
|
|
6374
|
+
var expression = $2;
|
|
6358
6375
|
return {
|
|
6359
6376
|
type: "PinPattern",
|
|
6360
6377
|
children: $0,
|
|
6361
|
-
|
|
6378
|
+
expression
|
|
6379
|
+
};
|
|
6380
|
+
});
|
|
6381
|
+
var PinPattern$1 = $TV(ActualMemberExpression, function($skip, $loc, $0, $1) {
|
|
6382
|
+
var expression = $0;
|
|
6383
|
+
return {
|
|
6384
|
+
type: "PinPattern",
|
|
6385
|
+
children: [expression],
|
|
6386
|
+
expression
|
|
6362
6387
|
};
|
|
6363
6388
|
});
|
|
6389
|
+
var PinPattern$$ = [PinPattern$0, PinPattern$1];
|
|
6364
6390
|
function PinPattern(ctx, state) {
|
|
6365
|
-
return $
|
|
6391
|
+
return $EVENT_C(ctx, state, "PinPattern", PinPattern$$);
|
|
6366
6392
|
}
|
|
6367
6393
|
var BindingPattern$0 = ObjectBindingPattern;
|
|
6368
6394
|
var BindingPattern$1 = ArrayBindingPattern;
|
|
@@ -6512,7 +6538,7 @@ var require_parser = __commonJS({
|
|
|
6512
6538
|
names: value.names
|
|
6513
6539
|
};
|
|
6514
6540
|
});
|
|
6515
|
-
var BindingProperty$2 = $TS($S($E(_), $E(
|
|
6541
|
+
var BindingProperty$2 = $TS($S($E(_), $E(Caret), BindingIdentifier, $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6516
6542
|
var ws = $1;
|
|
6517
6543
|
var pin = $2;
|
|
6518
6544
|
var binding = $3;
|
|
@@ -6534,7 +6560,7 @@ var require_parser = __commonJS({
|
|
|
6534
6560
|
name: binding,
|
|
6535
6561
|
value: {
|
|
6536
6562
|
type: "PinPattern",
|
|
6537
|
-
|
|
6563
|
+
expression: binding
|
|
6538
6564
|
}
|
|
6539
6565
|
};
|
|
6540
6566
|
}
|
|
@@ -6602,7 +6628,7 @@ var require_parser = __commonJS({
|
|
|
6602
6628
|
children: [ws, binding]
|
|
6603
6629
|
};
|
|
6604
6630
|
});
|
|
6605
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
6631
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L22, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
6606
6632
|
return {
|
|
6607
6633
|
children: [{
|
|
6608
6634
|
type: "ElisionElement",
|
|
@@ -6726,7 +6752,7 @@ var require_parser = __commonJS({
|
|
|
6726
6752
|
block
|
|
6727
6753
|
};
|
|
6728
6754
|
});
|
|
6729
|
-
var FunctionExpression$1 = $TV($EXPECT($
|
|
6755
|
+
var FunctionExpression$1 = $TV($EXPECT($L23, 'FunctionExpression "(&)"'), function($skip, $loc, $0, $1) {
|
|
6730
6756
|
const ref = makeRef("$"), body = [ref];
|
|
6731
6757
|
const parameters = {
|
|
6732
6758
|
type: "Parameters",
|
|
@@ -6985,7 +7011,7 @@ var require_parser = __commonJS({
|
|
|
6985
7011
|
function ThinArrowFunction(ctx, state) {
|
|
6986
7012
|
return $EVENT(ctx, state, "ThinArrowFunction", ThinArrowFunction$0);
|
|
6987
7013
|
}
|
|
6988
|
-
var Arrow$0 = $TV($C($EXPECT($
|
|
7014
|
+
var Arrow$0 = $TV($C($EXPECT($L24, 'Arrow "->"'), $EXPECT($L25, 'Arrow "\u2192"')), function($skip, $loc, $0, $1) {
|
|
6989
7015
|
return { $loc, token: "->" };
|
|
6990
7016
|
});
|
|
6991
7017
|
function Arrow(ctx, state) {
|
|
@@ -7263,7 +7289,7 @@ var require_parser = __commonJS({
|
|
|
7263
7289
|
}
|
|
7264
7290
|
var BracedContent$0 = NestedBlockStatements;
|
|
7265
7291
|
var BracedContent$1 = SingleLineStatements;
|
|
7266
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
7292
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L26, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
7267
7293
|
const expressions = [];
|
|
7268
7294
|
return {
|
|
7269
7295
|
type: "BlockStatement",
|
|
@@ -7333,7 +7359,7 @@ var require_parser = __commonJS({
|
|
|
7333
7359
|
function LiteralContent(ctx, state) {
|
|
7334
7360
|
return $EVENT_C(ctx, state, "LiteralContent", LiteralContent$$);
|
|
7335
7361
|
}
|
|
7336
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
7362
|
+
var NullLiteral$0 = $TS($S($EXPECT($L27, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7337
7363
|
return { $loc, token: $1 };
|
|
7338
7364
|
});
|
|
7339
7365
|
function NullLiteral(ctx, state) {
|
|
@@ -7348,17 +7374,17 @@ var require_parser = __commonJS({
|
|
|
7348
7374
|
var _BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
7349
7375
|
return value[1];
|
|
7350
7376
|
});
|
|
7351
|
-
var _BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
7377
|
+
var _BooleanLiteral$1 = $TS($S($C($EXPECT($L28, '_BooleanLiteral "true"'), $EXPECT($L29, '_BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7352
7378
|
return { $loc, token: $1 };
|
|
7353
7379
|
});
|
|
7354
7380
|
var _BooleanLiteral$$ = [_BooleanLiteral$0, _BooleanLiteral$1];
|
|
7355
7381
|
function _BooleanLiteral(ctx, state) {
|
|
7356
7382
|
return $EVENT_C(ctx, state, "_BooleanLiteral", _BooleanLiteral$$);
|
|
7357
7383
|
}
|
|
7358
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
7384
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L30, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L31, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7359
7385
|
return { $loc, token: "true" };
|
|
7360
7386
|
});
|
|
7361
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
7387
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L32, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L33, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7362
7388
|
return { $loc, token: "false" };
|
|
7363
7389
|
});
|
|
7364
7390
|
var CoffeeScriptBooleanLiteral$$ = [CoffeeScriptBooleanLiteral$0, CoffeeScriptBooleanLiteral$1];
|
|
@@ -7390,7 +7416,7 @@ var require_parser = __commonJS({
|
|
|
7390
7416
|
function IdentifierReference(ctx, state) {
|
|
7391
7417
|
return $EVENT(ctx, state, "IdentifierReference", IdentifierReference$0);
|
|
7392
7418
|
}
|
|
7393
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L3, 'UpcomingAssignment "="'), $N($C($EXPECT($L3, 'UpcomingAssignment "="'), $EXPECT($
|
|
7419
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L3, 'UpcomingAssignment "="'), $N($C($EXPECT($L3, 'UpcomingAssignment "="'), $EXPECT($L34, 'UpcomingAssignment ">"')))));
|
|
7394
7420
|
function UpcomingAssignment(ctx, state) {
|
|
7395
7421
|
return $EVENT(ctx, state, "UpcomingAssignment", UpcomingAssignment$0);
|
|
7396
7422
|
}
|
|
@@ -7548,7 +7574,7 @@ var require_parser = __commonJS({
|
|
|
7548
7574
|
return $EVENT(ctx, state, "NestedElement", NestedElement$0);
|
|
7549
7575
|
}
|
|
7550
7576
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
7551
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7577
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L35, 'ArrayElementDelimiter "]"')));
|
|
7552
7578
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7553
7579
|
return value[1];
|
|
7554
7580
|
});
|
|
@@ -7778,7 +7804,7 @@ var require_parser = __commonJS({
|
|
|
7778
7804
|
return $EVENT_C(ctx, state, "ImplicitInlineObjectPropertyDelimiter", ImplicitInlineObjectPropertyDelimiter$$);
|
|
7779
7805
|
}
|
|
7780
7806
|
var ObjectPropertyDelimiter$0 = $S($E(_), Comma);
|
|
7781
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7807
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L26, 'ObjectPropertyDelimiter "}"')));
|
|
7782
7808
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7783
7809
|
return value[1];
|
|
7784
7810
|
});
|
|
@@ -7961,7 +7987,7 @@ var require_parser = __commonJS({
|
|
|
7961
7987
|
implicit: true
|
|
7962
7988
|
};
|
|
7963
7989
|
});
|
|
7964
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7990
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L19, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7965
7991
|
const expression = [$2, $3];
|
|
7966
7992
|
return {
|
|
7967
7993
|
type: "ComputedPropertyName",
|
|
@@ -8210,7 +8236,7 @@ var require_parser = __commonJS({
|
|
|
8210
8236
|
return $EVENT(ctx, state, "PrivateIdentifier", PrivateIdentifier$0);
|
|
8211
8237
|
}
|
|
8212
8238
|
var WAssignmentOp$0 = $S(__, AssignmentOp);
|
|
8213
|
-
var WAssignmentOp$1 = $S(_, OperatorAssignmentOp);
|
|
8239
|
+
var WAssignmentOp$1 = $S($E(_), OperatorAssignmentOp);
|
|
8214
8240
|
var WAssignmentOp$$ = [WAssignmentOp$0, WAssignmentOp$1];
|
|
8215
8241
|
function WAssignmentOp(ctx, state) {
|
|
8216
8242
|
return $EVENT_C(ctx, state, "WAssignmentOp", WAssignmentOp$$);
|
|
@@ -8227,47 +8253,47 @@ var require_parser = __commonJS({
|
|
|
8227
8253
|
function AssignmentOp(ctx, state) {
|
|
8228
8254
|
return $EVENT(ctx, state, "AssignmentOp", AssignmentOp$0);
|
|
8229
8255
|
}
|
|
8230
|
-
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $
|
|
8256
|
+
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8231
8257
|
return {
|
|
8232
8258
|
special: true,
|
|
8233
8259
|
call: module.getRef("xor"),
|
|
8234
|
-
children: [$2, ...$
|
|
8260
|
+
children: [$2, ...$3 || []]
|
|
8235
8261
|
};
|
|
8236
8262
|
});
|
|
8237
|
-
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $
|
|
8263
|
+
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8238
8264
|
return {
|
|
8239
8265
|
special: true,
|
|
8240
8266
|
call: module.getRef("xnor"),
|
|
8241
|
-
children: [$2, ...$
|
|
8267
|
+
children: [$2, ...$3 || []]
|
|
8242
8268
|
};
|
|
8243
8269
|
});
|
|
8244
|
-
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L3, 'OperatorAssignmentOp "="'), $
|
|
8270
|
+
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L3, 'OperatorAssignmentOp "="'), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8245
8271
|
return {
|
|
8246
8272
|
special: true,
|
|
8247
8273
|
call: $1,
|
|
8248
|
-
children: [$2, ...$
|
|
8274
|
+
children: [$2, ...$3 || []]
|
|
8249
8275
|
};
|
|
8250
8276
|
});
|
|
8251
8277
|
var OperatorAssignmentOp$$ = [OperatorAssignmentOp$0, OperatorAssignmentOp$1, OperatorAssignmentOp$2];
|
|
8252
8278
|
function OperatorAssignmentOp(ctx, state) {
|
|
8253
8279
|
return $EVENT_C(ctx, state, "OperatorAssignmentOp", OperatorAssignmentOp$$);
|
|
8254
8280
|
}
|
|
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($
|
|
8281
|
+
var AssignmentOpSymbol$0 = $EXPECT($L36, 'AssignmentOpSymbol "**="');
|
|
8282
|
+
var AssignmentOpSymbol$1 = $EXPECT($L37, 'AssignmentOpSymbol "*="');
|
|
8283
|
+
var AssignmentOpSymbol$2 = $EXPECT($L38, 'AssignmentOpSymbol "/="');
|
|
8284
|
+
var AssignmentOpSymbol$3 = $EXPECT($L39, 'AssignmentOpSymbol "%="');
|
|
8285
|
+
var AssignmentOpSymbol$4 = $EXPECT($L40, 'AssignmentOpSymbol "+="');
|
|
8286
|
+
var AssignmentOpSymbol$5 = $EXPECT($L41, 'AssignmentOpSymbol "-="');
|
|
8287
|
+
var AssignmentOpSymbol$6 = $EXPECT($L42, 'AssignmentOpSymbol "<<="');
|
|
8288
|
+
var AssignmentOpSymbol$7 = $EXPECT($L43, 'AssignmentOpSymbol ">>>="');
|
|
8289
|
+
var AssignmentOpSymbol$8 = $EXPECT($L44, 'AssignmentOpSymbol ">>="');
|
|
8290
|
+
var AssignmentOpSymbol$9 = $EXPECT($L45, 'AssignmentOpSymbol "&&="');
|
|
8291
|
+
var AssignmentOpSymbol$10 = $EXPECT($L46, 'AssignmentOpSymbol "&="');
|
|
8292
|
+
var AssignmentOpSymbol$11 = $EXPECT($L47, 'AssignmentOpSymbol "^="');
|
|
8293
|
+
var AssignmentOpSymbol$12 = $EXPECT($L48, 'AssignmentOpSymbol "||="');
|
|
8294
|
+
var AssignmentOpSymbol$13 = $EXPECT($L49, 'AssignmentOpSymbol "|="');
|
|
8295
|
+
var AssignmentOpSymbol$14 = $EXPECT($L50, 'AssignmentOpSymbol "??="');
|
|
8296
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L51, 'AssignmentOpSymbol "?="'), function(value) {
|
|
8271
8297
|
return "??=";
|
|
8272
8298
|
});
|
|
8273
8299
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L3, 'AssignmentOpSymbol "="'), $N($EXPECT($L3, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -8280,10 +8306,10 @@ var require_parser = __commonJS({
|
|
|
8280
8306
|
function AssignmentOpSymbol(ctx, state) {
|
|
8281
8307
|
return $EVENT_C(ctx, state, "AssignmentOpSymbol", AssignmentOpSymbol$$);
|
|
8282
8308
|
}
|
|
8283
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
8309
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L52, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
8284
8310
|
return "&&=";
|
|
8285
8311
|
});
|
|
8286
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
8312
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L53, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
8287
8313
|
return "||=";
|
|
8288
8314
|
});
|
|
8289
8315
|
var CoffeeWordAssignmentOp$$ = [CoffeeWordAssignmentOp$0, CoffeeWordAssignmentOp$1];
|
|
@@ -8352,27 +8378,27 @@ var require_parser = __commonJS({
|
|
|
8352
8378
|
function _BinaryOp(ctx, state) {
|
|
8353
8379
|
return $EVENT_C(ctx, state, "_BinaryOp", _BinaryOp$$);
|
|
8354
8380
|
}
|
|
8355
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
8356
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
8357
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
8358
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
8381
|
+
var BinaryOpSymbol$0 = $EXPECT($L54, 'BinaryOpSymbol "**"');
|
|
8382
|
+
var BinaryOpSymbol$1 = $EXPECT($L55, 'BinaryOpSymbol "*"');
|
|
8383
|
+
var BinaryOpSymbol$2 = $EXPECT($L56, 'BinaryOpSymbol "/"');
|
|
8384
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L57, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
8359
8385
|
return {
|
|
8360
8386
|
call: module.getRef("modulo"),
|
|
8361
8387
|
special: true
|
|
8362
8388
|
};
|
|
8363
8389
|
});
|
|
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($
|
|
8390
|
+
var BinaryOpSymbol$4 = $EXPECT($L58, 'BinaryOpSymbol "%"');
|
|
8391
|
+
var BinaryOpSymbol$5 = $EXPECT($L59, 'BinaryOpSymbol "+"');
|
|
8392
|
+
var BinaryOpSymbol$6 = $EXPECT($L19, 'BinaryOpSymbol "-"');
|
|
8393
|
+
var BinaryOpSymbol$7 = $EXPECT($L60, 'BinaryOpSymbol "<="');
|
|
8394
|
+
var BinaryOpSymbol$8 = $T($EXPECT($L61, 'BinaryOpSymbol "\u2264"'), function(value) {
|
|
8369
8395
|
return "<=";
|
|
8370
8396
|
});
|
|
8371
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
8372
|
-
var BinaryOpSymbol$10 = $T($EXPECT($
|
|
8397
|
+
var BinaryOpSymbol$9 = $EXPECT($L62, 'BinaryOpSymbol ">="');
|
|
8398
|
+
var BinaryOpSymbol$10 = $T($EXPECT($L63, 'BinaryOpSymbol "\u2265"'), function(value) {
|
|
8373
8399
|
return ">=";
|
|
8374
8400
|
});
|
|
8375
|
-
var BinaryOpSymbol$11 = $TV($EXPECT($
|
|
8401
|
+
var BinaryOpSymbol$11 = $TV($EXPECT($L64, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
8376
8402
|
return {
|
|
8377
8403
|
$loc,
|
|
8378
8404
|
token: "instanceof",
|
|
@@ -8380,7 +8406,7 @@ var require_parser = __commonJS({
|
|
|
8380
8406
|
special: true
|
|
8381
8407
|
};
|
|
8382
8408
|
});
|
|
8383
|
-
var BinaryOpSymbol$12 = $TV($EXPECT($
|
|
8409
|
+
var BinaryOpSymbol$12 = $TV($EXPECT($L65, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
8384
8410
|
return {
|
|
8385
8411
|
$loc,
|
|
8386
8412
|
token: "instanceof",
|
|
@@ -8389,76 +8415,74 @@ var require_parser = __commonJS({
|
|
|
8389
8415
|
negated: true
|
|
8390
8416
|
};
|
|
8391
8417
|
});
|
|
8392
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
8393
|
-
var BinaryOpSymbol$14 = $T($EXPECT($
|
|
8418
|
+
var BinaryOpSymbol$13 = $EXPECT($L66, 'BinaryOpSymbol "<<"');
|
|
8419
|
+
var BinaryOpSymbol$14 = $T($EXPECT($L67, 'BinaryOpSymbol "\xAB"'), function(value) {
|
|
8394
8420
|
return "<<";
|
|
8395
8421
|
});
|
|
8396
|
-
var BinaryOpSymbol$15 = $
|
|
8397
|
-
|
|
8398
|
-
|
|
8399
|
-
var BinaryOpSymbol$16 = $EXPECT($L67, 'BinaryOpSymbol ">>>"');
|
|
8400
|
-
var BinaryOpSymbol$17 = $T($EXPECT($L68, 'BinaryOpSymbol "\u22D9"'), function(value) {
|
|
8422
|
+
var BinaryOpSymbol$15 = $EXPECT($L13, 'BinaryOpSymbol "<"');
|
|
8423
|
+
var BinaryOpSymbol$16 = $EXPECT($L68, 'BinaryOpSymbol ">>>"');
|
|
8424
|
+
var BinaryOpSymbol$17 = $T($EXPECT($L69, 'BinaryOpSymbol "\u22D9"'), function(value) {
|
|
8401
8425
|
return ">>>";
|
|
8402
8426
|
});
|
|
8403
|
-
var BinaryOpSymbol$18 = $EXPECT($
|
|
8404
|
-
var BinaryOpSymbol$19 = $T($EXPECT($
|
|
8427
|
+
var BinaryOpSymbol$18 = $EXPECT($L70, 'BinaryOpSymbol ">>"');
|
|
8428
|
+
var BinaryOpSymbol$19 = $T($EXPECT($L71, 'BinaryOpSymbol "\xBB"'), function(value) {
|
|
8405
8429
|
return ">>";
|
|
8406
8430
|
});
|
|
8407
|
-
var BinaryOpSymbol$20 = $EXPECT($
|
|
8408
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
8409
|
-
var BinaryOpSymbol$22 = $T($EXPECT($
|
|
8431
|
+
var BinaryOpSymbol$20 = $EXPECT($L34, 'BinaryOpSymbol ">"');
|
|
8432
|
+
var BinaryOpSymbol$21 = $EXPECT($L72, 'BinaryOpSymbol "!=="');
|
|
8433
|
+
var BinaryOpSymbol$22 = $T($EXPECT($L73, 'BinaryOpSymbol "\u2262"'), function(value) {
|
|
8410
8434
|
return "!==";
|
|
8411
8435
|
});
|
|
8412
|
-
var BinaryOpSymbol$23 = $TV($C($EXPECT($
|
|
8436
|
+
var BinaryOpSymbol$23 = $TV($C($EXPECT($L74, 'BinaryOpSymbol "!="'), $EXPECT($L75, 'BinaryOpSymbol "\u2260"')), function($skip, $loc, $0, $1) {
|
|
8413
8437
|
if (module.config.coffeeEq)
|
|
8414
8438
|
return "!==";
|
|
8415
8439
|
return "!=";
|
|
8416
8440
|
});
|
|
8417
|
-
var BinaryOpSymbol$24 = $TS($S($EXPECT($
|
|
8441
|
+
var BinaryOpSymbol$24 = $TS($S($EXPECT($L76, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8418
8442
|
if (module.config.coffeeIsnt)
|
|
8419
8443
|
return "!==";
|
|
8420
8444
|
return $skip;
|
|
8421
8445
|
});
|
|
8422
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
8423
|
-
var BinaryOpSymbol$26 = $T($C($EXPECT($
|
|
8446
|
+
var BinaryOpSymbol$25 = $EXPECT($L77, 'BinaryOpSymbol "==="');
|
|
8447
|
+
var BinaryOpSymbol$26 = $T($C($EXPECT($L78, 'BinaryOpSymbol "\u2263"'), $EXPECT($L79, 'BinaryOpSymbol "\u2A76"')), function(value) {
|
|
8424
8448
|
return "===";
|
|
8425
8449
|
});
|
|
8426
|
-
var BinaryOpSymbol$27 = $TV($C($EXPECT($
|
|
8450
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($L80, 'BinaryOpSymbol "=="'), $EXPECT($L81, 'BinaryOpSymbol "\u2261"'), $EXPECT($L82, 'BinaryOpSymbol "\u2A75"')), function($skip, $loc, $0, $1) {
|
|
8427
8451
|
if (module.config.coffeeEq)
|
|
8428
8452
|
return "===";
|
|
8429
8453
|
return "==";
|
|
8430
8454
|
});
|
|
8431
|
-
var BinaryOpSymbol$28 = $T($S($EXPECT($
|
|
8455
|
+
var BinaryOpSymbol$28 = $T($S($EXPECT($L83, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
8432
8456
|
return "&&";
|
|
8433
8457
|
});
|
|
8434
|
-
var BinaryOpSymbol$29 = $EXPECT($
|
|
8435
|
-
var BinaryOpSymbol$30 = $T($S($EXPECT($
|
|
8458
|
+
var BinaryOpSymbol$29 = $EXPECT($L84, 'BinaryOpSymbol "&&"');
|
|
8459
|
+
var BinaryOpSymbol$30 = $T($S($EXPECT($L85, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
8436
8460
|
return "||";
|
|
8437
8461
|
});
|
|
8438
|
-
var BinaryOpSymbol$31 = $EXPECT($
|
|
8439
|
-
var BinaryOpSymbol$32 = $T($EXPECT($
|
|
8462
|
+
var BinaryOpSymbol$31 = $EXPECT($L86, 'BinaryOpSymbol "||"');
|
|
8463
|
+
var BinaryOpSymbol$32 = $T($EXPECT($L87, 'BinaryOpSymbol "\u2016"'), function(value) {
|
|
8440
8464
|
return "||";
|
|
8441
8465
|
});
|
|
8442
|
-
var BinaryOpSymbol$33 = $TV($C($EXPECT($
|
|
8466
|
+
var BinaryOpSymbol$33 = $TV($C($EXPECT($L88, 'BinaryOpSymbol "^^"'), $S($EXPECT($L89, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8443
8467
|
return {
|
|
8444
8468
|
call: module.getRef("xor"),
|
|
8445
8469
|
special: true
|
|
8446
8470
|
};
|
|
8447
8471
|
});
|
|
8448
|
-
var BinaryOpSymbol$34 = $TV($C($EXPECT($
|
|
8472
|
+
var BinaryOpSymbol$34 = $TV($C($EXPECT($R17, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L90, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8449
8473
|
return {
|
|
8450
8474
|
call: module.getRef("xnor"),
|
|
8451
8475
|
special: true
|
|
8452
8476
|
};
|
|
8453
8477
|
});
|
|
8454
|
-
var BinaryOpSymbol$35 = $EXPECT($
|
|
8455
|
-
var BinaryOpSymbol$36 = $T($EXPECT($
|
|
8478
|
+
var BinaryOpSymbol$35 = $EXPECT($L91, 'BinaryOpSymbol "??"');
|
|
8479
|
+
var BinaryOpSymbol$36 = $T($EXPECT($L92, 'BinaryOpSymbol "\u2047"'), function(value) {
|
|
8456
8480
|
return "??";
|
|
8457
8481
|
});
|
|
8458
8482
|
var BinaryOpSymbol$37 = $T($S($EXPECT($L5, 'BinaryOpSymbol "?"'), CoffeeBinaryExistentialEnabled), function(value) {
|
|
8459
8483
|
return "??";
|
|
8460
8484
|
});
|
|
8461
|
-
var BinaryOpSymbol$38 = $TS($S($EXPECT($
|
|
8485
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L93, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8462
8486
|
return {
|
|
8463
8487
|
$loc,
|
|
8464
8488
|
token: $1,
|
|
@@ -8475,7 +8499,7 @@ var require_parser = __commonJS({
|
|
|
8475
8499
|
var op = $3;
|
|
8476
8500
|
return { ...op, $loc };
|
|
8477
8501
|
});
|
|
8478
|
-
var BinaryOpSymbol$41 = $TV($C($S(Is, __, In), $EXPECT($
|
|
8502
|
+
var BinaryOpSymbol$41 = $TV($C($S(Is, __, In), $EXPECT($L94, 'BinaryOpSymbol "\u2208"')), function($skip, $loc, $0, $1) {
|
|
8479
8503
|
return {
|
|
8480
8504
|
method: "includes",
|
|
8481
8505
|
relational: true,
|
|
@@ -8483,14 +8507,14 @@ var require_parser = __commonJS({
|
|
|
8483
8507
|
special: true
|
|
8484
8508
|
};
|
|
8485
8509
|
});
|
|
8486
|
-
var BinaryOpSymbol$42 = $TV($EXPECT($
|
|
8510
|
+
var BinaryOpSymbol$42 = $TV($EXPECT($L95, 'BinaryOpSymbol "\u220B"'), function($skip, $loc, $0, $1) {
|
|
8487
8511
|
return {
|
|
8488
8512
|
method: "includes",
|
|
8489
8513
|
relational: true,
|
|
8490
8514
|
special: true
|
|
8491
8515
|
};
|
|
8492
8516
|
});
|
|
8493
|
-
var BinaryOpSymbol$43 = $TV($EXPECT($
|
|
8517
|
+
var BinaryOpSymbol$43 = $TV($EXPECT($L96, 'BinaryOpSymbol "\u220C"'), function($skip, $loc, $0, $1) {
|
|
8494
8518
|
return {
|
|
8495
8519
|
method: "includes",
|
|
8496
8520
|
relational: true,
|
|
@@ -8498,7 +8522,7 @@ var require_parser = __commonJS({
|
|
|
8498
8522
|
negated: true
|
|
8499
8523
|
};
|
|
8500
8524
|
});
|
|
8501
|
-
var BinaryOpSymbol$44 = $TV($C($S(Is, __, Not, __, In), $EXPECT($
|
|
8525
|
+
var BinaryOpSymbol$44 = $TV($C($S(Is, __, Not, __, In), $EXPECT($L97, 'BinaryOpSymbol "\u2209"')), function($skip, $loc, $0, $1) {
|
|
8502
8526
|
return {
|
|
8503
8527
|
method: "includes",
|
|
8504
8528
|
relational: true,
|
|
@@ -8531,9 +8555,9 @@ var require_parser = __commonJS({
|
|
|
8531
8555
|
return "===";
|
|
8532
8556
|
});
|
|
8533
8557
|
var BinaryOpSymbol$47 = In;
|
|
8534
|
-
var BinaryOpSymbol$48 = $EXPECT($
|
|
8535
|
-
var BinaryOpSymbol$49 = $EXPECT($
|
|
8536
|
-
var BinaryOpSymbol$50 = $EXPECT($
|
|
8558
|
+
var BinaryOpSymbol$48 = $EXPECT($L98, 'BinaryOpSymbol "&"');
|
|
8559
|
+
var BinaryOpSymbol$49 = $EXPECT($L18, 'BinaryOpSymbol "^"');
|
|
8560
|
+
var BinaryOpSymbol$50 = $EXPECT($L99, 'BinaryOpSymbol "|"');
|
|
8537
8561
|
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
8562
|
function BinaryOpSymbol(ctx, state) {
|
|
8539
8563
|
return $EVENT_C(ctx, state, "BinaryOpSymbol", BinaryOpSymbol$$);
|
|
@@ -8571,7 +8595,7 @@ var require_parser = __commonJS({
|
|
|
8571
8595
|
function CoffeeOfOp(ctx, state) {
|
|
8572
8596
|
return $EVENT_C(ctx, state, "CoffeeOfOp", CoffeeOfOp$$);
|
|
8573
8597
|
}
|
|
8574
|
-
var NotOp$0 = $TS($S($EXPECT($
|
|
8598
|
+
var NotOp$0 = $TS($S($EXPECT($L93, 'NotOp "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8575
8599
|
return {
|
|
8576
8600
|
$loc,
|
|
8577
8601
|
token: "instanceof",
|
|
@@ -8592,19 +8616,19 @@ var require_parser = __commonJS({
|
|
|
8592
8616
|
function NotOp(ctx, state) {
|
|
8593
8617
|
return $EVENT_C(ctx, state, "NotOp", NotOp$$);
|
|
8594
8618
|
}
|
|
8595
|
-
var Xor$0 = $EXPECT($
|
|
8596
|
-
var Xor$1 = $S($EXPECT($
|
|
8619
|
+
var Xor$0 = $EXPECT($L88, 'Xor "^^"');
|
|
8620
|
+
var Xor$1 = $S($EXPECT($L89, 'Xor "xor"'), NonIdContinue);
|
|
8597
8621
|
var Xor$$ = [Xor$0, Xor$1];
|
|
8598
8622
|
function Xor(ctx, state) {
|
|
8599
8623
|
return $EVENT_C(ctx, state, "Xor", Xor$$);
|
|
8600
8624
|
}
|
|
8601
|
-
var Xnor$0 = $R$0($EXPECT($
|
|
8602
|
-
var Xnor$1 = $EXPECT($
|
|
8625
|
+
var Xnor$0 = $R$0($EXPECT($R17, "Xnor /!\\^\\^?/"));
|
|
8626
|
+
var Xnor$1 = $EXPECT($L90, 'Xnor "xnor"');
|
|
8603
8627
|
var Xnor$$ = [Xnor$0, Xnor$1];
|
|
8604
8628
|
function Xnor(ctx, state) {
|
|
8605
8629
|
return $EVENT_C(ctx, state, "Xnor", Xnor$$);
|
|
8606
8630
|
}
|
|
8607
|
-
var UnaryOp$0 = $TR($EXPECT($
|
|
8631
|
+
var UnaryOp$0 = $TR($EXPECT($R18, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*(&|\\.[^0-9]))/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8608
8632
|
return { $loc, token: $0 };
|
|
8609
8633
|
});
|
|
8610
8634
|
var UnaryOp$1 = AwaitOp;
|
|
@@ -8704,7 +8728,7 @@ var require_parser = __commonJS({
|
|
|
8704
8728
|
function NonPipelinePostfixedExpression(ctx, state) {
|
|
8705
8729
|
return $EVENT(ctx, state, "NonPipelinePostfixedExpression", NonPipelinePostfixedExpression$0);
|
|
8706
8730
|
}
|
|
8707
|
-
var PostfixStatement$0 = $T($S($EXPECT($
|
|
8731
|
+
var PostfixStatement$0 = $T($S($EXPECT($R19, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
|
|
8708
8732
|
return value[1];
|
|
8709
8733
|
});
|
|
8710
8734
|
function PostfixStatement(ctx, state) {
|
|
@@ -8747,7 +8771,7 @@ var require_parser = __commonJS({
|
|
|
8747
8771
|
function NoCommaStatement(ctx, state) {
|
|
8748
8772
|
return $EVENT_C(ctx, state, "NoCommaStatement", NoCommaStatement$$);
|
|
8749
8773
|
}
|
|
8750
|
-
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($
|
|
8774
|
+
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L100, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
|
|
8751
8775
|
return { type: "EmptyStatement", children: $1 || [] };
|
|
8752
8776
|
});
|
|
8753
8777
|
function EmptyStatement(ctx, state) {
|
|
@@ -8769,7 +8793,7 @@ var require_parser = __commonJS({
|
|
|
8769
8793
|
var w = $3;
|
|
8770
8794
|
return [id, colon, w];
|
|
8771
8795
|
});
|
|
8772
|
-
var Label$1 = $S($EXPECT($
|
|
8796
|
+
var Label$1 = $S($EXPECT($L101, 'Label "$:"'), Whitespace);
|
|
8773
8797
|
var Label$$ = [Label$0, Label$1];
|
|
8774
8798
|
function Label(ctx, state) {
|
|
8775
8799
|
return $EVENT_C(ctx, state, "Label", Label$$);
|
|
@@ -8942,7 +8966,7 @@ var require_parser = __commonJS({
|
|
|
8942
8966
|
function BlockExpressionPart(ctx, state) {
|
|
8943
8967
|
return $EVENT(ctx, state, "BlockExpressionPart", BlockExpressionPart$0);
|
|
8944
8968
|
}
|
|
8945
|
-
var IterationStatement$0 = $T($S($EXPECT($
|
|
8969
|
+
var IterationStatement$0 = $T($S($EXPECT($R20, "IterationStatement /(?=loop|do|for|until|while)/"), _IterationStatement), function(value) {
|
|
8946
8970
|
return value[1];
|
|
8947
8971
|
});
|
|
8948
8972
|
function IterationStatement(ctx, state) {
|
|
@@ -9295,7 +9319,7 @@ var require_parser = __commonJS({
|
|
|
9295
9319
|
names: binding.names
|
|
9296
9320
|
};
|
|
9297
9321
|
});
|
|
9298
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
9322
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R21, "ForDeclaration /(?=[\\s\\),])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
9299
9323
|
var c = $1;
|
|
9300
9324
|
var binding = $2;
|
|
9301
9325
|
return {
|
|
@@ -9651,6 +9675,15 @@ var require_parser = __commonJS({
|
|
|
9651
9675
|
function ExpressionWithIndentedApplicationForbidden(ctx, state) {
|
|
9652
9676
|
return $EVENT(ctx, state, "ExpressionWithIndentedApplicationForbidden", ExpressionWithIndentedApplicationForbidden$0);
|
|
9653
9677
|
}
|
|
9678
|
+
var SingleLineExpressionWithIndentedApplicationForbidden$0 = $TS($S(ForbidIndentedApplication, ForbidNewlineBinaryOp, $E(SingleLineAssignmentExpression), RestoreNewlineBinaryOp, RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
9679
|
+
var exp = $3;
|
|
9680
|
+
if (exp)
|
|
9681
|
+
return exp;
|
|
9682
|
+
return $skip;
|
|
9683
|
+
});
|
|
9684
|
+
function SingleLineExpressionWithIndentedApplicationForbidden(ctx, state) {
|
|
9685
|
+
return $EVENT(ctx, state, "SingleLineExpressionWithIndentedApplicationForbidden", SingleLineExpressionWithIndentedApplicationForbidden$0);
|
|
9686
|
+
}
|
|
9654
9687
|
var ExpressionWithObjectApplicationForbidden$0 = $TS($S(ForbidBracedApplication, ForbidIndentedApplication, ForbidNewlineBinaryOp, $E(ExtendedExpression), RestoreNewlineBinaryOp, RestoreBracedApplication, RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
9655
9688
|
var exp = $4;
|
|
9656
9689
|
if (exp)
|
|
@@ -9660,6 +9693,15 @@ var require_parser = __commonJS({
|
|
|
9660
9693
|
function ExpressionWithObjectApplicationForbidden(ctx, state) {
|
|
9661
9694
|
return $EVENT(ctx, state, "ExpressionWithObjectApplicationForbidden", ExpressionWithObjectApplicationForbidden$0);
|
|
9662
9695
|
}
|
|
9696
|
+
var LeftHandSideExpressionWithObjectApplicationForbidden$0 = $TS($S(ForbidBracedApplication, ForbidIndentedApplication, ForbidNewlineBinaryOp, $E(LeftHandSideExpression), RestoreNewlineBinaryOp, RestoreBracedApplication, RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
9697
|
+
var exp = $4;
|
|
9698
|
+
if (exp)
|
|
9699
|
+
return exp;
|
|
9700
|
+
return $skip;
|
|
9701
|
+
});
|
|
9702
|
+
function LeftHandSideExpressionWithObjectApplicationForbidden(ctx, state) {
|
|
9703
|
+
return $EVENT(ctx, state, "LeftHandSideExpressionWithObjectApplicationForbidden", LeftHandSideExpressionWithObjectApplicationForbidden$0);
|
|
9704
|
+
}
|
|
9663
9705
|
var ForbidClassImplicitCall$0 = $TV($EXPECT($L0, 'ForbidClassImplicitCall ""'), function($skip, $loc, $0, $1) {
|
|
9664
9706
|
module.forbidClassImplicitCall.push(true);
|
|
9665
9707
|
});
|
|
@@ -9860,19 +9902,19 @@ var require_parser = __commonJS({
|
|
|
9860
9902
|
function ThrowStatement(ctx, state) {
|
|
9861
9903
|
return $EVENT(ctx, state, "ThrowStatement", ThrowStatement$0);
|
|
9862
9904
|
}
|
|
9863
|
-
var Break$0 = $TS($S($EXPECT($
|
|
9905
|
+
var Break$0 = $TS($S($EXPECT($L102, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9864
9906
|
return { $loc, token: $1 };
|
|
9865
9907
|
});
|
|
9866
9908
|
function Break(ctx, state) {
|
|
9867
9909
|
return $EVENT(ctx, state, "Break", Break$0);
|
|
9868
9910
|
}
|
|
9869
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
9911
|
+
var Continue$0 = $TS($S($EXPECT($L103, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9870
9912
|
return { $loc, token: $1 };
|
|
9871
9913
|
});
|
|
9872
9914
|
function Continue(ctx, state) {
|
|
9873
9915
|
return $EVENT(ctx, state, "Continue", Continue$0);
|
|
9874
9916
|
}
|
|
9875
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
9917
|
+
var Debugger$0 = $TS($S($EXPECT($L104, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9876
9918
|
return { $loc, token: $1 };
|
|
9877
9919
|
});
|
|
9878
9920
|
function Debugger(ctx, state) {
|
|
@@ -9993,7 +10035,7 @@ var require_parser = __commonJS({
|
|
|
9993
10035
|
function FromClause(ctx, state) {
|
|
9994
10036
|
return $EVENT(ctx, state, "FromClause", FromClause$0);
|
|
9995
10037
|
}
|
|
9996
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10038
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L105, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
9997
10039
|
function ImportAssertion(ctx, state) {
|
|
9998
10040
|
return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
|
|
9999
10041
|
}
|
|
@@ -10081,7 +10123,7 @@ var require_parser = __commonJS({
|
|
|
10081
10123
|
function UnprocessedModuleSpecifier(ctx, state) {
|
|
10082
10124
|
return $EVENT_C(ctx, state, "UnprocessedModuleSpecifier", UnprocessedModuleSpecifier$$);
|
|
10083
10125
|
}
|
|
10084
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
10126
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R22, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
10085
10127
|
var spec = $0;
|
|
10086
10128
|
return { $loc, token: `"${spec}"` };
|
|
10087
10129
|
});
|
|
@@ -10213,13 +10255,13 @@ var require_parser = __commonJS({
|
|
|
10213
10255
|
function LexicalDeclaration(ctx, state) {
|
|
10214
10256
|
return $EVENT_C(ctx, state, "LexicalDeclaration", LexicalDeclaration$$);
|
|
10215
10257
|
}
|
|
10216
|
-
var ConstAssignment$0 = $TV($C($EXPECT($
|
|
10258
|
+
var ConstAssignment$0 = $TV($C($EXPECT($L106, 'ConstAssignment ":="'), $EXPECT($L107, 'ConstAssignment "\u2254"')), function($skip, $loc, $0, $1) {
|
|
10217
10259
|
return { $loc, token: "=" };
|
|
10218
10260
|
});
|
|
10219
10261
|
function ConstAssignment(ctx, state) {
|
|
10220
10262
|
return $EVENT(ctx, state, "ConstAssignment", ConstAssignment$0);
|
|
10221
10263
|
}
|
|
10222
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
10264
|
+
var LetAssignment$0 = $TV($EXPECT($L108, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10223
10265
|
return { $loc, token: "=" };
|
|
10224
10266
|
});
|
|
10225
10267
|
function LetAssignment(ctx, state) {
|
|
@@ -10287,7 +10329,7 @@ var require_parser = __commonJS({
|
|
|
10287
10329
|
function VariableDeclarationList(ctx, state) {
|
|
10288
10330
|
return $EVENT(ctx, state, "VariableDeclarationList", VariableDeclarationList$0);
|
|
10289
10331
|
}
|
|
10290
|
-
var NumericLiteral$0 = $TS($S($EXPECT($
|
|
10332
|
+
var NumericLiteral$0 = $TS($S($EXPECT($R23, "NumericLiteral /(?=[0-9.])/"), NumericLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
10291
10333
|
var token = $2;
|
|
10292
10334
|
return { type: "NumericLiteral", $loc, token };
|
|
10293
10335
|
});
|
|
@@ -10303,36 +10345,36 @@ var require_parser = __commonJS({
|
|
|
10303
10345
|
function NumericLiteralKind(ctx, state) {
|
|
10304
10346
|
return $EVENT_C(ctx, state, "NumericLiteralKind", NumericLiteralKind$$);
|
|
10305
10347
|
}
|
|
10306
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
10348
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R24, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
10307
10349
|
function DecimalBigIntegerLiteral(ctx, state) {
|
|
10308
10350
|
return $EVENT(ctx, state, "DecimalBigIntegerLiteral", DecimalBigIntegerLiteral$0);
|
|
10309
10351
|
}
|
|
10310
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
10352
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R25, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
10311
10353
|
return $1 + ".";
|
|
10312
10354
|
});
|
|
10313
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
10314
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
10355
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R26, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
10356
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R27, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
10315
10357
|
var DecimalLiteral$$ = [DecimalLiteral$0, DecimalLiteral$1, DecimalLiteral$2];
|
|
10316
10358
|
function DecimalLiteral(ctx, state) {
|
|
10317
10359
|
return $EVENT_C(ctx, state, "DecimalLiteral", DecimalLiteral$$);
|
|
10318
10360
|
}
|
|
10319
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
10361
|
+
var ExponentPart$0 = $R$0($EXPECT($R28, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
10320
10362
|
function ExponentPart(ctx, state) {
|
|
10321
10363
|
return $EVENT(ctx, state, "ExponentPart", ExponentPart$0);
|
|
10322
10364
|
}
|
|
10323
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
10365
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R29, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
10324
10366
|
function BinaryIntegerLiteral(ctx, state) {
|
|
10325
10367
|
return $EVENT(ctx, state, "BinaryIntegerLiteral", BinaryIntegerLiteral$0);
|
|
10326
10368
|
}
|
|
10327
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
10369
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R30, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
10328
10370
|
function OctalIntegerLiteral(ctx, state) {
|
|
10329
10371
|
return $EVENT(ctx, state, "OctalIntegerLiteral", OctalIntegerLiteral$0);
|
|
10330
10372
|
}
|
|
10331
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
10373
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R31, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
10332
10374
|
function HexIntegerLiteral(ctx, state) {
|
|
10333
10375
|
return $EVENT(ctx, state, "HexIntegerLiteral", HexIntegerLiteral$0);
|
|
10334
10376
|
}
|
|
10335
|
-
var IntegerLiteral$0 = $TS($S($EXPECT($
|
|
10377
|
+
var IntegerLiteral$0 = $TS($S($EXPECT($R32, "IntegerLiteral /(?=[0-9])/"), IntegerLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
10336
10378
|
var token = $2;
|
|
10337
10379
|
return { $loc, token };
|
|
10338
10380
|
});
|
|
@@ -10348,7 +10390,7 @@ var require_parser = __commonJS({
|
|
|
10348
10390
|
function IntegerLiteralKind(ctx, state) {
|
|
10349
10391
|
return $EVENT_C(ctx, state, "IntegerLiteralKind", IntegerLiteralKind$$);
|
|
10350
10392
|
}
|
|
10351
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
10393
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R33, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
10352
10394
|
function DecimalIntegerLiteral(ctx, state) {
|
|
10353
10395
|
return $EVENT(ctx, state, "DecimalIntegerLiteral", DecimalIntegerLiteral$0);
|
|
10354
10396
|
}
|
|
@@ -10372,25 +10414,25 @@ var require_parser = __commonJS({
|
|
|
10372
10414
|
function StringLiteral(ctx, state) {
|
|
10373
10415
|
return $EVENT_C(ctx, state, "StringLiteral", StringLiteral$$);
|
|
10374
10416
|
}
|
|
10375
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
10417
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R34, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10376
10418
|
return { $loc, token: $0 };
|
|
10377
10419
|
});
|
|
10378
10420
|
function DoubleStringCharacters(ctx, state) {
|
|
10379
10421
|
return $EVENT(ctx, state, "DoubleStringCharacters", DoubleStringCharacters$0);
|
|
10380
10422
|
}
|
|
10381
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
10423
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R35, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10382
10424
|
return { $loc, token: $0 };
|
|
10383
10425
|
});
|
|
10384
10426
|
function SingleStringCharacters(ctx, state) {
|
|
10385
10427
|
return $EVENT(ctx, state, "SingleStringCharacters", SingleStringCharacters$0);
|
|
10386
10428
|
}
|
|
10387
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
10429
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R36, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10388
10430
|
return { $loc, token: $0 };
|
|
10389
10431
|
});
|
|
10390
10432
|
function TripleDoubleStringCharacters(ctx, state) {
|
|
10391
10433
|
return $EVENT(ctx, state, "TripleDoubleStringCharacters", TripleDoubleStringCharacters$0);
|
|
10392
10434
|
}
|
|
10393
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
10435
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R37, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10394
10436
|
return { $loc, token: $0 };
|
|
10395
10437
|
});
|
|
10396
10438
|
function TripleSingleStringCharacters(ctx, state) {
|
|
@@ -10409,14 +10451,14 @@ var require_parser = __commonJS({
|
|
|
10409
10451
|
function CoffeeInterpolatedDoubleQuotedString(ctx, state) {
|
|
10410
10452
|
return $EVENT(ctx, state, "CoffeeInterpolatedDoubleQuotedString", CoffeeInterpolatedDoubleQuotedString$0);
|
|
10411
10453
|
}
|
|
10412
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
10454
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R38, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10413
10455
|
return { $loc, token: $0 };
|
|
10414
10456
|
});
|
|
10415
10457
|
function CoffeeDoubleQuotedStringCharacters(ctx, state) {
|
|
10416
10458
|
return $EVENT(ctx, state, "CoffeeDoubleQuotedStringCharacters", CoffeeDoubleQuotedStringCharacters$0);
|
|
10417
10459
|
}
|
|
10418
10460
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
10419
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
10461
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L56, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L56, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
10420
10462
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
10421
10463
|
});
|
|
10422
10464
|
var RegularExpressionLiteral$$ = [RegularExpressionLiteral$0, RegularExpressionLiteral$1];
|
|
@@ -10429,7 +10471,7 @@ var require_parser = __commonJS({
|
|
|
10429
10471
|
function RegularExpressionClass(ctx, state) {
|
|
10430
10472
|
return $EVENT(ctx, state, "RegularExpressionClass", RegularExpressionClass$0);
|
|
10431
10473
|
}
|
|
10432
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
10474
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R39, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10433
10475
|
return { $loc, token: $0 };
|
|
10434
10476
|
});
|
|
10435
10477
|
function RegularExpressionClassCharacters(ctx, state) {
|
|
@@ -10483,7 +10525,7 @@ var require_parser = __commonJS({
|
|
|
10483
10525
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
10484
10526
|
return { "type": "Substitution", "children": value[0] };
|
|
10485
10527
|
});
|
|
10486
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
10528
|
+
var HeregexPart$3 = $TR($EXPECT($R40, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10487
10529
|
let token = $0;
|
|
10488
10530
|
switch ($0[1]) {
|
|
10489
10531
|
case "\n":
|
|
@@ -10501,13 +10543,13 @@ var require_parser = __commonJS({
|
|
|
10501
10543
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
10502
10544
|
return { $loc, token: "" };
|
|
10503
10545
|
});
|
|
10504
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
10546
|
+
var HeregexPart$5 = $TR($EXPECT($R41, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10505
10547
|
return { $loc, token: "" };
|
|
10506
10548
|
});
|
|
10507
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
10549
|
+
var HeregexPart$6 = $TR($EXPECT($R42, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10508
10550
|
return { $loc, token: "\\/" };
|
|
10509
10551
|
});
|
|
10510
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
10552
|
+
var HeregexPart$7 = $TR($EXPECT($R43, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10511
10553
|
return { $loc, token: $0 };
|
|
10512
10554
|
});
|
|
10513
10555
|
var HeregexPart$$ = [HeregexPart$0, HeregexPart$1, HeregexPart$2, HeregexPart$3, HeregexPart$4, HeregexPart$5, HeregexPart$6, HeregexPart$7];
|
|
@@ -10520,7 +10562,7 @@ var require_parser = __commonJS({
|
|
|
10520
10562
|
function HeregexComment(ctx, state) {
|
|
10521
10563
|
return $EVENT_C(ctx, state, "HeregexComment", HeregexComment$$);
|
|
10522
10564
|
}
|
|
10523
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
10565
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R44, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
10524
10566
|
function RegularExpressionBody(ctx, state) {
|
|
10525
10567
|
return $EVENT(ctx, state, "RegularExpressionBody", RegularExpressionBody$0);
|
|
10526
10568
|
}
|
|
@@ -10530,15 +10572,15 @@ var require_parser = __commonJS({
|
|
|
10530
10572
|
function RegExpPart(ctx, state) {
|
|
10531
10573
|
return $EVENT_C(ctx, state, "RegExpPart", RegExpPart$$);
|
|
10532
10574
|
}
|
|
10533
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
10575
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R45, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
10534
10576
|
function RegExpCharacter(ctx, state) {
|
|
10535
10577
|
return $EVENT(ctx, state, "RegExpCharacter", RegExpCharacter$0);
|
|
10536
10578
|
}
|
|
10537
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
10579
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R46, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
10538
10580
|
function RegularExpressionFlags(ctx, state) {
|
|
10539
10581
|
return $EVENT(ctx, state, "RegularExpressionFlags", RegularExpressionFlags$0);
|
|
10540
10582
|
}
|
|
10541
|
-
var TemplateLiteral$0 = $T($S($EXPECT($
|
|
10583
|
+
var TemplateLiteral$0 = $T($S($EXPECT($R47, "TemplateLiteral /(?=[`'\"])/"), _TemplateLiteral), function(value) {
|
|
10542
10584
|
return value[1];
|
|
10543
10585
|
});
|
|
10544
10586
|
function TemplateLiteral(ctx, state) {
|
|
@@ -10574,28 +10616,28 @@ var require_parser = __commonJS({
|
|
|
10574
10616
|
function TemplateSubstitution(ctx, state) {
|
|
10575
10617
|
return $EVENT(ctx, state, "TemplateSubstitution", TemplateSubstitution$0);
|
|
10576
10618
|
}
|
|
10577
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
10619
|
+
var TemplateCharacters$0 = $TR($EXPECT($R48, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10578
10620
|
return { $loc, token: $0 };
|
|
10579
10621
|
});
|
|
10580
10622
|
function TemplateCharacters(ctx, state) {
|
|
10581
10623
|
return $EVENT(ctx, state, "TemplateCharacters", TemplateCharacters$0);
|
|
10582
10624
|
}
|
|
10583
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
10625
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R49, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10584
10626
|
return { $loc, token: $0 };
|
|
10585
10627
|
});
|
|
10586
10628
|
function TemplateBlockCharacters(ctx, state) {
|
|
10587
10629
|
return $EVENT(ctx, state, "TemplateBlockCharacters", TemplateBlockCharacters$0);
|
|
10588
10630
|
}
|
|
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($
|
|
10631
|
+
var ReservedWord$0 = $S($R$0($EXPECT($R50, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")), CoffeeBooleansEnabled);
|
|
10632
|
+
var ReservedWord$1 = $S($R$0($EXPECT($R51, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")), CoffeeIsntEnabled);
|
|
10633
|
+
var ReservedWord$2 = $S($R$0($EXPECT($R52, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")), CoffeeForLoopsEnabled);
|
|
10634
|
+
var ReservedWord$3 = $S($R$0($EXPECT($R53, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")), CoffeeOfEnabled);
|
|
10635
|
+
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
10636
|
var ReservedWord$$ = [ReservedWord$0, ReservedWord$1, ReservedWord$2, ReservedWord$3, ReservedWord$4];
|
|
10595
10637
|
function ReservedWord(ctx, state) {
|
|
10596
10638
|
return $EVENT_C(ctx, state, "ReservedWord", ReservedWord$$);
|
|
10597
10639
|
}
|
|
10598
|
-
var Comment$0 = $T($S($EXPECT($
|
|
10640
|
+
var Comment$0 = $T($S($EXPECT($R55, "Comment /(?=\\/|#)/"), _Comment), function(value) {
|
|
10599
10641
|
return value[1];
|
|
10600
10642
|
});
|
|
10601
10643
|
function Comment(ctx, state) {
|
|
@@ -10613,7 +10655,7 @@ var require_parser = __commonJS({
|
|
|
10613
10655
|
function SingleLineComment(ctx, state) {
|
|
10614
10656
|
return $EVENT_C(ctx, state, "SingleLineComment", SingleLineComment$$);
|
|
10615
10657
|
}
|
|
10616
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
10658
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R56, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10617
10659
|
return { type: "Comment", $loc, token: $0 };
|
|
10618
10660
|
});
|
|
10619
10661
|
function JSSingleLineComment(ctx, state) {
|
|
@@ -10625,30 +10667,30 @@ var require_parser = __commonJS({
|
|
|
10625
10667
|
function MultiLineComment(ctx, state) {
|
|
10626
10668
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
10627
10669
|
}
|
|
10628
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
10670
|
+
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
10671
|
return { type: "Comment", $loc, token: $1 };
|
|
10630
10672
|
});
|
|
10631
10673
|
function JSMultiLineComment(ctx, state) {
|
|
10632
10674
|
return $EVENT(ctx, state, "JSMultiLineComment", JSMultiLineComment$0);
|
|
10633
10675
|
}
|
|
10634
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
10676
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R58, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10635
10677
|
return { type: "Comment", $loc, token: `//${$1}` };
|
|
10636
10678
|
});
|
|
10637
10679
|
function CoffeeSingleLineComment(ctx, state) {
|
|
10638
10680
|
return $EVENT(ctx, state, "CoffeeSingleLineComment", CoffeeSingleLineComment$0);
|
|
10639
10681
|
}
|
|
10640
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
10682
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R59, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
10641
10683
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
10642
10684
|
return { type: "Comment", $loc, token: `/*${$2}*/` };
|
|
10643
10685
|
});
|
|
10644
10686
|
function CoffeeMultiLineComment(ctx, state) {
|
|
10645
10687
|
return $EVENT(ctx, state, "CoffeeMultiLineComment", CoffeeMultiLineComment$0);
|
|
10646
10688
|
}
|
|
10647
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
10689
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R60, "CoffeeHereCommentStart /###(?!#)/"));
|
|
10648
10690
|
function CoffeeHereCommentStart(ctx, state) {
|
|
10649
10691
|
return $EVENT(ctx, state, "CoffeeHereCommentStart", CoffeeHereCommentStart$0);
|
|
10650
10692
|
}
|
|
10651
|
-
var InlineComment$0 = $TR($EXPECT($
|
|
10693
|
+
var InlineComment$0 = $TR($EXPECT($R61, "InlineComment /\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\//"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10652
10694
|
return { $loc, token: $0 };
|
|
10653
10695
|
});
|
|
10654
10696
|
function InlineComment(ctx, state) {
|
|
@@ -10662,16 +10704,16 @@ var require_parser = __commonJS({
|
|
|
10662
10704
|
function TrailingComment(ctx, state) {
|
|
10663
10705
|
return $EVENT(ctx, state, "TrailingComment", TrailingComment$0);
|
|
10664
10706
|
}
|
|
10665
|
-
var _$0 = $T($S($EXPECT($
|
|
10707
|
+
var _$0 = $T($S($EXPECT($R62, "_ /(?=[ \\t\\/\\\\])/"), $P($C(NonNewlineWhitespace, InlineComment))), function(value) {
|
|
10666
10708
|
return value[1];
|
|
10667
10709
|
});
|
|
10668
10710
|
function _(ctx, state) {
|
|
10669
10711
|
return $EVENT(ctx, state, "_", _$0);
|
|
10670
10712
|
}
|
|
10671
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
10713
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R63, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10672
10714
|
return { $loc, token: $0 };
|
|
10673
10715
|
});
|
|
10674
|
-
var NonNewlineWhitespace$1 = $T($S($EXPECT($
|
|
10716
|
+
var NonNewlineWhitespace$1 = $T($S($EXPECT($L111, 'NonNewlineWhitespace "\\\\\\\\"'), CoffeeLineContinuationEnabled, EOL), function(value) {
|
|
10675
10717
|
return " ";
|
|
10676
10718
|
});
|
|
10677
10719
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
@@ -10685,7 +10727,7 @@ var require_parser = __commonJS({
|
|
|
10685
10727
|
function Trimmed_(ctx, state) {
|
|
10686
10728
|
return $EVENT(ctx, state, "Trimmed_", Trimmed_$0);
|
|
10687
10729
|
}
|
|
10688
|
-
var __$0 = $T($S($EXPECT($
|
|
10730
|
+
var __$0 = $T($S($EXPECT($R64, "__ /(?=\\s|\\/|#)/"), $Q($C(Whitespace, Comment))), function(value) {
|
|
10689
10731
|
return value[1];
|
|
10690
10732
|
});
|
|
10691
10733
|
var __$1 = $EXPECT($L0, '__ ""');
|
|
@@ -10693,7 +10735,7 @@ var require_parser = __commonJS({
|
|
|
10693
10735
|
function __(ctx, state) {
|
|
10694
10736
|
return $EVENT_C(ctx, state, "__", __$$);
|
|
10695
10737
|
}
|
|
10696
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
10738
|
+
var Whitespace$0 = $TR($EXPECT($R41, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10697
10739
|
return { $loc, token: $0 };
|
|
10698
10740
|
});
|
|
10699
10741
|
function Whitespace(ctx, state) {
|
|
@@ -10717,7 +10759,7 @@ var require_parser = __commonJS({
|
|
|
10717
10759
|
}
|
|
10718
10760
|
var StatementDelimiter$0 = $Y(EOS);
|
|
10719
10761
|
var StatementDelimiter$1 = SemicolonDelimiter;
|
|
10720
|
-
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($
|
|
10762
|
+
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L26, 'StatementDelimiter "}"'), $EXPECT($L112, 'StatementDelimiter ")"'), $EXPECT($L35, 'StatementDelimiter "]"'))));
|
|
10721
10763
|
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2];
|
|
10722
10764
|
function StatementDelimiter(ctx, state) {
|
|
10723
10765
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
@@ -10731,7 +10773,7 @@ var require_parser = __commonJS({
|
|
|
10731
10773
|
function SemicolonDelimiter(ctx, state) {
|
|
10732
10774
|
return $EVENT(ctx, state, "SemicolonDelimiter", SemicolonDelimiter$0);
|
|
10733
10775
|
}
|
|
10734
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
10776
|
+
var NonIdContinue$0 = $R$0($EXPECT($R65, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
10735
10777
|
function NonIdContinue(ctx, state) {
|
|
10736
10778
|
return $EVENT(ctx, state, "NonIdContinue", NonIdContinue$0);
|
|
10737
10779
|
}
|
|
@@ -10741,103 +10783,109 @@ var require_parser = __commonJS({
|
|
|
10741
10783
|
function Loc(ctx, state) {
|
|
10742
10784
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
10743
10785
|
}
|
|
10744
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
10786
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L113, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L12, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
10745
10787
|
return { $loc, token: $1, ts: true };
|
|
10746
10788
|
});
|
|
10747
10789
|
function Abstract(ctx, state) {
|
|
10748
10790
|
return $EVENT(ctx, state, "Abstract", Abstract$0);
|
|
10749
10791
|
}
|
|
10750
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
10792
|
+
var Ampersand$0 = $TV($EXPECT($L98, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
10751
10793
|
return { $loc, token: $1 };
|
|
10752
10794
|
});
|
|
10753
10795
|
function Ampersand(ctx, state) {
|
|
10754
10796
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
10755
10797
|
}
|
|
10756
|
-
var As$0 = $TS($S($EXPECT($
|
|
10798
|
+
var As$0 = $TS($S($EXPECT($L114, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10757
10799
|
return { $loc, token: $1 };
|
|
10758
10800
|
});
|
|
10759
10801
|
function As(ctx, state) {
|
|
10760
10802
|
return $EVENT(ctx, state, "As", As$0);
|
|
10761
10803
|
}
|
|
10762
|
-
var At$0 = $TV($EXPECT($
|
|
10804
|
+
var At$0 = $TV($EXPECT($L115, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
10763
10805
|
return { $loc, token: $1 };
|
|
10764
10806
|
});
|
|
10765
10807
|
function At(ctx, state) {
|
|
10766
10808
|
return $EVENT(ctx, state, "At", At$0);
|
|
10767
10809
|
}
|
|
10768
|
-
var AtAt$0 = $TV($EXPECT($
|
|
10810
|
+
var AtAt$0 = $TV($EXPECT($L116, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
10769
10811
|
return { $loc, token: "@" };
|
|
10770
10812
|
});
|
|
10771
10813
|
function AtAt(ctx, state) {
|
|
10772
10814
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
10773
10815
|
}
|
|
10774
|
-
var Async$0 = $TS($S($EXPECT($
|
|
10816
|
+
var Async$0 = $TS($S($EXPECT($L117, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10775
10817
|
return { $loc, token: $1, type: "Async" };
|
|
10776
10818
|
});
|
|
10777
10819
|
function Async(ctx, state) {
|
|
10778
10820
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
10779
10821
|
}
|
|
10780
|
-
var Await$0 = $TS($S($EXPECT($
|
|
10822
|
+
var Await$0 = $TS($S($EXPECT($L118, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10781
10823
|
return { $loc, token: $1, type: "Await" };
|
|
10782
10824
|
});
|
|
10783
10825
|
function Await(ctx, state) {
|
|
10784
10826
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
10785
10827
|
}
|
|
10786
|
-
var Backtick$0 = $TV($EXPECT($
|
|
10828
|
+
var Backtick$0 = $TV($EXPECT($L119, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
10787
10829
|
return { $loc, token: $1 };
|
|
10788
10830
|
});
|
|
10789
10831
|
function Backtick(ctx, state) {
|
|
10790
10832
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
10791
10833
|
}
|
|
10792
|
-
var By$0 = $TS($S($EXPECT($
|
|
10834
|
+
var By$0 = $TS($S($EXPECT($L120, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10793
10835
|
return { $loc, token: $1 };
|
|
10794
10836
|
});
|
|
10795
10837
|
function By(ctx, state) {
|
|
10796
10838
|
return $EVENT(ctx, state, "By", By$0);
|
|
10797
10839
|
}
|
|
10798
|
-
var
|
|
10840
|
+
var Caret$0 = $TV($EXPECT($L18, 'Caret "^"'), function($skip, $loc, $0, $1) {
|
|
10841
|
+
return { $loc, token: $1 };
|
|
10842
|
+
});
|
|
10843
|
+
function Caret(ctx, state) {
|
|
10844
|
+
return $EVENT(ctx, state, "Caret", Caret$0);
|
|
10845
|
+
}
|
|
10846
|
+
var Case$0 = $TS($S($EXPECT($L121, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10799
10847
|
return { $loc, token: $1 };
|
|
10800
10848
|
});
|
|
10801
10849
|
function Case(ctx, state) {
|
|
10802
10850
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
10803
10851
|
}
|
|
10804
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
10852
|
+
var Catch$0 = $TS($S($EXPECT($L122, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10805
10853
|
return { $loc, token: $1 };
|
|
10806
10854
|
});
|
|
10807
10855
|
function Catch(ctx, state) {
|
|
10808
10856
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
10809
10857
|
}
|
|
10810
|
-
var Class$0 = $TS($S($EXPECT($
|
|
10858
|
+
var Class$0 = $TS($S($EXPECT($L123, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10811
10859
|
return { $loc, token: $1 };
|
|
10812
10860
|
});
|
|
10813
10861
|
function Class(ctx, state) {
|
|
10814
10862
|
return $EVENT(ctx, state, "Class", Class$0);
|
|
10815
10863
|
}
|
|
10816
|
-
var CloseAngleBracket$0 = $TV($EXPECT($
|
|
10864
|
+
var CloseAngleBracket$0 = $TV($EXPECT($L34, 'CloseAngleBracket ">"'), function($skip, $loc, $0, $1) {
|
|
10817
10865
|
return { $loc, token: $1 };
|
|
10818
10866
|
});
|
|
10819
10867
|
function CloseAngleBracket(ctx, state) {
|
|
10820
10868
|
return $EVENT(ctx, state, "CloseAngleBracket", CloseAngleBracket$0);
|
|
10821
10869
|
}
|
|
10822
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
10870
|
+
var CloseBrace$0 = $TV($EXPECT($L26, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
10823
10871
|
return { $loc, token: $1 };
|
|
10824
10872
|
});
|
|
10825
10873
|
function CloseBrace(ctx, state) {
|
|
10826
10874
|
return $EVENT(ctx, state, "CloseBrace", CloseBrace$0);
|
|
10827
10875
|
}
|
|
10828
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
10876
|
+
var CloseBracket$0 = $TV($EXPECT($L35, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
10829
10877
|
return { $loc, token: $1 };
|
|
10830
10878
|
});
|
|
10831
10879
|
function CloseBracket(ctx, state) {
|
|
10832
10880
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
10833
10881
|
}
|
|
10834
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
10882
|
+
var CloseParen$0 = $TV($EXPECT($L112, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
10835
10883
|
return { $loc, token: $1 };
|
|
10836
10884
|
});
|
|
10837
10885
|
function CloseParen(ctx, state) {
|
|
10838
10886
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
10839
10887
|
}
|
|
10840
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
10888
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L124, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
10841
10889
|
return { $loc, token: "${" };
|
|
10842
10890
|
});
|
|
10843
10891
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
@@ -10849,37 +10897,37 @@ var require_parser = __commonJS({
|
|
|
10849
10897
|
function Colon(ctx, state) {
|
|
10850
10898
|
return $EVENT(ctx, state, "Colon", Colon$0);
|
|
10851
10899
|
}
|
|
10852
|
-
var Comma$0 = $TV($EXPECT($
|
|
10900
|
+
var Comma$0 = $TV($EXPECT($L22, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
10853
10901
|
return { $loc, token: $1 };
|
|
10854
10902
|
});
|
|
10855
10903
|
function Comma(ctx, state) {
|
|
10856
10904
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
10857
10905
|
}
|
|
10858
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
10906
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L115, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
10859
10907
|
return { $loc, token: "constructor" };
|
|
10860
10908
|
});
|
|
10861
10909
|
function ConstructorShorthand(ctx, state) {
|
|
10862
10910
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
10863
10911
|
}
|
|
10864
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
10912
|
+
var Declare$0 = $TS($S($EXPECT($L125, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10865
10913
|
return { $loc, token: $1 };
|
|
10866
10914
|
});
|
|
10867
10915
|
function Declare(ctx, state) {
|
|
10868
10916
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
10869
10917
|
}
|
|
10870
|
-
var Default$0 = $TS($S($EXPECT($
|
|
10918
|
+
var Default$0 = $TS($S($EXPECT($L126, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10871
10919
|
return { $loc, token: $1 };
|
|
10872
10920
|
});
|
|
10873
10921
|
function Default(ctx, state) {
|
|
10874
10922
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
10875
10923
|
}
|
|
10876
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
10924
|
+
var Delete$0 = $TS($S($EXPECT($L127, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10877
10925
|
return { $loc, token: $1 };
|
|
10878
10926
|
});
|
|
10879
10927
|
function Delete(ctx, state) {
|
|
10880
10928
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
10881
10929
|
}
|
|
10882
|
-
var Do$0 = $TS($S($EXPECT($
|
|
10930
|
+
var Do$0 = $TS($S($EXPECT($L128, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10883
10931
|
return { $loc, token: $1 };
|
|
10884
10932
|
});
|
|
10885
10933
|
function Do(ctx, state) {
|
|
@@ -10888,7 +10936,7 @@ var require_parser = __commonJS({
|
|
|
10888
10936
|
var Dot$0 = $TV($EXPECT($L6, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
10889
10937
|
return { $loc, token: $1 };
|
|
10890
10938
|
});
|
|
10891
|
-
var Dot$1 = $TS($S($EXPECT($
|
|
10939
|
+
var Dot$1 = $TS($S($EXPECT($R66, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
|
|
10892
10940
|
var ws = $2;
|
|
10893
10941
|
return [
|
|
10894
10942
|
{ $loc, token: "." },
|
|
@@ -10899,45 +10947,45 @@ var require_parser = __commonJS({
|
|
|
10899
10947
|
function Dot(ctx, state) {
|
|
10900
10948
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
10901
10949
|
}
|
|
10902
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
10950
|
+
var DotDot$0 = $TS($S($EXPECT($L129, 'DotDot ".."'), $N($EXPECT($L6, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
10903
10951
|
return { $loc, token: $1 };
|
|
10904
10952
|
});
|
|
10905
|
-
var DotDot$1 = $TV($EXPECT($
|
|
10953
|
+
var DotDot$1 = $TV($EXPECT($L130, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
10906
10954
|
return { $loc, token: ".." };
|
|
10907
10955
|
});
|
|
10908
10956
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
10909
10957
|
function DotDot(ctx, state) {
|
|
10910
10958
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
10911
10959
|
}
|
|
10912
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
10960
|
+
var DotDotDot$0 = $TV($EXPECT($L131, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
10913
10961
|
return { $loc, token: $1 };
|
|
10914
10962
|
});
|
|
10915
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
10963
|
+
var DotDotDot$1 = $TV($EXPECT($L132, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
10916
10964
|
return { $loc, token: "..." };
|
|
10917
10965
|
});
|
|
10918
10966
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
10919
10967
|
function DotDotDot(ctx, state) {
|
|
10920
10968
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
10921
10969
|
}
|
|
10922
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
10970
|
+
var DoubleColon$0 = $TV($EXPECT($L133, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
10923
10971
|
return { $loc, token: $1 };
|
|
10924
10972
|
});
|
|
10925
10973
|
function DoubleColon(ctx, state) {
|
|
10926
10974
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
10927
10975
|
}
|
|
10928
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
10976
|
+
var DoubleQuote$0 = $TV($EXPECT($L134, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
10929
10977
|
return { $loc, token: $1 };
|
|
10930
10978
|
});
|
|
10931
10979
|
function DoubleQuote(ctx, state) {
|
|
10932
10980
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
10933
10981
|
}
|
|
10934
|
-
var Each$0 = $TS($S($EXPECT($
|
|
10982
|
+
var Each$0 = $TS($S($EXPECT($L135, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10935
10983
|
return { $loc, token: $1 };
|
|
10936
10984
|
});
|
|
10937
10985
|
function Each(ctx, state) {
|
|
10938
10986
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
10939
10987
|
}
|
|
10940
|
-
var Else$0 = $TS($S($EXPECT($
|
|
10988
|
+
var Else$0 = $TS($S($EXPECT($L136, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10941
10989
|
return { $loc, token: $1 };
|
|
10942
10990
|
});
|
|
10943
10991
|
function Else(ctx, state) {
|
|
@@ -10949,85 +10997,85 @@ var require_parser = __commonJS({
|
|
|
10949
10997
|
function Equals(ctx, state) {
|
|
10950
10998
|
return $EVENT(ctx, state, "Equals", Equals$0);
|
|
10951
10999
|
}
|
|
10952
|
-
var Export$0 = $TS($S($EXPECT($
|
|
11000
|
+
var Export$0 = $TS($S($EXPECT($L137, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10953
11001
|
return { $loc, token: $1 };
|
|
10954
11002
|
});
|
|
10955
11003
|
function Export(ctx, state) {
|
|
10956
11004
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
10957
11005
|
}
|
|
10958
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
11006
|
+
var Extends$0 = $TS($S($EXPECT($L138, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10959
11007
|
return { $loc, token: $1 };
|
|
10960
11008
|
});
|
|
10961
11009
|
function Extends(ctx, state) {
|
|
10962
11010
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
10963
11011
|
}
|
|
10964
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
11012
|
+
var Finally$0 = $TS($S($EXPECT($L139, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10965
11013
|
return { $loc, token: $1 };
|
|
10966
11014
|
});
|
|
10967
11015
|
function Finally(ctx, state) {
|
|
10968
11016
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
10969
11017
|
}
|
|
10970
|
-
var For$0 = $TS($S($EXPECT($
|
|
11018
|
+
var For$0 = $TS($S($EXPECT($L140, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10971
11019
|
return { $loc, token: $1 };
|
|
10972
11020
|
});
|
|
10973
11021
|
function For(ctx, state) {
|
|
10974
11022
|
return $EVENT(ctx, state, "For", For$0);
|
|
10975
11023
|
}
|
|
10976
|
-
var From$0 = $TS($S($EXPECT($
|
|
11024
|
+
var From$0 = $TS($S($EXPECT($L141, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10977
11025
|
return { $loc, token: $1 };
|
|
10978
11026
|
});
|
|
10979
11027
|
function From(ctx, state) {
|
|
10980
11028
|
return $EVENT(ctx, state, "From", From$0);
|
|
10981
11029
|
}
|
|
10982
|
-
var Function$0 = $TS($S($EXPECT($
|
|
11030
|
+
var Function$0 = $TS($S($EXPECT($L142, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10983
11031
|
return { $loc, token: $1 };
|
|
10984
11032
|
});
|
|
10985
11033
|
function Function(ctx, state) {
|
|
10986
11034
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
10987
11035
|
}
|
|
10988
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
11036
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L143, 'GetOrSet "get"'), $EXPECT($L144, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10989
11037
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
10990
11038
|
});
|
|
10991
11039
|
function GetOrSet(ctx, state) {
|
|
10992
11040
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
10993
11041
|
}
|
|
10994
|
-
var Hash$0 = $TV($EXPECT($
|
|
11042
|
+
var Hash$0 = $TV($EXPECT($L145, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
10995
11043
|
return { $loc, token: $1 };
|
|
10996
11044
|
});
|
|
10997
11045
|
function Hash(ctx, state) {
|
|
10998
11046
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
10999
11047
|
}
|
|
11000
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
11048
|
+
var If$0 = $TV($TEXT($S($EXPECT($L146, 'If "if"'), NonIdContinue, $E($EXPECT($L12, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
11001
11049
|
return { $loc, token: $1 };
|
|
11002
11050
|
});
|
|
11003
11051
|
function If(ctx, state) {
|
|
11004
11052
|
return $EVENT(ctx, state, "If", If$0);
|
|
11005
11053
|
}
|
|
11006
|
-
var Import$0 = $TS($S($EXPECT($
|
|
11054
|
+
var Import$0 = $TS($S($EXPECT($L16, 'Import "import"'), $Y($EXPECT($R67, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
11007
11055
|
return { $loc, token: $1 };
|
|
11008
11056
|
});
|
|
11009
11057
|
function Import(ctx, state) {
|
|
11010
11058
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
11011
11059
|
}
|
|
11012
|
-
var In$0 = $TS($S($EXPECT($
|
|
11060
|
+
var In$0 = $TS($S($EXPECT($L147, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11013
11061
|
return { $loc, token: $1 };
|
|
11014
11062
|
});
|
|
11015
11063
|
function In(ctx, state) {
|
|
11016
11064
|
return $EVENT(ctx, state, "In", In$0);
|
|
11017
11065
|
}
|
|
11018
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
11066
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L148, 'LetOrConst "let"'), $EXPECT($L149, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11019
11067
|
return { $loc, token: $1 };
|
|
11020
11068
|
});
|
|
11021
11069
|
function LetOrConst(ctx, state) {
|
|
11022
11070
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
11023
11071
|
}
|
|
11024
|
-
var Const$0 = $TS($S($EXPECT($
|
|
11072
|
+
var Const$0 = $TS($S($EXPECT($L149, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11025
11073
|
return { $loc, token: $1 };
|
|
11026
11074
|
});
|
|
11027
11075
|
function Const(ctx, state) {
|
|
11028
11076
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
11029
11077
|
}
|
|
11030
|
-
var Is$0 = $TS($S($EXPECT($
|
|
11078
|
+
var Is$0 = $TS($S($EXPECT($L150, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11031
11079
|
return { $loc, token: $1 };
|
|
11032
11080
|
});
|
|
11033
11081
|
function Is(ctx, state) {
|
|
@@ -11039,31 +11087,31 @@ var require_parser = __commonJS({
|
|
|
11039
11087
|
function LetOrConstOrVar(ctx, state) {
|
|
11040
11088
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
11041
11089
|
}
|
|
11042
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
11090
|
+
var Loop$0 = $TS($S($EXPECT($L151, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11043
11091
|
return { $loc, token: "while(true)" };
|
|
11044
11092
|
});
|
|
11045
11093
|
function Loop(ctx, state) {
|
|
11046
11094
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
11047
11095
|
}
|
|
11048
|
-
var New$0 = $TS($S($EXPECT($
|
|
11096
|
+
var New$0 = $TS($S($EXPECT($L152, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11049
11097
|
return { $loc, token: $1 };
|
|
11050
11098
|
});
|
|
11051
11099
|
function New(ctx, state) {
|
|
11052
11100
|
return $EVENT(ctx, state, "New", New$0);
|
|
11053
11101
|
}
|
|
11054
|
-
var Not$0 = $TS($S($EXPECT($
|
|
11102
|
+
var Not$0 = $TS($S($EXPECT($L153, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L11, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
11055
11103
|
return { $loc, token: "!" };
|
|
11056
11104
|
});
|
|
11057
11105
|
function Not(ctx, state) {
|
|
11058
11106
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
11059
11107
|
}
|
|
11060
|
-
var Of$0 = $TS($S($EXPECT($
|
|
11108
|
+
var Of$0 = $TS($S($EXPECT($L154, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11061
11109
|
return { $loc, token: $1 };
|
|
11062
11110
|
});
|
|
11063
11111
|
function Of(ctx, state) {
|
|
11064
11112
|
return $EVENT(ctx, state, "Of", Of$0);
|
|
11065
11113
|
}
|
|
11066
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
11114
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L13, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
11067
11115
|
return { $loc, token: $1 };
|
|
11068
11116
|
});
|
|
11069
11117
|
function OpenAngleBracket(ctx, state) {
|
|
@@ -11154,7 +11202,7 @@ var require_parser = __commonJS({
|
|
|
11154
11202
|
function Satisfies(ctx, state) {
|
|
11155
11203
|
return $EVENT(ctx, state, "Satisfies", Satisfies$0);
|
|
11156
11204
|
}
|
|
11157
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
11205
|
+
var Semicolon$0 = $TV($EXPECT($L100, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
11158
11206
|
return { $loc, token: $1 };
|
|
11159
11207
|
});
|
|
11160
11208
|
function Semicolon(ctx, state) {
|
|
@@ -11166,7 +11214,7 @@ var require_parser = __commonJS({
|
|
|
11166
11214
|
function SingleQuote(ctx, state) {
|
|
11167
11215
|
return $EVENT(ctx, state, "SingleQuote", SingleQuote$0);
|
|
11168
11216
|
}
|
|
11169
|
-
var Star$0 = $TV($EXPECT($
|
|
11217
|
+
var Star$0 = $TV($EXPECT($L55, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
11170
11218
|
return { $loc, token: $1 };
|
|
11171
11219
|
});
|
|
11172
11220
|
function Star(ctx, state) {
|
|
@@ -11175,7 +11223,7 @@ var require_parser = __commonJS({
|
|
|
11175
11223
|
var Static$0 = $TS($S($EXPECT($L171, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11176
11224
|
return { $loc, token: $1 };
|
|
11177
11225
|
});
|
|
11178
|
-
var Static$1 = $TS($S($EXPECT($
|
|
11226
|
+
var Static$1 = $TS($S($EXPECT($L115, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L115, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
11179
11227
|
return { $loc, token: "static " };
|
|
11180
11228
|
});
|
|
11181
11229
|
var Static$$ = [Static$0, Static$1];
|
|
@@ -11331,7 +11379,7 @@ var require_parser = __commonJS({
|
|
|
11331
11379
|
function JSXImplicitFragment(ctx, state) {
|
|
11332
11380
|
return $EVENT(ctx, state, "JSXImplicitFragment", JSXImplicitFragment$0);
|
|
11333
11381
|
}
|
|
11334
|
-
var JSXTag$0 = $T($S($EXPECT($
|
|
11382
|
+
var JSXTag$0 = $T($S($EXPECT($R68, "JSXTag /(?=[<])/"), _JSXTag), function(value) {
|
|
11335
11383
|
return value[1];
|
|
11336
11384
|
});
|
|
11337
11385
|
function JSXTag(ctx, state) {
|
|
@@ -11381,7 +11429,7 @@ var require_parser = __commonJS({
|
|
|
11381
11429
|
function JSXElement(ctx, state) {
|
|
11382
11430
|
return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
|
|
11383
11431
|
}
|
|
11384
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
11432
|
+
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
11433
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
11386
11434
|
});
|
|
11387
11435
|
function JSXSelfClosingElement(ctx, state) {
|
|
@@ -11400,7 +11448,7 @@ var require_parser = __commonJS({
|
|
|
11400
11448
|
function PopJSXStack(ctx, state) {
|
|
11401
11449
|
return $EVENT(ctx, state, "PopJSXStack", PopJSXStack$0);
|
|
11402
11450
|
}
|
|
11403
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
11451
|
+
var JSXOpeningElement$0 = $S($EXPECT($L13, 'JSXOpeningElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L34, 'JSXOpeningElement ">"'));
|
|
11404
11452
|
function JSXOpeningElement(ctx, state) {
|
|
11405
11453
|
return $EVENT(ctx, state, "JSXOpeningElement", JSXOpeningElement$0);
|
|
11406
11454
|
}
|
|
@@ -11415,7 +11463,7 @@ var require_parser = __commonJS({
|
|
|
11415
11463
|
function JSXOptionalClosingElement(ctx, state) {
|
|
11416
11464
|
return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
|
|
11417
11465
|
}
|
|
11418
|
-
var JSXClosingElement$0 = $S($EXPECT($L194, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($
|
|
11466
|
+
var JSXClosingElement$0 = $S($EXPECT($L194, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L34, 'JSXClosingElement ">"'));
|
|
11419
11467
|
function JSXClosingElement(ctx, state) {
|
|
11420
11468
|
return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
|
|
11421
11469
|
}
|
|
@@ -11470,7 +11518,7 @@ var require_parser = __commonJS({
|
|
|
11470
11518
|
function JSXClosingFragment(ctx, state) {
|
|
11471
11519
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
11472
11520
|
}
|
|
11473
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
11521
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L145, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
11474
11522
|
return module.config.defaultElement;
|
|
11475
11523
|
});
|
|
11476
11524
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -11478,7 +11526,7 @@ var require_parser = __commonJS({
|
|
|
11478
11526
|
function JSXElementName(ctx, state) {
|
|
11479
11527
|
return $EVENT_C(ctx, state, "JSXElementName", JSXElementName$$);
|
|
11480
11528
|
}
|
|
11481
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
11529
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R69, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
11482
11530
|
function JSXIdentifierName(ctx, state) {
|
|
11483
11531
|
return $EVENT(ctx, state, "JSXIdentifierName", JSXIdentifierName$0);
|
|
11484
11532
|
}
|
|
@@ -11642,7 +11690,7 @@ var require_parser = __commonJS({
|
|
|
11642
11690
|
}
|
|
11643
11691
|
return $skip;
|
|
11644
11692
|
});
|
|
11645
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
11693
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L145, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
11646
11694
|
return [" ", "id=", $2];
|
|
11647
11695
|
});
|
|
11648
11696
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -11661,11 +11709,11 @@ var require_parser = __commonJS({
|
|
|
11661
11709
|
function JSXAttribute(ctx, state) {
|
|
11662
11710
|
return $EVENT_C(ctx, state, "JSXAttribute", JSXAttribute$$);
|
|
11663
11711
|
}
|
|
11664
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
11712
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R70, "JSXAttributeSpace /[\\s>]|\\/>/"));
|
|
11665
11713
|
function JSXAttributeSpace(ctx, state) {
|
|
11666
11714
|
return $EVENT(ctx, state, "JSXAttributeSpace", JSXAttributeSpace$0);
|
|
11667
11715
|
}
|
|
11668
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
11716
|
+
var JSXShorthandString$0 = $TR($EXPECT($R71, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11669
11717
|
return quoteString($0);
|
|
11670
11718
|
});
|
|
11671
11719
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -11699,7 +11747,7 @@ var require_parser = __commonJS({
|
|
|
11699
11747
|
}
|
|
11700
11748
|
return [open, value, close];
|
|
11701
11749
|
});
|
|
11702
|
-
var JSXAttributeValue$4 = $R$0($EXPECT($
|
|
11750
|
+
var JSXAttributeValue$4 = $R$0($EXPECT($R72, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
|
|
11703
11751
|
var JSXAttributeValue$$ = [JSXAttributeValue$0, JSXAttributeValue$1, JSXAttributeValue$2, JSXAttributeValue$3, JSXAttributeValue$4];
|
|
11704
11752
|
function JSXAttributeValue(ctx, state) {
|
|
11705
11753
|
return $EVENT_C(ctx, state, "JSXAttributeValue", JSXAttributeValue$$);
|
|
@@ -11712,7 +11760,7 @@ var require_parser = __commonJS({
|
|
|
11712
11760
|
function InlineJSXAttributeValue(ctx, state) {
|
|
11713
11761
|
return $EVENT(ctx, state, "InlineJSXAttributeValue", InlineJSXAttributeValue$0);
|
|
11714
11762
|
}
|
|
11715
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
11763
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R73, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
11716
11764
|
var op = $2;
|
|
11717
11765
|
var rhs = $3;
|
|
11718
11766
|
return [[], op, [], rhs];
|
|
@@ -11729,7 +11777,7 @@ var require_parser = __commonJS({
|
|
|
11729
11777
|
function InlineJSXUnaryExpression(ctx, state) {
|
|
11730
11778
|
return $EVENT(ctx, state, "InlineJSXUnaryExpression", InlineJSXUnaryExpression$0);
|
|
11731
11779
|
}
|
|
11732
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
11780
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R74, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11733
11781
|
return { $loc, token: $0 };
|
|
11734
11782
|
});
|
|
11735
11783
|
function InlineJSXUnaryOp(ctx, state) {
|
|
@@ -11761,7 +11809,7 @@ var require_parser = __commonJS({
|
|
|
11761
11809
|
]
|
|
11762
11810
|
});
|
|
11763
11811
|
});
|
|
11764
|
-
var InlineJSXCallExpression$1 = $TS($S($EXPECT($
|
|
11812
|
+
var InlineJSXCallExpression$1 = $TS($S($EXPECT($L16, 'InlineJSXCallExpression "import"'), ExplicitArguments, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
11765
11813
|
var args = $2;
|
|
11766
11814
|
var rest = $3;
|
|
11767
11815
|
return processCallMemberExpression({
|
|
@@ -11880,7 +11928,7 @@ var require_parser = __commonJS({
|
|
|
11880
11928
|
}
|
|
11881
11929
|
return $skip;
|
|
11882
11930
|
});
|
|
11883
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
11931
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L26, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
11884
11932
|
return { children: [], jsxChildren: [] };
|
|
11885
11933
|
});
|
|
11886
11934
|
var JSXNestedChildren$$ = [JSXNestedChildren$0, JSXNestedChildren$1];
|
|
@@ -11941,13 +11989,13 @@ var require_parser = __commonJS({
|
|
|
11941
11989
|
function JSXComment(ctx, state) {
|
|
11942
11990
|
return $EVENT(ctx, state, "JSXComment", JSXComment$0);
|
|
11943
11991
|
}
|
|
11944
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
11992
|
+
var JSXCommentContent$0 = $TR($EXPECT($R75, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11945
11993
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
11946
11994
|
});
|
|
11947
11995
|
function JSXCommentContent(ctx, state) {
|
|
11948
11996
|
return $EVENT(ctx, state, "JSXCommentContent", JSXCommentContent$0);
|
|
11949
11997
|
}
|
|
11950
|
-
var JSXText$0 = $TR($EXPECT($
|
|
11998
|
+
var JSXText$0 = $TR($EXPECT($R76, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11951
11999
|
return {
|
|
11952
12000
|
type: "JSXText",
|
|
11953
12001
|
token: $0,
|
|
@@ -12312,7 +12360,7 @@ var require_parser = __commonJS({
|
|
|
12312
12360
|
function TypeProperty(ctx, state) {
|
|
12313
12361
|
return $EVENT(ctx, state, "TypeProperty", TypeProperty$0);
|
|
12314
12362
|
}
|
|
12315
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
12363
|
+
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
12364
|
function TypeIndexSignature(ctx, state) {
|
|
12317
12365
|
return $EVENT(ctx, state, "TypeIndexSignature", TypeIndexSignature$0);
|
|
12318
12366
|
}
|
|
@@ -12363,7 +12411,7 @@ var require_parser = __commonJS({
|
|
|
12363
12411
|
function ReturnType(ctx, state) {
|
|
12364
12412
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
12365
12413
|
}
|
|
12366
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
12414
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L150, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
12367
12415
|
var lhs = $1;
|
|
12368
12416
|
var rhs = $2;
|
|
12369
12417
|
if (!rhs)
|
|
@@ -12464,8 +12512,8 @@ var require_parser = __commonJS({
|
|
|
12464
12512
|
function TypePrimary(ctx, state) {
|
|
12465
12513
|
return $EVENT_C(ctx, state, "TypePrimary", TypePrimary$$);
|
|
12466
12514
|
}
|
|
12467
|
-
var ImportType$0 = $S($EXPECT($
|
|
12468
|
-
var ImportType$1 = $S($EXPECT($
|
|
12515
|
+
var ImportType$0 = $S($EXPECT($L16, 'ImportType "import"'), OpenParen, __, StringLiteral, __, CloseParen, $E($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
12516
|
+
var ImportType$1 = $S($EXPECT($L16, 'ImportType "import"'), InsertOpenParen, Trimmed_, StringLiteral, InsertCloseParen);
|
|
12469
12517
|
var ImportType$$ = [ImportType$0, ImportType$1];
|
|
12470
12518
|
function ImportType(ctx, state) {
|
|
12471
12519
|
return $EVENT_C(ctx, state, "ImportType", ImportType$$);
|
|
@@ -12525,7 +12573,7 @@ var require_parser = __commonJS({
|
|
|
12525
12573
|
function NestedType(ctx, state) {
|
|
12526
12574
|
return $EVENT(ctx, state, "NestedType", NestedType$0);
|
|
12527
12575
|
}
|
|
12528
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
12576
|
+
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
12577
|
if ($2)
|
|
12530
12578
|
return $0;
|
|
12531
12579
|
return $1;
|
|
@@ -12585,16 +12633,16 @@ var require_parser = __commonJS({
|
|
|
12585
12633
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
12586
12634
|
return value[1];
|
|
12587
12635
|
});
|
|
12588
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($
|
|
12636
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L112, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L35, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L26, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
12589
12637
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
12590
12638
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
12591
12639
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
12592
12640
|
return $EVENT_C(ctx, state, "InlineInterfacePropertyDelimiter", InlineInterfacePropertyDelimiter$$);
|
|
12593
12641
|
}
|
|
12594
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
12642
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L99, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
12595
12643
|
return { $loc, token: "|" };
|
|
12596
12644
|
});
|
|
12597
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
12645
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L98, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
12598
12646
|
return { $loc, token: "&" };
|
|
12599
12647
|
});
|
|
12600
12648
|
var TypeBinaryOp$$ = [TypeBinaryOp$0, TypeBinaryOp$1];
|
|
@@ -12611,7 +12659,7 @@ var require_parser = __commonJS({
|
|
|
12611
12659
|
function FunctionType(ctx, state) {
|
|
12612
12660
|
return $EVENT(ctx, state, "FunctionType", FunctionType$0);
|
|
12613
12661
|
}
|
|
12614
|
-
var TypeArrowFunction$0 = $TV($C($EXPECT($L9, 'TypeArrowFunction "=>"'), $EXPECT($L10, 'TypeArrowFunction "\u21D2"'), $EXPECT($
|
|
12662
|
+
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
12663
|
return { $loc, token: "=>" };
|
|
12616
12664
|
});
|
|
12617
12665
|
function TypeArrowFunction(ctx, state) {
|
|
@@ -12649,11 +12697,11 @@ var require_parser = __commonJS({
|
|
|
12649
12697
|
function TypeParameters(ctx, state) {
|
|
12650
12698
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
12651
12699
|
}
|
|
12652
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
12700
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L149, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
12653
12701
|
function TypeParameter(ctx, state) {
|
|
12654
12702
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
12655
12703
|
}
|
|
12656
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
12704
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L138, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
12657
12705
|
function TypeConstraint(ctx, state) {
|
|
12658
12706
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
12659
12707
|
}
|
|
@@ -12662,7 +12710,7 @@ var require_parser = __commonJS({
|
|
|
12662
12710
|
return $EVENT(ctx, state, "TypeInitializer", TypeInitializer$0);
|
|
12663
12711
|
}
|
|
12664
12712
|
var TypeParameterDelimiter$0 = $S($E(_), Comma);
|
|
12665
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
12713
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L34, 'TypeParameterDelimiter ">"')));
|
|
12666
12714
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
12667
12715
|
return value[1];
|
|
12668
12716
|
});
|
|
@@ -12676,15 +12724,15 @@ var require_parser = __commonJS({
|
|
|
12676
12724
|
function ThisType(ctx, state) {
|
|
12677
12725
|
return $EVENT(ctx, state, "ThisType", ThisType$0);
|
|
12678
12726
|
}
|
|
12679
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
12727
|
+
var Shebang$0 = $S($R$0($EXPECT($R79, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
12680
12728
|
function Shebang(ctx, state) {
|
|
12681
12729
|
return $EVENT(ctx, state, "Shebang", Shebang$0);
|
|
12682
12730
|
}
|
|
12683
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
12731
|
+
var CivetPrologue$0 = $T($S($EXPECT($R80, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, SimpleStatementDelimiter, $EXPECT($R81, "CivetPrologue /[ \\t]*/"), $C(EOL, $Y(RestOfLine))), function(value) {
|
|
12684
12732
|
var content = value[2];
|
|
12685
12733
|
return content;
|
|
12686
12734
|
});
|
|
12687
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
12735
|
+
var CivetPrologue$1 = $T($S($EXPECT($R80, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, SimpleStatementDelimiter, $EXPECT($R81, "CivetPrologue /[ \\t]*/"), $C(EOL, $Y(RestOfLine))), function(value) {
|
|
12688
12736
|
var content = value[2];
|
|
12689
12737
|
return content;
|
|
12690
12738
|
});
|
|
@@ -12692,7 +12740,7 @@ var require_parser = __commonJS({
|
|
|
12692
12740
|
function CivetPrologue(ctx, state) {
|
|
12693
12741
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
12694
12742
|
}
|
|
12695
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($
|
|
12743
|
+
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
12744
|
var options = $3;
|
|
12697
12745
|
return {
|
|
12698
12746
|
type: "CivetPrologue",
|
|
@@ -12703,7 +12751,7 @@ var require_parser = __commonJS({
|
|
|
12703
12751
|
function CivetPrologueContent(ctx, state) {
|
|
12704
12752
|
return $EVENT(ctx, state, "CivetPrologueContent", CivetPrologueContent$0);
|
|
12705
12753
|
}
|
|
12706
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
12754
|
+
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
12755
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
12708
12756
|
if (l)
|
|
12709
12757
|
return l.toUpperCase();
|
|
@@ -12720,11 +12768,11 @@ var require_parser = __commonJS({
|
|
|
12720
12768
|
function CivetOption(ctx, state) {
|
|
12721
12769
|
return $EVENT(ctx, state, "CivetOption", CivetOption$0);
|
|
12722
12770
|
}
|
|
12723
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
12771
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R80, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
12724
12772
|
function UnknownPrologue(ctx, state) {
|
|
12725
12773
|
return $EVENT(ctx, state, "UnknownPrologue", UnknownPrologue$0);
|
|
12726
12774
|
}
|
|
12727
|
-
var TripleSlashDirective$0 = $S($R$0($EXPECT($
|
|
12775
|
+
var TripleSlashDirective$0 = $S($R$0($EXPECT($R84, "TripleSlashDirective /\\/\\/\\/[^\\r\\n]*/")), $E(EOS));
|
|
12728
12776
|
function TripleSlashDirective(ctx, state) {
|
|
12729
12777
|
return $EVENT(ctx, state, "TripleSlashDirective", TripleSlashDirective$0);
|
|
12730
12778
|
}
|
|
@@ -12738,13 +12786,13 @@ var require_parser = __commonJS({
|
|
|
12738
12786
|
function PrologueString(ctx, state) {
|
|
12739
12787
|
return $EVENT_C(ctx, state, "PrologueString", PrologueString$$);
|
|
12740
12788
|
}
|
|
12741
|
-
var EOS$0 = $T($S($EXPECT($
|
|
12789
|
+
var EOS$0 = $T($S($EXPECT($R85, "EOS /(?=[ \\t\\r\\n\\/#]|$)/"), $P(RestOfLine)), function(value) {
|
|
12742
12790
|
return value[1];
|
|
12743
12791
|
});
|
|
12744
12792
|
function EOS(ctx, state) {
|
|
12745
12793
|
return $EVENT(ctx, state, "EOS", EOS$0);
|
|
12746
12794
|
}
|
|
12747
|
-
var EOL$0 = $TR($EXPECT($
|
|
12795
|
+
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
12796
|
return { $loc, token: $0 };
|
|
12749
12797
|
});
|
|
12750
12798
|
function EOL(ctx, state) {
|
|
@@ -13264,7 +13312,7 @@ var require_parser = __commonJS({
|
|
|
13264
13312
|
function Init(ctx, state) {
|
|
13265
13313
|
return $EVENT(ctx, state, "Init", Init$0);
|
|
13266
13314
|
}
|
|
13267
|
-
var Indent$0 = $TR($EXPECT($
|
|
13315
|
+
var Indent$0 = $TR($EXPECT($R81, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
13268
13316
|
const level = getIndentLevel($0, module.config.tab);
|
|
13269
13317
|
return {
|
|
13270
13318
|
$loc,
|
|
@@ -13446,6 +13494,7 @@ var require_parser = __commonJS({
|
|
|
13446
13494
|
exports.ClassHeritage = ClassHeritage;
|
|
13447
13495
|
exports.ExtendsClause = ExtendsClause;
|
|
13448
13496
|
exports.ExtendsToken = ExtendsToken;
|
|
13497
|
+
exports.ExtendsShorthand = ExtendsShorthand;
|
|
13449
13498
|
exports.ExtendsTarget = ExtendsTarget;
|
|
13450
13499
|
exports.ImplementsClause = ImplementsClause;
|
|
13451
13500
|
exports.ImplementsToken = ImplementsToken;
|
|
@@ -13473,6 +13522,7 @@ var require_parser = __commonJS({
|
|
|
13473
13522
|
exports.OptionalDot = OptionalDot;
|
|
13474
13523
|
exports.NonNullAssertion = NonNullAssertion;
|
|
13475
13524
|
exports.MemberExpression = MemberExpression;
|
|
13525
|
+
exports.ActualMemberExpression = ActualMemberExpression;
|
|
13476
13526
|
exports.MemberBase = MemberBase;
|
|
13477
13527
|
exports.MemberExpressionRest = MemberExpressionRest;
|
|
13478
13528
|
exports.MemberExpressionRestBody = MemberExpressionRestBody;
|
|
@@ -13685,7 +13735,9 @@ var require_parser = __commonJS({
|
|
|
13685
13735
|
exports.Condition = Condition;
|
|
13686
13736
|
exports.DeclarationCondition = DeclarationCondition;
|
|
13687
13737
|
exports.ExpressionWithIndentedApplicationForbidden = ExpressionWithIndentedApplicationForbidden;
|
|
13738
|
+
exports.SingleLineExpressionWithIndentedApplicationForbidden = SingleLineExpressionWithIndentedApplicationForbidden;
|
|
13688
13739
|
exports.ExpressionWithObjectApplicationForbidden = ExpressionWithObjectApplicationForbidden;
|
|
13740
|
+
exports.LeftHandSideExpressionWithObjectApplicationForbidden = LeftHandSideExpressionWithObjectApplicationForbidden;
|
|
13689
13741
|
exports.ForbidClassImplicitCall = ForbidClassImplicitCall;
|
|
13690
13742
|
exports.AllowClassImplicitCall = AllowClassImplicitCall;
|
|
13691
13743
|
exports.RestoreClassImplicitCall = RestoreClassImplicitCall;
|
|
@@ -13818,6 +13870,7 @@ var require_parser = __commonJS({
|
|
|
13818
13870
|
exports.Await = Await;
|
|
13819
13871
|
exports.Backtick = Backtick;
|
|
13820
13872
|
exports.By = By;
|
|
13873
|
+
exports.Caret = Caret;
|
|
13821
13874
|
exports.Case = Case;
|
|
13822
13875
|
exports.Catch = Catch;
|
|
13823
13876
|
exports.Class = Class;
|