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