@danielx/civet 0.6.52 → 0.6.53
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/browser.js +483 -470
- package/dist/esbuild.js +107 -69
- package/dist/main.js +483 -470
- package/dist/main.mjs +483 -470
- package/dist/rollup.js +107 -69
- package/dist/unplugin-shared.mjs +97 -59
- package/dist/unplugin.d.mts +8 -9
- package/dist/unplugin.d.ts +8 -9
- package/dist/unplugin.js +107 -69
- package/dist/vite.js +107 -69
- package/dist/webpack.js +107 -69
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -3838,6 +3838,7 @@ ${input.slice(result.pos)}
|
|
|
3838
3838
|
ClassHeritage,
|
|
3839
3839
|
ExtendsClause,
|
|
3840
3840
|
ExtendsToken,
|
|
3841
|
+
ExtendsShorthand,
|
|
3841
3842
|
ExtendsTarget,
|
|
3842
3843
|
ImplementsClause,
|
|
3843
3844
|
ImplementsToken,
|
|
@@ -4078,6 +4079,7 @@ ${input.slice(result.pos)}
|
|
|
4078
4079
|
DeclarationCondition,
|
|
4079
4080
|
ExpressionWithIndentedApplicationForbidden,
|
|
4080
4081
|
ExpressionWithObjectApplicationForbidden,
|
|
4082
|
+
LeftHandSideExpressionWithObjectApplicationForbidden,
|
|
4081
4083
|
ForbidClassImplicitCall,
|
|
4082
4084
|
AllowClassImplicitCall,
|
|
4083
4085
|
RestoreClassImplicitCall,
|
|
@@ -4483,148 +4485,148 @@ ${input.slice(result.pos)}
|
|
|
4483
4485
|
var $L10 = $L("\u21D2");
|
|
4484
4486
|
var $L11 = $L(":");
|
|
4485
4487
|
var $L12 = $L(" ");
|
|
4486
|
-
var $L13 = $L("
|
|
4487
|
-
var $L14 = $L("
|
|
4488
|
-
var $L15 = $L("
|
|
4489
|
-
var $L16 = $L("
|
|
4490
|
-
var $L17 = $L("
|
|
4491
|
-
var $L18 = $L("
|
|
4492
|
-
var $L19 = $L("
|
|
4493
|
-
var $L20 = $L("
|
|
4494
|
-
var $L21 = $L("
|
|
4495
|
-
var $L22 = $L("
|
|
4496
|
-
var $L23 = $L("
|
|
4497
|
-
var $L24 = $L("
|
|
4498
|
-
var $L25 = $L("
|
|
4499
|
-
var $L26 = $L("
|
|
4500
|
-
var $L27 = $L("
|
|
4501
|
-
var $L28 = $L("
|
|
4502
|
-
var $L29 = $L("
|
|
4503
|
-
var $L30 = $L("
|
|
4504
|
-
var $L31 = $L("
|
|
4505
|
-
var $L32 = $L("
|
|
4506
|
-
var $L33 = $L("
|
|
4507
|
-
var $L34 = $L("
|
|
4508
|
-
var $L35 = $L("
|
|
4509
|
-
var $L36 = $L("
|
|
4510
|
-
var $L37 = $L("
|
|
4511
|
-
var $L38 = $L("
|
|
4512
|
-
var $L39 = $L("
|
|
4513
|
-
var $L40 = $L("
|
|
4514
|
-
var $L41 = $L("
|
|
4515
|
-
var $L42 = $L("
|
|
4516
|
-
var $L43 = $L("
|
|
4517
|
-
var $L44 = $L("
|
|
4518
|
-
var $L45 = $L("
|
|
4519
|
-
var $L46 = $L("
|
|
4520
|
-
var $L47 = $L("
|
|
4521
|
-
var $L48 = $L("
|
|
4522
|
-
var $L49 = $L("
|
|
4523
|
-
var $L50 = $L("
|
|
4524
|
-
var $L51 = $L("
|
|
4525
|
-
var $L52 = $L("
|
|
4526
|
-
var $L53 = $L("
|
|
4527
|
-
var $L54 = $L("
|
|
4528
|
-
var $L55 = $L("
|
|
4529
|
-
var $L56 = $L("
|
|
4530
|
-
var $L57 = $L("
|
|
4531
|
-
var $L58 = $L("
|
|
4532
|
-
var $L59 = $L("
|
|
4533
|
-
var $L60 = $L("
|
|
4534
|
-
var $L61 = $L("
|
|
4535
|
-
var $L62 = $L("
|
|
4536
|
-
var $L63 = $L("
|
|
4537
|
-
var $L64 = $L("
|
|
4538
|
-
var $L65 = $L("
|
|
4539
|
-
var $L66 = $L("
|
|
4540
|
-
var $L67 = $L("
|
|
4541
|
-
var $L68 = $L("
|
|
4542
|
-
var $L69 = $L("
|
|
4543
|
-
var $L70 = $L("
|
|
4544
|
-
var $L71 = $L("
|
|
4545
|
-
var $L72 = $L("
|
|
4546
|
-
var $L73 = $L("
|
|
4547
|
-
var $L74 = $L("
|
|
4548
|
-
var $L75 = $L("
|
|
4549
|
-
var $L76 = $L("
|
|
4550
|
-
var $L77 = $L("
|
|
4551
|
-
var $L78 = $L("\
|
|
4552
|
-
var $L79 = $L("
|
|
4553
|
-
var $L80 = $L("
|
|
4554
|
-
var $L81 = $L("\
|
|
4555
|
-
var $L82 = $L("
|
|
4556
|
-
var $L83 = $L("
|
|
4557
|
-
var $L84 = $L("
|
|
4558
|
-
var $L85 = $L("
|
|
4559
|
-
var $L86 = $L("
|
|
4560
|
-
var $L87 = $L("
|
|
4561
|
-
var $L88 = $L("
|
|
4562
|
-
var $L89 = $L("
|
|
4563
|
-
var $L90 = $L("
|
|
4564
|
-
var $L91 = $L("
|
|
4565
|
-
var $L92 = $L("
|
|
4566
|
-
var $L93 = $L("
|
|
4567
|
-
var $L94 = $L("\
|
|
4568
|
-
var $L95 = $L("\
|
|
4569
|
-
var $L96 = $L("\
|
|
4570
|
-
var $L97 = $L("
|
|
4571
|
-
var $L98 = $L("
|
|
4572
|
-
var $L99 = $L("
|
|
4573
|
-
var $L100 = $L("
|
|
4574
|
-
var $L101 = $L("
|
|
4575
|
-
var $L102 = $L("
|
|
4576
|
-
var $L103 = $L("
|
|
4577
|
-
var $L104 = $L("
|
|
4578
|
-
var $L105 = $L("
|
|
4579
|
-
var $L106 = $L("
|
|
4580
|
-
var $L107 = $L("
|
|
4581
|
-
var $L108 = $L("
|
|
4582
|
-
var $L109 = $L("
|
|
4583
|
-
var $L110 = $L("
|
|
4584
|
-
var $L111 = $L("
|
|
4585
|
-
var $L112 = $L("
|
|
4586
|
-
var $L113 = $L("
|
|
4587
|
-
var $L114 = $L("
|
|
4588
|
-
var $L115 = $L("
|
|
4589
|
-
var $L116 = $L("
|
|
4590
|
-
var $L117 = $L("
|
|
4591
|
-
var $L118 = $L("
|
|
4592
|
-
var $L119 = $L("
|
|
4593
|
-
var $L120 = $L("
|
|
4594
|
-
var $L121 = $L("
|
|
4595
|
-
var $L122 = $L("
|
|
4596
|
-
var $L123 = $L("
|
|
4597
|
-
var $L124 = $L("
|
|
4598
|
-
var $L125 = $L("
|
|
4599
|
-
var $L126 = $L("
|
|
4600
|
-
var $L127 = $L("
|
|
4601
|
-
var $L128 = $L("
|
|
4602
|
-
var $L129 = $L("
|
|
4603
|
-
var $L130 = $L("
|
|
4604
|
-
var $L131 = $L("
|
|
4605
|
-
var $L132 = $L("
|
|
4606
|
-
var $L133 = $L(
|
|
4607
|
-
var $L134 = $L("
|
|
4608
|
-
var $L135 = $L("
|
|
4609
|
-
var $L136 = $L("
|
|
4610
|
-
var $L137 = $L("
|
|
4611
|
-
var $L138 = $L("
|
|
4612
|
-
var $L139 = $L("
|
|
4613
|
-
var $L140 = $L("
|
|
4614
|
-
var $L141 = $L("
|
|
4615
|
-
var $L142 = $L("
|
|
4616
|
-
var $L143 = $L("
|
|
4617
|
-
var $L144 = $L("
|
|
4618
|
-
var $L145 = $L("
|
|
4619
|
-
var $L146 = $L("
|
|
4620
|
-
var $L147 = $L("
|
|
4621
|
-
var $L148 = $L("
|
|
4622
|
-
var $L149 = $L("
|
|
4623
|
-
var $L150 = $L("
|
|
4624
|
-
var $L151 = $L("
|
|
4625
|
-
var $L152 = $L("
|
|
4626
|
-
var $L153 = $L("
|
|
4627
|
-
var $L154 = $L("
|
|
4488
|
+
var $L13 = $L("<");
|
|
4489
|
+
var $L14 = $L("implements");
|
|
4490
|
+
var $L15 = $L("<:");
|
|
4491
|
+
var $L16 = $L("import");
|
|
4492
|
+
var $L17 = $L("!");
|
|
4493
|
+
var $L18 = $L("^");
|
|
4494
|
+
var $L19 = $L("-");
|
|
4495
|
+
var $L20 = $L("import.meta");
|
|
4496
|
+
var $L21 = $L("return.value");
|
|
4497
|
+
var $L22 = $L(",");
|
|
4498
|
+
var $L23 = $L("(&)");
|
|
4499
|
+
var $L24 = $L("->");
|
|
4500
|
+
var $L25 = $L("\u2192");
|
|
4501
|
+
var $L26 = $L("}");
|
|
4502
|
+
var $L27 = $L("null");
|
|
4503
|
+
var $L28 = $L("true");
|
|
4504
|
+
var $L29 = $L("false");
|
|
4505
|
+
var $L30 = $L("yes");
|
|
4506
|
+
var $L31 = $L("on");
|
|
4507
|
+
var $L32 = $L("no");
|
|
4508
|
+
var $L33 = $L("off");
|
|
4509
|
+
var $L34 = $L(">");
|
|
4510
|
+
var $L35 = $L("]");
|
|
4511
|
+
var $L36 = $L("**=");
|
|
4512
|
+
var $L37 = $L("*=");
|
|
4513
|
+
var $L38 = $L("/=");
|
|
4514
|
+
var $L39 = $L("%=");
|
|
4515
|
+
var $L40 = $L("+=");
|
|
4516
|
+
var $L41 = $L("-=");
|
|
4517
|
+
var $L42 = $L("<<=");
|
|
4518
|
+
var $L43 = $L(">>>=");
|
|
4519
|
+
var $L44 = $L(">>=");
|
|
4520
|
+
var $L45 = $L("&&=");
|
|
4521
|
+
var $L46 = $L("&=");
|
|
4522
|
+
var $L47 = $L("^=");
|
|
4523
|
+
var $L48 = $L("||=");
|
|
4524
|
+
var $L49 = $L("|=");
|
|
4525
|
+
var $L50 = $L("??=");
|
|
4526
|
+
var $L51 = $L("?=");
|
|
4527
|
+
var $L52 = $L("and=");
|
|
4528
|
+
var $L53 = $L("or=");
|
|
4529
|
+
var $L54 = $L("**");
|
|
4530
|
+
var $L55 = $L("*");
|
|
4531
|
+
var $L56 = $L("/");
|
|
4532
|
+
var $L57 = $L("%%");
|
|
4533
|
+
var $L58 = $L("%");
|
|
4534
|
+
var $L59 = $L("+");
|
|
4535
|
+
var $L60 = $L("<=");
|
|
4536
|
+
var $L61 = $L("\u2264");
|
|
4537
|
+
var $L62 = $L(">=");
|
|
4538
|
+
var $L63 = $L("\u2265");
|
|
4539
|
+
var $L64 = $L("<?");
|
|
4540
|
+
var $L65 = $L("!<?");
|
|
4541
|
+
var $L66 = $L("<<");
|
|
4542
|
+
var $L67 = $L("\xAB");
|
|
4543
|
+
var $L68 = $L(">>>");
|
|
4544
|
+
var $L69 = $L("\u22D9");
|
|
4545
|
+
var $L70 = $L(">>");
|
|
4546
|
+
var $L71 = $L("\xBB");
|
|
4547
|
+
var $L72 = $L("!==");
|
|
4548
|
+
var $L73 = $L("\u2262");
|
|
4549
|
+
var $L74 = $L("!=");
|
|
4550
|
+
var $L75 = $L("\u2260");
|
|
4551
|
+
var $L76 = $L("isnt");
|
|
4552
|
+
var $L77 = $L("===");
|
|
4553
|
+
var $L78 = $L("\u2263");
|
|
4554
|
+
var $L79 = $L("\u2A76");
|
|
4555
|
+
var $L80 = $L("==");
|
|
4556
|
+
var $L81 = $L("\u2261");
|
|
4557
|
+
var $L82 = $L("\u2A75");
|
|
4558
|
+
var $L83 = $L("and");
|
|
4559
|
+
var $L84 = $L("&&");
|
|
4560
|
+
var $L85 = $L("or");
|
|
4561
|
+
var $L86 = $L("||");
|
|
4562
|
+
var $L87 = $L("\u2016");
|
|
4563
|
+
var $L88 = $L("^^");
|
|
4564
|
+
var $L89 = $L("xor");
|
|
4565
|
+
var $L90 = $L("xnor");
|
|
4566
|
+
var $L91 = $L("??");
|
|
4567
|
+
var $L92 = $L("\u2047");
|
|
4568
|
+
var $L93 = $L("instanceof");
|
|
4569
|
+
var $L94 = $L("\u2208");
|
|
4570
|
+
var $L95 = $L("\u220B");
|
|
4571
|
+
var $L96 = $L("\u220C");
|
|
4572
|
+
var $L97 = $L("\u2209");
|
|
4573
|
+
var $L98 = $L("&");
|
|
4574
|
+
var $L99 = $L("|");
|
|
4575
|
+
var $L100 = $L(";");
|
|
4576
|
+
var $L101 = $L("$:");
|
|
4577
|
+
var $L102 = $L("break");
|
|
4578
|
+
var $L103 = $L("continue");
|
|
4579
|
+
var $L104 = $L("debugger");
|
|
4580
|
+
var $L105 = $L("assert");
|
|
4581
|
+
var $L106 = $L(":=");
|
|
4582
|
+
var $L107 = $L("\u2254");
|
|
4583
|
+
var $L108 = $L(".=");
|
|
4584
|
+
var $L109 = $L("/*");
|
|
4585
|
+
var $L110 = $L("*/");
|
|
4586
|
+
var $L111 = $L("\\");
|
|
4587
|
+
var $L112 = $L(")");
|
|
4588
|
+
var $L113 = $L("abstract");
|
|
4589
|
+
var $L114 = $L("as");
|
|
4590
|
+
var $L115 = $L("@");
|
|
4591
|
+
var $L116 = $L("@@");
|
|
4592
|
+
var $L117 = $L("async");
|
|
4593
|
+
var $L118 = $L("await");
|
|
4594
|
+
var $L119 = $L("`");
|
|
4595
|
+
var $L120 = $L("by");
|
|
4596
|
+
var $L121 = $L("case");
|
|
4597
|
+
var $L122 = $L("catch");
|
|
4598
|
+
var $L123 = $L("class");
|
|
4599
|
+
var $L124 = $L("#{");
|
|
4600
|
+
var $L125 = $L("declare");
|
|
4601
|
+
var $L126 = $L("default");
|
|
4602
|
+
var $L127 = $L("delete");
|
|
4603
|
+
var $L128 = $L("do");
|
|
4604
|
+
var $L129 = $L("..");
|
|
4605
|
+
var $L130 = $L("\u2025");
|
|
4606
|
+
var $L131 = $L("...");
|
|
4607
|
+
var $L132 = $L("\u2026");
|
|
4608
|
+
var $L133 = $L("::");
|
|
4609
|
+
var $L134 = $L('"');
|
|
4610
|
+
var $L135 = $L("each");
|
|
4611
|
+
var $L136 = $L("else");
|
|
4612
|
+
var $L137 = $L("export");
|
|
4613
|
+
var $L138 = $L("extends");
|
|
4614
|
+
var $L139 = $L("finally");
|
|
4615
|
+
var $L140 = $L("for");
|
|
4616
|
+
var $L141 = $L("from");
|
|
4617
|
+
var $L142 = $L("function");
|
|
4618
|
+
var $L143 = $L("get");
|
|
4619
|
+
var $L144 = $L("set");
|
|
4620
|
+
var $L145 = $L("#");
|
|
4621
|
+
var $L146 = $L("if");
|
|
4622
|
+
var $L147 = $L("in");
|
|
4623
|
+
var $L148 = $L("let");
|
|
4624
|
+
var $L149 = $L("const");
|
|
4625
|
+
var $L150 = $L("is");
|
|
4626
|
+
var $L151 = $L("loop");
|
|
4627
|
+
var $L152 = $L("new");
|
|
4628
|
+
var $L153 = $L("not");
|
|
4629
|
+
var $L154 = $L("of");
|
|
4628
4630
|
var $L155 = $L("[");
|
|
4629
4631
|
var $L156 = $L("operator");
|
|
4630
4632
|
var $L157 = $L("own");
|
|
@@ -4698,77 +4700,76 @@ ${input.slice(result.pos)}
|
|
|
4698
4700
|
var $R14 = $R(new RegExp("(?=\\[)", "suy"));
|
|
4699
4701
|
var $R15 = $R(new RegExp("[!+-]", "suy"));
|
|
4700
4702
|
var $R16 = $R(new RegExp("(?=\\p{ID_Start}|[_$^\xAB\xBB\u22D9\u2264\u2265\u2208\u220B\u2209\u220C\u2263\u2261\u2262\u2260=\u2016\u2047&|*\\/!?%<>+-])", "suy"));
|
|
4701
|
-
var $R17 = $R(new RegExp("
|
|
4702
|
-
var $R18 = $R(new RegExp("
|
|
4703
|
-
var $R19 = $R(new RegExp("(
|
|
4704
|
-
var $R20 = $R(new RegExp("(?=
|
|
4705
|
-
var $R21 = $R(new RegExp("(?=
|
|
4706
|
-
var $R22 = $R(new RegExp("
|
|
4707
|
-
var $R23 = $R(new RegExp(
|
|
4708
|
-
var $R24 = $R(new RegExp("(
|
|
4709
|
-
var $R25 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)
|
|
4710
|
-
var $R26 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(
|
|
4711
|
-
var $R27 = $R(new RegExp("(
|
|
4712
|
-
var $R28 = $R(new RegExp("(
|
|
4713
|
-
var $R29 = $R(new RegExp("
|
|
4714
|
-
var $R30 = $R(new RegExp("0[
|
|
4715
|
-
var $R31 = $R(new RegExp("0[
|
|
4716
|
-
var $R32 = $R(new RegExp("
|
|
4717
|
-
var $R33 = $R(new RegExp("(
|
|
4718
|
-
var $R34 = $R(new RegExp(
|
|
4719
|
-
var $R35 = $R(new RegExp(
|
|
4720
|
-
var $R36 = $R(new RegExp("(
|
|
4721
|
-
var $R37 = $R(new RegExp(
|
|
4722
|
-
var $R38 = $R(new RegExp(
|
|
4723
|
-
var $R39 = $R(new RegExp(
|
|
4724
|
-
var $R40 = $R(new RegExp("(
|
|
4725
|
-
var $R41 = $R(new RegExp("
|
|
4726
|
-
var $R42 = $R(new RegExp("
|
|
4727
|
-
var $R43 = $R(new RegExp("
|
|
4728
|
-
var $R44 = $R(new RegExp("[
|
|
4729
|
-
var $R45 = $R(new RegExp("[
|
|
4730
|
-
var $R46 = $R(new RegExp("(
|
|
4731
|
-
var $R47 = $R(new RegExp("(
|
|
4732
|
-
var $R48 = $R(new RegExp("(
|
|
4733
|
-
var $R49 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
4734
|
-
var $R50 = $R(new RegExp("(
|
|
4735
|
-
var $R51 = $R(new RegExp("(?:
|
|
4736
|
-
var $R52 = $R(new RegExp("(?:
|
|
4737
|
-
var $R53 = $R(new RegExp("(?:
|
|
4738
|
-
var $R54 = $R(new RegExp("(?:
|
|
4739
|
-
var $R55 = $R(new RegExp("(
|
|
4740
|
-
var $R56 = $R(new RegExp("(
|
|
4741
|
-
var $R57 = $R(new RegExp("
|
|
4742
|
-
var $R58 = $R(new RegExp("
|
|
4743
|
-
var $R59 = $R(new RegExp("
|
|
4744
|
-
var $R60 = $R(new RegExp("
|
|
4745
|
-
var $R61 = $R(new RegExp("
|
|
4746
|
-
var $R62 = $R(new RegExp("
|
|
4747
|
-
var $R63 = $R(new RegExp("
|
|
4748
|
-
var $R64 = $R(new RegExp("
|
|
4749
|
-
var $R65 = $R(new RegExp("(
|
|
4750
|
-
var $R66 = $R(new RegExp("
|
|
4751
|
-
var $R67 = $R(new RegExp("
|
|
4752
|
-
var $R68 = $R(new RegExp("
|
|
4753
|
-
var $R69 = $R(new RegExp("(
|
|
4754
|
-
var $R70 = $R(new RegExp("
|
|
4755
|
-
var $R71 = $R(new RegExp("[\\
|
|
4756
|
-
var $R72 = $R(new RegExp("
|
|
4757
|
-
var $R73 = $R(new RegExp(
|
|
4758
|
-
var $R74 = $R(new RegExp("[
|
|
4759
|
-
var $R75 = $R(new RegExp("[
|
|
4760
|
-
var $R76 = $R(new RegExp("
|
|
4761
|
-
var $R77 = $R(new RegExp("[
|
|
4762
|
-
var $R78 = $R(new RegExp("[+-]
|
|
4763
|
-
var $R79 = $R(new RegExp("[
|
|
4764
|
-
var $R80 = $R(new RegExp("
|
|
4765
|
-
var $R81 = $R(new RegExp("[\\t
|
|
4766
|
-
var $R82 = $R(new RegExp("[
|
|
4767
|
-
var $R83 = $R(new RegExp("[\\s]*", "suy"));
|
|
4768
|
-
var $R84 = $R(new RegExp("
|
|
4769
|
-
var $R85 = $R(new RegExp("
|
|
4770
|
-
var $R86 = $R(new RegExp("
|
|
4771
|
-
var $R87 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
4703
|
+
var $R17 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
4704
|
+
var $R18 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*(&|\\.[^0-9]))", "suy"));
|
|
4705
|
+
var $R19 = $R(new RegExp("(?=for|if|loop|unless|until|while)", "suy"));
|
|
4706
|
+
var $R20 = $R(new RegExp("(?=loop|do|for|until|while)", "suy"));
|
|
4707
|
+
var $R21 = $R(new RegExp("(?=[\\s\\),])", "suy"));
|
|
4708
|
+
var $R22 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
4709
|
+
var $R23 = $R(new RegExp("(?=[0-9.])", "suy"));
|
|
4710
|
+
var $R24 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
4711
|
+
var $R25 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
4712
|
+
var $R26 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
4713
|
+
var $R27 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4714
|
+
var $R28 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
4715
|
+
var $R29 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
4716
|
+
var $R30 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
4717
|
+
var $R31 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
4718
|
+
var $R32 = $R(new RegExp("(?=[0-9])", "suy"));
|
|
4719
|
+
var $R33 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4720
|
+
var $R34 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
4721
|
+
var $R35 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
4722
|
+
var $R36 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
4723
|
+
var $R37 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
4724
|
+
var $R38 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
4725
|
+
var $R39 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
4726
|
+
var $R40 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
4727
|
+
var $R41 = $R(new RegExp("[\\s]+", "suy"));
|
|
4728
|
+
var $R42 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
4729
|
+
var $R43 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
4730
|
+
var $R44 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
4731
|
+
var $R45 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
4732
|
+
var $R46 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
4733
|
+
var $R47 = $R(new RegExp("(?=[`'\"])", "suy"));
|
|
4734
|
+
var $R48 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
4735
|
+
var $R49 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
4736
|
+
var $R50 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
4737
|
+
var $R51 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
4738
|
+
var $R52 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
4739
|
+
var $R53 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
4740
|
+
var $R54 = $R(new RegExp("(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
4741
|
+
var $R55 = $R(new RegExp("(?=\\/|#)", "suy"));
|
|
4742
|
+
var $R56 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
4743
|
+
var $R57 = $R(new RegExp(".", "suy"));
|
|
4744
|
+
var $R58 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
4745
|
+
var $R59 = $R(new RegExp("[^]*?###", "suy"));
|
|
4746
|
+
var $R60 = $R(new RegExp("###(?!#)", "suy"));
|
|
4747
|
+
var $R61 = $R(new RegExp("\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\/", "suy"));
|
|
4748
|
+
var $R62 = $R(new RegExp("(?=[ \\t\\/\\\\])", "suy"));
|
|
4749
|
+
var $R63 = $R(new RegExp("[ \\t]+", "suy"));
|
|
4750
|
+
var $R64 = $R(new RegExp("(?=\\s|\\/|#)", "suy"));
|
|
4751
|
+
var $R65 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
4752
|
+
var $R66 = $R(new RegExp("['\u2019]s", "suy"));
|
|
4753
|
+
var $R67 = $R(new RegExp("\\s", "suy"));
|
|
4754
|
+
var $R68 = $R(new RegExp("(?=[<])", "suy"));
|
|
4755
|
+
var $R69 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
4756
|
+
var $R70 = $R(new RegExp("[\\s>]|\\/>", "suy"));
|
|
4757
|
+
var $R71 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
4758
|
+
var $R72 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
|
|
4759
|
+
var $R73 = $R(new RegExp("[<>]", "suy"));
|
|
4760
|
+
var $R74 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
4761
|
+
var $R75 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
4762
|
+
var $R76 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
4763
|
+
var $R77 = $R(new RegExp("[+-]?", "suy"));
|
|
4764
|
+
var $R78 = $R(new RegExp("[+-]", "suy"));
|
|
4765
|
+
var $R79 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
4766
|
+
var $R80 = $R(new RegExp("[\\t ]*", "suy"));
|
|
4767
|
+
var $R81 = $R(new RegExp("[ \\t]*", "suy"));
|
|
4768
|
+
var $R82 = $R(new RegExp("[\\s]*", "suy"));
|
|
4769
|
+
var $R83 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
4770
|
+
var $R84 = $R(new RegExp("\\/\\/\\/[^\\r\\n]*", "suy"));
|
|
4771
|
+
var $R85 = $R(new RegExp("(?=[ \\t\\r\\n\\/#]|$)", "suy"));
|
|
4772
|
+
var $R86 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
4772
4773
|
var Program$0 = $TS($S(Reset, Init, $E(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
4773
4774
|
var statements = $4;
|
|
4774
4775
|
processProgram({
|
|
@@ -5503,14 +5504,11 @@ ${input.slice(result.pos)}
|
|
|
5503
5504
|
function ExtendsClause(ctx, state) {
|
|
5504
5505
|
return $EVENT(ctx, state, "ExtendsClause", ExtendsClause$0);
|
|
5505
5506
|
}
|
|
5506
|
-
var ExtendsToken$0 = $TS($S(Loc, __,
|
|
5507
|
+
var ExtendsToken$0 = $TS($S(Loc, __, ExtendsShorthand, $E($EXPECT($L12, 'ExtendsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5507
5508
|
var l = $1;
|
|
5508
5509
|
var ws = $2;
|
|
5509
|
-
var
|
|
5510
|
-
const children = [
|
|
5511
|
-
...ws,
|
|
5512
|
-
{ ...lt, token: "extends " }
|
|
5513
|
-
];
|
|
5510
|
+
var t = $3;
|
|
5511
|
+
const children = [...ws, t];
|
|
5514
5512
|
if (!ws.length) {
|
|
5515
5513
|
children.unshift({ $loc: l.$loc, token: " " });
|
|
5516
5514
|
}
|
|
@@ -5521,7 +5519,13 @@ ${input.slice(result.pos)}
|
|
|
5521
5519
|
function ExtendsToken(ctx, state) {
|
|
5522
5520
|
return $EVENT_C(ctx, state, "ExtendsToken", ExtendsToken$$);
|
|
5523
5521
|
}
|
|
5524
|
-
var
|
|
5522
|
+
var ExtendsShorthand$0 = $TV($EXPECT($L13, 'ExtendsShorthand "<"'), function($skip, $loc, $0, $1) {
|
|
5523
|
+
return { $loc, token: "extends " };
|
|
5524
|
+
});
|
|
5525
|
+
function ExtendsShorthand(ctx, state) {
|
|
5526
|
+
return $EVENT(ctx, state, "ExtendsShorthand", ExtendsShorthand$0);
|
|
5527
|
+
}
|
|
5528
|
+
var ExtendsTarget$0 = $TS($S(LeftHandSideExpressionWithObjectApplicationForbidden, $E(TypeArguments)), function($skip, $loc, $0, $1, $2) {
|
|
5525
5529
|
var exp = $1;
|
|
5526
5530
|
var ta = $2;
|
|
5527
5531
|
exp = makeLeftHandSideExpression(exp);
|
|
@@ -5551,7 +5555,7 @@ ${input.slice(result.pos)}
|
|
|
5551
5555
|
}
|
|
5552
5556
|
return { children };
|
|
5553
5557
|
});
|
|
5554
|
-
var ImplementsToken$1 = $TS($S(__, $EXPECT($
|
|
5558
|
+
var ImplementsToken$1 = $TS($S(__, $EXPECT($L14, 'ImplementsToken "implements"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
5555
5559
|
$2 = { $loc, token: $2 };
|
|
5556
5560
|
return [$1, $2];
|
|
5557
5561
|
});
|
|
@@ -5559,7 +5563,7 @@ ${input.slice(result.pos)}
|
|
|
5559
5563
|
function ImplementsToken(ctx, state) {
|
|
5560
5564
|
return $EVENT_C(ctx, state, "ImplementsToken", ImplementsToken$$);
|
|
5561
5565
|
}
|
|
5562
|
-
var ImplementsShorthand$0 = $TV($EXPECT($
|
|
5566
|
+
var ImplementsShorthand$0 = $TV($EXPECT($L15, 'ImplementsShorthand "<:"'), function($skip, $loc, $0, $1) {
|
|
5563
5567
|
return { $loc, token: "implements " };
|
|
5564
5568
|
});
|
|
5565
5569
|
function ImplementsShorthand(ctx, state) {
|
|
@@ -5784,7 +5788,7 @@ ${input.slice(result.pos)}
|
|
|
5784
5788
|
children: [$1, ...$2, ...rest.flat()]
|
|
5785
5789
|
});
|
|
5786
5790
|
});
|
|
5787
|
-
var CallExpression$1 = $TS($S($EXPECT($
|
|
5791
|
+
var CallExpression$1 = $TS($S($EXPECT($L16, 'CallExpression "import"'), ArgumentsWithTrailingMemberExpressions, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5788
5792
|
var rest = $3;
|
|
5789
5793
|
return processCallMemberExpression({
|
|
5790
5794
|
type: "CallExpression",
|
|
@@ -5845,7 +5849,7 @@ ${input.slice(result.pos)}
|
|
|
5845
5849
|
function OptionalDot(ctx, state) {
|
|
5846
5850
|
return $EVENT_C(ctx, state, "OptionalDot", OptionalDot$$);
|
|
5847
5851
|
}
|
|
5848
|
-
var NonNullAssertion$0 = $T($S($EXPECT($
|
|
5852
|
+
var NonNullAssertion$0 = $T($S($EXPECT($L17, 'NonNullAssertion "!"'), $N($EXPECT($L18, 'NonNullAssertion "^"'))), function(value) {
|
|
5849
5853
|
return { "type": "NonNullAssertion", "ts": true, "children": value[0] };
|
|
5850
5854
|
});
|
|
5851
5855
|
function NonNullAssertion(ctx, state) {
|
|
@@ -5942,7 +5946,7 @@ ${input.slice(result.pos)}
|
|
|
5942
5946
|
]
|
|
5943
5947
|
};
|
|
5944
5948
|
});
|
|
5945
|
-
var MemberBracketContent$2 = $TS($S(Dot, $EXPECT($
|
|
5949
|
+
var MemberBracketContent$2 = $TS($S(Dot, $EXPECT($L19, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
5946
5950
|
var dot = $1;
|
|
5947
5951
|
var neg = $2;
|
|
5948
5952
|
var num = $3;
|
|
@@ -6100,7 +6104,7 @@ ${input.slice(result.pos)}
|
|
|
6100
6104
|
return $EVENT_C(ctx, state, "SuperProperty", SuperProperty$$);
|
|
6101
6105
|
}
|
|
6102
6106
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
6103
|
-
var MetaProperty$1 = $TS($S($EXPECT($
|
|
6107
|
+
var MetaProperty$1 = $TS($S($EXPECT($L20, 'MetaProperty "import.meta"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6104
6108
|
return { $loc, token: $1 };
|
|
6105
6109
|
});
|
|
6106
6110
|
var MetaProperty$2 = ReturnValue;
|
|
@@ -6108,7 +6112,7 @@ ${input.slice(result.pos)}
|
|
|
6108
6112
|
function MetaProperty(ctx, state) {
|
|
6109
6113
|
return $EVENT_C(ctx, state, "MetaProperty", MetaProperty$$);
|
|
6110
6114
|
}
|
|
6111
|
-
var ReturnValue$0 = $TV($C($S($EXPECT($
|
|
6115
|
+
var ReturnValue$0 = $TV($C($S($EXPECT($L21, 'ReturnValue "return.value"'), NonIdContinue), $S(Return, $Y(AfterReturnShorthand))), function($skip, $loc, $0, $1) {
|
|
6112
6116
|
return { type: "ReturnValue", children: [$1[0]] };
|
|
6113
6117
|
});
|
|
6114
6118
|
function ReturnValue(ctx, state) {
|
|
@@ -6363,7 +6367,7 @@ ${input.slice(result.pos)}
|
|
|
6363
6367
|
function AtIdentifierRef(ctx, state) {
|
|
6364
6368
|
return $EVENT_C(ctx, state, "AtIdentifierRef", AtIdentifierRef$$);
|
|
6365
6369
|
}
|
|
6366
|
-
var PinPattern$0 = $TS($S($EXPECT($
|
|
6370
|
+
var PinPattern$0 = $TS($S($EXPECT($L18, 'PinPattern "^"'), Identifier), function($skip, $loc, $0, $1, $2) {
|
|
6367
6371
|
var identifier = $2;
|
|
6368
6372
|
return {
|
|
6369
6373
|
type: "PinPattern",
|
|
@@ -6522,7 +6526,7 @@ ${input.slice(result.pos)}
|
|
|
6522
6526
|
names: value.names
|
|
6523
6527
|
};
|
|
6524
6528
|
});
|
|
6525
|
-
var BindingProperty$2 = $TS($S($E(_), $E($EXPECT($
|
|
6529
|
+
var BindingProperty$2 = $TS($S($E(_), $E($EXPECT($L18, 'BindingProperty "^"')), BindingIdentifier, $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6526
6530
|
var ws = $1;
|
|
6527
6531
|
var pin = $2;
|
|
6528
6532
|
var binding = $3;
|
|
@@ -6612,7 +6616,7 @@ ${input.slice(result.pos)}
|
|
|
6612
6616
|
children: [ws, binding]
|
|
6613
6617
|
};
|
|
6614
6618
|
});
|
|
6615
|
-
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($
|
|
6619
|
+
var BindingElement$2 = $TV($Y($S($E(_), $EXPECT($L22, 'BindingElement ","'))), function($skip, $loc, $0, $1) {
|
|
6616
6620
|
return {
|
|
6617
6621
|
children: [{
|
|
6618
6622
|
type: "ElisionElement",
|
|
@@ -6736,7 +6740,7 @@ ${input.slice(result.pos)}
|
|
|
6736
6740
|
block
|
|
6737
6741
|
};
|
|
6738
6742
|
});
|
|
6739
|
-
var FunctionExpression$1 = $TV($EXPECT($
|
|
6743
|
+
var FunctionExpression$1 = $TV($EXPECT($L23, 'FunctionExpression "(&)"'), function($skip, $loc, $0, $1) {
|
|
6740
6744
|
const ref = makeRef("$"), body = [ref];
|
|
6741
6745
|
const parameters = {
|
|
6742
6746
|
type: "Parameters",
|
|
@@ -6995,7 +6999,7 @@ ${input.slice(result.pos)}
|
|
|
6995
6999
|
function ThinArrowFunction(ctx, state) {
|
|
6996
7000
|
return $EVENT(ctx, state, "ThinArrowFunction", ThinArrowFunction$0);
|
|
6997
7001
|
}
|
|
6998
|
-
var Arrow$0 = $TV($C($EXPECT($
|
|
7002
|
+
var Arrow$0 = $TV($C($EXPECT($L24, 'Arrow "->"'), $EXPECT($L25, 'Arrow "\u2192"')), function($skip, $loc, $0, $1) {
|
|
6999
7003
|
return { $loc, token: "->" };
|
|
7000
7004
|
});
|
|
7001
7005
|
function Arrow(ctx, state) {
|
|
@@ -7273,7 +7277,7 @@ ${input.slice(result.pos)}
|
|
|
7273
7277
|
}
|
|
7274
7278
|
var BracedContent$0 = NestedBlockStatements;
|
|
7275
7279
|
var BracedContent$1 = SingleLineStatements;
|
|
7276
|
-
var BracedContent$2 = $TV($Y($S(__, $EXPECT($
|
|
7280
|
+
var BracedContent$2 = $TV($Y($S(__, $EXPECT($L26, 'BracedContent "}"'))), function($skip, $loc, $0, $1) {
|
|
7277
7281
|
const expressions = [];
|
|
7278
7282
|
return {
|
|
7279
7283
|
type: "BlockStatement",
|
|
@@ -7343,7 +7347,7 @@ ${input.slice(result.pos)}
|
|
|
7343
7347
|
function LiteralContent(ctx, state) {
|
|
7344
7348
|
return $EVENT_C(ctx, state, "LiteralContent", LiteralContent$$);
|
|
7345
7349
|
}
|
|
7346
|
-
var NullLiteral$0 = $TS($S($EXPECT($
|
|
7350
|
+
var NullLiteral$0 = $TS($S($EXPECT($L27, 'NullLiteral "null"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7347
7351
|
return { $loc, token: $1 };
|
|
7348
7352
|
});
|
|
7349
7353
|
function NullLiteral(ctx, state) {
|
|
@@ -7358,17 +7362,17 @@ ${input.slice(result.pos)}
|
|
|
7358
7362
|
var _BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
7359
7363
|
return value[1];
|
|
7360
7364
|
});
|
|
7361
|
-
var _BooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
7365
|
+
var _BooleanLiteral$1 = $TS($S($C($EXPECT($L28, '_BooleanLiteral "true"'), $EXPECT($L29, '_BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7362
7366
|
return { $loc, token: $1 };
|
|
7363
7367
|
});
|
|
7364
7368
|
var _BooleanLiteral$$ = [_BooleanLiteral$0, _BooleanLiteral$1];
|
|
7365
7369
|
function _BooleanLiteral(ctx, state) {
|
|
7366
7370
|
return $EVENT_C(ctx, state, "_BooleanLiteral", _BooleanLiteral$$);
|
|
7367
7371
|
}
|
|
7368
|
-
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($
|
|
7372
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L30, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L31, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7369
7373
|
return { $loc, token: "true" };
|
|
7370
7374
|
});
|
|
7371
|
-
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($
|
|
7375
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L32, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L33, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
7372
7376
|
return { $loc, token: "false" };
|
|
7373
7377
|
});
|
|
7374
7378
|
var CoffeeScriptBooleanLiteral$$ = [CoffeeScriptBooleanLiteral$0, CoffeeScriptBooleanLiteral$1];
|
|
@@ -7400,7 +7404,7 @@ ${input.slice(result.pos)}
|
|
|
7400
7404
|
function IdentifierReference(ctx, state) {
|
|
7401
7405
|
return $EVENT(ctx, state, "IdentifierReference", IdentifierReference$0);
|
|
7402
7406
|
}
|
|
7403
|
-
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L3, 'UpcomingAssignment "="'), $N($C($EXPECT($L3, 'UpcomingAssignment "="'), $EXPECT($
|
|
7407
|
+
var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L3, 'UpcomingAssignment "="'), $N($C($EXPECT($L3, 'UpcomingAssignment "="'), $EXPECT($L34, 'UpcomingAssignment ">"')))));
|
|
7404
7408
|
function UpcomingAssignment(ctx, state) {
|
|
7405
7409
|
return $EVENT(ctx, state, "UpcomingAssignment", UpcomingAssignment$0);
|
|
7406
7410
|
}
|
|
@@ -7558,7 +7562,7 @@ ${input.slice(result.pos)}
|
|
|
7558
7562
|
return $EVENT(ctx, state, "NestedElement", NestedElement$0);
|
|
7559
7563
|
}
|
|
7560
7564
|
var ArrayElementDelimiter$0 = $S(__, Comma);
|
|
7561
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7565
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L35, 'ArrayElementDelimiter "]"')));
|
|
7562
7566
|
var ArrayElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7563
7567
|
return value[1];
|
|
7564
7568
|
});
|
|
@@ -7788,7 +7792,7 @@ ${input.slice(result.pos)}
|
|
|
7788
7792
|
return $EVENT_C(ctx, state, "ImplicitInlineObjectPropertyDelimiter", ImplicitInlineObjectPropertyDelimiter$$);
|
|
7789
7793
|
}
|
|
7790
7794
|
var ObjectPropertyDelimiter$0 = $S($E(_), Comma);
|
|
7791
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
7795
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L26, 'ObjectPropertyDelimiter "}"')));
|
|
7792
7796
|
var ObjectPropertyDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
7793
7797
|
return value[1];
|
|
7794
7798
|
});
|
|
@@ -7971,7 +7975,7 @@ ${input.slice(result.pos)}
|
|
|
7971
7975
|
implicit: true
|
|
7972
7976
|
};
|
|
7973
7977
|
});
|
|
7974
|
-
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($
|
|
7978
|
+
var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L19, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7975
7979
|
const expression = [$2, $3];
|
|
7976
7980
|
return {
|
|
7977
7981
|
type: "ComputedPropertyName",
|
|
@@ -8220,7 +8224,7 @@ ${input.slice(result.pos)}
|
|
|
8220
8224
|
return $EVENT(ctx, state, "PrivateIdentifier", PrivateIdentifier$0);
|
|
8221
8225
|
}
|
|
8222
8226
|
var WAssignmentOp$0 = $S(__, AssignmentOp);
|
|
8223
|
-
var WAssignmentOp$1 = $S(_, OperatorAssignmentOp);
|
|
8227
|
+
var WAssignmentOp$1 = $S($E(_), OperatorAssignmentOp);
|
|
8224
8228
|
var WAssignmentOp$$ = [WAssignmentOp$0, WAssignmentOp$1];
|
|
8225
8229
|
function WAssignmentOp(ctx, state) {
|
|
8226
8230
|
return $EVENT_C(ctx, state, "WAssignmentOp", WAssignmentOp$$);
|
|
@@ -8237,47 +8241,47 @@ ${input.slice(result.pos)}
|
|
|
8237
8241
|
function AssignmentOp(ctx, state) {
|
|
8238
8242
|
return $EVENT(ctx, state, "AssignmentOp", AssignmentOp$0);
|
|
8239
8243
|
}
|
|
8240
|
-
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $
|
|
8244
|
+
var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8241
8245
|
return {
|
|
8242
8246
|
special: true,
|
|
8243
8247
|
call: module.getRef("xor"),
|
|
8244
|
-
children: [$2, ...$
|
|
8248
|
+
children: [$2, ...$3 || []]
|
|
8245
8249
|
};
|
|
8246
8250
|
});
|
|
8247
|
-
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $
|
|
8251
|
+
var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L3, 'OperatorAssignmentOp "="'), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8248
8252
|
return {
|
|
8249
8253
|
special: true,
|
|
8250
8254
|
call: module.getRef("xnor"),
|
|
8251
|
-
children: [$2, ...$
|
|
8255
|
+
children: [$2, ...$3 || []]
|
|
8252
8256
|
};
|
|
8253
8257
|
});
|
|
8254
|
-
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L3, 'OperatorAssignmentOp "="'), $
|
|
8258
|
+
var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L3, 'OperatorAssignmentOp "="'), $E(_)), function($skip, $loc, $0, $1, $2, $3) {
|
|
8255
8259
|
return {
|
|
8256
8260
|
special: true,
|
|
8257
8261
|
call: $1,
|
|
8258
|
-
children: [$2, ...$
|
|
8262
|
+
children: [$2, ...$3 || []]
|
|
8259
8263
|
};
|
|
8260
8264
|
});
|
|
8261
8265
|
var OperatorAssignmentOp$$ = [OperatorAssignmentOp$0, OperatorAssignmentOp$1, OperatorAssignmentOp$2];
|
|
8262
8266
|
function OperatorAssignmentOp(ctx, state) {
|
|
8263
8267
|
return $EVENT_C(ctx, state, "OperatorAssignmentOp", OperatorAssignmentOp$$);
|
|
8264
8268
|
}
|
|
8265
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
8266
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
8267
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
8268
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
8269
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
8270
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
8271
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
8272
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
8273
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
8274
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
8275
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
8276
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
8277
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
8278
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
8279
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
8280
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
8269
|
+
var AssignmentOpSymbol$0 = $EXPECT($L36, 'AssignmentOpSymbol "**="');
|
|
8270
|
+
var AssignmentOpSymbol$1 = $EXPECT($L37, 'AssignmentOpSymbol "*="');
|
|
8271
|
+
var AssignmentOpSymbol$2 = $EXPECT($L38, 'AssignmentOpSymbol "/="');
|
|
8272
|
+
var AssignmentOpSymbol$3 = $EXPECT($L39, 'AssignmentOpSymbol "%="');
|
|
8273
|
+
var AssignmentOpSymbol$4 = $EXPECT($L40, 'AssignmentOpSymbol "+="');
|
|
8274
|
+
var AssignmentOpSymbol$5 = $EXPECT($L41, 'AssignmentOpSymbol "-="');
|
|
8275
|
+
var AssignmentOpSymbol$6 = $EXPECT($L42, 'AssignmentOpSymbol "<<="');
|
|
8276
|
+
var AssignmentOpSymbol$7 = $EXPECT($L43, 'AssignmentOpSymbol ">>>="');
|
|
8277
|
+
var AssignmentOpSymbol$8 = $EXPECT($L44, 'AssignmentOpSymbol ">>="');
|
|
8278
|
+
var AssignmentOpSymbol$9 = $EXPECT($L45, 'AssignmentOpSymbol "&&="');
|
|
8279
|
+
var AssignmentOpSymbol$10 = $EXPECT($L46, 'AssignmentOpSymbol "&="');
|
|
8280
|
+
var AssignmentOpSymbol$11 = $EXPECT($L47, 'AssignmentOpSymbol "^="');
|
|
8281
|
+
var AssignmentOpSymbol$12 = $EXPECT($L48, 'AssignmentOpSymbol "||="');
|
|
8282
|
+
var AssignmentOpSymbol$13 = $EXPECT($L49, 'AssignmentOpSymbol "|="');
|
|
8283
|
+
var AssignmentOpSymbol$14 = $EXPECT($L50, 'AssignmentOpSymbol "??="');
|
|
8284
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L51, 'AssignmentOpSymbol "?="'), function(value) {
|
|
8281
8285
|
return "??=";
|
|
8282
8286
|
});
|
|
8283
8287
|
var AssignmentOpSymbol$16 = $T($S($EXPECT($L3, 'AssignmentOpSymbol "="'), $N($EXPECT($L3, 'AssignmentOpSymbol "="'))), function(value) {
|
|
@@ -8290,10 +8294,10 @@ ${input.slice(result.pos)}
|
|
|
8290
8294
|
function AssignmentOpSymbol(ctx, state) {
|
|
8291
8295
|
return $EVENT_C(ctx, state, "AssignmentOpSymbol", AssignmentOpSymbol$$);
|
|
8292
8296
|
}
|
|
8293
|
-
var CoffeeWordAssignmentOp$0 = $T($EXPECT($
|
|
8297
|
+
var CoffeeWordAssignmentOp$0 = $T($EXPECT($L52, 'CoffeeWordAssignmentOp "and="'), function(value) {
|
|
8294
8298
|
return "&&=";
|
|
8295
8299
|
});
|
|
8296
|
-
var CoffeeWordAssignmentOp$1 = $T($EXPECT($
|
|
8300
|
+
var CoffeeWordAssignmentOp$1 = $T($EXPECT($L53, 'CoffeeWordAssignmentOp "or="'), function(value) {
|
|
8297
8301
|
return "||=";
|
|
8298
8302
|
});
|
|
8299
8303
|
var CoffeeWordAssignmentOp$$ = [CoffeeWordAssignmentOp$0, CoffeeWordAssignmentOp$1];
|
|
@@ -8362,27 +8366,27 @@ ${input.slice(result.pos)}
|
|
|
8362
8366
|
function _BinaryOp(ctx, state) {
|
|
8363
8367
|
return $EVENT_C(ctx, state, "_BinaryOp", _BinaryOp$$);
|
|
8364
8368
|
}
|
|
8365
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
8366
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
8367
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
8368
|
-
var BinaryOpSymbol$3 = $TV($EXPECT($
|
|
8369
|
+
var BinaryOpSymbol$0 = $EXPECT($L54, 'BinaryOpSymbol "**"');
|
|
8370
|
+
var BinaryOpSymbol$1 = $EXPECT($L55, 'BinaryOpSymbol "*"');
|
|
8371
|
+
var BinaryOpSymbol$2 = $EXPECT($L56, 'BinaryOpSymbol "/"');
|
|
8372
|
+
var BinaryOpSymbol$3 = $TV($EXPECT($L57, 'BinaryOpSymbol "%%"'), function($skip, $loc, $0, $1) {
|
|
8369
8373
|
return {
|
|
8370
8374
|
call: module.getRef("modulo"),
|
|
8371
8375
|
special: true
|
|
8372
8376
|
};
|
|
8373
8377
|
});
|
|
8374
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
8375
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
8376
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
8377
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
8378
|
-
var BinaryOpSymbol$8 = $T($EXPECT($
|
|
8378
|
+
var BinaryOpSymbol$4 = $EXPECT($L58, 'BinaryOpSymbol "%"');
|
|
8379
|
+
var BinaryOpSymbol$5 = $EXPECT($L59, 'BinaryOpSymbol "+"');
|
|
8380
|
+
var BinaryOpSymbol$6 = $EXPECT($L19, 'BinaryOpSymbol "-"');
|
|
8381
|
+
var BinaryOpSymbol$7 = $EXPECT($L60, 'BinaryOpSymbol "<="');
|
|
8382
|
+
var BinaryOpSymbol$8 = $T($EXPECT($L61, 'BinaryOpSymbol "\u2264"'), function(value) {
|
|
8379
8383
|
return "<=";
|
|
8380
8384
|
});
|
|
8381
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
8382
|
-
var BinaryOpSymbol$10 = $T($EXPECT($
|
|
8385
|
+
var BinaryOpSymbol$9 = $EXPECT($L62, 'BinaryOpSymbol ">="');
|
|
8386
|
+
var BinaryOpSymbol$10 = $T($EXPECT($L63, 'BinaryOpSymbol "\u2265"'), function(value) {
|
|
8383
8387
|
return ">=";
|
|
8384
8388
|
});
|
|
8385
|
-
var BinaryOpSymbol$11 = $TV($EXPECT($
|
|
8389
|
+
var BinaryOpSymbol$11 = $TV($EXPECT($L64, 'BinaryOpSymbol "<?"'), function($skip, $loc, $0, $1) {
|
|
8386
8390
|
return {
|
|
8387
8391
|
$loc,
|
|
8388
8392
|
token: "instanceof",
|
|
@@ -8390,7 +8394,7 @@ ${input.slice(result.pos)}
|
|
|
8390
8394
|
special: true
|
|
8391
8395
|
};
|
|
8392
8396
|
});
|
|
8393
|
-
var BinaryOpSymbol$12 = $TV($EXPECT($
|
|
8397
|
+
var BinaryOpSymbol$12 = $TV($EXPECT($L65, 'BinaryOpSymbol "!<?"'), function($skip, $loc, $0, $1) {
|
|
8394
8398
|
return {
|
|
8395
8399
|
$loc,
|
|
8396
8400
|
token: "instanceof",
|
|
@@ -8399,76 +8403,74 @@ ${input.slice(result.pos)}
|
|
|
8399
8403
|
negated: true
|
|
8400
8404
|
};
|
|
8401
8405
|
});
|
|
8402
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
8403
|
-
var BinaryOpSymbol$14 = $T($EXPECT($
|
|
8406
|
+
var BinaryOpSymbol$13 = $EXPECT($L66, 'BinaryOpSymbol "<<"');
|
|
8407
|
+
var BinaryOpSymbol$14 = $T($EXPECT($L67, 'BinaryOpSymbol "\xAB"'), function(value) {
|
|
8404
8408
|
return "<<";
|
|
8405
8409
|
});
|
|
8406
|
-
var BinaryOpSymbol$15 = $
|
|
8407
|
-
|
|
8408
|
-
|
|
8409
|
-
var BinaryOpSymbol$16 = $EXPECT($L67, 'BinaryOpSymbol ">>>"');
|
|
8410
|
-
var BinaryOpSymbol$17 = $T($EXPECT($L68, 'BinaryOpSymbol "\u22D9"'), function(value) {
|
|
8410
|
+
var BinaryOpSymbol$15 = $EXPECT($L13, 'BinaryOpSymbol "<"');
|
|
8411
|
+
var BinaryOpSymbol$16 = $EXPECT($L68, 'BinaryOpSymbol ">>>"');
|
|
8412
|
+
var BinaryOpSymbol$17 = $T($EXPECT($L69, 'BinaryOpSymbol "\u22D9"'), function(value) {
|
|
8411
8413
|
return ">>>";
|
|
8412
8414
|
});
|
|
8413
|
-
var BinaryOpSymbol$18 = $EXPECT($
|
|
8414
|
-
var BinaryOpSymbol$19 = $T($EXPECT($
|
|
8415
|
+
var BinaryOpSymbol$18 = $EXPECT($L70, 'BinaryOpSymbol ">>"');
|
|
8416
|
+
var BinaryOpSymbol$19 = $T($EXPECT($L71, 'BinaryOpSymbol "\xBB"'), function(value) {
|
|
8415
8417
|
return ">>";
|
|
8416
8418
|
});
|
|
8417
|
-
var BinaryOpSymbol$20 = $EXPECT($
|
|
8418
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
8419
|
-
var BinaryOpSymbol$22 = $T($EXPECT($
|
|
8419
|
+
var BinaryOpSymbol$20 = $EXPECT($L34, 'BinaryOpSymbol ">"');
|
|
8420
|
+
var BinaryOpSymbol$21 = $EXPECT($L72, 'BinaryOpSymbol "!=="');
|
|
8421
|
+
var BinaryOpSymbol$22 = $T($EXPECT($L73, 'BinaryOpSymbol "\u2262"'), function(value) {
|
|
8420
8422
|
return "!==";
|
|
8421
8423
|
});
|
|
8422
|
-
var BinaryOpSymbol$23 = $TV($C($EXPECT($
|
|
8424
|
+
var BinaryOpSymbol$23 = $TV($C($EXPECT($L74, 'BinaryOpSymbol "!="'), $EXPECT($L75, 'BinaryOpSymbol "\u2260"')), function($skip, $loc, $0, $1) {
|
|
8423
8425
|
if (module.config.coffeeEq)
|
|
8424
8426
|
return "!==";
|
|
8425
8427
|
return "!=";
|
|
8426
8428
|
});
|
|
8427
|
-
var BinaryOpSymbol$24 = $TS($S($EXPECT($
|
|
8429
|
+
var BinaryOpSymbol$24 = $TS($S($EXPECT($L76, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8428
8430
|
if (module.config.coffeeIsnt)
|
|
8429
8431
|
return "!==";
|
|
8430
8432
|
return $skip;
|
|
8431
8433
|
});
|
|
8432
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
8433
|
-
var BinaryOpSymbol$26 = $T($C($EXPECT($
|
|
8434
|
+
var BinaryOpSymbol$25 = $EXPECT($L77, 'BinaryOpSymbol "==="');
|
|
8435
|
+
var BinaryOpSymbol$26 = $T($C($EXPECT($L78, 'BinaryOpSymbol "\u2263"'), $EXPECT($L79, 'BinaryOpSymbol "\u2A76"')), function(value) {
|
|
8434
8436
|
return "===";
|
|
8435
8437
|
});
|
|
8436
|
-
var BinaryOpSymbol$27 = $TV($C($EXPECT($
|
|
8438
|
+
var BinaryOpSymbol$27 = $TV($C($EXPECT($L80, 'BinaryOpSymbol "=="'), $EXPECT($L81, 'BinaryOpSymbol "\u2261"'), $EXPECT($L82, 'BinaryOpSymbol "\u2A75"')), function($skip, $loc, $0, $1) {
|
|
8437
8439
|
if (module.config.coffeeEq)
|
|
8438
8440
|
return "===";
|
|
8439
8441
|
return "==";
|
|
8440
8442
|
});
|
|
8441
|
-
var BinaryOpSymbol$28 = $T($S($EXPECT($
|
|
8443
|
+
var BinaryOpSymbol$28 = $T($S($EXPECT($L83, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
8442
8444
|
return "&&";
|
|
8443
8445
|
});
|
|
8444
|
-
var BinaryOpSymbol$29 = $EXPECT($
|
|
8445
|
-
var BinaryOpSymbol$30 = $T($S($EXPECT($
|
|
8446
|
+
var BinaryOpSymbol$29 = $EXPECT($L84, 'BinaryOpSymbol "&&"');
|
|
8447
|
+
var BinaryOpSymbol$30 = $T($S($EXPECT($L85, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
8446
8448
|
return "||";
|
|
8447
8449
|
});
|
|
8448
|
-
var BinaryOpSymbol$31 = $EXPECT($
|
|
8449
|
-
var BinaryOpSymbol$32 = $T($EXPECT($
|
|
8450
|
+
var BinaryOpSymbol$31 = $EXPECT($L86, 'BinaryOpSymbol "||"');
|
|
8451
|
+
var BinaryOpSymbol$32 = $T($EXPECT($L87, 'BinaryOpSymbol "\u2016"'), function(value) {
|
|
8450
8452
|
return "||";
|
|
8451
8453
|
});
|
|
8452
|
-
var BinaryOpSymbol$33 = $TV($C($EXPECT($
|
|
8454
|
+
var BinaryOpSymbol$33 = $TV($C($EXPECT($L88, 'BinaryOpSymbol "^^"'), $S($EXPECT($L89, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8453
8455
|
return {
|
|
8454
8456
|
call: module.getRef("xor"),
|
|
8455
8457
|
special: true
|
|
8456
8458
|
};
|
|
8457
8459
|
});
|
|
8458
|
-
var BinaryOpSymbol$34 = $TV($C($EXPECT($
|
|
8460
|
+
var BinaryOpSymbol$34 = $TV($C($EXPECT($R17, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L90, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8459
8461
|
return {
|
|
8460
8462
|
call: module.getRef("xnor"),
|
|
8461
8463
|
special: true
|
|
8462
8464
|
};
|
|
8463
8465
|
});
|
|
8464
|
-
var BinaryOpSymbol$35 = $EXPECT($
|
|
8465
|
-
var BinaryOpSymbol$36 = $T($EXPECT($
|
|
8466
|
+
var BinaryOpSymbol$35 = $EXPECT($L91, 'BinaryOpSymbol "??"');
|
|
8467
|
+
var BinaryOpSymbol$36 = $T($EXPECT($L92, 'BinaryOpSymbol "\u2047"'), function(value) {
|
|
8466
8468
|
return "??";
|
|
8467
8469
|
});
|
|
8468
8470
|
var BinaryOpSymbol$37 = $T($S($EXPECT($L5, 'BinaryOpSymbol "?"'), CoffeeBinaryExistentialEnabled), function(value) {
|
|
8469
8471
|
return "??";
|
|
8470
8472
|
});
|
|
8471
|
-
var BinaryOpSymbol$38 = $TS($S($EXPECT($
|
|
8473
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L93, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8472
8474
|
return {
|
|
8473
8475
|
$loc,
|
|
8474
8476
|
token: $1,
|
|
@@ -8485,7 +8487,7 @@ ${input.slice(result.pos)}
|
|
|
8485
8487
|
var op = $3;
|
|
8486
8488
|
return { ...op, $loc };
|
|
8487
8489
|
});
|
|
8488
|
-
var BinaryOpSymbol$41 = $TV($C($S(Is, __, In), $EXPECT($
|
|
8490
|
+
var BinaryOpSymbol$41 = $TV($C($S(Is, __, In), $EXPECT($L94, 'BinaryOpSymbol "\u2208"')), function($skip, $loc, $0, $1) {
|
|
8489
8491
|
return {
|
|
8490
8492
|
method: "includes",
|
|
8491
8493
|
relational: true,
|
|
@@ -8493,14 +8495,14 @@ ${input.slice(result.pos)}
|
|
|
8493
8495
|
special: true
|
|
8494
8496
|
};
|
|
8495
8497
|
});
|
|
8496
|
-
var BinaryOpSymbol$42 = $TV($EXPECT($
|
|
8498
|
+
var BinaryOpSymbol$42 = $TV($EXPECT($L95, 'BinaryOpSymbol "\u220B"'), function($skip, $loc, $0, $1) {
|
|
8497
8499
|
return {
|
|
8498
8500
|
method: "includes",
|
|
8499
8501
|
relational: true,
|
|
8500
8502
|
special: true
|
|
8501
8503
|
};
|
|
8502
8504
|
});
|
|
8503
|
-
var BinaryOpSymbol$43 = $TV($EXPECT($
|
|
8505
|
+
var BinaryOpSymbol$43 = $TV($EXPECT($L96, 'BinaryOpSymbol "\u220C"'), function($skip, $loc, $0, $1) {
|
|
8504
8506
|
return {
|
|
8505
8507
|
method: "includes",
|
|
8506
8508
|
relational: true,
|
|
@@ -8508,7 +8510,7 @@ ${input.slice(result.pos)}
|
|
|
8508
8510
|
negated: true
|
|
8509
8511
|
};
|
|
8510
8512
|
});
|
|
8511
|
-
var BinaryOpSymbol$44 = $TV($C($S(Is, __, Not, __, In), $EXPECT($
|
|
8513
|
+
var BinaryOpSymbol$44 = $TV($C($S(Is, __, Not, __, In), $EXPECT($L97, 'BinaryOpSymbol "\u2209"')), function($skip, $loc, $0, $1) {
|
|
8512
8514
|
return {
|
|
8513
8515
|
method: "includes",
|
|
8514
8516
|
relational: true,
|
|
@@ -8541,9 +8543,9 @@ ${input.slice(result.pos)}
|
|
|
8541
8543
|
return "===";
|
|
8542
8544
|
});
|
|
8543
8545
|
var BinaryOpSymbol$47 = In;
|
|
8544
|
-
var BinaryOpSymbol$48 = $EXPECT($
|
|
8545
|
-
var BinaryOpSymbol$49 = $EXPECT($
|
|
8546
|
-
var BinaryOpSymbol$50 = $EXPECT($
|
|
8546
|
+
var BinaryOpSymbol$48 = $EXPECT($L98, 'BinaryOpSymbol "&"');
|
|
8547
|
+
var BinaryOpSymbol$49 = $EXPECT($L18, 'BinaryOpSymbol "^"');
|
|
8548
|
+
var BinaryOpSymbol$50 = $EXPECT($L99, 'BinaryOpSymbol "|"');
|
|
8547
8549
|
var BinaryOpSymbol$$ = [BinaryOpSymbol$0, BinaryOpSymbol$1, BinaryOpSymbol$2, BinaryOpSymbol$3, BinaryOpSymbol$4, BinaryOpSymbol$5, BinaryOpSymbol$6, BinaryOpSymbol$7, BinaryOpSymbol$8, BinaryOpSymbol$9, BinaryOpSymbol$10, BinaryOpSymbol$11, BinaryOpSymbol$12, BinaryOpSymbol$13, BinaryOpSymbol$14, BinaryOpSymbol$15, BinaryOpSymbol$16, BinaryOpSymbol$17, BinaryOpSymbol$18, BinaryOpSymbol$19, BinaryOpSymbol$20, BinaryOpSymbol$21, BinaryOpSymbol$22, BinaryOpSymbol$23, BinaryOpSymbol$24, BinaryOpSymbol$25, BinaryOpSymbol$26, BinaryOpSymbol$27, BinaryOpSymbol$28, BinaryOpSymbol$29, BinaryOpSymbol$30, BinaryOpSymbol$31, BinaryOpSymbol$32, BinaryOpSymbol$33, BinaryOpSymbol$34, BinaryOpSymbol$35, BinaryOpSymbol$36, BinaryOpSymbol$37, BinaryOpSymbol$38, BinaryOpSymbol$39, BinaryOpSymbol$40, BinaryOpSymbol$41, BinaryOpSymbol$42, BinaryOpSymbol$43, BinaryOpSymbol$44, BinaryOpSymbol$45, BinaryOpSymbol$46, BinaryOpSymbol$47, BinaryOpSymbol$48, BinaryOpSymbol$49, BinaryOpSymbol$50];
|
|
8548
8550
|
function BinaryOpSymbol(ctx, state) {
|
|
8549
8551
|
return $EVENT_C(ctx, state, "BinaryOpSymbol", BinaryOpSymbol$$);
|
|
@@ -8581,7 +8583,7 @@ ${input.slice(result.pos)}
|
|
|
8581
8583
|
function CoffeeOfOp(ctx, state) {
|
|
8582
8584
|
return $EVENT_C(ctx, state, "CoffeeOfOp", CoffeeOfOp$$);
|
|
8583
8585
|
}
|
|
8584
|
-
var NotOp$0 = $TS($S($EXPECT($
|
|
8586
|
+
var NotOp$0 = $TS($S($EXPECT($L93, 'NotOp "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8585
8587
|
return {
|
|
8586
8588
|
$loc,
|
|
8587
8589
|
token: "instanceof",
|
|
@@ -8602,19 +8604,19 @@ ${input.slice(result.pos)}
|
|
|
8602
8604
|
function NotOp(ctx, state) {
|
|
8603
8605
|
return $EVENT_C(ctx, state, "NotOp", NotOp$$);
|
|
8604
8606
|
}
|
|
8605
|
-
var Xor$0 = $EXPECT($
|
|
8606
|
-
var Xor$1 = $S($EXPECT($
|
|
8607
|
+
var Xor$0 = $EXPECT($L88, 'Xor "^^"');
|
|
8608
|
+
var Xor$1 = $S($EXPECT($L89, 'Xor "xor"'), NonIdContinue);
|
|
8607
8609
|
var Xor$$ = [Xor$0, Xor$1];
|
|
8608
8610
|
function Xor(ctx, state) {
|
|
8609
8611
|
return $EVENT_C(ctx, state, "Xor", Xor$$);
|
|
8610
8612
|
}
|
|
8611
|
-
var Xnor$0 = $R$0($EXPECT($
|
|
8612
|
-
var Xnor$1 = $EXPECT($
|
|
8613
|
+
var Xnor$0 = $R$0($EXPECT($R17, "Xnor /!\\^\\^?/"));
|
|
8614
|
+
var Xnor$1 = $EXPECT($L90, 'Xnor "xnor"');
|
|
8613
8615
|
var Xnor$$ = [Xnor$0, Xnor$1];
|
|
8614
8616
|
function Xnor(ctx, state) {
|
|
8615
8617
|
return $EVENT_C(ctx, state, "Xnor", Xnor$$);
|
|
8616
8618
|
}
|
|
8617
|
-
var UnaryOp$0 = $TR($EXPECT($
|
|
8619
|
+
var UnaryOp$0 = $TR($EXPECT($R18, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*(&|\\.[^0-9]))/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8618
8620
|
return { $loc, token: $0 };
|
|
8619
8621
|
});
|
|
8620
8622
|
var UnaryOp$1 = AwaitOp;
|
|
@@ -8714,7 +8716,7 @@ ${input.slice(result.pos)}
|
|
|
8714
8716
|
function NonPipelinePostfixedExpression(ctx, state) {
|
|
8715
8717
|
return $EVENT(ctx, state, "NonPipelinePostfixedExpression", NonPipelinePostfixedExpression$0);
|
|
8716
8718
|
}
|
|
8717
|
-
var PostfixStatement$0 = $T($S($EXPECT($
|
|
8719
|
+
var PostfixStatement$0 = $T($S($EXPECT($R19, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
|
|
8718
8720
|
return value[1];
|
|
8719
8721
|
});
|
|
8720
8722
|
function PostfixStatement(ctx, state) {
|
|
@@ -8757,7 +8759,7 @@ ${input.slice(result.pos)}
|
|
|
8757
8759
|
function NoCommaStatement(ctx, state) {
|
|
8758
8760
|
return $EVENT_C(ctx, state, "NoCommaStatement", NoCommaStatement$$);
|
|
8759
8761
|
}
|
|
8760
|
-
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($
|
|
8762
|
+
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L100, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
|
|
8761
8763
|
return { type: "EmptyStatement", children: $1 || [] };
|
|
8762
8764
|
});
|
|
8763
8765
|
function EmptyStatement(ctx, state) {
|
|
@@ -8779,7 +8781,7 @@ ${input.slice(result.pos)}
|
|
|
8779
8781
|
var w = $3;
|
|
8780
8782
|
return [id, colon, w];
|
|
8781
8783
|
});
|
|
8782
|
-
var Label$1 = $S($EXPECT($
|
|
8784
|
+
var Label$1 = $S($EXPECT($L101, 'Label "$:"'), Whitespace);
|
|
8783
8785
|
var Label$$ = [Label$0, Label$1];
|
|
8784
8786
|
function Label(ctx, state) {
|
|
8785
8787
|
return $EVENT_C(ctx, state, "Label", Label$$);
|
|
@@ -8952,7 +8954,7 @@ ${input.slice(result.pos)}
|
|
|
8952
8954
|
function BlockExpressionPart(ctx, state) {
|
|
8953
8955
|
return $EVENT(ctx, state, "BlockExpressionPart", BlockExpressionPart$0);
|
|
8954
8956
|
}
|
|
8955
|
-
var IterationStatement$0 = $T($S($EXPECT($
|
|
8957
|
+
var IterationStatement$0 = $T($S($EXPECT($R20, "IterationStatement /(?=loop|do|for|until|while)/"), _IterationStatement), function(value) {
|
|
8956
8958
|
return value[1];
|
|
8957
8959
|
});
|
|
8958
8960
|
function IterationStatement(ctx, state) {
|
|
@@ -9305,7 +9307,7 @@ ${input.slice(result.pos)}
|
|
|
9305
9307
|
names: binding.names
|
|
9306
9308
|
};
|
|
9307
9309
|
});
|
|
9308
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
9310
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R21, "ForDeclaration /(?=[\\s\\),])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
9309
9311
|
var c = $1;
|
|
9310
9312
|
var binding = $2;
|
|
9311
9313
|
return {
|
|
@@ -9670,6 +9672,15 @@ ${input.slice(result.pos)}
|
|
|
9670
9672
|
function ExpressionWithObjectApplicationForbidden(ctx, state) {
|
|
9671
9673
|
return $EVENT(ctx, state, "ExpressionWithObjectApplicationForbidden", ExpressionWithObjectApplicationForbidden$0);
|
|
9672
9674
|
}
|
|
9675
|
+
var LeftHandSideExpressionWithObjectApplicationForbidden$0 = $TS($S(ForbidBracedApplication, ForbidIndentedApplication, ForbidNewlineBinaryOp, $E(LeftHandSideExpression), RestoreNewlineBinaryOp, RestoreBracedApplication, RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
9676
|
+
var exp = $4;
|
|
9677
|
+
if (exp)
|
|
9678
|
+
return exp;
|
|
9679
|
+
return $skip;
|
|
9680
|
+
});
|
|
9681
|
+
function LeftHandSideExpressionWithObjectApplicationForbidden(ctx, state) {
|
|
9682
|
+
return $EVENT(ctx, state, "LeftHandSideExpressionWithObjectApplicationForbidden", LeftHandSideExpressionWithObjectApplicationForbidden$0);
|
|
9683
|
+
}
|
|
9673
9684
|
var ForbidClassImplicitCall$0 = $TV($EXPECT($L0, 'ForbidClassImplicitCall ""'), function($skip, $loc, $0, $1) {
|
|
9674
9685
|
module.forbidClassImplicitCall.push(true);
|
|
9675
9686
|
});
|
|
@@ -9870,19 +9881,19 @@ ${input.slice(result.pos)}
|
|
|
9870
9881
|
function ThrowStatement(ctx, state) {
|
|
9871
9882
|
return $EVENT(ctx, state, "ThrowStatement", ThrowStatement$0);
|
|
9872
9883
|
}
|
|
9873
|
-
var Break$0 = $TS($S($EXPECT($
|
|
9884
|
+
var Break$0 = $TS($S($EXPECT($L102, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9874
9885
|
return { $loc, token: $1 };
|
|
9875
9886
|
});
|
|
9876
9887
|
function Break(ctx, state) {
|
|
9877
9888
|
return $EVENT(ctx, state, "Break", Break$0);
|
|
9878
9889
|
}
|
|
9879
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
9890
|
+
var Continue$0 = $TS($S($EXPECT($L103, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9880
9891
|
return { $loc, token: $1 };
|
|
9881
9892
|
});
|
|
9882
9893
|
function Continue(ctx, state) {
|
|
9883
9894
|
return $EVENT(ctx, state, "Continue", Continue$0);
|
|
9884
9895
|
}
|
|
9885
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
9896
|
+
var Debugger$0 = $TS($S($EXPECT($L104, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9886
9897
|
return { $loc, token: $1 };
|
|
9887
9898
|
});
|
|
9888
9899
|
function Debugger(ctx, state) {
|
|
@@ -10003,7 +10014,7 @@ ${input.slice(result.pos)}
|
|
|
10003
10014
|
function FromClause(ctx, state) {
|
|
10004
10015
|
return $EVENT(ctx, state, "FromClause", FromClause$0);
|
|
10005
10016
|
}
|
|
10006
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
10017
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L105, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
10007
10018
|
function ImportAssertion(ctx, state) {
|
|
10008
10019
|
return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
|
|
10009
10020
|
}
|
|
@@ -10091,7 +10102,7 @@ ${input.slice(result.pos)}
|
|
|
10091
10102
|
function UnprocessedModuleSpecifier(ctx, state) {
|
|
10092
10103
|
return $EVENT_C(ctx, state, "UnprocessedModuleSpecifier", UnprocessedModuleSpecifier$$);
|
|
10093
10104
|
}
|
|
10094
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
10105
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R22, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
10095
10106
|
var spec = $0;
|
|
10096
10107
|
return { $loc, token: `"${spec}"` };
|
|
10097
10108
|
});
|
|
@@ -10223,13 +10234,13 @@ ${input.slice(result.pos)}
|
|
|
10223
10234
|
function LexicalDeclaration(ctx, state) {
|
|
10224
10235
|
return $EVENT_C(ctx, state, "LexicalDeclaration", LexicalDeclaration$$);
|
|
10225
10236
|
}
|
|
10226
|
-
var ConstAssignment$0 = $TV($C($EXPECT($
|
|
10237
|
+
var ConstAssignment$0 = $TV($C($EXPECT($L106, 'ConstAssignment ":="'), $EXPECT($L107, 'ConstAssignment "\u2254"')), function($skip, $loc, $0, $1) {
|
|
10227
10238
|
return { $loc, token: "=" };
|
|
10228
10239
|
});
|
|
10229
10240
|
function ConstAssignment(ctx, state) {
|
|
10230
10241
|
return $EVENT(ctx, state, "ConstAssignment", ConstAssignment$0);
|
|
10231
10242
|
}
|
|
10232
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
10243
|
+
var LetAssignment$0 = $TV($EXPECT($L108, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
10233
10244
|
return { $loc, token: "=" };
|
|
10234
10245
|
});
|
|
10235
10246
|
function LetAssignment(ctx, state) {
|
|
@@ -10297,7 +10308,7 @@ ${input.slice(result.pos)}
|
|
|
10297
10308
|
function VariableDeclarationList(ctx, state) {
|
|
10298
10309
|
return $EVENT(ctx, state, "VariableDeclarationList", VariableDeclarationList$0);
|
|
10299
10310
|
}
|
|
10300
|
-
var NumericLiteral$0 = $TS($S($EXPECT($
|
|
10311
|
+
var NumericLiteral$0 = $TS($S($EXPECT($R23, "NumericLiteral /(?=[0-9.])/"), NumericLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
10301
10312
|
var token = $2;
|
|
10302
10313
|
return { type: "NumericLiteral", $loc, token };
|
|
10303
10314
|
});
|
|
@@ -10313,36 +10324,36 @@ ${input.slice(result.pos)}
|
|
|
10313
10324
|
function NumericLiteralKind(ctx, state) {
|
|
10314
10325
|
return $EVENT_C(ctx, state, "NumericLiteralKind", NumericLiteralKind$$);
|
|
10315
10326
|
}
|
|
10316
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
10327
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R24, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
10317
10328
|
function DecimalBigIntegerLiteral(ctx, state) {
|
|
10318
10329
|
return $EVENT(ctx, state, "DecimalBigIntegerLiteral", DecimalBigIntegerLiteral$0);
|
|
10319
10330
|
}
|
|
10320
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
10331
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R25, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
10321
10332
|
return $1 + ".";
|
|
10322
10333
|
});
|
|
10323
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
10324
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
10334
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R26, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
10335
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R27, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
10325
10336
|
var DecimalLiteral$$ = [DecimalLiteral$0, DecimalLiteral$1, DecimalLiteral$2];
|
|
10326
10337
|
function DecimalLiteral(ctx, state) {
|
|
10327
10338
|
return $EVENT_C(ctx, state, "DecimalLiteral", DecimalLiteral$$);
|
|
10328
10339
|
}
|
|
10329
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
10340
|
+
var ExponentPart$0 = $R$0($EXPECT($R28, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
10330
10341
|
function ExponentPart(ctx, state) {
|
|
10331
10342
|
return $EVENT(ctx, state, "ExponentPart", ExponentPart$0);
|
|
10332
10343
|
}
|
|
10333
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
10344
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R29, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
10334
10345
|
function BinaryIntegerLiteral(ctx, state) {
|
|
10335
10346
|
return $EVENT(ctx, state, "BinaryIntegerLiteral", BinaryIntegerLiteral$0);
|
|
10336
10347
|
}
|
|
10337
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
10348
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R30, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
10338
10349
|
function OctalIntegerLiteral(ctx, state) {
|
|
10339
10350
|
return $EVENT(ctx, state, "OctalIntegerLiteral", OctalIntegerLiteral$0);
|
|
10340
10351
|
}
|
|
10341
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
10352
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R31, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
10342
10353
|
function HexIntegerLiteral(ctx, state) {
|
|
10343
10354
|
return $EVENT(ctx, state, "HexIntegerLiteral", HexIntegerLiteral$0);
|
|
10344
10355
|
}
|
|
10345
|
-
var IntegerLiteral$0 = $TS($S($EXPECT($
|
|
10356
|
+
var IntegerLiteral$0 = $TS($S($EXPECT($R32, "IntegerLiteral /(?=[0-9])/"), IntegerLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
10346
10357
|
var token = $2;
|
|
10347
10358
|
return { $loc, token };
|
|
10348
10359
|
});
|
|
@@ -10358,7 +10369,7 @@ ${input.slice(result.pos)}
|
|
|
10358
10369
|
function IntegerLiteralKind(ctx, state) {
|
|
10359
10370
|
return $EVENT_C(ctx, state, "IntegerLiteralKind", IntegerLiteralKind$$);
|
|
10360
10371
|
}
|
|
10361
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
10372
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R33, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
10362
10373
|
function DecimalIntegerLiteral(ctx, state) {
|
|
10363
10374
|
return $EVENT(ctx, state, "DecimalIntegerLiteral", DecimalIntegerLiteral$0);
|
|
10364
10375
|
}
|
|
@@ -10382,25 +10393,25 @@ ${input.slice(result.pos)}
|
|
|
10382
10393
|
function StringLiteral(ctx, state) {
|
|
10383
10394
|
return $EVENT_C(ctx, state, "StringLiteral", StringLiteral$$);
|
|
10384
10395
|
}
|
|
10385
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
10396
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R34, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10386
10397
|
return { $loc, token: $0 };
|
|
10387
10398
|
});
|
|
10388
10399
|
function DoubleStringCharacters(ctx, state) {
|
|
10389
10400
|
return $EVENT(ctx, state, "DoubleStringCharacters", DoubleStringCharacters$0);
|
|
10390
10401
|
}
|
|
10391
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
10402
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R35, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10392
10403
|
return { $loc, token: $0 };
|
|
10393
10404
|
});
|
|
10394
10405
|
function SingleStringCharacters(ctx, state) {
|
|
10395
10406
|
return $EVENT(ctx, state, "SingleStringCharacters", SingleStringCharacters$0);
|
|
10396
10407
|
}
|
|
10397
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
10408
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R36, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10398
10409
|
return { $loc, token: $0 };
|
|
10399
10410
|
});
|
|
10400
10411
|
function TripleDoubleStringCharacters(ctx, state) {
|
|
10401
10412
|
return $EVENT(ctx, state, "TripleDoubleStringCharacters", TripleDoubleStringCharacters$0);
|
|
10402
10413
|
}
|
|
10403
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
10414
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R37, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10404
10415
|
return { $loc, token: $0 };
|
|
10405
10416
|
});
|
|
10406
10417
|
function TripleSingleStringCharacters(ctx, state) {
|
|
@@ -10419,14 +10430,14 @@ ${input.slice(result.pos)}
|
|
|
10419
10430
|
function CoffeeInterpolatedDoubleQuotedString(ctx, state) {
|
|
10420
10431
|
return $EVENT(ctx, state, "CoffeeInterpolatedDoubleQuotedString", CoffeeInterpolatedDoubleQuotedString$0);
|
|
10421
10432
|
}
|
|
10422
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
10433
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R38, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10423
10434
|
return { $loc, token: $0 };
|
|
10424
10435
|
});
|
|
10425
10436
|
function CoffeeDoubleQuotedStringCharacters(ctx, state) {
|
|
10426
10437
|
return $EVENT(ctx, state, "CoffeeDoubleQuotedStringCharacters", CoffeeDoubleQuotedStringCharacters$0);
|
|
10427
10438
|
}
|
|
10428
10439
|
var RegularExpressionLiteral$0 = HeregexLiteral;
|
|
10429
|
-
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($
|
|
10440
|
+
var RegularExpressionLiteral$1 = $TV($TEXT($S($EXPECT($L56, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L56, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
10430
10441
|
return { type: "RegularExpressionLiteral", $loc, token: $1 };
|
|
10431
10442
|
});
|
|
10432
10443
|
var RegularExpressionLiteral$$ = [RegularExpressionLiteral$0, RegularExpressionLiteral$1];
|
|
@@ -10439,7 +10450,7 @@ ${input.slice(result.pos)}
|
|
|
10439
10450
|
function RegularExpressionClass(ctx, state) {
|
|
10440
10451
|
return $EVENT(ctx, state, "RegularExpressionClass", RegularExpressionClass$0);
|
|
10441
10452
|
}
|
|
10442
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
10453
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R39, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10443
10454
|
return { $loc, token: $0 };
|
|
10444
10455
|
});
|
|
10445
10456
|
function RegularExpressionClassCharacters(ctx, state) {
|
|
@@ -10493,7 +10504,7 @@ ${input.slice(result.pos)}
|
|
|
10493
10504
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
10494
10505
|
return { "type": "Substitution", "children": value[0] };
|
|
10495
10506
|
});
|
|
10496
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
10507
|
+
var HeregexPart$3 = $TR($EXPECT($R40, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10497
10508
|
let token = $0;
|
|
10498
10509
|
switch ($0[1]) {
|
|
10499
10510
|
case "\n":
|
|
@@ -10511,13 +10522,13 @@ ${input.slice(result.pos)}
|
|
|
10511
10522
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
10512
10523
|
return { $loc, token: "" };
|
|
10513
10524
|
});
|
|
10514
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
10525
|
+
var HeregexPart$5 = $TR($EXPECT($R41, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10515
10526
|
return { $loc, token: "" };
|
|
10516
10527
|
});
|
|
10517
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
10528
|
+
var HeregexPart$6 = $TR($EXPECT($R42, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10518
10529
|
return { $loc, token: "\\/" };
|
|
10519
10530
|
});
|
|
10520
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
10531
|
+
var HeregexPart$7 = $TR($EXPECT($R43, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10521
10532
|
return { $loc, token: $0 };
|
|
10522
10533
|
});
|
|
10523
10534
|
var HeregexPart$$ = [HeregexPart$0, HeregexPart$1, HeregexPart$2, HeregexPart$3, HeregexPart$4, HeregexPart$5, HeregexPart$6, HeregexPart$7];
|
|
@@ -10530,7 +10541,7 @@ ${input.slice(result.pos)}
|
|
|
10530
10541
|
function HeregexComment(ctx, state) {
|
|
10531
10542
|
return $EVENT_C(ctx, state, "HeregexComment", HeregexComment$$);
|
|
10532
10543
|
}
|
|
10533
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
10544
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R44, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
10534
10545
|
function RegularExpressionBody(ctx, state) {
|
|
10535
10546
|
return $EVENT(ctx, state, "RegularExpressionBody", RegularExpressionBody$0);
|
|
10536
10547
|
}
|
|
@@ -10540,15 +10551,15 @@ ${input.slice(result.pos)}
|
|
|
10540
10551
|
function RegExpPart(ctx, state) {
|
|
10541
10552
|
return $EVENT_C(ctx, state, "RegExpPart", RegExpPart$$);
|
|
10542
10553
|
}
|
|
10543
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
10554
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R45, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
10544
10555
|
function RegExpCharacter(ctx, state) {
|
|
10545
10556
|
return $EVENT(ctx, state, "RegExpCharacter", RegExpCharacter$0);
|
|
10546
10557
|
}
|
|
10547
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
10558
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R46, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
10548
10559
|
function RegularExpressionFlags(ctx, state) {
|
|
10549
10560
|
return $EVENT(ctx, state, "RegularExpressionFlags", RegularExpressionFlags$0);
|
|
10550
10561
|
}
|
|
10551
|
-
var TemplateLiteral$0 = $T($S($EXPECT($
|
|
10562
|
+
var TemplateLiteral$0 = $T($S($EXPECT($R47, "TemplateLiteral /(?=[`'\"])/"), _TemplateLiteral), function(value) {
|
|
10552
10563
|
return value[1];
|
|
10553
10564
|
});
|
|
10554
10565
|
function TemplateLiteral(ctx, state) {
|
|
@@ -10584,28 +10595,28 @@ ${input.slice(result.pos)}
|
|
|
10584
10595
|
function TemplateSubstitution(ctx, state) {
|
|
10585
10596
|
return $EVENT(ctx, state, "TemplateSubstitution", TemplateSubstitution$0);
|
|
10586
10597
|
}
|
|
10587
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
10598
|
+
var TemplateCharacters$0 = $TR($EXPECT($R48, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10588
10599
|
return { $loc, token: $0 };
|
|
10589
10600
|
});
|
|
10590
10601
|
function TemplateCharacters(ctx, state) {
|
|
10591
10602
|
return $EVENT(ctx, state, "TemplateCharacters", TemplateCharacters$0);
|
|
10592
10603
|
}
|
|
10593
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
10604
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R49, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10594
10605
|
return { $loc, token: $0 };
|
|
10595
10606
|
});
|
|
10596
10607
|
function TemplateBlockCharacters(ctx, state) {
|
|
10597
10608
|
return $EVENT(ctx, state, "TemplateBlockCharacters", TemplateBlockCharacters$0);
|
|
10598
10609
|
}
|
|
10599
|
-
var ReservedWord$0 = $S($R$0($EXPECT($
|
|
10600
|
-
var ReservedWord$1 = $S($R$0($EXPECT($
|
|
10601
|
-
var ReservedWord$2 = $S($R$0($EXPECT($
|
|
10602
|
-
var ReservedWord$3 = $S($R$0($EXPECT($
|
|
10603
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
10610
|
+
var ReservedWord$0 = $S($R$0($EXPECT($R50, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")), CoffeeBooleansEnabled);
|
|
10611
|
+
var ReservedWord$1 = $S($R$0($EXPECT($R51, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")), CoffeeIsntEnabled);
|
|
10612
|
+
var ReservedWord$2 = $S($R$0($EXPECT($R52, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")), CoffeeForLoopsEnabled);
|
|
10613
|
+
var ReservedWord$3 = $S($R$0($EXPECT($R53, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")), CoffeeOfEnabled);
|
|
10614
|
+
var ReservedWord$4 = $R$0($EXPECT($R54, "ReservedWord /(?:and|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|not|null|or|private|protected|public|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
10604
10615
|
var ReservedWord$$ = [ReservedWord$0, ReservedWord$1, ReservedWord$2, ReservedWord$3, ReservedWord$4];
|
|
10605
10616
|
function ReservedWord(ctx, state) {
|
|
10606
10617
|
return $EVENT_C(ctx, state, "ReservedWord", ReservedWord$$);
|
|
10607
10618
|
}
|
|
10608
|
-
var Comment$0 = $T($S($EXPECT($
|
|
10619
|
+
var Comment$0 = $T($S($EXPECT($R55, "Comment /(?=\\/|#)/"), _Comment), function(value) {
|
|
10609
10620
|
return value[1];
|
|
10610
10621
|
});
|
|
10611
10622
|
function Comment(ctx, state) {
|
|
@@ -10623,7 +10634,7 @@ ${input.slice(result.pos)}
|
|
|
10623
10634
|
function SingleLineComment(ctx, state) {
|
|
10624
10635
|
return $EVENT_C(ctx, state, "SingleLineComment", SingleLineComment$$);
|
|
10625
10636
|
}
|
|
10626
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
10637
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R56, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10627
10638
|
return { type: "Comment", $loc, token: $0 };
|
|
10628
10639
|
});
|
|
10629
10640
|
function JSSingleLineComment(ctx, state) {
|
|
@@ -10635,30 +10646,30 @@ ${input.slice(result.pos)}
|
|
|
10635
10646
|
function MultiLineComment(ctx, state) {
|
|
10636
10647
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
10637
10648
|
}
|
|
10638
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
10649
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L109, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L110, 'JSMultiLineComment "*/"')), $EXPECT($R57, "JSMultiLineComment /./"))), $EXPECT($L110, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
10639
10650
|
return { type: "Comment", $loc, token: $1 };
|
|
10640
10651
|
});
|
|
10641
10652
|
function JSMultiLineComment(ctx, state) {
|
|
10642
10653
|
return $EVENT(ctx, state, "JSMultiLineComment", JSMultiLineComment$0);
|
|
10643
10654
|
}
|
|
10644
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
10655
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R58, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10645
10656
|
return { type: "Comment", $loc, token: `//${$1}` };
|
|
10646
10657
|
});
|
|
10647
10658
|
function CoffeeSingleLineComment(ctx, state) {
|
|
10648
10659
|
return $EVENT(ctx, state, "CoffeeSingleLineComment", CoffeeSingleLineComment$0);
|
|
10649
10660
|
}
|
|
10650
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
10661
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R59, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
10651
10662
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
10652
10663
|
return { type: "Comment", $loc, token: `/*${$2}*/` };
|
|
10653
10664
|
});
|
|
10654
10665
|
function CoffeeMultiLineComment(ctx, state) {
|
|
10655
10666
|
return $EVENT(ctx, state, "CoffeeMultiLineComment", CoffeeMultiLineComment$0);
|
|
10656
10667
|
}
|
|
10657
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
10668
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R60, "CoffeeHereCommentStart /###(?!#)/"));
|
|
10658
10669
|
function CoffeeHereCommentStart(ctx, state) {
|
|
10659
10670
|
return $EVENT(ctx, state, "CoffeeHereCommentStart", CoffeeHereCommentStart$0);
|
|
10660
10671
|
}
|
|
10661
|
-
var InlineComment$0 = $TR($EXPECT($
|
|
10672
|
+
var InlineComment$0 = $TR($EXPECT($R61, "InlineComment /\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\//"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10662
10673
|
return { $loc, token: $0 };
|
|
10663
10674
|
});
|
|
10664
10675
|
function InlineComment(ctx, state) {
|
|
@@ -10672,16 +10683,16 @@ ${input.slice(result.pos)}
|
|
|
10672
10683
|
function TrailingComment(ctx, state) {
|
|
10673
10684
|
return $EVENT(ctx, state, "TrailingComment", TrailingComment$0);
|
|
10674
10685
|
}
|
|
10675
|
-
var _$0 = $T($S($EXPECT($
|
|
10686
|
+
var _$0 = $T($S($EXPECT($R62, "_ /(?=[ \\t\\/\\\\])/"), $P($C(NonNewlineWhitespace, InlineComment))), function(value) {
|
|
10676
10687
|
return value[1];
|
|
10677
10688
|
});
|
|
10678
10689
|
function _(ctx, state) {
|
|
10679
10690
|
return $EVENT(ctx, state, "_", _$0);
|
|
10680
10691
|
}
|
|
10681
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
10692
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R63, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10682
10693
|
return { $loc, token: $0 };
|
|
10683
10694
|
});
|
|
10684
|
-
var NonNewlineWhitespace$1 = $T($S($EXPECT($
|
|
10695
|
+
var NonNewlineWhitespace$1 = $T($S($EXPECT($L111, 'NonNewlineWhitespace "\\\\\\\\"'), CoffeeLineContinuationEnabled, EOL), function(value) {
|
|
10685
10696
|
return " ";
|
|
10686
10697
|
});
|
|
10687
10698
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
@@ -10695,7 +10706,7 @@ ${input.slice(result.pos)}
|
|
|
10695
10706
|
function Trimmed_(ctx, state) {
|
|
10696
10707
|
return $EVENT(ctx, state, "Trimmed_", Trimmed_$0);
|
|
10697
10708
|
}
|
|
10698
|
-
var __$0 = $T($S($EXPECT($
|
|
10709
|
+
var __$0 = $T($S($EXPECT($R64, "__ /(?=\\s|\\/|#)/"), $Q($C(Whitespace, Comment))), function(value) {
|
|
10699
10710
|
return value[1];
|
|
10700
10711
|
});
|
|
10701
10712
|
var __$1 = $EXPECT($L0, '__ ""');
|
|
@@ -10703,7 +10714,7 @@ ${input.slice(result.pos)}
|
|
|
10703
10714
|
function __(ctx, state) {
|
|
10704
10715
|
return $EVENT_C(ctx, state, "__", __$$);
|
|
10705
10716
|
}
|
|
10706
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
10717
|
+
var Whitespace$0 = $TR($EXPECT($R41, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10707
10718
|
return { $loc, token: $0 };
|
|
10708
10719
|
});
|
|
10709
10720
|
function Whitespace(ctx, state) {
|
|
@@ -10727,7 +10738,7 @@ ${input.slice(result.pos)}
|
|
|
10727
10738
|
}
|
|
10728
10739
|
var StatementDelimiter$0 = $Y(EOS);
|
|
10729
10740
|
var StatementDelimiter$1 = SemicolonDelimiter;
|
|
10730
|
-
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($
|
|
10741
|
+
var StatementDelimiter$2 = $Y($S($E(_), $C($EXPECT($L26, 'StatementDelimiter "}"'), $EXPECT($L112, 'StatementDelimiter ")"'), $EXPECT($L35, 'StatementDelimiter "]"'))));
|
|
10731
10742
|
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2];
|
|
10732
10743
|
function StatementDelimiter(ctx, state) {
|
|
10733
10744
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
@@ -10741,7 +10752,7 @@ ${input.slice(result.pos)}
|
|
|
10741
10752
|
function SemicolonDelimiter(ctx, state) {
|
|
10742
10753
|
return $EVENT(ctx, state, "SemicolonDelimiter", SemicolonDelimiter$0);
|
|
10743
10754
|
}
|
|
10744
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
10755
|
+
var NonIdContinue$0 = $R$0($EXPECT($R65, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
10745
10756
|
function NonIdContinue(ctx, state) {
|
|
10746
10757
|
return $EVENT(ctx, state, "NonIdContinue", NonIdContinue$0);
|
|
10747
10758
|
}
|
|
@@ -10751,103 +10762,103 @@ ${input.slice(result.pos)}
|
|
|
10751
10762
|
function Loc(ctx, state) {
|
|
10752
10763
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
10753
10764
|
}
|
|
10754
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
10765
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L113, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L12, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
10755
10766
|
return { $loc, token: $1, ts: true };
|
|
10756
10767
|
});
|
|
10757
10768
|
function Abstract(ctx, state) {
|
|
10758
10769
|
return $EVENT(ctx, state, "Abstract", Abstract$0);
|
|
10759
10770
|
}
|
|
10760
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
10771
|
+
var Ampersand$0 = $TV($EXPECT($L98, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
10761
10772
|
return { $loc, token: $1 };
|
|
10762
10773
|
});
|
|
10763
10774
|
function Ampersand(ctx, state) {
|
|
10764
10775
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
10765
10776
|
}
|
|
10766
|
-
var As$0 = $TS($S($EXPECT($
|
|
10777
|
+
var As$0 = $TS($S($EXPECT($L114, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10767
10778
|
return { $loc, token: $1 };
|
|
10768
10779
|
});
|
|
10769
10780
|
function As(ctx, state) {
|
|
10770
10781
|
return $EVENT(ctx, state, "As", As$0);
|
|
10771
10782
|
}
|
|
10772
|
-
var At$0 = $TV($EXPECT($
|
|
10783
|
+
var At$0 = $TV($EXPECT($L115, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
10773
10784
|
return { $loc, token: $1 };
|
|
10774
10785
|
});
|
|
10775
10786
|
function At(ctx, state) {
|
|
10776
10787
|
return $EVENT(ctx, state, "At", At$0);
|
|
10777
10788
|
}
|
|
10778
|
-
var AtAt$0 = $TV($EXPECT($
|
|
10789
|
+
var AtAt$0 = $TV($EXPECT($L116, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
10779
10790
|
return { $loc, token: "@" };
|
|
10780
10791
|
});
|
|
10781
10792
|
function AtAt(ctx, state) {
|
|
10782
10793
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
10783
10794
|
}
|
|
10784
|
-
var Async$0 = $TS($S($EXPECT($
|
|
10795
|
+
var Async$0 = $TS($S($EXPECT($L117, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10785
10796
|
return { $loc, token: $1, type: "Async" };
|
|
10786
10797
|
});
|
|
10787
10798
|
function Async(ctx, state) {
|
|
10788
10799
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
10789
10800
|
}
|
|
10790
|
-
var Await$0 = $TS($S($EXPECT($
|
|
10801
|
+
var Await$0 = $TS($S($EXPECT($L118, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10791
10802
|
return { $loc, token: $1, type: "Await" };
|
|
10792
10803
|
});
|
|
10793
10804
|
function Await(ctx, state) {
|
|
10794
10805
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
10795
10806
|
}
|
|
10796
|
-
var Backtick$0 = $TV($EXPECT($
|
|
10807
|
+
var Backtick$0 = $TV($EXPECT($L119, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
10797
10808
|
return { $loc, token: $1 };
|
|
10798
10809
|
});
|
|
10799
10810
|
function Backtick(ctx, state) {
|
|
10800
10811
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
10801
10812
|
}
|
|
10802
|
-
var By$0 = $TS($S($EXPECT($
|
|
10813
|
+
var By$0 = $TS($S($EXPECT($L120, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10803
10814
|
return { $loc, token: $1 };
|
|
10804
10815
|
});
|
|
10805
10816
|
function By(ctx, state) {
|
|
10806
10817
|
return $EVENT(ctx, state, "By", By$0);
|
|
10807
10818
|
}
|
|
10808
|
-
var Case$0 = $TS($S($EXPECT($
|
|
10819
|
+
var Case$0 = $TS($S($EXPECT($L121, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10809
10820
|
return { $loc, token: $1 };
|
|
10810
10821
|
});
|
|
10811
10822
|
function Case(ctx, state) {
|
|
10812
10823
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
10813
10824
|
}
|
|
10814
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
10825
|
+
var Catch$0 = $TS($S($EXPECT($L122, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10815
10826
|
return { $loc, token: $1 };
|
|
10816
10827
|
});
|
|
10817
10828
|
function Catch(ctx, state) {
|
|
10818
10829
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
10819
10830
|
}
|
|
10820
|
-
var Class$0 = $TS($S($EXPECT($
|
|
10831
|
+
var Class$0 = $TS($S($EXPECT($L123, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10821
10832
|
return { $loc, token: $1 };
|
|
10822
10833
|
});
|
|
10823
10834
|
function Class(ctx, state) {
|
|
10824
10835
|
return $EVENT(ctx, state, "Class", Class$0);
|
|
10825
10836
|
}
|
|
10826
|
-
var CloseAngleBracket$0 = $TV($EXPECT($
|
|
10837
|
+
var CloseAngleBracket$0 = $TV($EXPECT($L34, 'CloseAngleBracket ">"'), function($skip, $loc, $0, $1) {
|
|
10827
10838
|
return { $loc, token: $1 };
|
|
10828
10839
|
});
|
|
10829
10840
|
function CloseAngleBracket(ctx, state) {
|
|
10830
10841
|
return $EVENT(ctx, state, "CloseAngleBracket", CloseAngleBracket$0);
|
|
10831
10842
|
}
|
|
10832
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
10843
|
+
var CloseBrace$0 = $TV($EXPECT($L26, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
10833
10844
|
return { $loc, token: $1 };
|
|
10834
10845
|
});
|
|
10835
10846
|
function CloseBrace(ctx, state) {
|
|
10836
10847
|
return $EVENT(ctx, state, "CloseBrace", CloseBrace$0);
|
|
10837
10848
|
}
|
|
10838
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
10849
|
+
var CloseBracket$0 = $TV($EXPECT($L35, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
10839
10850
|
return { $loc, token: $1 };
|
|
10840
10851
|
});
|
|
10841
10852
|
function CloseBracket(ctx, state) {
|
|
10842
10853
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
10843
10854
|
}
|
|
10844
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
10855
|
+
var CloseParen$0 = $TV($EXPECT($L112, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
10845
10856
|
return { $loc, token: $1 };
|
|
10846
10857
|
});
|
|
10847
10858
|
function CloseParen(ctx, state) {
|
|
10848
10859
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
10849
10860
|
}
|
|
10850
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
10861
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L124, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
10851
10862
|
return { $loc, token: "${" };
|
|
10852
10863
|
});
|
|
10853
10864
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
@@ -10859,37 +10870,37 @@ ${input.slice(result.pos)}
|
|
|
10859
10870
|
function Colon(ctx, state) {
|
|
10860
10871
|
return $EVENT(ctx, state, "Colon", Colon$0);
|
|
10861
10872
|
}
|
|
10862
|
-
var Comma$0 = $TV($EXPECT($
|
|
10873
|
+
var Comma$0 = $TV($EXPECT($L22, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
10863
10874
|
return { $loc, token: $1 };
|
|
10864
10875
|
});
|
|
10865
10876
|
function Comma(ctx, state) {
|
|
10866
10877
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
10867
10878
|
}
|
|
10868
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
10879
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L115, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
10869
10880
|
return { $loc, token: "constructor" };
|
|
10870
10881
|
});
|
|
10871
10882
|
function ConstructorShorthand(ctx, state) {
|
|
10872
10883
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
10873
10884
|
}
|
|
10874
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
10885
|
+
var Declare$0 = $TS($S($EXPECT($L125, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10875
10886
|
return { $loc, token: $1 };
|
|
10876
10887
|
});
|
|
10877
10888
|
function Declare(ctx, state) {
|
|
10878
10889
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
10879
10890
|
}
|
|
10880
|
-
var Default$0 = $TS($S($EXPECT($
|
|
10891
|
+
var Default$0 = $TS($S($EXPECT($L126, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10881
10892
|
return { $loc, token: $1 };
|
|
10882
10893
|
});
|
|
10883
10894
|
function Default(ctx, state) {
|
|
10884
10895
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
10885
10896
|
}
|
|
10886
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
10897
|
+
var Delete$0 = $TS($S($EXPECT($L127, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10887
10898
|
return { $loc, token: $1 };
|
|
10888
10899
|
});
|
|
10889
10900
|
function Delete(ctx, state) {
|
|
10890
10901
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
10891
10902
|
}
|
|
10892
|
-
var Do$0 = $TS($S($EXPECT($
|
|
10903
|
+
var Do$0 = $TS($S($EXPECT($L128, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10893
10904
|
return { $loc, token: $1 };
|
|
10894
10905
|
});
|
|
10895
10906
|
function Do(ctx, state) {
|
|
@@ -10898,7 +10909,7 @@ ${input.slice(result.pos)}
|
|
|
10898
10909
|
var Dot$0 = $TV($EXPECT($L6, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
10899
10910
|
return { $loc, token: $1 };
|
|
10900
10911
|
});
|
|
10901
|
-
var Dot$1 = $TS($S($EXPECT($
|
|
10912
|
+
var Dot$1 = $TS($S($EXPECT($R66, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
|
|
10902
10913
|
var ws = $2;
|
|
10903
10914
|
return [
|
|
10904
10915
|
{ $loc, token: "." },
|
|
@@ -10909,45 +10920,45 @@ ${input.slice(result.pos)}
|
|
|
10909
10920
|
function Dot(ctx, state) {
|
|
10910
10921
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
10911
10922
|
}
|
|
10912
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
10923
|
+
var DotDot$0 = $TS($S($EXPECT($L129, 'DotDot ".."'), $N($EXPECT($L6, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
10913
10924
|
return { $loc, token: $1 };
|
|
10914
10925
|
});
|
|
10915
|
-
var DotDot$1 = $TV($EXPECT($
|
|
10926
|
+
var DotDot$1 = $TV($EXPECT($L130, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
10916
10927
|
return { $loc, token: ".." };
|
|
10917
10928
|
});
|
|
10918
10929
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
10919
10930
|
function DotDot(ctx, state) {
|
|
10920
10931
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
10921
10932
|
}
|
|
10922
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
10933
|
+
var DotDotDot$0 = $TV($EXPECT($L131, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
10923
10934
|
return { $loc, token: $1 };
|
|
10924
10935
|
});
|
|
10925
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
10936
|
+
var DotDotDot$1 = $TV($EXPECT($L132, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
10926
10937
|
return { $loc, token: "..." };
|
|
10927
10938
|
});
|
|
10928
10939
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
10929
10940
|
function DotDotDot(ctx, state) {
|
|
10930
10941
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
10931
10942
|
}
|
|
10932
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
10943
|
+
var DoubleColon$0 = $TV($EXPECT($L133, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
10933
10944
|
return { $loc, token: $1 };
|
|
10934
10945
|
});
|
|
10935
10946
|
function DoubleColon(ctx, state) {
|
|
10936
10947
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
10937
10948
|
}
|
|
10938
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
10949
|
+
var DoubleQuote$0 = $TV($EXPECT($L134, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
10939
10950
|
return { $loc, token: $1 };
|
|
10940
10951
|
});
|
|
10941
10952
|
function DoubleQuote(ctx, state) {
|
|
10942
10953
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
10943
10954
|
}
|
|
10944
|
-
var Each$0 = $TS($S($EXPECT($
|
|
10955
|
+
var Each$0 = $TS($S($EXPECT($L135, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10945
10956
|
return { $loc, token: $1 };
|
|
10946
10957
|
});
|
|
10947
10958
|
function Each(ctx, state) {
|
|
10948
10959
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
10949
10960
|
}
|
|
10950
|
-
var Else$0 = $TS($S($EXPECT($
|
|
10961
|
+
var Else$0 = $TS($S($EXPECT($L136, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10951
10962
|
return { $loc, token: $1 };
|
|
10952
10963
|
});
|
|
10953
10964
|
function Else(ctx, state) {
|
|
@@ -10959,85 +10970,85 @@ ${input.slice(result.pos)}
|
|
|
10959
10970
|
function Equals(ctx, state) {
|
|
10960
10971
|
return $EVENT(ctx, state, "Equals", Equals$0);
|
|
10961
10972
|
}
|
|
10962
|
-
var Export$0 = $TS($S($EXPECT($
|
|
10973
|
+
var Export$0 = $TS($S($EXPECT($L137, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10963
10974
|
return { $loc, token: $1 };
|
|
10964
10975
|
});
|
|
10965
10976
|
function Export(ctx, state) {
|
|
10966
10977
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
10967
10978
|
}
|
|
10968
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
10979
|
+
var Extends$0 = $TS($S($EXPECT($L138, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10969
10980
|
return { $loc, token: $1 };
|
|
10970
10981
|
});
|
|
10971
10982
|
function Extends(ctx, state) {
|
|
10972
10983
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
10973
10984
|
}
|
|
10974
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
10985
|
+
var Finally$0 = $TS($S($EXPECT($L139, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10975
10986
|
return { $loc, token: $1 };
|
|
10976
10987
|
});
|
|
10977
10988
|
function Finally(ctx, state) {
|
|
10978
10989
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
10979
10990
|
}
|
|
10980
|
-
var For$0 = $TS($S($EXPECT($
|
|
10991
|
+
var For$0 = $TS($S($EXPECT($L140, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10981
10992
|
return { $loc, token: $1 };
|
|
10982
10993
|
});
|
|
10983
10994
|
function For(ctx, state) {
|
|
10984
10995
|
return $EVENT(ctx, state, "For", For$0);
|
|
10985
10996
|
}
|
|
10986
|
-
var From$0 = $TS($S($EXPECT($
|
|
10997
|
+
var From$0 = $TS($S($EXPECT($L141, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10987
10998
|
return { $loc, token: $1 };
|
|
10988
10999
|
});
|
|
10989
11000
|
function From(ctx, state) {
|
|
10990
11001
|
return $EVENT(ctx, state, "From", From$0);
|
|
10991
11002
|
}
|
|
10992
|
-
var Function$0 = $TS($S($EXPECT($
|
|
11003
|
+
var Function$0 = $TS($S($EXPECT($L142, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10993
11004
|
return { $loc, token: $1 };
|
|
10994
11005
|
});
|
|
10995
11006
|
function Function(ctx, state) {
|
|
10996
11007
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
10997
11008
|
}
|
|
10998
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
11009
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L143, 'GetOrSet "get"'), $EXPECT($L144, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10999
11010
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
11000
11011
|
});
|
|
11001
11012
|
function GetOrSet(ctx, state) {
|
|
11002
11013
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
11003
11014
|
}
|
|
11004
|
-
var Hash$0 = $TV($EXPECT($
|
|
11015
|
+
var Hash$0 = $TV($EXPECT($L145, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
11005
11016
|
return { $loc, token: $1 };
|
|
11006
11017
|
});
|
|
11007
11018
|
function Hash(ctx, state) {
|
|
11008
11019
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
11009
11020
|
}
|
|
11010
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
11021
|
+
var If$0 = $TV($TEXT($S($EXPECT($L146, 'If "if"'), NonIdContinue, $E($EXPECT($L12, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
11011
11022
|
return { $loc, token: $1 };
|
|
11012
11023
|
});
|
|
11013
11024
|
function If(ctx, state) {
|
|
11014
11025
|
return $EVENT(ctx, state, "If", If$0);
|
|
11015
11026
|
}
|
|
11016
|
-
var Import$0 = $TS($S($EXPECT($
|
|
11027
|
+
var Import$0 = $TS($S($EXPECT($L16, 'Import "import"'), $Y($EXPECT($R67, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
11017
11028
|
return { $loc, token: $1 };
|
|
11018
11029
|
});
|
|
11019
11030
|
function Import(ctx, state) {
|
|
11020
11031
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
11021
11032
|
}
|
|
11022
|
-
var In$0 = $TS($S($EXPECT($
|
|
11033
|
+
var In$0 = $TS($S($EXPECT($L147, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11023
11034
|
return { $loc, token: $1 };
|
|
11024
11035
|
});
|
|
11025
11036
|
function In(ctx, state) {
|
|
11026
11037
|
return $EVENT(ctx, state, "In", In$0);
|
|
11027
11038
|
}
|
|
11028
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
11039
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L148, 'LetOrConst "let"'), $EXPECT($L149, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11029
11040
|
return { $loc, token: $1 };
|
|
11030
11041
|
});
|
|
11031
11042
|
function LetOrConst(ctx, state) {
|
|
11032
11043
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
11033
11044
|
}
|
|
11034
|
-
var Const$0 = $TS($S($EXPECT($
|
|
11045
|
+
var Const$0 = $TS($S($EXPECT($L149, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11035
11046
|
return { $loc, token: $1 };
|
|
11036
11047
|
});
|
|
11037
11048
|
function Const(ctx, state) {
|
|
11038
11049
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
11039
11050
|
}
|
|
11040
|
-
var Is$0 = $TS($S($EXPECT($
|
|
11051
|
+
var Is$0 = $TS($S($EXPECT($L150, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11041
11052
|
return { $loc, token: $1 };
|
|
11042
11053
|
});
|
|
11043
11054
|
function Is(ctx, state) {
|
|
@@ -11049,31 +11060,31 @@ ${input.slice(result.pos)}
|
|
|
11049
11060
|
function LetOrConstOrVar(ctx, state) {
|
|
11050
11061
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
11051
11062
|
}
|
|
11052
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
11063
|
+
var Loop$0 = $TS($S($EXPECT($L151, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11053
11064
|
return { $loc, token: "while(true)" };
|
|
11054
11065
|
});
|
|
11055
11066
|
function Loop(ctx, state) {
|
|
11056
11067
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
11057
11068
|
}
|
|
11058
|
-
var New$0 = $TS($S($EXPECT($
|
|
11069
|
+
var New$0 = $TS($S($EXPECT($L152, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11059
11070
|
return { $loc, token: $1 };
|
|
11060
11071
|
});
|
|
11061
11072
|
function New(ctx, state) {
|
|
11062
11073
|
return $EVENT(ctx, state, "New", New$0);
|
|
11063
11074
|
}
|
|
11064
|
-
var Not$0 = $TS($S($EXPECT($
|
|
11075
|
+
var Not$0 = $TS($S($EXPECT($L153, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L11, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
11065
11076
|
return { $loc, token: "!" };
|
|
11066
11077
|
});
|
|
11067
11078
|
function Not(ctx, state) {
|
|
11068
11079
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
11069
11080
|
}
|
|
11070
|
-
var Of$0 = $TS($S($EXPECT($
|
|
11081
|
+
var Of$0 = $TS($S($EXPECT($L154, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11071
11082
|
return { $loc, token: $1 };
|
|
11072
11083
|
});
|
|
11073
11084
|
function Of(ctx, state) {
|
|
11074
11085
|
return $EVENT(ctx, state, "Of", Of$0);
|
|
11075
11086
|
}
|
|
11076
|
-
var OpenAngleBracket$0 = $TV($EXPECT($
|
|
11087
|
+
var OpenAngleBracket$0 = $TV($EXPECT($L13, 'OpenAngleBracket "<"'), function($skip, $loc, $0, $1) {
|
|
11077
11088
|
return { $loc, token: $1 };
|
|
11078
11089
|
});
|
|
11079
11090
|
function OpenAngleBracket(ctx, state) {
|
|
@@ -11164,7 +11175,7 @@ ${input.slice(result.pos)}
|
|
|
11164
11175
|
function Satisfies(ctx, state) {
|
|
11165
11176
|
return $EVENT(ctx, state, "Satisfies", Satisfies$0);
|
|
11166
11177
|
}
|
|
11167
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
11178
|
+
var Semicolon$0 = $TV($EXPECT($L100, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
11168
11179
|
return { $loc, token: $1 };
|
|
11169
11180
|
});
|
|
11170
11181
|
function Semicolon(ctx, state) {
|
|
@@ -11176,7 +11187,7 @@ ${input.slice(result.pos)}
|
|
|
11176
11187
|
function SingleQuote(ctx, state) {
|
|
11177
11188
|
return $EVENT(ctx, state, "SingleQuote", SingleQuote$0);
|
|
11178
11189
|
}
|
|
11179
|
-
var Star$0 = $TV($EXPECT($
|
|
11190
|
+
var Star$0 = $TV($EXPECT($L55, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
11180
11191
|
return { $loc, token: $1 };
|
|
11181
11192
|
});
|
|
11182
11193
|
function Star(ctx, state) {
|
|
@@ -11185,7 +11196,7 @@ ${input.slice(result.pos)}
|
|
|
11185
11196
|
var Static$0 = $TS($S($EXPECT($L171, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
11186
11197
|
return { $loc, token: $1 };
|
|
11187
11198
|
});
|
|
11188
|
-
var Static$1 = $TS($S($EXPECT($
|
|
11199
|
+
var Static$1 = $TS($S($EXPECT($L115, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L115, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
11189
11200
|
return { $loc, token: "static " };
|
|
11190
11201
|
});
|
|
11191
11202
|
var Static$$ = [Static$0, Static$1];
|
|
@@ -11341,7 +11352,7 @@ ${input.slice(result.pos)}
|
|
|
11341
11352
|
function JSXImplicitFragment(ctx, state) {
|
|
11342
11353
|
return $EVENT(ctx, state, "JSXImplicitFragment", JSXImplicitFragment$0);
|
|
11343
11354
|
}
|
|
11344
|
-
var JSXTag$0 = $T($S($EXPECT($
|
|
11355
|
+
var JSXTag$0 = $T($S($EXPECT($R68, "JSXTag /(?=[<])/"), _JSXTag), function(value) {
|
|
11345
11356
|
return value[1];
|
|
11346
11357
|
});
|
|
11347
11358
|
function JSXTag(ctx, state) {
|
|
@@ -11391,7 +11402,7 @@ ${input.slice(result.pos)}
|
|
|
11391
11402
|
function JSXElement(ctx, state) {
|
|
11392
11403
|
return $EVENT_C(ctx, state, "JSXElement", JSXElement$$);
|
|
11393
11404
|
}
|
|
11394
|
-
var JSXSelfClosingElement$0 = $TS($S($EXPECT($
|
|
11405
|
+
var JSXSelfClosingElement$0 = $TS($S($EXPECT($L13, 'JSXSelfClosingElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L193, 'JSXSelfClosingElement "/>"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
11395
11406
|
return { type: "JSXElement", children: $0, tag: $2 };
|
|
11396
11407
|
});
|
|
11397
11408
|
function JSXSelfClosingElement(ctx, state) {
|
|
@@ -11410,7 +11421,7 @@ ${input.slice(result.pos)}
|
|
|
11410
11421
|
function PopJSXStack(ctx, state) {
|
|
11411
11422
|
return $EVENT(ctx, state, "PopJSXStack", PopJSXStack$0);
|
|
11412
11423
|
}
|
|
11413
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
11424
|
+
var JSXOpeningElement$0 = $S($EXPECT($L13, 'JSXOpeningElement "<"'), JSXElementName, $E(TypeArguments), $E(JSXAttributes), $E(Whitespace), $EXPECT($L34, 'JSXOpeningElement ">"'));
|
|
11414
11425
|
function JSXOpeningElement(ctx, state) {
|
|
11415
11426
|
return $EVENT(ctx, state, "JSXOpeningElement", JSXOpeningElement$0);
|
|
11416
11427
|
}
|
|
@@ -11425,7 +11436,7 @@ ${input.slice(result.pos)}
|
|
|
11425
11436
|
function JSXOptionalClosingElement(ctx, state) {
|
|
11426
11437
|
return $EVENT_C(ctx, state, "JSXOptionalClosingElement", JSXOptionalClosingElement$$);
|
|
11427
11438
|
}
|
|
11428
|
-
var JSXClosingElement$0 = $S($EXPECT($L194, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($
|
|
11439
|
+
var JSXClosingElement$0 = $S($EXPECT($L194, 'JSXClosingElement "</"'), $E(Whitespace), JSXElementName, $E(Whitespace), $EXPECT($L34, 'JSXClosingElement ">"'));
|
|
11429
11440
|
function JSXClosingElement(ctx, state) {
|
|
11430
11441
|
return $EVENT(ctx, state, "JSXClosingElement", JSXClosingElement$0);
|
|
11431
11442
|
}
|
|
@@ -11480,7 +11491,7 @@ ${input.slice(result.pos)}
|
|
|
11480
11491
|
function JSXClosingFragment(ctx, state) {
|
|
11481
11492
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
11482
11493
|
}
|
|
11483
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
11494
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L145, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
11484
11495
|
return module.config.defaultElement;
|
|
11485
11496
|
});
|
|
11486
11497
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -11488,7 +11499,7 @@ ${input.slice(result.pos)}
|
|
|
11488
11499
|
function JSXElementName(ctx, state) {
|
|
11489
11500
|
return $EVENT_C(ctx, state, "JSXElementName", JSXElementName$$);
|
|
11490
11501
|
}
|
|
11491
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
11502
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R69, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
11492
11503
|
function JSXIdentifierName(ctx, state) {
|
|
11493
11504
|
return $EVENT(ctx, state, "JSXIdentifierName", JSXIdentifierName$0);
|
|
11494
11505
|
}
|
|
@@ -11652,7 +11663,7 @@ ${input.slice(result.pos)}
|
|
|
11652
11663
|
}
|
|
11653
11664
|
return $skip;
|
|
11654
11665
|
});
|
|
11655
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
11666
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L145, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
11656
11667
|
return [" ", "id=", $2];
|
|
11657
11668
|
});
|
|
11658
11669
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -11671,11 +11682,11 @@ ${input.slice(result.pos)}
|
|
|
11671
11682
|
function JSXAttribute(ctx, state) {
|
|
11672
11683
|
return $EVENT_C(ctx, state, "JSXAttribute", JSXAttribute$$);
|
|
11673
11684
|
}
|
|
11674
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
11685
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R70, "JSXAttributeSpace /[\\s>]|\\/>/"));
|
|
11675
11686
|
function JSXAttributeSpace(ctx, state) {
|
|
11676
11687
|
return $EVENT(ctx, state, "JSXAttributeSpace", JSXAttributeSpace$0);
|
|
11677
11688
|
}
|
|
11678
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
11689
|
+
var JSXShorthandString$0 = $TR($EXPECT($R71, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11679
11690
|
return quoteString($0);
|
|
11680
11691
|
});
|
|
11681
11692
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -11709,7 +11720,7 @@ ${input.slice(result.pos)}
|
|
|
11709
11720
|
}
|
|
11710
11721
|
return [open, value, close];
|
|
11711
11722
|
});
|
|
11712
|
-
var JSXAttributeValue$4 = $R$0($EXPECT($
|
|
11723
|
+
var JSXAttributeValue$4 = $R$0($EXPECT($R72, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
|
|
11713
11724
|
var JSXAttributeValue$$ = [JSXAttributeValue$0, JSXAttributeValue$1, JSXAttributeValue$2, JSXAttributeValue$3, JSXAttributeValue$4];
|
|
11714
11725
|
function JSXAttributeValue(ctx, state) {
|
|
11715
11726
|
return $EVENT_C(ctx, state, "JSXAttributeValue", JSXAttributeValue$$);
|
|
@@ -11722,7 +11733,7 @@ ${input.slice(result.pos)}
|
|
|
11722
11733
|
function InlineJSXAttributeValue(ctx, state) {
|
|
11723
11734
|
return $EVENT(ctx, state, "InlineJSXAttributeValue", InlineJSXAttributeValue$0);
|
|
11724
11735
|
}
|
|
11725
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
11736
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R73, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
11726
11737
|
var op = $2;
|
|
11727
11738
|
var rhs = $3;
|
|
11728
11739
|
return [[], op, [], rhs];
|
|
@@ -11739,7 +11750,7 @@ ${input.slice(result.pos)}
|
|
|
11739
11750
|
function InlineJSXUnaryExpression(ctx, state) {
|
|
11740
11751
|
return $EVENT(ctx, state, "InlineJSXUnaryExpression", InlineJSXUnaryExpression$0);
|
|
11741
11752
|
}
|
|
11742
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
11753
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R74, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11743
11754
|
return { $loc, token: $0 };
|
|
11744
11755
|
});
|
|
11745
11756
|
function InlineJSXUnaryOp(ctx, state) {
|
|
@@ -11771,7 +11782,7 @@ ${input.slice(result.pos)}
|
|
|
11771
11782
|
]
|
|
11772
11783
|
});
|
|
11773
11784
|
});
|
|
11774
|
-
var InlineJSXCallExpression$1 = $TS($S($EXPECT($
|
|
11785
|
+
var InlineJSXCallExpression$1 = $TS($S($EXPECT($L16, 'InlineJSXCallExpression "import"'), ExplicitArguments, $Q(InlineJSXCallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
11775
11786
|
var args = $2;
|
|
11776
11787
|
var rest = $3;
|
|
11777
11788
|
return processCallMemberExpression({
|
|
@@ -11890,7 +11901,7 @@ ${input.slice(result.pos)}
|
|
|
11890
11901
|
}
|
|
11891
11902
|
return $skip;
|
|
11892
11903
|
});
|
|
11893
|
-
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($
|
|
11904
|
+
var JSXNestedChildren$1 = $TV($Y($C(JSXEOS, $EXPECT($L26, 'JSXNestedChildren "}"'), JSXClosingElement, JSXClosingFragment)), function($skip, $loc, $0, $1) {
|
|
11894
11905
|
return { children: [], jsxChildren: [] };
|
|
11895
11906
|
});
|
|
11896
11907
|
var JSXNestedChildren$$ = [JSXNestedChildren$0, JSXNestedChildren$1];
|
|
@@ -11951,13 +11962,13 @@ ${input.slice(result.pos)}
|
|
|
11951
11962
|
function JSXComment(ctx, state) {
|
|
11952
11963
|
return $EVENT(ctx, state, "JSXComment", JSXComment$0);
|
|
11953
11964
|
}
|
|
11954
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
11965
|
+
var JSXCommentContent$0 = $TR($EXPECT($R75, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11955
11966
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
11956
11967
|
});
|
|
11957
11968
|
function JSXCommentContent(ctx, state) {
|
|
11958
11969
|
return $EVENT(ctx, state, "JSXCommentContent", JSXCommentContent$0);
|
|
11959
11970
|
}
|
|
11960
|
-
var JSXText$0 = $TR($EXPECT($
|
|
11971
|
+
var JSXText$0 = $TR($EXPECT($R76, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11961
11972
|
return {
|
|
11962
11973
|
type: "JSXText",
|
|
11963
11974
|
token: $0,
|
|
@@ -12322,7 +12333,7 @@ ${input.slice(result.pos)}
|
|
|
12322
12333
|
function TypeProperty(ctx, state) {
|
|
12323
12334
|
return $EVENT(ctx, state, "TypeProperty", TypeProperty$0);
|
|
12324
12335
|
}
|
|
12325
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
12336
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R77, "TypeIndexSignature /[+-]?/")), Readonly, NotDedented)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R78, "TypeIndexSignature /[+-]/")), $Y($S($E(_), QuestionMark)))));
|
|
12326
12337
|
function TypeIndexSignature(ctx, state) {
|
|
12327
12338
|
return $EVENT(ctx, state, "TypeIndexSignature", TypeIndexSignature$0);
|
|
12328
12339
|
}
|
|
@@ -12373,7 +12384,7 @@ ${input.slice(result.pos)}
|
|
|
12373
12384
|
function ReturnType(ctx, state) {
|
|
12374
12385
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
12375
12386
|
}
|
|
12376
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
12387
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L150, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
12377
12388
|
var lhs = $1;
|
|
12378
12389
|
var rhs = $2;
|
|
12379
12390
|
if (!rhs)
|
|
@@ -12474,8 +12485,8 @@ ${input.slice(result.pos)}
|
|
|
12474
12485
|
function TypePrimary(ctx, state) {
|
|
12475
12486
|
return $EVENT_C(ctx, state, "TypePrimary", TypePrimary$$);
|
|
12476
12487
|
}
|
|
12477
|
-
var ImportType$0 = $S($EXPECT($
|
|
12478
|
-
var ImportType$1 = $S($EXPECT($
|
|
12488
|
+
var ImportType$0 = $S($EXPECT($L16, 'ImportType "import"'), OpenParen, __, StringLiteral, __, CloseParen, $E($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
12489
|
+
var ImportType$1 = $S($EXPECT($L16, 'ImportType "import"'), InsertOpenParen, Trimmed_, StringLiteral, InsertCloseParen);
|
|
12479
12490
|
var ImportType$$ = [ImportType$0, ImportType$1];
|
|
12480
12491
|
function ImportType(ctx, state) {
|
|
12481
12492
|
return $EVENT_C(ctx, state, "ImportType", ImportType$$);
|
|
@@ -12535,7 +12546,7 @@ ${input.slice(result.pos)}
|
|
|
12535
12546
|
function NestedType(ctx, state) {
|
|
12536
12547
|
return $EVENT(ctx, state, "NestedType", NestedType$0);
|
|
12537
12548
|
}
|
|
12538
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
12549
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L138, 'TypeConditional "extends"'), NonIdContinue, Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
12539
12550
|
if ($2)
|
|
12540
12551
|
return $0;
|
|
12541
12552
|
return $1;
|
|
@@ -12595,16 +12606,16 @@ ${input.slice(result.pos)}
|
|
|
12595
12606
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
12596
12607
|
return value[1];
|
|
12597
12608
|
});
|
|
12598
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($
|
|
12609
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L112, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L35, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L26, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
12599
12610
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
12600
12611
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
12601
12612
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
12602
12613
|
return $EVENT_C(ctx, state, "InlineInterfacePropertyDelimiter", InlineInterfacePropertyDelimiter$$);
|
|
12603
12614
|
}
|
|
12604
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
12615
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L99, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
12605
12616
|
return { $loc, token: "|" };
|
|
12606
12617
|
});
|
|
12607
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
12618
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L98, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
12608
12619
|
return { $loc, token: "&" };
|
|
12609
12620
|
});
|
|
12610
12621
|
var TypeBinaryOp$$ = [TypeBinaryOp$0, TypeBinaryOp$1];
|
|
@@ -12621,7 +12632,7 @@ ${input.slice(result.pos)}
|
|
|
12621
12632
|
function FunctionType(ctx, state) {
|
|
12622
12633
|
return $EVENT(ctx, state, "FunctionType", FunctionType$0);
|
|
12623
12634
|
}
|
|
12624
|
-
var TypeArrowFunction$0 = $TV($C($EXPECT($L9, 'TypeArrowFunction "=>"'), $EXPECT($L10, 'TypeArrowFunction "\u21D2"'), $EXPECT($
|
|
12635
|
+
var TypeArrowFunction$0 = $TV($C($EXPECT($L9, 'TypeArrowFunction "=>"'), $EXPECT($L10, 'TypeArrowFunction "\u21D2"'), $EXPECT($L24, 'TypeArrowFunction "->"'), $EXPECT($L25, 'TypeArrowFunction "\u2192"')), function($skip, $loc, $0, $1) {
|
|
12625
12636
|
return { $loc, token: "=>" };
|
|
12626
12637
|
});
|
|
12627
12638
|
function TypeArrowFunction(ctx, state) {
|
|
@@ -12659,11 +12670,11 @@ ${input.slice(result.pos)}
|
|
|
12659
12670
|
function TypeParameters(ctx, state) {
|
|
12660
12671
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
12661
12672
|
}
|
|
12662
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
12673
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L149, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
12663
12674
|
function TypeParameter(ctx, state) {
|
|
12664
12675
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
12665
12676
|
}
|
|
12666
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
12677
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L138, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
12667
12678
|
function TypeConstraint(ctx, state) {
|
|
12668
12679
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
12669
12680
|
}
|
|
@@ -12672,7 +12683,7 @@ ${input.slice(result.pos)}
|
|
|
12672
12683
|
return $EVENT(ctx, state, "TypeInitializer", TypeInitializer$0);
|
|
12673
12684
|
}
|
|
12674
12685
|
var TypeParameterDelimiter$0 = $S($E(_), Comma);
|
|
12675
|
-
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($
|
|
12686
|
+
var TypeParameterDelimiter$1 = $Y($S(__, $EXPECT($L34, 'TypeParameterDelimiter ">"')));
|
|
12676
12687
|
var TypeParameterDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
12677
12688
|
return value[1];
|
|
12678
12689
|
});
|
|
@@ -12686,15 +12697,15 @@ ${input.slice(result.pos)}
|
|
|
12686
12697
|
function ThisType(ctx, state) {
|
|
12687
12698
|
return $EVENT(ctx, state, "ThisType", ThisType$0);
|
|
12688
12699
|
}
|
|
12689
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
12700
|
+
var Shebang$0 = $S($R$0($EXPECT($R79, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
12690
12701
|
function Shebang(ctx, state) {
|
|
12691
12702
|
return $EVENT(ctx, state, "Shebang", Shebang$0);
|
|
12692
12703
|
}
|
|
12693
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
12704
|
+
var CivetPrologue$0 = $T($S($EXPECT($R80, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, SimpleStatementDelimiter, $EXPECT($R81, "CivetPrologue /[ \\t]*/"), $C(EOL, $Y(RestOfLine))), function(value) {
|
|
12694
12705
|
var content = value[2];
|
|
12695
12706
|
return content;
|
|
12696
12707
|
});
|
|
12697
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
12708
|
+
var CivetPrologue$1 = $T($S($EXPECT($R80, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, SimpleStatementDelimiter, $EXPECT($R81, "CivetPrologue /[ \\t]*/"), $C(EOL, $Y(RestOfLine))), function(value) {
|
|
12698
12709
|
var content = value[2];
|
|
12699
12710
|
return content;
|
|
12700
12711
|
});
|
|
@@ -12702,7 +12713,7 @@ ${input.slice(result.pos)}
|
|
|
12702
12713
|
function CivetPrologue(ctx, state) {
|
|
12703
12714
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
12704
12715
|
}
|
|
12705
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($
|
|
12716
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R82, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
12706
12717
|
var options = $3;
|
|
12707
12718
|
return {
|
|
12708
12719
|
type: "CivetPrologue",
|
|
@@ -12713,7 +12724,7 @@ ${input.slice(result.pos)}
|
|
|
12713
12724
|
function CivetPrologueContent(ctx, state) {
|
|
12714
12725
|
return $EVENT(ctx, state, "CivetPrologueContent", CivetPrologueContent$0);
|
|
12715
12726
|
}
|
|
12716
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
12727
|
+
var CivetOption$0 = $TR($EXPECT($R83, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12717
12728
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
12718
12729
|
if (l)
|
|
12719
12730
|
return l.toUpperCase();
|
|
@@ -12730,11 +12741,11 @@ ${input.slice(result.pos)}
|
|
|
12730
12741
|
function CivetOption(ctx, state) {
|
|
12731
12742
|
return $EVENT(ctx, state, "CivetOption", CivetOption$0);
|
|
12732
12743
|
}
|
|
12733
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
12744
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R80, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
12734
12745
|
function UnknownPrologue(ctx, state) {
|
|
12735
12746
|
return $EVENT(ctx, state, "UnknownPrologue", UnknownPrologue$0);
|
|
12736
12747
|
}
|
|
12737
|
-
var TripleSlashDirective$0 = $S($R$0($EXPECT($
|
|
12748
|
+
var TripleSlashDirective$0 = $S($R$0($EXPECT($R84, "TripleSlashDirective /\\/\\/\\/[^\\r\\n]*/")), $E(EOS));
|
|
12738
12749
|
function TripleSlashDirective(ctx, state) {
|
|
12739
12750
|
return $EVENT(ctx, state, "TripleSlashDirective", TripleSlashDirective$0);
|
|
12740
12751
|
}
|
|
@@ -12748,13 +12759,13 @@ ${input.slice(result.pos)}
|
|
|
12748
12759
|
function PrologueString(ctx, state) {
|
|
12749
12760
|
return $EVENT_C(ctx, state, "PrologueString", PrologueString$$);
|
|
12750
12761
|
}
|
|
12751
|
-
var EOS$0 = $T($S($EXPECT($
|
|
12762
|
+
var EOS$0 = $T($S($EXPECT($R85, "EOS /(?=[ \\t\\r\\n\\/#]|$)/"), $P(RestOfLine)), function(value) {
|
|
12752
12763
|
return value[1];
|
|
12753
12764
|
});
|
|
12754
12765
|
function EOS(ctx, state) {
|
|
12755
12766
|
return $EVENT(ctx, state, "EOS", EOS$0);
|
|
12756
12767
|
}
|
|
12757
|
-
var EOL$0 = $TR($EXPECT($
|
|
12768
|
+
var EOL$0 = $TR($EXPECT($R86, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12758
12769
|
return { $loc, token: $0 };
|
|
12759
12770
|
});
|
|
12760
12771
|
function EOL(ctx, state) {
|
|
@@ -13274,7 +13285,7 @@ ${input.slice(result.pos)}
|
|
|
13274
13285
|
function Init(ctx, state) {
|
|
13275
13286
|
return $EVENT(ctx, state, "Init", Init$0);
|
|
13276
13287
|
}
|
|
13277
|
-
var Indent$0 = $TR($EXPECT($
|
|
13288
|
+
var Indent$0 = $TR($EXPECT($R81, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
13278
13289
|
const level = getIndentLevel($0, module.config.tab);
|
|
13279
13290
|
return {
|
|
13280
13291
|
$loc,
|
|
@@ -13456,6 +13467,7 @@ ${input.slice(result.pos)}
|
|
|
13456
13467
|
exports.ClassHeritage = ClassHeritage;
|
|
13457
13468
|
exports.ExtendsClause = ExtendsClause;
|
|
13458
13469
|
exports.ExtendsToken = ExtendsToken;
|
|
13470
|
+
exports.ExtendsShorthand = ExtendsShorthand;
|
|
13459
13471
|
exports.ExtendsTarget = ExtendsTarget;
|
|
13460
13472
|
exports.ImplementsClause = ImplementsClause;
|
|
13461
13473
|
exports.ImplementsToken = ImplementsToken;
|
|
@@ -13696,6 +13708,7 @@ ${input.slice(result.pos)}
|
|
|
13696
13708
|
exports.DeclarationCondition = DeclarationCondition;
|
|
13697
13709
|
exports.ExpressionWithIndentedApplicationForbidden = ExpressionWithIndentedApplicationForbidden;
|
|
13698
13710
|
exports.ExpressionWithObjectApplicationForbidden = ExpressionWithObjectApplicationForbidden;
|
|
13711
|
+
exports.LeftHandSideExpressionWithObjectApplicationForbidden = LeftHandSideExpressionWithObjectApplicationForbidden;
|
|
13699
13712
|
exports.ForbidClassImplicitCall = ForbidClassImplicitCall;
|
|
13700
13713
|
exports.AllowClassImplicitCall = AllowClassImplicitCall;
|
|
13701
13714
|
exports.RestoreClassImplicitCall = RestoreClassImplicitCall;
|