@danielx/civet 0.6.42 → 0.6.43
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 +556 -457
- package/dist/main.js +556 -457
- package/dist/main.mjs +556 -457
- package/package.json +2 -2
package/dist/browser.js
CHANGED
|
@@ -3637,6 +3637,7 @@ ${input.slice(result.pos)}
|
|
|
3637
3637
|
NestedNonAssignmentExtendedExpression,
|
|
3638
3638
|
ExpressionizedStatementWithTrailingCallExpressions,
|
|
3639
3639
|
ExpressionizedStatement,
|
|
3640
|
+
_ExpressionizedStatement,
|
|
3640
3641
|
Expression,
|
|
3641
3642
|
Arguments,
|
|
3642
3643
|
ImplicitArguments,
|
|
@@ -3728,6 +3729,7 @@ ${input.slice(result.pos)}
|
|
|
3728
3729
|
MemberBracketContent,
|
|
3729
3730
|
SliceParameters,
|
|
3730
3731
|
AccessStart,
|
|
3732
|
+
PropertyAccessModifier,
|
|
3731
3733
|
PropertyAccess,
|
|
3732
3734
|
PropertyGlob,
|
|
3733
3735
|
PropertyBind,
|
|
@@ -3798,12 +3800,14 @@ ${input.slice(result.pos)}
|
|
|
3798
3800
|
LiteralContent,
|
|
3799
3801
|
NullLiteral,
|
|
3800
3802
|
BooleanLiteral,
|
|
3803
|
+
_BooleanLiteral,
|
|
3801
3804
|
CoffeeScriptBooleanLiteral,
|
|
3802
3805
|
Identifier,
|
|
3803
3806
|
IdentifierName,
|
|
3804
3807
|
IdentifierReference,
|
|
3805
3808
|
UpcomingAssignment,
|
|
3806
3809
|
ArrayLiteral,
|
|
3810
|
+
_ArrayLiteral,
|
|
3807
3811
|
RangeExpression,
|
|
3808
3812
|
ArrayLiteralContent,
|
|
3809
3813
|
NestedElementList,
|
|
@@ -3845,6 +3849,8 @@ ${input.slice(result.pos)}
|
|
|
3845
3849
|
IdentifierBinaryOp,
|
|
3846
3850
|
BinaryOp,
|
|
3847
3851
|
BinaryOpSymbol,
|
|
3852
|
+
CoffeeOfOp,
|
|
3853
|
+
NotOp,
|
|
3848
3854
|
Xor,
|
|
3849
3855
|
Xnor,
|
|
3850
3856
|
UnaryOp,
|
|
@@ -3855,6 +3861,7 @@ ${input.slice(result.pos)}
|
|
|
3855
3861
|
PostfixedExpression,
|
|
3856
3862
|
NonPipelinePostfixedExpression,
|
|
3857
3863
|
PostfixStatement,
|
|
3864
|
+
_PostfixStatement,
|
|
3858
3865
|
Statement,
|
|
3859
3866
|
EmptyStatement,
|
|
3860
3867
|
BlockStatement,
|
|
@@ -3874,6 +3881,7 @@ ${input.slice(result.pos)}
|
|
|
3874
3881
|
NestedBlockExpression,
|
|
3875
3882
|
BlockExpressionPart,
|
|
3876
3883
|
IterationStatement,
|
|
3884
|
+
_IterationStatement,
|
|
3877
3885
|
IterationExpression,
|
|
3878
3886
|
LoopStatement,
|
|
3879
3887
|
LoopClause,
|
|
@@ -4010,6 +4018,7 @@ ${input.slice(result.pos)}
|
|
|
4010
4018
|
RegExpCharacter,
|
|
4011
4019
|
RegularExpressionFlags,
|
|
4012
4020
|
TemplateLiteral,
|
|
4021
|
+
_TemplateLiteral,
|
|
4013
4022
|
TemplateSubstitution,
|
|
4014
4023
|
TemplateCharacters,
|
|
4015
4024
|
TemplateBlockCharacters,
|
|
@@ -4315,8 +4324,8 @@ ${input.slice(result.pos)}
|
|
|
4315
4324
|
var $L8 = $L("--");
|
|
4316
4325
|
var $L9 = $L("=>");
|
|
4317
4326
|
var $L10 = $L("\u21D2");
|
|
4318
|
-
var $L11 = $L("
|
|
4319
|
-
var $L12 = $L("
|
|
4327
|
+
var $L11 = $L(":");
|
|
4328
|
+
var $L12 = $L(" ");
|
|
4320
4329
|
var $L13 = $L("implements");
|
|
4321
4330
|
var $L14 = $L("<:");
|
|
4322
4331
|
var $L15 = $L("import");
|
|
@@ -4388,77 +4397,77 @@ ${input.slice(result.pos)}
|
|
|
4388
4397
|
var $L81 = $L("\u2A75");
|
|
4389
4398
|
var $L82 = $L("and");
|
|
4390
4399
|
var $L83 = $L("&&");
|
|
4391
|
-
var $L84 = $L("
|
|
4392
|
-
var $L85 = $L("
|
|
4393
|
-
var $L86 = $L("
|
|
4394
|
-
var $L87 = $L("
|
|
4395
|
-
var $L88 = $L("
|
|
4396
|
-
var $L89 = $L("
|
|
4397
|
-
var $L90 = $L("
|
|
4398
|
-
var $L91 = $L("
|
|
4399
|
-
var $L92 = $L("
|
|
4400
|
-
var $L93 = $L("
|
|
4401
|
-
var $L94 = $L("\
|
|
4402
|
-
var $L95 = $L("\
|
|
4403
|
-
var $L96 = $L("\
|
|
4404
|
-
var $L97 = $L("
|
|
4405
|
-
var $L98 = $L("
|
|
4406
|
-
var $L99 = $L("
|
|
4407
|
-
var $L100 = $L("
|
|
4408
|
-
var $L101 = $L("
|
|
4409
|
-
var $L102 = $L("
|
|
4410
|
-
var $L103 = $L("
|
|
4411
|
-
var $L104 = $L("
|
|
4412
|
-
var $L105 = $L("
|
|
4413
|
-
var $L106 = $L("
|
|
4414
|
-
var $L107 = $L("
|
|
4415
|
-
var $L108 = $L("
|
|
4416
|
-
var $L109 = $L("
|
|
4417
|
-
var $L110 = $L("
|
|
4418
|
-
var $L111 = $L("
|
|
4419
|
-
var $L112 = $L("
|
|
4420
|
-
var $L113 = $L("
|
|
4421
|
-
var $L114 = $L("
|
|
4422
|
-
var $L115 = $L("
|
|
4423
|
-
var $L116 = $L("
|
|
4424
|
-
var $L117 = $L("
|
|
4425
|
-
var $L118 = $L("
|
|
4426
|
-
var $L119 = $L("
|
|
4427
|
-
var $L120 = $L("
|
|
4428
|
-
var $L121 = $L("
|
|
4429
|
-
var $L122 = $L("
|
|
4430
|
-
var $L123 = $L("
|
|
4431
|
-
var $L124 = $L("
|
|
4432
|
-
var $L125 = $L("
|
|
4433
|
-
var $L126 = $L("
|
|
4434
|
-
var $L127 = $L("
|
|
4435
|
-
var $L128 = $L("
|
|
4436
|
-
var $L129 = $L("
|
|
4437
|
-
var $L130 = $L("
|
|
4438
|
-
var $L131 = $L("
|
|
4439
|
-
var $L132 = $L("
|
|
4440
|
-
var $L133 = $L("
|
|
4441
|
-
var $L134 = $L("
|
|
4442
|
-
var $L135 = $L(
|
|
4443
|
-
var $L136 = $L("
|
|
4444
|
-
var $L137 = $L("
|
|
4445
|
-
var $L138 = $L("
|
|
4446
|
-
var $L139 = $L("
|
|
4447
|
-
var $L140 = $L("
|
|
4448
|
-
var $L141 = $L("
|
|
4449
|
-
var $L142 = $L("
|
|
4450
|
-
var $L143 = $L("
|
|
4451
|
-
var $L144 = $L("
|
|
4452
|
-
var $L145 = $L("
|
|
4453
|
-
var $L146 = $L("
|
|
4454
|
-
var $L147 = $L("
|
|
4455
|
-
var $L148 = $L("
|
|
4456
|
-
var $L149 = $L("
|
|
4457
|
-
var $L150 = $L("
|
|
4458
|
-
var $L151 = $L("
|
|
4459
|
-
var $L152 = $L("
|
|
4460
|
-
var $L153 = $L("
|
|
4461
|
-
var $L154 = $L("
|
|
4400
|
+
var $L84 = $L("or");
|
|
4401
|
+
var $L85 = $L("||");
|
|
4402
|
+
var $L86 = $L("\u2016");
|
|
4403
|
+
var $L87 = $L("^^");
|
|
4404
|
+
var $L88 = $L("xor");
|
|
4405
|
+
var $L89 = $L("xnor");
|
|
4406
|
+
var $L90 = $L("??");
|
|
4407
|
+
var $L91 = $L("\u2047");
|
|
4408
|
+
var $L92 = $L("instanceof");
|
|
4409
|
+
var $L93 = $L("\u2208");
|
|
4410
|
+
var $L94 = $L("\u220B");
|
|
4411
|
+
var $L95 = $L("\u220C");
|
|
4412
|
+
var $L96 = $L("\u2209");
|
|
4413
|
+
var $L97 = $L("&");
|
|
4414
|
+
var $L98 = $L("|");
|
|
4415
|
+
var $L99 = $L(";");
|
|
4416
|
+
var $L100 = $L("$:");
|
|
4417
|
+
var $L101 = $L("break");
|
|
4418
|
+
var $L102 = $L("continue");
|
|
4419
|
+
var $L103 = $L("debugger");
|
|
4420
|
+
var $L104 = $L("assert");
|
|
4421
|
+
var $L105 = $L(":=");
|
|
4422
|
+
var $L106 = $L("\u2254");
|
|
4423
|
+
var $L107 = $L(".=");
|
|
4424
|
+
var $L108 = $L("/*");
|
|
4425
|
+
var $L109 = $L("*/");
|
|
4426
|
+
var $L110 = $L("\\");
|
|
4427
|
+
var $L111 = $L("[");
|
|
4428
|
+
var $L112 = $L("`");
|
|
4429
|
+
var $L113 = $L(")");
|
|
4430
|
+
var $L114 = $L("abstract");
|
|
4431
|
+
var $L115 = $L("as");
|
|
4432
|
+
var $L116 = $L("@");
|
|
4433
|
+
var $L117 = $L("@@");
|
|
4434
|
+
var $L118 = $L("async");
|
|
4435
|
+
var $L119 = $L("await");
|
|
4436
|
+
var $L120 = $L("by");
|
|
4437
|
+
var $L121 = $L("case");
|
|
4438
|
+
var $L122 = $L("catch");
|
|
4439
|
+
var $L123 = $L("class");
|
|
4440
|
+
var $L124 = $L("#{");
|
|
4441
|
+
var $L125 = $L("declare");
|
|
4442
|
+
var $L126 = $L("default");
|
|
4443
|
+
var $L127 = $L("delete");
|
|
4444
|
+
var $L128 = $L("do");
|
|
4445
|
+
var $L129 = $L("..");
|
|
4446
|
+
var $L130 = $L("\u2025");
|
|
4447
|
+
var $L131 = $L("...");
|
|
4448
|
+
var $L132 = $L("\u2026");
|
|
4449
|
+
var $L133 = $L("::");
|
|
4450
|
+
var $L134 = $L('"');
|
|
4451
|
+
var $L135 = $L("each");
|
|
4452
|
+
var $L136 = $L("else");
|
|
4453
|
+
var $L137 = $L("export");
|
|
4454
|
+
var $L138 = $L("extends");
|
|
4455
|
+
var $L139 = $L("finally");
|
|
4456
|
+
var $L140 = $L("for");
|
|
4457
|
+
var $L141 = $L("from");
|
|
4458
|
+
var $L142 = $L("function");
|
|
4459
|
+
var $L143 = $L("get");
|
|
4460
|
+
var $L144 = $L("set");
|
|
4461
|
+
var $L145 = $L("#");
|
|
4462
|
+
var $L146 = $L("if");
|
|
4463
|
+
var $L147 = $L("in");
|
|
4464
|
+
var $L148 = $L("let");
|
|
4465
|
+
var $L149 = $L("const");
|
|
4466
|
+
var $L150 = $L("is");
|
|
4467
|
+
var $L151 = $L("loop");
|
|
4468
|
+
var $L152 = $L("new");
|
|
4469
|
+
var $L153 = $L("not");
|
|
4470
|
+
var $L154 = $L("of");
|
|
4462
4471
|
var $L155 = $L("<");
|
|
4463
4472
|
var $L156 = $L("operator");
|
|
4464
4473
|
var $L157 = $L("own");
|
|
@@ -4515,77 +4524,91 @@ ${input.slice(result.pos)}
|
|
|
4515
4524
|
var $L208 = $L("???");
|
|
4516
4525
|
var $L209 = $L("[]");
|
|
4517
4526
|
var $L210 = $L("civet");
|
|
4518
|
-
var $R0 = $R(new RegExp("(
|
|
4519
|
-
var $R1 = $R(new RegExp("[
|
|
4520
|
-
var $R2 = $R(new RegExp("[
|
|
4521
|
-
var $R3 = $R(new RegExp("[
|
|
4522
|
-
var $R4 = $R(new RegExp("[
|
|
4523
|
-
var $R5 = $R(new RegExp("(
|
|
4524
|
-
var $R6 = $R(new RegExp("[
|
|
4525
|
-
var $R7 = $R(new RegExp("
|
|
4526
|
-
var $R8 = $R(new RegExp("
|
|
4527
|
-
var $R9 = $R(new RegExp(
|
|
4528
|
-
var $R10 = $R(new RegExp("(?=
|
|
4529
|
-
var $R11 = $R(new RegExp(
|
|
4530
|
-
var $R12 = $R(new RegExp("(
|
|
4531
|
-
var $R13 = $R(new RegExp("(
|
|
4532
|
-
var $R14 = $R(new RegExp("
|
|
4533
|
-
var $R15 = $R(new RegExp("(
|
|
4534
|
-
var $R16 = $R(new RegExp("
|
|
4535
|
-
var $R17 = $R(new RegExp("
|
|
4536
|
-
var $R18 = $R(new RegExp("
|
|
4537
|
-
var $R19 = $R(new RegExp("
|
|
4538
|
-
var $R20 = $R(new RegExp("(
|
|
4539
|
-
var $R21 = $R(new RegExp('
|
|
4540
|
-
var $R22 = $R(new RegExp("(
|
|
4541
|
-
var $R23 = $R(new RegExp(
|
|
4542
|
-
var $R24 = $R(new RegExp("(?:
|
|
4543
|
-
var $R25 = $R(new RegExp(
|
|
4544
|
-
var $R26 = $R(new RegExp("(
|
|
4545
|
-
var $R27 = $R(new RegExp("(
|
|
4546
|
-
var $R28 = $R(new RegExp("[
|
|
4547
|
-
var $R29 = $R(new RegExp("
|
|
4548
|
-
var $R30 = $R(new RegExp("[
|
|
4549
|
-
var $R31 = $R(new RegExp("[
|
|
4550
|
-
var $R32 = $R(new RegExp("(
|
|
4551
|
-
var $R33 = $R(new RegExp(
|
|
4552
|
-
var $R34 = $R(new RegExp("(
|
|
4553
|
-
var $R35 = $R(new RegExp("(
|
|
4554
|
-
var $R36 = $R(new RegExp("(?:
|
|
4555
|
-
var $R37 = $R(new RegExp(
|
|
4556
|
-
var $R38 = $R(new RegExp("(
|
|
4557
|
-
var $R39 = $R(new RegExp("(
|
|
4558
|
-
var $R40 = $R(new RegExp("
|
|
4559
|
-
var $R41 = $R(new RegExp("(
|
|
4560
|
-
var $R42 = $R(new RegExp("
|
|
4561
|
-
var $R43 = $R(new RegExp("
|
|
4562
|
-
var $R44 = $R(new RegExp("
|
|
4563
|
-
var $R45 = $R(new RegExp("[
|
|
4564
|
-
var $R46 = $R(new RegExp("
|
|
4565
|
-
var $R47 = $R(new RegExp("
|
|
4566
|
-
var $R48 = $R(new RegExp("(
|
|
4567
|
-
var $R49 = $R(new RegExp("
|
|
4568
|
-
var $R50 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
4569
|
-
var $R51 = $R(new RegExp("
|
|
4570
|
-
var $R52 = $R(new RegExp("
|
|
4571
|
-
var $R53 = $R(new RegExp("(
|
|
4572
|
-
var $R54 = $R(new RegExp("
|
|
4573
|
-
var $R55 = $R(new RegExp("(
|
|
4574
|
-
var $R56 = $R(new RegExp(
|
|
4575
|
-
var $R57 = $R(new RegExp("[
|
|
4576
|
-
var $R58 = $R(new RegExp("[
|
|
4577
|
-
var $R59 = $R(new RegExp("(
|
|
4578
|
-
var $R60 = $R(new RegExp("[
|
|
4579
|
-
var $R61 = $R(new RegExp("[
|
|
4580
|
-
var $R62 = $R(new RegExp("[
|
|
4581
|
-
var $R63 = $R(new RegExp("
|
|
4582
|
-
var $R64 = $R(new RegExp("
|
|
4583
|
-
var $R65 = $R(new RegExp("[
|
|
4584
|
-
var $R66 = $R(new RegExp("\\s
|
|
4585
|
-
var $R67 = $R(new RegExp("
|
|
4586
|
-
var $R68 = $R(new RegExp("
|
|
4587
|
-
var $R69 = $R(new RegExp("\\
|
|
4588
|
-
var $R70 = $R(new RegExp("[
|
|
4527
|
+
var $R0 = $R(new RegExp("(?=debugger|if|unless|do|for|loop|until|while|switch|throw|try)", "suy"));
|
|
4528
|
+
var $R1 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
4529
|
+
var $R2 = $R(new RegExp("[0-9]", "suy"));
|
|
4530
|
+
var $R3 = $R(new RegExp("[ \\t]", "suy"));
|
|
4531
|
+
var $R4 = $R(new RegExp("(?=['\"`])", "suy"));
|
|
4532
|
+
var $R5 = $R(new RegExp("(?=[\\/?])", "suy"));
|
|
4533
|
+
var $R6 = $R(new RegExp("[)}]", "suy"));
|
|
4534
|
+
var $R7 = $R(new RegExp("[&]", "suy"));
|
|
4535
|
+
var $R8 = $R(new RegExp("[!~+-]+", "suy"));
|
|
4536
|
+
var $R9 = $R(new RegExp(`(?=[0-9.'"tfyno])`, "suy"));
|
|
4537
|
+
var $R10 = $R(new RegExp("(?=true|false|yes|no|on|off)", "suy"));
|
|
4538
|
+
var $R11 = $R(new RegExp("(?=\\p{ID_Start}|[_$])", "suy"));
|
|
4539
|
+
var $R12 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
4540
|
+
var $R13 = $R(new RegExp("(?=\\[)", "suy"));
|
|
4541
|
+
var $R14 = $R(new RegExp("[!+-]", "suy"));
|
|
4542
|
+
var $R15 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
|
|
4543
|
+
var $R16 = $R(new RegExp("!\\^\\^?", "suy"));
|
|
4544
|
+
var $R17 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])", "suy"));
|
|
4545
|
+
var $R18 = $R(new RegExp("(?=for|if|loop|unless|until|while)", "suy"));
|
|
4546
|
+
var $R19 = $R(new RegExp("(?=loop|do|for|until|while)", "suy"));
|
|
4547
|
+
var $R20 = $R(new RegExp("(?=[\\s\\),])", "suy"));
|
|
4548
|
+
var $R21 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
4549
|
+
var $R22 = $R(new RegExp("(?=[0-9.])", "suy"));
|
|
4550
|
+
var $R23 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
4551
|
+
var $R24 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
4552
|
+
var $R25 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?", "suy"));
|
|
4553
|
+
var $R26 = $R(new RegExp("(?:\\.[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4554
|
+
var $R27 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
4555
|
+
var $R28 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
4556
|
+
var $R29 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
4557
|
+
var $R30 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
4558
|
+
var $R31 = $R(new RegExp("(?=[0-9])", "suy"));
|
|
4559
|
+
var $R32 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
4560
|
+
var $R33 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
4561
|
+
var $R34 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
4562
|
+
var $R35 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
4563
|
+
var $R36 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
4564
|
+
var $R37 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
4565
|
+
var $R38 = $R(new RegExp("(?:\\\\.|[^\\]])*", "suy"));
|
|
4566
|
+
var $R39 = $R(new RegExp("(?:\\\\.)", "suy"));
|
|
4567
|
+
var $R40 = $R(new RegExp("[\\s]+", "suy"));
|
|
4568
|
+
var $R41 = $R(new RegExp("\\/(?!\\/\\/)", "suy"));
|
|
4569
|
+
var $R42 = $R(new RegExp("[^[\\/\\s#\\\\]+", "suy"));
|
|
4570
|
+
var $R43 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
4571
|
+
var $R44 = $R(new RegExp("(?:\\\\.|[^[\\/\\r\\n])+", "suy"));
|
|
4572
|
+
var $R45 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
4573
|
+
var $R46 = $R(new RegExp("(?=[`'\"])", "suy"));
|
|
4574
|
+
var $R47 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
4575
|
+
var $R48 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
4576
|
+
var $R49 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
4577
|
+
var $R50 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
4578
|
+
var $R51 = $R(new RegExp("(?:by)(?!\\p{ID_Continue})", "suy"));
|
|
4579
|
+
var $R52 = $R(new RegExp("(?:of)(?!\\p{ID_Continue})", "suy"));
|
|
4580
|
+
var $R53 = $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"));
|
|
4581
|
+
var $R54 = $R(new RegExp("(?=\\/|#)", "suy"));
|
|
4582
|
+
var $R55 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
|
|
4583
|
+
var $R56 = $R(new RegExp(".", "suy"));
|
|
4584
|
+
var $R57 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
|
|
4585
|
+
var $R58 = $R(new RegExp("[^]*?###", "suy"));
|
|
4586
|
+
var $R59 = $R(new RegExp("###(?!#)", "suy"));
|
|
4587
|
+
var $R60 = $R(new RegExp("\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\/", "suy"));
|
|
4588
|
+
var $R61 = $R(new RegExp("(?=[ \\t\\/\\\\])", "suy"));
|
|
4589
|
+
var $R62 = $R(new RegExp("[ \\t]+", "suy"));
|
|
4590
|
+
var $R63 = $R(new RegExp("(?=\\s|\\/|#)", "suy"));
|
|
4591
|
+
var $R64 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
4592
|
+
var $R65 = $R(new RegExp("['\u2019]s", "suy"));
|
|
4593
|
+
var $R66 = $R(new RegExp("\\s", "suy"));
|
|
4594
|
+
var $R67 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
4595
|
+
var $R68 = $R(new RegExp("[\\s>]|\\/>", "suy"));
|
|
4596
|
+
var $R69 = $R(new RegExp("(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+", "suy"));
|
|
4597
|
+
var $R70 = $R(new RegExp(`"[^"]*"|'[^']*'`, "suy"));
|
|
4598
|
+
var $R71 = $R(new RegExp("[<>]", "suy"));
|
|
4599
|
+
var $R72 = $R(new RegExp("[!~+-](?!\\s|[!~+-]*&)", "suy"));
|
|
4600
|
+
var $R73 = $R(new RegExp("(?:-[^-]|[^-]*)*", "suy"));
|
|
4601
|
+
var $R74 = $R(new RegExp("[^{}<>\\r\\n]+", "suy"));
|
|
4602
|
+
var $R75 = $R(new RegExp("[+-]?", "suy"));
|
|
4603
|
+
var $R76 = $R(new RegExp("[+-]", "suy"));
|
|
4604
|
+
var $R77 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
4605
|
+
var $R78 = $R(new RegExp("[\\t ]*", "suy"));
|
|
4606
|
+
var $R79 = $R(new RegExp("[\\s]*", "suy"));
|
|
4607
|
+
var $R80 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)(\\s*=\\s*([a-zA-Z0-9.+-]*))?", "suy"));
|
|
4608
|
+
var $R81 = $R(new RegExp("\\/\\/\\/[^\\r\\n]*", "suy"));
|
|
4609
|
+
var $R82 = $R(new RegExp("(?=[ \\t\\r\\n\\/#]|$)", "suy"));
|
|
4610
|
+
var $R83 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
4611
|
+
var $R84 = $R(new RegExp("[ \\t]*", "suy"));
|
|
4589
4612
|
var Program$0 = $TS($S(Reset, Init, $E(EOS), TopLevelStatements, __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
4590
4613
|
var statements = $4;
|
|
4591
4614
|
processProgram({
|
|
@@ -4716,16 +4739,22 @@ ${input.slice(result.pos)}
|
|
|
4716
4739
|
function ExpressionizedStatementWithTrailingCallExpressions(ctx, state) {
|
|
4717
4740
|
return $EVENT(ctx, state, "ExpressionizedStatementWithTrailingCallExpressions", ExpressionizedStatementWithTrailingCallExpressions$0);
|
|
4718
4741
|
}
|
|
4719
|
-
var ExpressionizedStatement$0 =
|
|
4720
|
-
|
|
4721
|
-
|
|
4722
|
-
var ExpressionizedStatement$3 = IterationExpression;
|
|
4723
|
-
var ExpressionizedStatement$4 = SwitchExpression;
|
|
4724
|
-
var ExpressionizedStatement$5 = ThrowExpression;
|
|
4725
|
-
var ExpressionizedStatement$6 = TryExpression;
|
|
4726
|
-
var ExpressionizedStatement$$ = [ExpressionizedStatement$0, ExpressionizedStatement$1, ExpressionizedStatement$2, ExpressionizedStatement$3, ExpressionizedStatement$4, ExpressionizedStatement$5, ExpressionizedStatement$6];
|
|
4742
|
+
var ExpressionizedStatement$0 = $T($S($EXPECT($R0, "ExpressionizedStatement /(?=debugger|if|unless|do|for|loop|until|while|switch|throw|try)/"), _ExpressionizedStatement), function(value) {
|
|
4743
|
+
return value[1];
|
|
4744
|
+
});
|
|
4727
4745
|
function ExpressionizedStatement(ctx, state) {
|
|
4728
|
-
return $
|
|
4746
|
+
return $EVENT(ctx, state, "ExpressionizedStatement", ExpressionizedStatement$0);
|
|
4747
|
+
}
|
|
4748
|
+
var _ExpressionizedStatement$0 = DebuggerExpression;
|
|
4749
|
+
var _ExpressionizedStatement$1 = IfExpression;
|
|
4750
|
+
var _ExpressionizedStatement$2 = UnlessExpression;
|
|
4751
|
+
var _ExpressionizedStatement$3 = IterationExpression;
|
|
4752
|
+
var _ExpressionizedStatement$4 = SwitchExpression;
|
|
4753
|
+
var _ExpressionizedStatement$5 = ThrowExpression;
|
|
4754
|
+
var _ExpressionizedStatement$6 = TryExpression;
|
|
4755
|
+
var _ExpressionizedStatement$$ = [_ExpressionizedStatement$0, _ExpressionizedStatement$1, _ExpressionizedStatement$2, _ExpressionizedStatement$3, _ExpressionizedStatement$4, _ExpressionizedStatement$5, _ExpressionizedStatement$6];
|
|
4756
|
+
function _ExpressionizedStatement(ctx, state) {
|
|
4757
|
+
return $EVENT_C(ctx, state, "_ExpressionizedStatement", _ExpressionizedStatement$$);
|
|
4729
4758
|
}
|
|
4730
4759
|
var Expression$0 = $TS($S(AssignmentExpression, $Q($S(CommaDelimiter, AssignmentExpression))), function($skip, $loc, $0, $1, $2) {
|
|
4731
4760
|
if ($2.length == 0)
|
|
@@ -4770,7 +4799,7 @@ ${input.slice(result.pos)}
|
|
|
4770
4799
|
function ApplicationStart(ctx, state) {
|
|
4771
4800
|
return $EVENT_C(ctx, state, "ApplicationStart", ApplicationStart$$);
|
|
4772
4801
|
}
|
|
4773
|
-
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($
|
|
4802
|
+
var ForbiddenImplicitCalls$0 = $R$0($EXPECT($R1, "ForbiddenImplicitCalls /(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
4774
4803
|
var ForbiddenImplicitCalls$1 = $EXPECT($L2, 'ForbiddenImplicitCalls "/ "');
|
|
4775
4804
|
var ForbiddenImplicitCalls$2 = $S(ClassImplicitCallForbidden, $C(Class, AtAt));
|
|
4776
4805
|
var ForbiddenImplicitCalls$3 = $S(Identifier, $EXPECT($L3, 'ForbiddenImplicitCalls "="'), Whitespace);
|
|
@@ -4802,7 +4831,7 @@ ${input.slice(result.pos)}
|
|
|
4802
4831
|
function ArgumentsWithTrailingMemberExpressions(ctx, state) {
|
|
4803
4832
|
return $EVENT(ctx, state, "ArgumentsWithTrailingMemberExpressions", ArgumentsWithTrailingMemberExpressions$0);
|
|
4804
4833
|
}
|
|
4805
|
-
var TrailingMemberExpressions$0 = $TS($S($Q(MemberExpressionRest), $Q($S(IndentedAtLeast, $Y($S($E($EXPECT($L5, 'TrailingMemberExpressions "?"')), $EXPECT($L6, 'TrailingMemberExpressions "."'), $N($EXPECT($
|
|
4834
|
+
var TrailingMemberExpressions$0 = $TS($S($Q(MemberExpressionRest), $Q($S(IndentedAtLeast, $Y($S($E($EXPECT($L5, 'TrailingMemberExpressions "?"')), $EXPECT($L6, 'TrailingMemberExpressions "."'), $N($EXPECT($R2, "TrailingMemberExpressions /[0-9]/")))), MemberExpressionRest))), function($skip, $loc, $0, $1, $2) {
|
|
4806
4835
|
return $1.concat($2);
|
|
4807
4836
|
});
|
|
4808
4837
|
function TrailingMemberExpressions(ctx, state) {
|
|
@@ -4816,7 +4845,7 @@ ${input.slice(result.pos)}
|
|
|
4816
4845
|
function AllowedTrailingMemberExpressions(ctx, state) {
|
|
4817
4846
|
return $EVENT_C(ctx, state, "AllowedTrailingMemberExpressions", AllowedTrailingMemberExpressions$$);
|
|
4818
4847
|
}
|
|
4819
|
-
var TrailingCallExpressions$0 = $P($S(IndentedAtLeast, $Y($S($E($EXPECT($L5, 'TrailingCallExpressions "?"')), $EXPECT($L6, 'TrailingCallExpressions "."'), $N($R$0($EXPECT($
|
|
4848
|
+
var TrailingCallExpressions$0 = $P($S(IndentedAtLeast, $Y($S($E($EXPECT($L5, 'TrailingCallExpressions "?"')), $EXPECT($L6, 'TrailingCallExpressions "."'), $N($R$0($EXPECT($R2, "TrailingCallExpressions /[0-9]/"))))), $P(CallExpressionRest)));
|
|
4820
4849
|
function TrailingCallExpressions(ctx, state) {
|
|
4821
4850
|
return $EVENT(ctx, state, "TrailingCallExpressions", TrailingCallExpressions$0);
|
|
4822
4851
|
}
|
|
@@ -5134,7 +5163,7 @@ ${input.slice(result.pos)}
|
|
|
5134
5163
|
function FatArrow(ctx, state) {
|
|
5135
5164
|
return $EVENT(ctx, state, "FatArrow", FatArrow$0);
|
|
5136
5165
|
}
|
|
5137
|
-
var TrailingDeclaration$0 = $S($
|
|
5166
|
+
var TrailingDeclaration$0 = $S($E(_), $C(ConstAssignment, LetAssignment));
|
|
5138
5167
|
function TrailingDeclaration(ctx, state) {
|
|
5139
5168
|
return $EVENT(ctx, state, "TrailingDeclaration", TrailingDeclaration$0);
|
|
5140
5169
|
}
|
|
@@ -5157,7 +5186,7 @@ ${input.slice(result.pos)}
|
|
|
5157
5186
|
return $EVENT(ctx, state, "ConditionalExpression", ConditionalExpression$0);
|
|
5158
5187
|
}
|
|
5159
5188
|
var TernaryRest$0 = NestedTernaryRest;
|
|
5160
|
-
var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($
|
|
5189
|
+
var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($R3, "TernaryRest /[ \\t]/")), _, QuestionMark, ExtendedExpression, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
5161
5190
|
return $0.slice(2);
|
|
5162
5191
|
});
|
|
5163
5192
|
var TernaryRest$$ = [TernaryRest$0, TernaryRest$1];
|
|
@@ -5271,7 +5300,7 @@ ${input.slice(result.pos)}
|
|
|
5271
5300
|
function ClassDeclaration(ctx, state) {
|
|
5272
5301
|
return $EVENT(ctx, state, "ClassDeclaration", ClassDeclaration$0);
|
|
5273
5302
|
}
|
|
5274
|
-
var ClassExpression$0 = $S($E(Decorators), $E($S(Abstract, __)), Class, $N($EXPECT($
|
|
5303
|
+
var ClassExpression$0 = $S($E(Decorators), $E($S(Abstract, __)), Class, $N($EXPECT($L11, 'ClassExpression ":"')), $E(ClassBinding), $E(ClassHeritage), ClassBody);
|
|
5275
5304
|
function ClassExpression(ctx, state) {
|
|
5276
5305
|
return $EVENT(ctx, state, "ClassExpression", ClassExpression$0);
|
|
5277
5306
|
}
|
|
@@ -5291,7 +5320,7 @@ ${input.slice(result.pos)}
|
|
|
5291
5320
|
function ExtendsClause(ctx, state) {
|
|
5292
5321
|
return $EVENT(ctx, state, "ExtendsClause", ExtendsClause$0);
|
|
5293
5322
|
}
|
|
5294
|
-
var ExtendsToken$0 = $TS($S(Loc, __, OpenAngleBracket, $E($EXPECT($
|
|
5323
|
+
var ExtendsToken$0 = $TS($S(Loc, __, OpenAngleBracket, $E($EXPECT($L12, 'ExtendsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5295
5324
|
var l = $1;
|
|
5296
5325
|
var ws = $2;
|
|
5297
5326
|
var lt = $3;
|
|
@@ -5329,7 +5358,7 @@ ${input.slice(result.pos)}
|
|
|
5329
5358
|
function ImplementsClause(ctx, state) {
|
|
5330
5359
|
return $EVENT(ctx, state, "ImplementsClause", ImplementsClause$0);
|
|
5331
5360
|
}
|
|
5332
|
-
var ImplementsToken$0 = $TS($S(Loc, __, ImplementsShorthand, $E($EXPECT($
|
|
5361
|
+
var ImplementsToken$0 = $TS($S(Loc, __, ImplementsShorthand, $E($EXPECT($L12, 'ImplementsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5333
5362
|
var l = $1;
|
|
5334
5363
|
var ws = $2;
|
|
5335
5364
|
var token = $3;
|
|
@@ -5559,7 +5588,7 @@ ${input.slice(result.pos)}
|
|
|
5559
5588
|
function AtThis(ctx, state) {
|
|
5560
5589
|
return $EVENT(ctx, state, "AtThis", AtThis$0);
|
|
5561
5590
|
}
|
|
5562
|
-
var LeftHandSideExpression$0 = $S($P($S(New, $N($C($EXPECT($L6, 'LeftHandSideExpression "."'), $EXPECT($
|
|
5591
|
+
var LeftHandSideExpression$0 = $S($P($S(New, $N($C($EXPECT($L6, 'LeftHandSideExpression "."'), $EXPECT($L11, 'LeftHandSideExpression ":"'))), __)), CallExpression, $E(TypeArguments));
|
|
5563
5592
|
var LeftHandSideExpression$1 = CallExpression;
|
|
5564
5593
|
var LeftHandSideExpression$$ = [LeftHandSideExpression$0, LeftHandSideExpression$1];
|
|
5565
5594
|
function LeftHandSideExpression(ctx, state) {
|
|
@@ -5597,13 +5626,14 @@ ${input.slice(result.pos)}
|
|
|
5597
5626
|
return $EVENT_C(ctx, state, "CallExpression", CallExpression$$);
|
|
5598
5627
|
}
|
|
5599
5628
|
var CallExpressionRest$0 = MemberExpressionRest;
|
|
5600
|
-
var CallExpressionRest$1 = $
|
|
5601
|
-
|
|
5602
|
-
|
|
5629
|
+
var CallExpressionRest$1 = $TS($S($EXPECT($R4, "CallExpressionRest /(?=['\"`])/"), $C(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2) {
|
|
5630
|
+
var literal = $2;
|
|
5631
|
+
if (literal.type === "StringLiteral") {
|
|
5632
|
+
return "`" + literal.token.slice(1, -1).replace(/(`|\$\{)/g, "\\$1") + "`";
|
|
5603
5633
|
}
|
|
5604
|
-
return
|
|
5634
|
+
return literal;
|
|
5605
5635
|
});
|
|
5606
|
-
var CallExpressionRest$2 = $TS($S($E(
|
|
5636
|
+
var CallExpressionRest$2 = $TS($S($E(OptionalShorthand), ArgumentsWithTrailingMemberExpressions), function($skip, $loc, $0, $1, $2) {
|
|
5607
5637
|
if (!$1)
|
|
5608
5638
|
return $2;
|
|
5609
5639
|
return [$1, ...$2];
|
|
@@ -5612,17 +5642,19 @@ ${input.slice(result.pos)}
|
|
|
5612
5642
|
function CallExpressionRest(ctx, state) {
|
|
5613
5643
|
return $EVENT_C(ctx, state, "CallExpressionRest", CallExpressionRest$$);
|
|
5614
5644
|
}
|
|
5615
|
-
var OptionalShorthand$0 = $TS($S($Q(InlineComment), QuestionMark, OptionalDot), function($skip, $loc, $0, $1, $2, $3) {
|
|
5645
|
+
var OptionalShorthand$0 = $TS($S($EXPECT($R5, "OptionalShorthand /(?=[\\/?])/"), $Q(InlineComment), QuestionMark, OptionalDot), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5616
5646
|
return {
|
|
5617
5647
|
type: "Optional",
|
|
5618
5648
|
children: $0
|
|
5619
5649
|
};
|
|
5620
5650
|
});
|
|
5651
|
+
var OptionalShorthand$1 = NonNullAssertion;
|
|
5652
|
+
var OptionalShorthand$$ = [OptionalShorthand$0, OptionalShorthand$1];
|
|
5621
5653
|
function OptionalShorthand(ctx, state) {
|
|
5622
|
-
return $
|
|
5654
|
+
return $EVENT_C(ctx, state, "OptionalShorthand", OptionalShorthand$$);
|
|
5623
5655
|
}
|
|
5624
5656
|
var OptionalDot$0 = $S($Q(InlineComment), Dot);
|
|
5625
|
-
var OptionalDot$1 =
|
|
5657
|
+
var OptionalDot$1 = InsertDot;
|
|
5626
5658
|
var OptionalDot$$ = [OptionalDot$0, OptionalDot$1];
|
|
5627
5659
|
function OptionalDot(ctx, state) {
|
|
5628
5660
|
return $EVENT_C(ctx, state, "OptionalDot", OptionalDot$$);
|
|
@@ -5666,7 +5698,7 @@ ${input.slice(result.pos)}
|
|
|
5666
5698
|
function MemberExpressionRest(ctx, state) {
|
|
5667
5699
|
return $EVENT(ctx, state, "MemberExpressionRest", MemberExpressionRest$0);
|
|
5668
5700
|
}
|
|
5669
|
-
var MemberExpressionRestBody$0 = $TS($S($E(
|
|
5701
|
+
var MemberExpressionRestBody$0 = $TS($S($E(OptionalShorthand), $Q(InlineComment), MemberBracketContent), function($skip, $loc, $0, $1, $2, $3) {
|
|
5670
5702
|
var dot = $1;
|
|
5671
5703
|
var comments = $2;
|
|
5672
5704
|
var content = $3;
|
|
@@ -5710,35 +5742,21 @@ ${input.slice(result.pos)}
|
|
|
5710
5742
|
expression
|
|
5711
5743
|
};
|
|
5712
5744
|
});
|
|
5713
|
-
var MemberBracketContent$1 = $TS($S(Dot, $C(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2) {
|
|
5714
|
-
var dot = $1;
|
|
5715
|
-
var str = $2;
|
|
5716
|
-
if (Array.isArray(dot))
|
|
5717
|
-
dot = dot[0];
|
|
5718
|
-
return {
|
|
5719
|
-
type: "Index",
|
|
5720
|
-
children: [
|
|
5721
|
-
{ token: "[", $loc: dot.$loc },
|
|
5722
|
-
str,
|
|
5723
|
-
"]"
|
|
5724
|
-
]
|
|
5725
|
-
};
|
|
5726
|
-
});
|
|
5727
|
-
var MemberBracketContent$2 = $TS($S(Dot, IntegerLiteral), function($skip, $loc, $0, $1, $2) {
|
|
5745
|
+
var MemberBracketContent$1 = $TS($S(Dot, $C(TemplateLiteral, StringLiteral, IntegerLiteral)), function($skip, $loc, $0, $1, $2) {
|
|
5728
5746
|
var dot = $1;
|
|
5729
|
-
var
|
|
5747
|
+
var literal = $2;
|
|
5730
5748
|
if (Array.isArray(dot))
|
|
5731
5749
|
dot = dot[0];
|
|
5732
5750
|
return {
|
|
5733
5751
|
type: "Index",
|
|
5734
5752
|
children: [
|
|
5735
5753
|
{ token: "[", $loc: dot.$loc },
|
|
5736
|
-
|
|
5754
|
+
literal,
|
|
5737
5755
|
"]"
|
|
5738
5756
|
]
|
|
5739
5757
|
};
|
|
5740
5758
|
});
|
|
5741
|
-
var MemberBracketContent$
|
|
5759
|
+
var MemberBracketContent$2 = $TS($S(Dot, $EXPECT($L18, 'MemberBracketContent "-"'), IntegerLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
5742
5760
|
var dot = $1;
|
|
5743
5761
|
var neg = $2;
|
|
5744
5762
|
var num = $3;
|
|
@@ -5748,7 +5766,7 @@ ${input.slice(result.pos)}
|
|
|
5748
5766
|
{ type: "Call", children: ["(", neg, num, ")"] }
|
|
5749
5767
|
];
|
|
5750
5768
|
});
|
|
5751
|
-
var MemberBracketContent$$ = [MemberBracketContent$0, MemberBracketContent$1, MemberBracketContent$2
|
|
5769
|
+
var MemberBracketContent$$ = [MemberBracketContent$0, MemberBracketContent$1, MemberBracketContent$2];
|
|
5752
5770
|
function MemberBracketContent(ctx, state) {
|
|
5753
5771
|
return $EVENT_C(ctx, state, "MemberBracketContent", MemberBracketContent$$);
|
|
5754
5772
|
}
|
|
@@ -5816,7 +5834,7 @@ ${input.slice(result.pos)}
|
|
|
5816
5834
|
function SliceParameters(ctx, state) {
|
|
5817
5835
|
return $EVENT_C(ctx, state, "SliceParameters", SliceParameters$$);
|
|
5818
5836
|
}
|
|
5819
|
-
var AccessStart$0 = $TS($S($E(
|
|
5837
|
+
var AccessStart$0 = $TS($S($E(PropertyAccessModifier), Dot, $N(Dot)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5820
5838
|
if ($1)
|
|
5821
5839
|
return [$1, $2];
|
|
5822
5840
|
return $2;
|
|
@@ -5824,6 +5842,12 @@ ${input.slice(result.pos)}
|
|
|
5824
5842
|
function AccessStart(ctx, state) {
|
|
5825
5843
|
return $EVENT(ctx, state, "AccessStart", AccessStart$0);
|
|
5826
5844
|
}
|
|
5845
|
+
var PropertyAccessModifier$0 = QuestionMark;
|
|
5846
|
+
var PropertyAccessModifier$1 = NonNullAssertion;
|
|
5847
|
+
var PropertyAccessModifier$$ = [PropertyAccessModifier$0, PropertyAccessModifier$1];
|
|
5848
|
+
function PropertyAccessModifier(ctx, state) {
|
|
5849
|
+
return $EVENT_C(ctx, state, "PropertyAccessModifier", PropertyAccessModifier$$);
|
|
5850
|
+
}
|
|
5827
5851
|
var PropertyAccess$0 = $TS($S(AccessStart, $Q(InlineComment), $C(IdentifierName, PrivateIdentifier)), function($skip, $loc, $0, $1, $2, $3) {
|
|
5828
5852
|
var access = $1;
|
|
5829
5853
|
var comments = $2;
|
|
@@ -5856,7 +5880,7 @@ ${input.slice(result.pos)}
|
|
|
5856
5880
|
function PropertyAccess(ctx, state) {
|
|
5857
5881
|
return $EVENT_C(ctx, state, "PropertyAccess", PropertyAccess$$);
|
|
5858
5882
|
}
|
|
5859
|
-
var PropertyGlob$0 = $TS($S($S($E(
|
|
5883
|
+
var PropertyGlob$0 = $TS($S($S($E(PropertyAccessModifier), OptionalDot), $Q(InlineComment), BracedObjectLiteral), function($skip, $loc, $0, $1, $2, $3) {
|
|
5860
5884
|
var dot = $1;
|
|
5861
5885
|
var object = $3;
|
|
5862
5886
|
return {
|
|
@@ -5869,7 +5893,7 @@ ${input.slice(result.pos)}
|
|
|
5869
5893
|
function PropertyGlob(ctx, state) {
|
|
5870
5894
|
return $EVENT(ctx, state, "PropertyGlob", PropertyGlob$0);
|
|
5871
5895
|
}
|
|
5872
|
-
var PropertyBind$0 = $TS($S($E(
|
|
5896
|
+
var PropertyBind$0 = $TS($S($E(PropertyAccessModifier), At, OptionalDot, $C(IdentifierName, PrivateIdentifier)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5873
5897
|
var modifier = $1;
|
|
5874
5898
|
var dot = $3;
|
|
5875
5899
|
var id = $4;
|
|
@@ -5884,7 +5908,7 @@ ${input.slice(result.pos)}
|
|
|
5884
5908
|
return $EVENT(ctx, state, "PropertyBind", PropertyBind$0);
|
|
5885
5909
|
}
|
|
5886
5910
|
var SuperProperty$0 = $S(Super, MemberBracketContent);
|
|
5887
|
-
var SuperProperty$1 = $S(Super, $N(
|
|
5911
|
+
var SuperProperty$1 = $S(Super, $N(PropertyAccessModifier), PropertyAccess);
|
|
5888
5912
|
var SuperProperty$$ = [SuperProperty$0, SuperProperty$1];
|
|
5889
5913
|
function SuperProperty(ctx, state) {
|
|
5890
5914
|
return $EVENT_C(ctx, state, "SuperProperty", SuperProperty$$);
|
|
@@ -6016,7 +6040,7 @@ ${input.slice(result.pos)}
|
|
|
6016
6040
|
return $EVENT(ctx, state, "ParameterElement", ParameterElement$0);
|
|
6017
6041
|
}
|
|
6018
6042
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
6019
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $R$0($EXPECT($
|
|
6043
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $R$0($EXPECT($R6, "ParameterElementDelimiter /[)}]/"))));
|
|
6020
6044
|
var ParameterElementDelimiter$2 = $T($S($Y(EOS), InsertComma), function(value) {
|
|
6021
6045
|
return value[1];
|
|
6022
6046
|
});
|
|
@@ -6090,10 +6114,14 @@ ${input.slice(result.pos)}
|
|
|
6090
6114
|
return $EVENT_C(ctx, state, "BindingPattern", BindingPattern$$);
|
|
6091
6115
|
}
|
|
6092
6116
|
var ObjectBindingPattern$0 = $TS($S($E(_), OpenBrace, ObjectBindingPatternContent, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
6117
|
+
var ws1 = $1;
|
|
6118
|
+
var open = $2;
|
|
6093
6119
|
var c = $3;
|
|
6120
|
+
var ws2 = $4;
|
|
6121
|
+
var close = $5;
|
|
6094
6122
|
return {
|
|
6095
6123
|
type: "ObjectBindingPattern",
|
|
6096
|
-
children: [
|
|
6124
|
+
children: [ws1, open, c.children, ws2, close],
|
|
6097
6125
|
names: c.names,
|
|
6098
6126
|
properties: c.children
|
|
6099
6127
|
};
|
|
@@ -6126,13 +6154,17 @@ ${input.slice(result.pos)}
|
|
|
6126
6154
|
return $EVENT(ctx, state, "BindingPropertyList", BindingPropertyList$0);
|
|
6127
6155
|
}
|
|
6128
6156
|
var ArrayBindingPattern$0 = $TS($S($E(_), OpenBracket, ArrayBindingPatternContent, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
6157
|
+
var ws1 = $1;
|
|
6158
|
+
var open = $2;
|
|
6129
6159
|
var c = $3;
|
|
6160
|
+
var ws2 = $4;
|
|
6161
|
+
var close = $5;
|
|
6130
6162
|
return {
|
|
6131
6163
|
...c,
|
|
6132
6164
|
// names, blockPrefix, length
|
|
6133
6165
|
type: "ArrayBindingPattern",
|
|
6134
6166
|
elements: c.children,
|
|
6135
|
-
children: [
|
|
6167
|
+
children: [ws1, open, c.children, ws2, close]
|
|
6136
6168
|
};
|
|
6137
6169
|
});
|
|
6138
6170
|
function ArrayBindingPattern(ctx, state) {
|
|
@@ -6574,7 +6606,7 @@ ${input.slice(result.pos)}
|
|
|
6574
6606
|
function AmpersandBlockRHS(ctx, state) {
|
|
6575
6607
|
return $EVENT(ctx, state, "AmpersandBlockRHS", AmpersandBlockRHS$0);
|
|
6576
6608
|
}
|
|
6577
|
-
var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S($N($EXPECT($
|
|
6609
|
+
var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S($N($EXPECT($R7, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2, $3) {
|
|
6578
6610
|
var callExpRest = $1;
|
|
6579
6611
|
var unaryPostfix = $2;
|
|
6580
6612
|
var binopRHS = $3;
|
|
@@ -6604,7 +6636,7 @@ ${input.slice(result.pos)}
|
|
|
6604
6636
|
function AmpersandBlockRHSBody(ctx, state) {
|
|
6605
6637
|
return $EVENT(ctx, state, "AmpersandBlockRHSBody", AmpersandBlockRHSBody$0);
|
|
6606
6638
|
}
|
|
6607
|
-
var AmpersandUnaryPrefix$0 = $R$0($EXPECT($
|
|
6639
|
+
var AmpersandUnaryPrefix$0 = $R$0($EXPECT($R8, "AmpersandUnaryPrefix /[!~+-]+/"));
|
|
6608
6640
|
function AmpersandUnaryPrefix(ctx, state) {
|
|
6609
6641
|
return $EVENT(ctx, state, "AmpersandUnaryPrefix", AmpersandUnaryPrefix$0);
|
|
6610
6642
|
}
|
|
@@ -6938,12 +6970,13 @@ ${input.slice(result.pos)}
|
|
|
6938
6970
|
function BlockStatementPart(ctx, state) {
|
|
6939
6971
|
return $EVENT(ctx, state, "BlockStatementPart", BlockStatementPart$0);
|
|
6940
6972
|
}
|
|
6941
|
-
var Literal$0 = $TS($S(LiteralContent), function($skip, $loc, $0, $1) {
|
|
6973
|
+
var Literal$0 = $TS($S($EXPECT($R9, `Literal /(?=[0-9.'"tfyno])/`), LiteralContent), function($skip, $loc, $0, $1, $2) {
|
|
6974
|
+
var literal = $2;
|
|
6942
6975
|
return {
|
|
6943
6976
|
type: "Literal",
|
|
6944
|
-
subtype:
|
|
6945
|
-
children:
|
|
6946
|
-
raw:
|
|
6977
|
+
subtype: literal.type,
|
|
6978
|
+
children: [literal],
|
|
6979
|
+
raw: literal.token
|
|
6947
6980
|
};
|
|
6948
6981
|
});
|
|
6949
6982
|
function Literal(ctx, state) {
|
|
@@ -6963,15 +6996,21 @@ ${input.slice(result.pos)}
|
|
|
6963
6996
|
function NullLiteral(ctx, state) {
|
|
6964
6997
|
return $EVENT(ctx, state, "NullLiteral", NullLiteral$0);
|
|
6965
6998
|
}
|
|
6966
|
-
var BooleanLiteral$0 = $T($S(
|
|
6999
|
+
var BooleanLiteral$0 = $T($S($EXPECT($R10, "BooleanLiteral /(?=true|false|yes|no|on|off)/"), _BooleanLiteral), function(value) {
|
|
6967
7000
|
return value[1];
|
|
6968
7001
|
});
|
|
6969
|
-
|
|
7002
|
+
function BooleanLiteral(ctx, state) {
|
|
7003
|
+
return $EVENT(ctx, state, "BooleanLiteral", BooleanLiteral$0);
|
|
7004
|
+
}
|
|
7005
|
+
var _BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
7006
|
+
return value[1];
|
|
7007
|
+
});
|
|
7008
|
+
var _BooleanLiteral$1 = $TS($S($C($EXPECT($L27, '_BooleanLiteral "true"'), $EXPECT($L28, '_BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6970
7009
|
return { $loc, token: $1 };
|
|
6971
7010
|
});
|
|
6972
|
-
var
|
|
6973
|
-
function
|
|
6974
|
-
return $EVENT_C(ctx, state, "
|
|
7011
|
+
var _BooleanLiteral$$ = [_BooleanLiteral$0, _BooleanLiteral$1];
|
|
7012
|
+
function _BooleanLiteral(ctx, state) {
|
|
7013
|
+
return $EVENT_C(ctx, state, "_BooleanLiteral", _BooleanLiteral$$);
|
|
6975
7014
|
}
|
|
6976
7015
|
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L29, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L30, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
6977
7016
|
return { $loc, token: "true" };
|
|
@@ -6983,13 +7022,14 @@ ${input.slice(result.pos)}
|
|
|
6983
7022
|
function CoffeeScriptBooleanLiteral(ctx, state) {
|
|
6984
7023
|
return $EVENT_C(ctx, state, "CoffeeScriptBooleanLiteral", CoffeeScriptBooleanLiteral$$);
|
|
6985
7024
|
}
|
|
6986
|
-
var Identifier$0 = $T($S($N(ReservedWord), IdentifierName), function(value) {
|
|
6987
|
-
|
|
7025
|
+
var Identifier$0 = $T($S($EXPECT($R11, "Identifier /(?=\\p{ID_Start}|[_$])/"), $N(ReservedWord), IdentifierName), function(value) {
|
|
7026
|
+
var id = value[2];
|
|
7027
|
+
return id;
|
|
6988
7028
|
});
|
|
6989
7029
|
function Identifier(ctx, state) {
|
|
6990
7030
|
return $EVENT(ctx, state, "Identifier", Identifier$0);
|
|
6991
7031
|
}
|
|
6992
|
-
var IdentifierName$0 = $TR($EXPECT($
|
|
7032
|
+
var IdentifierName$0 = $TR($EXPECT($R12, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
6993
7033
|
return {
|
|
6994
7034
|
type: "Identifier",
|
|
6995
7035
|
name: $0,
|
|
@@ -7011,10 +7051,16 @@ ${input.slice(result.pos)}
|
|
|
7011
7051
|
function UpcomingAssignment(ctx, state) {
|
|
7012
7052
|
return $EVENT(ctx, state, "UpcomingAssignment", UpcomingAssignment$0);
|
|
7013
7053
|
}
|
|
7014
|
-
var ArrayLiteral$0 = $T($S(
|
|
7054
|
+
var ArrayLiteral$0 = $T($S($EXPECT($R13, "ArrayLiteral /(?=\\[)/"), _ArrayLiteral), function(value) {
|
|
7055
|
+
return value[1];
|
|
7056
|
+
});
|
|
7057
|
+
function ArrayLiteral(ctx, state) {
|
|
7058
|
+
return $EVENT(ctx, state, "ArrayLiteral", ArrayLiteral$0);
|
|
7059
|
+
}
|
|
7060
|
+
var _ArrayLiteral$0 = $T($S(ArrayBindingPattern, UpcomingAssignment), function(value) {
|
|
7015
7061
|
return value[0];
|
|
7016
7062
|
});
|
|
7017
|
-
var
|
|
7063
|
+
var _ArrayLiteral$1 = $TS($S(OpenBracket, AllowAll, $E($S(ArrayLiteralContent, __, CloseBracket)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7018
7064
|
var open = $1;
|
|
7019
7065
|
if (!$3)
|
|
7020
7066
|
return $skip;
|
|
@@ -7038,9 +7084,9 @@ ${input.slice(result.pos)}
|
|
|
7038
7084
|
names
|
|
7039
7085
|
};
|
|
7040
7086
|
});
|
|
7041
|
-
var
|
|
7042
|
-
function
|
|
7043
|
-
return $EVENT_C(ctx, state, "
|
|
7087
|
+
var _ArrayLiteral$$ = [_ArrayLiteral$0, _ArrayLiteral$1];
|
|
7088
|
+
function _ArrayLiteral(ctx, state) {
|
|
7089
|
+
return $EVENT_C(ctx, state, "_ArrayLiteral", _ArrayLiteral$$);
|
|
7044
7090
|
}
|
|
7045
7091
|
var RangeExpression$0 = $TS($S(ExtendedExpression, __, $C(DotDotDot, DotDot), ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
7046
7092
|
var s = $1;
|
|
@@ -7405,7 +7451,7 @@ ${input.slice(result.pos)}
|
|
|
7405
7451
|
children: [ws, ...prop.children]
|
|
7406
7452
|
};
|
|
7407
7453
|
});
|
|
7408
|
-
var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($
|
|
7454
|
+
var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($R14, "PropertyDefinition /[!+-]/")), PropertyName), function($skip, $loc, $0, $1, $2, $3) {
|
|
7409
7455
|
var ws = $1;
|
|
7410
7456
|
var toggle = $2;
|
|
7411
7457
|
var id = $3;
|
|
@@ -7997,7 +8043,7 @@ ${input.slice(result.pos)}
|
|
|
7997
8043
|
var BinaryOpSymbol$14 = $T($EXPECT($L66, 'BinaryOpSymbol "\xAB"'), function(value) {
|
|
7998
8044
|
return "<<";
|
|
7999
8045
|
});
|
|
8000
|
-
var BinaryOpSymbol$15 = $TR($EXPECT($
|
|
8046
|
+
var BinaryOpSymbol$15 = $TR($EXPECT($R15, "BinaryOpSymbol /<(?!\\p{ID_Start}|[_$])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8001
8047
|
return "<";
|
|
8002
8048
|
});
|
|
8003
8049
|
var BinaryOpSymbol$16 = $EXPECT($L67, 'BinaryOpSymbol ">>>"');
|
|
@@ -8036,36 +8082,33 @@ ${input.slice(result.pos)}
|
|
|
8036
8082
|
return "&&";
|
|
8037
8083
|
});
|
|
8038
8084
|
var BinaryOpSymbol$29 = $EXPECT($L83, 'BinaryOpSymbol "&&"');
|
|
8039
|
-
var BinaryOpSymbol$30 = $T($S(
|
|
8040
|
-
return "in";
|
|
8041
|
-
});
|
|
8042
|
-
var BinaryOpSymbol$31 = $T($S($EXPECT($L85, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
8085
|
+
var BinaryOpSymbol$30 = $T($S($EXPECT($L84, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
8043
8086
|
return "||";
|
|
8044
8087
|
});
|
|
8045
|
-
var BinaryOpSymbol$
|
|
8046
|
-
var BinaryOpSymbol$
|
|
8088
|
+
var BinaryOpSymbol$31 = $EXPECT($L85, 'BinaryOpSymbol "||"');
|
|
8089
|
+
var BinaryOpSymbol$32 = $T($EXPECT($L86, 'BinaryOpSymbol "\u2016"'), function(value) {
|
|
8047
8090
|
return "||";
|
|
8048
8091
|
});
|
|
8049
|
-
var BinaryOpSymbol$
|
|
8092
|
+
var BinaryOpSymbol$33 = $TV($C($EXPECT($L87, 'BinaryOpSymbol "^^"'), $S($EXPECT($L88, 'BinaryOpSymbol "xor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8050
8093
|
return {
|
|
8051
8094
|
call: module.getRef("xor"),
|
|
8052
8095
|
special: true
|
|
8053
8096
|
};
|
|
8054
8097
|
});
|
|
8055
|
-
var BinaryOpSymbol$
|
|
8098
|
+
var BinaryOpSymbol$34 = $TV($C($EXPECT($R16, "BinaryOpSymbol /!\\^\\^?/"), $S($EXPECT($L89, 'BinaryOpSymbol "xnor"'), NonIdContinue)), function($skip, $loc, $0, $1) {
|
|
8056
8099
|
return {
|
|
8057
8100
|
call: module.getRef("xnor"),
|
|
8058
8101
|
special: true
|
|
8059
8102
|
};
|
|
8060
8103
|
});
|
|
8061
|
-
var BinaryOpSymbol$
|
|
8062
|
-
var BinaryOpSymbol$
|
|
8104
|
+
var BinaryOpSymbol$35 = $EXPECT($L90, 'BinaryOpSymbol "??"');
|
|
8105
|
+
var BinaryOpSymbol$36 = $T($EXPECT($L91, 'BinaryOpSymbol "\u2047"'), function(value) {
|
|
8063
8106
|
return "??";
|
|
8064
8107
|
});
|
|
8065
|
-
var BinaryOpSymbol$
|
|
8108
|
+
var BinaryOpSymbol$37 = $T($S($EXPECT($L5, 'BinaryOpSymbol "?"'), CoffeeBinaryExistentialEnabled), function(value) {
|
|
8066
8109
|
return "??";
|
|
8067
8110
|
});
|
|
8068
|
-
var BinaryOpSymbol$
|
|
8111
|
+
var BinaryOpSymbol$38 = $TS($S($EXPECT($L92, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8069
8112
|
return {
|
|
8070
8113
|
$loc,
|
|
8071
8114
|
token: $1,
|
|
@@ -8074,24 +8117,15 @@ ${input.slice(result.pos)}
|
|
|
8074
8117
|
// for typeof shorthand
|
|
8075
8118
|
};
|
|
8076
8119
|
});
|
|
8077
|
-
var BinaryOpSymbol$
|
|
8078
|
-
|
|
8079
|
-
|
|
8080
|
-
token: "instanceof",
|
|
8081
|
-
relational: true,
|
|
8082
|
-
special: true,
|
|
8083
|
-
negated: true
|
|
8084
|
-
};
|
|
8120
|
+
var BinaryOpSymbol$39 = $T($S(CoffeeOfEnabled, CoffeeOfOp), function(value) {
|
|
8121
|
+
var op = value[1];
|
|
8122
|
+
return op;
|
|
8085
8123
|
});
|
|
8086
|
-
var BinaryOpSymbol$
|
|
8087
|
-
|
|
8088
|
-
|
|
8089
|
-
token: "in",
|
|
8090
|
-
special: true,
|
|
8091
|
-
negated: true
|
|
8092
|
-
};
|
|
8124
|
+
var BinaryOpSymbol$40 = $TS($S(Not, __, NotOp), function($skip, $loc, $0, $1, $2, $3) {
|
|
8125
|
+
var op = $3;
|
|
8126
|
+
return { ...op, $loc };
|
|
8093
8127
|
});
|
|
8094
|
-
var BinaryOpSymbol$
|
|
8128
|
+
var BinaryOpSymbol$41 = $TV($C($S(Is, __, In), $EXPECT($L93, 'BinaryOpSymbol "\u2208"')), function($skip, $loc, $0, $1) {
|
|
8095
8129
|
return {
|
|
8096
8130
|
method: "includes",
|
|
8097
8131
|
relational: true,
|
|
@@ -8099,14 +8133,14 @@ ${input.slice(result.pos)}
|
|
|
8099
8133
|
special: true
|
|
8100
8134
|
};
|
|
8101
8135
|
});
|
|
8102
|
-
var BinaryOpSymbol$
|
|
8136
|
+
var BinaryOpSymbol$42 = $TV($EXPECT($L94, 'BinaryOpSymbol "\u220B"'), function($skip, $loc, $0, $1) {
|
|
8103
8137
|
return {
|
|
8104
8138
|
method: "includes",
|
|
8105
8139
|
relational: true,
|
|
8106
8140
|
special: true
|
|
8107
8141
|
};
|
|
8108
8142
|
});
|
|
8109
|
-
var BinaryOpSymbol$
|
|
8143
|
+
var BinaryOpSymbol$43 = $TV($EXPECT($L95, 'BinaryOpSymbol "\u220C"'), function($skip, $loc, $0, $1) {
|
|
8110
8144
|
return {
|
|
8111
8145
|
method: "includes",
|
|
8112
8146
|
relational: true,
|
|
@@ -8114,16 +8148,7 @@ ${input.slice(result.pos)}
|
|
|
8114
8148
|
negated: true
|
|
8115
8149
|
};
|
|
8116
8150
|
});
|
|
8117
|
-
var BinaryOpSymbol$
|
|
8118
|
-
return {
|
|
8119
|
-
call: [module.getRef("indexOf"), ".call"],
|
|
8120
|
-
relational: true,
|
|
8121
|
-
reversed: true,
|
|
8122
|
-
suffix: " >= 0",
|
|
8123
|
-
special: true
|
|
8124
|
-
};
|
|
8125
|
-
});
|
|
8126
|
-
var BinaryOpSymbol$46 = $TV($C($S(Is, __, Not, __, In), $EXPECT($L97, 'BinaryOpSymbol "\u2209"')), function($skip, $loc, $0, $1) {
|
|
8151
|
+
var BinaryOpSymbol$44 = $TV($C($S(Is, __, Not, __, In), $EXPECT($L96, 'BinaryOpSymbol "\u2209"')), function($skip, $loc, $0, $1) {
|
|
8127
8152
|
return {
|
|
8128
8153
|
method: "includes",
|
|
8129
8154
|
relational: true,
|
|
@@ -8132,16 +8157,7 @@ ${input.slice(result.pos)}
|
|
|
8132
8157
|
negated: true
|
|
8133
8158
|
};
|
|
8134
8159
|
});
|
|
8135
|
-
var BinaryOpSymbol$
|
|
8136
|
-
return {
|
|
8137
|
-
call: [module.getRef("indexOf"), ".call"],
|
|
8138
|
-
relational: true,
|
|
8139
|
-
reversed: true,
|
|
8140
|
-
suffix: " < 0",
|
|
8141
|
-
special: true
|
|
8142
|
-
};
|
|
8143
|
-
});
|
|
8144
|
-
var BinaryOpSymbol$48 = $TS($S($N(CoffeeNotEnabled), Is, __, Not), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8160
|
+
var BinaryOpSymbol$45 = $TS($S($N(CoffeeNotEnabled), Is, __, Not), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8145
8161
|
if (module.config.objectIs) {
|
|
8146
8162
|
return {
|
|
8147
8163
|
call: module.getRef("is"),
|
|
@@ -8153,7 +8169,7 @@ ${input.slice(result.pos)}
|
|
|
8153
8169
|
}
|
|
8154
8170
|
return "!==";
|
|
8155
8171
|
});
|
|
8156
|
-
var BinaryOpSymbol$
|
|
8172
|
+
var BinaryOpSymbol$46 = $TS($S(Is), function($skip, $loc, $0, $1) {
|
|
8157
8173
|
if (module.config.objectIs) {
|
|
8158
8174
|
return {
|
|
8159
8175
|
call: module.getRef("is"),
|
|
@@ -8164,34 +8180,86 @@ ${input.slice(result.pos)}
|
|
|
8164
8180
|
}
|
|
8165
8181
|
return "===";
|
|
8166
8182
|
});
|
|
8167
|
-
var BinaryOpSymbol$
|
|
8168
|
-
|
|
8169
|
-
|
|
8170
|
-
var BinaryOpSymbol$
|
|
8171
|
-
var BinaryOpSymbol
|
|
8172
|
-
var BinaryOpSymbol$53 = $EXPECT($L99, 'BinaryOpSymbol "|"');
|
|
8173
|
-
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, BinaryOpSymbol$51, BinaryOpSymbol$52, BinaryOpSymbol$53];
|
|
8183
|
+
var BinaryOpSymbol$47 = In;
|
|
8184
|
+
var BinaryOpSymbol$48 = $EXPECT($L97, 'BinaryOpSymbol "&"');
|
|
8185
|
+
var BinaryOpSymbol$49 = $EXPECT($L17, 'BinaryOpSymbol "^"');
|
|
8186
|
+
var BinaryOpSymbol$50 = $EXPECT($L98, 'BinaryOpSymbol "|"');
|
|
8187
|
+
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];
|
|
8174
8188
|
function BinaryOpSymbol(ctx, state) {
|
|
8175
8189
|
return $EVENT_C(ctx, state, "BinaryOpSymbol", BinaryOpSymbol$$);
|
|
8176
8190
|
}
|
|
8177
|
-
var
|
|
8178
|
-
|
|
8191
|
+
var CoffeeOfOp$0 = $T($S(Of), function(value) {
|
|
8192
|
+
return "in";
|
|
8193
|
+
});
|
|
8194
|
+
var CoffeeOfOp$1 = $TS($S(In), function($skip, $loc, $0, $1) {
|
|
8195
|
+
return {
|
|
8196
|
+
call: [module.getRef("indexOf"), ".call"],
|
|
8197
|
+
relational: true,
|
|
8198
|
+
reversed: true,
|
|
8199
|
+
suffix: " >= 0",
|
|
8200
|
+
special: true
|
|
8201
|
+
};
|
|
8202
|
+
});
|
|
8203
|
+
var CoffeeOfOp$2 = $TS($S(Not, __, Of, NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
8204
|
+
return {
|
|
8205
|
+
$loc,
|
|
8206
|
+
token: "in",
|
|
8207
|
+
special: true,
|
|
8208
|
+
negated: true
|
|
8209
|
+
};
|
|
8210
|
+
});
|
|
8211
|
+
var CoffeeOfOp$3 = $TS($S(Not, __, In), function($skip, $loc, $0, $1, $2, $3) {
|
|
8212
|
+
return {
|
|
8213
|
+
call: [module.getRef("indexOf"), ".call"],
|
|
8214
|
+
relational: true,
|
|
8215
|
+
reversed: true,
|
|
8216
|
+
suffix: " < 0",
|
|
8217
|
+
special: true
|
|
8218
|
+
};
|
|
8219
|
+
});
|
|
8220
|
+
var CoffeeOfOp$$ = [CoffeeOfOp$0, CoffeeOfOp$1, CoffeeOfOp$2, CoffeeOfOp$3];
|
|
8221
|
+
function CoffeeOfOp(ctx, state) {
|
|
8222
|
+
return $EVENT_C(ctx, state, "CoffeeOfOp", CoffeeOfOp$$);
|
|
8223
|
+
}
|
|
8224
|
+
var NotOp$0 = $TS($S($EXPECT($L92, 'NotOp "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
8225
|
+
return {
|
|
8226
|
+
$loc,
|
|
8227
|
+
token: "instanceof",
|
|
8228
|
+
relational: true,
|
|
8229
|
+
special: true,
|
|
8230
|
+
negated: true
|
|
8231
|
+
};
|
|
8232
|
+
});
|
|
8233
|
+
var NotOp$1 = $TS($S(In), function($skip, $loc, $0, $1) {
|
|
8234
|
+
return {
|
|
8235
|
+
$loc,
|
|
8236
|
+
token: "in",
|
|
8237
|
+
special: true,
|
|
8238
|
+
negated: true
|
|
8239
|
+
};
|
|
8240
|
+
});
|
|
8241
|
+
var NotOp$$ = [NotOp$0, NotOp$1];
|
|
8242
|
+
function NotOp(ctx, state) {
|
|
8243
|
+
return $EVENT_C(ctx, state, "NotOp", NotOp$$);
|
|
8244
|
+
}
|
|
8245
|
+
var Xor$0 = $EXPECT($L87, 'Xor "^^"');
|
|
8246
|
+
var Xor$1 = $S($EXPECT($L88, 'Xor "xor"'), NonIdContinue);
|
|
8179
8247
|
var Xor$$ = [Xor$0, Xor$1];
|
|
8180
8248
|
function Xor(ctx, state) {
|
|
8181
8249
|
return $EVENT_C(ctx, state, "Xor", Xor$$);
|
|
8182
8250
|
}
|
|
8183
|
-
var Xnor$0 = $R$0($EXPECT($
|
|
8184
|
-
var Xnor$1 = $EXPECT($
|
|
8251
|
+
var Xnor$0 = $R$0($EXPECT($R16, "Xnor /!\\^\\^?/"));
|
|
8252
|
+
var Xnor$1 = $EXPECT($L89, 'Xnor "xnor"');
|
|
8185
8253
|
var Xnor$$ = [Xnor$0, Xnor$1];
|
|
8186
8254
|
function Xnor(ctx, state) {
|
|
8187
8255
|
return $EVENT_C(ctx, state, "Xnor", Xnor$$);
|
|
8188
8256
|
}
|
|
8189
|
-
var UnaryOp$0 = $TR($EXPECT($
|
|
8257
|
+
var UnaryOp$0 = $TR($EXPECT($R17, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
8190
8258
|
return { $loc, token: $0 };
|
|
8191
8259
|
});
|
|
8192
8260
|
var UnaryOp$1 = AwaitOp;
|
|
8193
|
-
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($EXPECT($
|
|
8194
|
-
var UnaryOp$3 = $T($S(Not, $E($EXPECT($
|
|
8261
|
+
var UnaryOp$2 = $S($C(Delete, Void, Typeof), $N($EXPECT($L11, 'UnaryOp ":"')), $E(_));
|
|
8262
|
+
var UnaryOp$3 = $T($S(Not, $E($EXPECT($L12, 'UnaryOp " "')), $E(_)), function(value) {
|
|
8195
8263
|
return [value[0], value[2]];
|
|
8196
8264
|
});
|
|
8197
8265
|
var UnaryOp$$ = [UnaryOp$0, UnaryOp$1, UnaryOp$2, UnaryOp$3];
|
|
@@ -8257,14 +8325,20 @@ ${input.slice(result.pos)}
|
|
|
8257
8325
|
function NonPipelinePostfixedExpression(ctx, state) {
|
|
8258
8326
|
return $EVENT(ctx, state, "NonPipelinePostfixedExpression", NonPipelinePostfixedExpression$0);
|
|
8259
8327
|
}
|
|
8260
|
-
var PostfixStatement$0 =
|
|
8261
|
-
|
|
8262
|
-
|
|
8263
|
-
var PostfixStatement$3 = UnlessClause;
|
|
8264
|
-
var PostfixStatement$4 = WhileClause;
|
|
8265
|
-
var PostfixStatement$$ = [PostfixStatement$0, PostfixStatement$1, PostfixStatement$2, PostfixStatement$3, PostfixStatement$4];
|
|
8328
|
+
var PostfixStatement$0 = $T($S($EXPECT($R18, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
|
|
8329
|
+
return value[1];
|
|
8330
|
+
});
|
|
8266
8331
|
function PostfixStatement(ctx, state) {
|
|
8267
|
-
return $
|
|
8332
|
+
return $EVENT(ctx, state, "PostfixStatement", PostfixStatement$0);
|
|
8333
|
+
}
|
|
8334
|
+
var _PostfixStatement$0 = ForClause;
|
|
8335
|
+
var _PostfixStatement$1 = IfClause;
|
|
8336
|
+
var _PostfixStatement$2 = LoopClause;
|
|
8337
|
+
var _PostfixStatement$3 = UnlessClause;
|
|
8338
|
+
var _PostfixStatement$4 = WhileClause;
|
|
8339
|
+
var _PostfixStatement$$ = [_PostfixStatement$0, _PostfixStatement$1, _PostfixStatement$2, _PostfixStatement$3, _PostfixStatement$4];
|
|
8340
|
+
function _PostfixStatement(ctx, state) {
|
|
8341
|
+
return $EVENT_C(ctx, state, "_PostfixStatement", _PostfixStatement$$);
|
|
8268
8342
|
}
|
|
8269
8343
|
var Statement$0 = KeywordStatement;
|
|
8270
8344
|
var Statement$1 = VariableStatement;
|
|
@@ -8285,7 +8359,7 @@ ${input.slice(result.pos)}
|
|
|
8285
8359
|
function Statement(ctx, state) {
|
|
8286
8360
|
return $EVENT_C(ctx, state, "Statement", Statement$$);
|
|
8287
8361
|
}
|
|
8288
|
-
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($
|
|
8362
|
+
var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L99, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
|
|
8289
8363
|
return { type: "EmptyStatement", children: $1 || [] };
|
|
8290
8364
|
});
|
|
8291
8365
|
function EmptyStatement(ctx, state) {
|
|
@@ -8307,7 +8381,7 @@ ${input.slice(result.pos)}
|
|
|
8307
8381
|
var w = $3;
|
|
8308
8382
|
return [id, colon, w];
|
|
8309
8383
|
});
|
|
8310
|
-
var Label$1 = $S($EXPECT($
|
|
8384
|
+
var Label$1 = $S($EXPECT($L100, 'Label "$:"'), Whitespace);
|
|
8311
8385
|
var Label$$ = [Label$0, Label$1];
|
|
8312
8386
|
function Label(ctx, state) {
|
|
8313
8387
|
return $EVENT_C(ctx, state, "Label", Label$$);
|
|
@@ -8480,18 +8554,24 @@ ${input.slice(result.pos)}
|
|
|
8480
8554
|
function BlockExpressionPart(ctx, state) {
|
|
8481
8555
|
return $EVENT(ctx, state, "BlockExpressionPart", BlockExpressionPart$0);
|
|
8482
8556
|
}
|
|
8483
|
-
var IterationStatement$0 =
|
|
8484
|
-
var IterationStatement$1 = $T($S($N(CoffeeDoEnabled), DoWhileStatement), function(value) {
|
|
8557
|
+
var IterationStatement$0 = $T($S($EXPECT($R19, "IterationStatement /(?=loop|do|for|until|while)/"), _IterationStatement), function(value) {
|
|
8485
8558
|
return value[1];
|
|
8486
8559
|
});
|
|
8487
|
-
|
|
8560
|
+
function IterationStatement(ctx, state) {
|
|
8561
|
+
return $EVENT(ctx, state, "IterationStatement", IterationStatement$0);
|
|
8562
|
+
}
|
|
8563
|
+
var _IterationStatement$0 = LoopStatement;
|
|
8564
|
+
var _IterationStatement$1 = $T($S($N(CoffeeDoEnabled), DoWhileStatement), function(value) {
|
|
8488
8565
|
return value[1];
|
|
8489
8566
|
});
|
|
8490
|
-
var
|
|
8491
|
-
|
|
8492
|
-
|
|
8493
|
-
|
|
8494
|
-
|
|
8567
|
+
var _IterationStatement$2 = $T($S($N(CoffeeDoEnabled), DoStatement), function(value) {
|
|
8568
|
+
return value[1];
|
|
8569
|
+
});
|
|
8570
|
+
var _IterationStatement$3 = WhileStatement;
|
|
8571
|
+
var _IterationStatement$4 = ForStatement;
|
|
8572
|
+
var _IterationStatement$$ = [_IterationStatement$0, _IterationStatement$1, _IterationStatement$2, _IterationStatement$3, _IterationStatement$4];
|
|
8573
|
+
function _IterationStatement(ctx, state) {
|
|
8574
|
+
return $EVENT_C(ctx, state, "_IterationStatement", _IterationStatement$$);
|
|
8495
8575
|
}
|
|
8496
8576
|
var IterationExpression$0 = $TS($S($E($S(Async, __)), IterationStatement), function($skip, $loc, $0, $1, $2) {
|
|
8497
8577
|
var async = $1;
|
|
@@ -8826,7 +8906,7 @@ ${input.slice(result.pos)}
|
|
|
8826
8906
|
names: binding.names
|
|
8827
8907
|
};
|
|
8828
8908
|
});
|
|
8829
|
-
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($
|
|
8909
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R20, "ForDeclaration /(?=[\\s\\),])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
8830
8910
|
var c = $1;
|
|
8831
8911
|
var binding = $2;
|
|
8832
8912
|
return {
|
|
@@ -9052,7 +9132,7 @@ ${input.slice(result.pos)}
|
|
|
9052
9132
|
function IgnoreColon(ctx, state) {
|
|
9053
9133
|
return $EVENT(ctx, state, "IgnoreColon", IgnoreColon$0);
|
|
9054
9134
|
}
|
|
9055
|
-
var TryStatement$0 = $TS($S(Try, $N($EXPECT($
|
|
9135
|
+
var TryStatement$0 = $TS($S(Try, $N($EXPECT($L11, 'TryStatement ":"')), NoPostfixBracedOrEmptyBlock, $E(CatchClause), $E(FinallyClause)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
9056
9136
|
var t = $1;
|
|
9057
9137
|
var b = $3;
|
|
9058
9138
|
var c = $4;
|
|
@@ -9360,7 +9440,7 @@ ${input.slice(result.pos)}
|
|
|
9360
9440
|
};
|
|
9361
9441
|
});
|
|
9362
9442
|
var KeywordStatement$2 = DebuggerStatement;
|
|
9363
|
-
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($
|
|
9443
|
+
var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L11, 'KeywordStatement ":"'), $EXPECT($L6, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
|
|
9364
9444
|
var expression = value[2];
|
|
9365
9445
|
return { "type": "ReturnStatement", "expression": expression, "children": value };
|
|
9366
9446
|
});
|
|
@@ -9381,19 +9461,19 @@ ${input.slice(result.pos)}
|
|
|
9381
9461
|
function ThrowStatement(ctx, state) {
|
|
9382
9462
|
return $EVENT(ctx, state, "ThrowStatement", ThrowStatement$0);
|
|
9383
9463
|
}
|
|
9384
|
-
var Break$0 = $TS($S($EXPECT($
|
|
9464
|
+
var Break$0 = $TS($S($EXPECT($L101, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9385
9465
|
return { $loc, token: $1 };
|
|
9386
9466
|
});
|
|
9387
9467
|
function Break(ctx, state) {
|
|
9388
9468
|
return $EVENT(ctx, state, "Break", Break$0);
|
|
9389
9469
|
}
|
|
9390
|
-
var Continue$0 = $TS($S($EXPECT($
|
|
9470
|
+
var Continue$0 = $TS($S($EXPECT($L102, 'Continue "continue"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9391
9471
|
return { $loc, token: $1 };
|
|
9392
9472
|
});
|
|
9393
9473
|
function Continue(ctx, state) {
|
|
9394
9474
|
return $EVENT(ctx, state, "Continue", Continue$0);
|
|
9395
9475
|
}
|
|
9396
|
-
var Debugger$0 = $TS($S($EXPECT($
|
|
9476
|
+
var Debugger$0 = $TS($S($EXPECT($L103, 'Debugger "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
9397
9477
|
return { $loc, token: $1 };
|
|
9398
9478
|
});
|
|
9399
9479
|
function Debugger(ctx, state) {
|
|
@@ -9514,7 +9594,7 @@ ${input.slice(result.pos)}
|
|
|
9514
9594
|
function FromClause(ctx, state) {
|
|
9515
9595
|
return $EVENT(ctx, state, "FromClause", FromClause$0);
|
|
9516
9596
|
}
|
|
9517
|
-
var ImportAssertion$0 = $S($E(_), $EXPECT($
|
|
9597
|
+
var ImportAssertion$0 = $S($E(_), $EXPECT($L104, 'ImportAssertion "assert"'), NonIdContinue, $E(_), ObjectLiteral);
|
|
9518
9598
|
function ImportAssertion(ctx, state) {
|
|
9519
9599
|
return $EVENT(ctx, state, "ImportAssertion", ImportAssertion$0);
|
|
9520
9600
|
}
|
|
@@ -9562,7 +9642,7 @@ ${input.slice(result.pos)}
|
|
|
9562
9642
|
return $EVENT_C(ctx, state, "ImportSpecifier", ImportSpecifier$$);
|
|
9563
9643
|
}
|
|
9564
9644
|
var ImportAsToken$0 = $S(__, As);
|
|
9565
|
-
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($
|
|
9645
|
+
var ImportAsToken$1 = $TS($S(Loc, __, Colon, $E($EXPECT($L12, 'ImportAsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
9566
9646
|
var l = $1;
|
|
9567
9647
|
var ws = $2;
|
|
9568
9648
|
var c = $3;
|
|
@@ -9602,7 +9682,7 @@ ${input.slice(result.pos)}
|
|
|
9602
9682
|
function UnprocessedModuleSpecifier(ctx, state) {
|
|
9603
9683
|
return $EVENT_C(ctx, state, "UnprocessedModuleSpecifier", UnprocessedModuleSpecifier$$);
|
|
9604
9684
|
}
|
|
9605
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
9685
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R21, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
9606
9686
|
var spec = $0;
|
|
9607
9687
|
return { $loc, token: `"${spec}"` };
|
|
9608
9688
|
});
|
|
@@ -9734,13 +9814,13 @@ ${input.slice(result.pos)}
|
|
|
9734
9814
|
function LexicalDeclaration(ctx, state) {
|
|
9735
9815
|
return $EVENT_C(ctx, state, "LexicalDeclaration", LexicalDeclaration$$);
|
|
9736
9816
|
}
|
|
9737
|
-
var ConstAssignment$0 = $TV($C($EXPECT($
|
|
9817
|
+
var ConstAssignment$0 = $TV($C($EXPECT($L105, 'ConstAssignment ":="'), $EXPECT($L106, 'ConstAssignment "\u2254"')), function($skip, $loc, $0, $1) {
|
|
9738
9818
|
return { $loc, token: "=" };
|
|
9739
9819
|
});
|
|
9740
9820
|
function ConstAssignment(ctx, state) {
|
|
9741
9821
|
return $EVENT(ctx, state, "ConstAssignment", ConstAssignment$0);
|
|
9742
9822
|
}
|
|
9743
|
-
var LetAssignment$0 = $TV($EXPECT($
|
|
9823
|
+
var LetAssignment$0 = $TV($EXPECT($L107, 'LetAssignment ".="'), function($skip, $loc, $0, $1) {
|
|
9744
9824
|
return { $loc, token: "=" };
|
|
9745
9825
|
});
|
|
9746
9826
|
function LetAssignment(ctx, state) {
|
|
@@ -9808,8 +9888,9 @@ ${input.slice(result.pos)}
|
|
|
9808
9888
|
function VariableDeclarationList(ctx, state) {
|
|
9809
9889
|
return $EVENT(ctx, state, "VariableDeclarationList", VariableDeclarationList$0);
|
|
9810
9890
|
}
|
|
9811
|
-
var NumericLiteral$0 = $TS($S(NumericLiteralKind), function($skip, $loc, $0, $1) {
|
|
9812
|
-
|
|
9891
|
+
var NumericLiteral$0 = $TS($S($EXPECT($R22, "NumericLiteral /(?=[0-9.])/"), NumericLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
9892
|
+
var token = $2;
|
|
9893
|
+
return { type: "NumericLiteral", $loc, token };
|
|
9813
9894
|
});
|
|
9814
9895
|
function NumericLiteral(ctx, state) {
|
|
9815
9896
|
return $EVENT(ctx, state, "NumericLiteral", NumericLiteral$0);
|
|
@@ -9823,37 +9904,38 @@ ${input.slice(result.pos)}
|
|
|
9823
9904
|
function NumericLiteralKind(ctx, state) {
|
|
9824
9905
|
return $EVENT_C(ctx, state, "NumericLiteralKind", NumericLiteralKind$$);
|
|
9825
9906
|
}
|
|
9826
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
9907
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R23, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
9827
9908
|
function DecimalBigIntegerLiteral(ctx, state) {
|
|
9828
9909
|
return $EVENT(ctx, state, "DecimalBigIntegerLiteral", DecimalBigIntegerLiteral$0);
|
|
9829
9910
|
}
|
|
9830
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
9911
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R24, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
9831
9912
|
return $1 + ".";
|
|
9832
9913
|
});
|
|
9833
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
9834
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
9914
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R25, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*))?/"), $E(ExponentPart)));
|
|
9915
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R26, "DecimalLiteral /(?:\\.[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
9835
9916
|
var DecimalLiteral$$ = [DecimalLiteral$0, DecimalLiteral$1, DecimalLiteral$2];
|
|
9836
9917
|
function DecimalLiteral(ctx, state) {
|
|
9837
9918
|
return $EVENT_C(ctx, state, "DecimalLiteral", DecimalLiteral$$);
|
|
9838
9919
|
}
|
|
9839
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
9920
|
+
var ExponentPart$0 = $R$0($EXPECT($R27, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
9840
9921
|
function ExponentPart(ctx, state) {
|
|
9841
9922
|
return $EVENT(ctx, state, "ExponentPart", ExponentPart$0);
|
|
9842
9923
|
}
|
|
9843
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
9924
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R28, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
9844
9925
|
function BinaryIntegerLiteral(ctx, state) {
|
|
9845
9926
|
return $EVENT(ctx, state, "BinaryIntegerLiteral", BinaryIntegerLiteral$0);
|
|
9846
9927
|
}
|
|
9847
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
9928
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R29, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
9848
9929
|
function OctalIntegerLiteral(ctx, state) {
|
|
9849
9930
|
return $EVENT(ctx, state, "OctalIntegerLiteral", OctalIntegerLiteral$0);
|
|
9850
9931
|
}
|
|
9851
|
-
var HexIntegerLiteral$0 = $R$0($EXPECT($
|
|
9932
|
+
var HexIntegerLiteral$0 = $R$0($EXPECT($R30, "HexIntegerLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
9852
9933
|
function HexIntegerLiteral(ctx, state) {
|
|
9853
9934
|
return $EVENT(ctx, state, "HexIntegerLiteral", HexIntegerLiteral$0);
|
|
9854
9935
|
}
|
|
9855
|
-
var IntegerLiteral$0 = $TS($S(IntegerLiteralKind), function($skip, $loc, $0, $1) {
|
|
9856
|
-
|
|
9936
|
+
var IntegerLiteral$0 = $TS($S($EXPECT($R31, "IntegerLiteral /(?=[0-9])/"), IntegerLiteralKind), function($skip, $loc, $0, $1, $2) {
|
|
9937
|
+
var token = $2;
|
|
9938
|
+
return { $loc, token };
|
|
9857
9939
|
});
|
|
9858
9940
|
function IntegerLiteral(ctx, state) {
|
|
9859
9941
|
return $EVENT(ctx, state, "IntegerLiteral", IntegerLiteral$0);
|
|
@@ -9867,7 +9949,7 @@ ${input.slice(result.pos)}
|
|
|
9867
9949
|
function IntegerLiteralKind(ctx, state) {
|
|
9868
9950
|
return $EVENT_C(ctx, state, "IntegerLiteralKind", IntegerLiteralKind$$);
|
|
9869
9951
|
}
|
|
9870
|
-
var DecimalIntegerLiteral$0 = $R$0($EXPECT($
|
|
9952
|
+
var DecimalIntegerLiteral$0 = $R$0($EXPECT($R32, "DecimalIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)/"));
|
|
9871
9953
|
function DecimalIntegerLiteral(ctx, state) {
|
|
9872
9954
|
return $EVENT(ctx, state, "DecimalIntegerLiteral", DecimalIntegerLiteral$0);
|
|
9873
9955
|
}
|
|
@@ -9891,25 +9973,25 @@ ${input.slice(result.pos)}
|
|
|
9891
9973
|
function StringLiteral(ctx, state) {
|
|
9892
9974
|
return $EVENT_C(ctx, state, "StringLiteral", StringLiteral$$);
|
|
9893
9975
|
}
|
|
9894
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
9976
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R33, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9895
9977
|
return { $loc, token: $0 };
|
|
9896
9978
|
});
|
|
9897
9979
|
function DoubleStringCharacters(ctx, state) {
|
|
9898
9980
|
return $EVENT(ctx, state, "DoubleStringCharacters", DoubleStringCharacters$0);
|
|
9899
9981
|
}
|
|
9900
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
9982
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R34, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9901
9983
|
return { $loc, token: $0 };
|
|
9902
9984
|
});
|
|
9903
9985
|
function SingleStringCharacters(ctx, state) {
|
|
9904
9986
|
return $EVENT(ctx, state, "SingleStringCharacters", SingleStringCharacters$0);
|
|
9905
9987
|
}
|
|
9906
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
9988
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R35, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9907
9989
|
return { $loc, token: $0 };
|
|
9908
9990
|
});
|
|
9909
9991
|
function TripleDoubleStringCharacters(ctx, state) {
|
|
9910
9992
|
return $EVENT(ctx, state, "TripleDoubleStringCharacters", TripleDoubleStringCharacters$0);
|
|
9911
9993
|
}
|
|
9912
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
9994
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R36, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9913
9995
|
return { $loc, token: $0 };
|
|
9914
9996
|
});
|
|
9915
9997
|
function TripleSingleStringCharacters(ctx, state) {
|
|
@@ -9928,7 +10010,7 @@ ${input.slice(result.pos)}
|
|
|
9928
10010
|
function CoffeeInterpolatedDoubleQuotedString(ctx, state) {
|
|
9929
10011
|
return $EVENT(ctx, state, "CoffeeInterpolatedDoubleQuotedString", CoffeeInterpolatedDoubleQuotedString$0);
|
|
9930
10012
|
}
|
|
9931
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
10013
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R37, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9932
10014
|
return { $loc, token: $0 };
|
|
9933
10015
|
});
|
|
9934
10016
|
function CoffeeDoubleQuotedStringCharacters(ctx, state) {
|
|
@@ -9948,7 +10030,7 @@ ${input.slice(result.pos)}
|
|
|
9948
10030
|
function RegularExpressionClass(ctx, state) {
|
|
9949
10031
|
return $EVENT(ctx, state, "RegularExpressionClass", RegularExpressionClass$0);
|
|
9950
10032
|
}
|
|
9951
|
-
var RegularExpressionClassCharacters$0 = $TR($EXPECT($
|
|
10033
|
+
var RegularExpressionClassCharacters$0 = $TR($EXPECT($R38, "RegularExpressionClassCharacters /(?:\\\\.|[^\\]])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
9952
10034
|
return { $loc, token: $0 };
|
|
9953
10035
|
});
|
|
9954
10036
|
function RegularExpressionClassCharacters(ctx, state) {
|
|
@@ -10002,7 +10084,7 @@ ${input.slice(result.pos)}
|
|
|
10002
10084
|
var HeregexPart$2 = $T($S(TemplateSubstitution), function(value) {
|
|
10003
10085
|
return { "type": "Substitution", "children": value[0] };
|
|
10004
10086
|
});
|
|
10005
|
-
var HeregexPart$3 = $TR($EXPECT($
|
|
10087
|
+
var HeregexPart$3 = $TR($EXPECT($R39, "HeregexPart /(?:\\\\.)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10006
10088
|
let token = $0;
|
|
10007
10089
|
switch ($0[1]) {
|
|
10008
10090
|
case "\n":
|
|
@@ -10020,13 +10102,13 @@ ${input.slice(result.pos)}
|
|
|
10020
10102
|
var HeregexPart$4 = $TS($S(HeregexComment), function($skip, $loc, $0, $1) {
|
|
10021
10103
|
return { $loc, token: "" };
|
|
10022
10104
|
});
|
|
10023
|
-
var HeregexPart$5 = $TR($EXPECT($
|
|
10105
|
+
var HeregexPart$5 = $TR($EXPECT($R40, "HeregexPart /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10024
10106
|
return { $loc, token: "" };
|
|
10025
10107
|
});
|
|
10026
|
-
var HeregexPart$6 = $TR($EXPECT($
|
|
10108
|
+
var HeregexPart$6 = $TR($EXPECT($R41, "HeregexPart /\\/(?!\\/\\/)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10027
10109
|
return { $loc, token: "\\/" };
|
|
10028
10110
|
});
|
|
10029
|
-
var HeregexPart$7 = $TR($EXPECT($
|
|
10111
|
+
var HeregexPart$7 = $TR($EXPECT($R42, "HeregexPart /[^[\\/\\s#\\\\]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10030
10112
|
return { $loc, token: $0 };
|
|
10031
10113
|
});
|
|
10032
10114
|
var HeregexPart$$ = [HeregexPart$0, HeregexPart$1, HeregexPart$2, HeregexPart$3, HeregexPart$4, HeregexPart$5, HeregexPart$6, HeregexPart$7];
|
|
@@ -10039,7 +10121,7 @@ ${input.slice(result.pos)}
|
|
|
10039
10121
|
function HeregexComment(ctx, state) {
|
|
10040
10122
|
return $EVENT_C(ctx, state, "HeregexComment", HeregexComment$$);
|
|
10041
10123
|
}
|
|
10042
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
10124
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R43, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpPart));
|
|
10043
10125
|
function RegularExpressionBody(ctx, state) {
|
|
10044
10126
|
return $EVENT(ctx, state, "RegularExpressionBody", RegularExpressionBody$0);
|
|
10045
10127
|
}
|
|
@@ -10049,27 +10131,33 @@ ${input.slice(result.pos)}
|
|
|
10049
10131
|
function RegExpPart(ctx, state) {
|
|
10050
10132
|
return $EVENT_C(ctx, state, "RegExpPart", RegExpPart$$);
|
|
10051
10133
|
}
|
|
10052
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
10134
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R44, "RegExpCharacter /(?:\\\\.|[^[\\/\\r\\n])+/"));
|
|
10053
10135
|
function RegExpCharacter(ctx, state) {
|
|
10054
10136
|
return $EVENT(ctx, state, "RegExpCharacter", RegExpCharacter$0);
|
|
10055
10137
|
}
|
|
10056
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
10138
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R45, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
10057
10139
|
function RegularExpressionFlags(ctx, state) {
|
|
10058
10140
|
return $EVENT(ctx, state, "RegularExpressionFlags", RegularExpressionFlags$0);
|
|
10059
10141
|
}
|
|
10060
|
-
var TemplateLiteral$0 = $
|
|
10142
|
+
var TemplateLiteral$0 = $T($S($EXPECT($R46, "TemplateLiteral /(?=[`'\"])/"), _TemplateLiteral), function(value) {
|
|
10143
|
+
return value[1];
|
|
10144
|
+
});
|
|
10145
|
+
function TemplateLiteral(ctx, state) {
|
|
10146
|
+
return $EVENT(ctx, state, "TemplateLiteral", TemplateLiteral$0);
|
|
10147
|
+
}
|
|
10148
|
+
var _TemplateLiteral$0 = $TS($S(TripleTick, $Q($C(TemplateBlockCharacters, TemplateSubstitution)), TripleTick), function($skip, $loc, $0, $1, $2, $3) {
|
|
10061
10149
|
return dedentBlockSubstitutions($0, module.config.tab);
|
|
10062
10150
|
});
|
|
10063
|
-
var
|
|
10151
|
+
var _TemplateLiteral$1 = $TS($S(Backtick, $Q($C(TemplateCharacters, TemplateSubstitution)), Backtick), function($skip, $loc, $0, $1, $2, $3) {
|
|
10064
10152
|
return {
|
|
10065
10153
|
type: "TemplateLiteral",
|
|
10066
10154
|
children: $0
|
|
10067
10155
|
};
|
|
10068
10156
|
});
|
|
10069
|
-
var
|
|
10157
|
+
var _TemplateLiteral$2 = $TS($S(TripleDoubleQuote, $Q($C(TripleDoubleStringCharacters, CoffeeStringSubstitution)), TripleDoubleQuote), function($skip, $loc, $0, $1, $2, $3) {
|
|
10070
10158
|
return dedentBlockSubstitutions($0, module.config.tab);
|
|
10071
10159
|
});
|
|
10072
|
-
var
|
|
10160
|
+
var _TemplateLiteral$3 = $TS($S(TripleSingleQuote, TripleSingleStringCharacters, TripleSingleQuote), function($skip, $loc, $0, $1, $2, $3) {
|
|
10073
10161
|
var s = $1;
|
|
10074
10162
|
var str = $2;
|
|
10075
10163
|
var e = $3;
|
|
@@ -10078,37 +10166,37 @@ ${input.slice(result.pos)}
|
|
|
10078
10166
|
children: [s, dedentBlockString(str, module.config.tab), e]
|
|
10079
10167
|
};
|
|
10080
10168
|
});
|
|
10081
|
-
var
|
|
10082
|
-
var
|
|
10083
|
-
function
|
|
10084
|
-
return $EVENT_C(ctx, state, "
|
|
10169
|
+
var _TemplateLiteral$4 = CoffeeInterpolatedDoubleQuotedString;
|
|
10170
|
+
var _TemplateLiteral$$ = [_TemplateLiteral$0, _TemplateLiteral$1, _TemplateLiteral$2, _TemplateLiteral$3, _TemplateLiteral$4];
|
|
10171
|
+
function _TemplateLiteral(ctx, state) {
|
|
10172
|
+
return $EVENT_C(ctx, state, "_TemplateLiteral", _TemplateLiteral$$);
|
|
10085
10173
|
}
|
|
10086
10174
|
var TemplateSubstitution$0 = $S(SubstitutionStart, PostfixedExpression, __, CloseBrace);
|
|
10087
10175
|
function TemplateSubstitution(ctx, state) {
|
|
10088
10176
|
return $EVENT(ctx, state, "TemplateSubstitution", TemplateSubstitution$0);
|
|
10089
10177
|
}
|
|
10090
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
10178
|
+
var TemplateCharacters$0 = $TR($EXPECT($R47, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10091
10179
|
return { $loc, token: $0 };
|
|
10092
10180
|
});
|
|
10093
10181
|
function TemplateCharacters(ctx, state) {
|
|
10094
10182
|
return $EVENT(ctx, state, "TemplateCharacters", TemplateCharacters$0);
|
|
10095
10183
|
}
|
|
10096
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
10184
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R48, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10097
10185
|
return { $loc, token: $0 };
|
|
10098
10186
|
});
|
|
10099
10187
|
function TemplateBlockCharacters(ctx, state) {
|
|
10100
10188
|
return $EVENT(ctx, state, "TemplateBlockCharacters", TemplateBlockCharacters$0);
|
|
10101
10189
|
}
|
|
10102
|
-
var ReservedWord$0 = $S(
|
|
10103
|
-
var ReservedWord$1 = $S(
|
|
10104
|
-
var ReservedWord$2 = $S(
|
|
10105
|
-
var ReservedWord$3 = $S(
|
|
10106
|
-
var ReservedWord$4 = $R$0($EXPECT($
|
|
10190
|
+
var ReservedWord$0 = $S($R$0($EXPECT($R49, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")), CoffeeBooleansEnabled);
|
|
10191
|
+
var ReservedWord$1 = $S($R$0($EXPECT($R50, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")), CoffeeIsntEnabled);
|
|
10192
|
+
var ReservedWord$2 = $S($R$0($EXPECT($R51, "ReservedWord /(?:by)(?!\\p{ID_Continue})/")), CoffeeForLoopsEnabled);
|
|
10193
|
+
var ReservedWord$3 = $S($R$0($EXPECT($R52, "ReservedWord /(?:of)(?!\\p{ID_Continue})/")), CoffeeOfEnabled);
|
|
10194
|
+
var ReservedWord$4 = $R$0($EXPECT($R53, "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})/"));
|
|
10107
10195
|
var ReservedWord$$ = [ReservedWord$0, ReservedWord$1, ReservedWord$2, ReservedWord$3, ReservedWord$4];
|
|
10108
10196
|
function ReservedWord(ctx, state) {
|
|
10109
10197
|
return $EVENT_C(ctx, state, "ReservedWord", ReservedWord$$);
|
|
10110
10198
|
}
|
|
10111
|
-
var Comment$0 = $T($S($EXPECT($
|
|
10199
|
+
var Comment$0 = $T($S($EXPECT($R54, "Comment /(?=\\/|#)/"), _Comment), function(value) {
|
|
10112
10200
|
return value[1];
|
|
10113
10201
|
});
|
|
10114
10202
|
function Comment(ctx, state) {
|
|
@@ -10126,7 +10214,7 @@ ${input.slice(result.pos)}
|
|
|
10126
10214
|
function SingleLineComment(ctx, state) {
|
|
10127
10215
|
return $EVENT_C(ctx, state, "SingleLineComment", SingleLineComment$$);
|
|
10128
10216
|
}
|
|
10129
|
-
var JSSingleLineComment$0 = $TR($EXPECT($
|
|
10217
|
+
var JSSingleLineComment$0 = $TR($EXPECT($R55, "JSSingleLineComment /\\/\\/(?!\\/)[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10130
10218
|
return { type: "Comment", $loc, token: $0 };
|
|
10131
10219
|
});
|
|
10132
10220
|
function JSSingleLineComment(ctx, state) {
|
|
@@ -10138,30 +10226,30 @@ ${input.slice(result.pos)}
|
|
|
10138
10226
|
function MultiLineComment(ctx, state) {
|
|
10139
10227
|
return $EVENT_C(ctx, state, "MultiLineComment", MultiLineComment$$);
|
|
10140
10228
|
}
|
|
10141
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
10229
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L108, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L109, 'JSMultiLineComment "*/"')), $EXPECT($R56, "JSMultiLineComment /./"))), $EXPECT($L109, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
10142
10230
|
return { type: "Comment", $loc, token: $1 };
|
|
10143
10231
|
});
|
|
10144
10232
|
function JSMultiLineComment(ctx, state) {
|
|
10145
10233
|
return $EVENT(ctx, state, "JSMultiLineComment", JSMultiLineComment$0);
|
|
10146
10234
|
}
|
|
10147
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
10235
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R57, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10148
10236
|
return { type: "Comment", $loc, token: `//${$1}` };
|
|
10149
10237
|
});
|
|
10150
10238
|
function CoffeeSingleLineComment(ctx, state) {
|
|
10151
10239
|
return $EVENT(ctx, state, "CoffeeSingleLineComment", CoffeeSingleLineComment$0);
|
|
10152
10240
|
}
|
|
10153
|
-
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($
|
|
10241
|
+
var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($EXPECT($R58, "CoffeeMultiLineComment /[^]*?###/"))), function($skip, $loc, $0, $1, $2) {
|
|
10154
10242
|
$2 = $2.slice(0, $2.length - 3).replace(/\*\//g, "* /");
|
|
10155
10243
|
return { type: "Comment", $loc, token: `/*${$2}*/` };
|
|
10156
10244
|
});
|
|
10157
10245
|
function CoffeeMultiLineComment(ctx, state) {
|
|
10158
10246
|
return $EVENT(ctx, state, "CoffeeMultiLineComment", CoffeeMultiLineComment$0);
|
|
10159
10247
|
}
|
|
10160
|
-
var CoffeeHereCommentStart$0 = $R$0($EXPECT($
|
|
10248
|
+
var CoffeeHereCommentStart$0 = $R$0($EXPECT($R59, "CoffeeHereCommentStart /###(?!#)/"));
|
|
10161
10249
|
function CoffeeHereCommentStart(ctx, state) {
|
|
10162
10250
|
return $EVENT(ctx, state, "CoffeeHereCommentStart", CoffeeHereCommentStart$0);
|
|
10163
10251
|
}
|
|
10164
|
-
var InlineComment$0 = $TR($EXPECT($
|
|
10252
|
+
var InlineComment$0 = $TR($EXPECT($R60, "InlineComment /\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\//"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10165
10253
|
return { $loc, token: $0 };
|
|
10166
10254
|
});
|
|
10167
10255
|
function InlineComment(ctx, state) {
|
|
@@ -10175,17 +10263,17 @@ ${input.slice(result.pos)}
|
|
|
10175
10263
|
function TrailingComment(ctx, state) {
|
|
10176
10264
|
return $EVENT(ctx, state, "TrailingComment", TrailingComment$0);
|
|
10177
10265
|
}
|
|
10178
|
-
var _$0 = $T($S($EXPECT($
|
|
10266
|
+
var _$0 = $T($S($EXPECT($R61, "_ /(?=[ \\t\\/\\\\])/"), $P($C(NonNewlineWhitespace, InlineComment))), function(value) {
|
|
10179
10267
|
return value[1];
|
|
10180
10268
|
});
|
|
10181
10269
|
function _(ctx, state) {
|
|
10182
10270
|
return $EVENT(ctx, state, "_", _$0);
|
|
10183
10271
|
}
|
|
10184
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
10272
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R62, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10185
10273
|
return { $loc, token: $0 };
|
|
10186
10274
|
});
|
|
10187
|
-
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($
|
|
10188
|
-
return "";
|
|
10275
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L110, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
10276
|
+
return " ";
|
|
10189
10277
|
});
|
|
10190
10278
|
var NonNewlineWhitespace$$ = [NonNewlineWhitespace$0, NonNewlineWhitespace$1];
|
|
10191
10279
|
function NonNewlineWhitespace(ctx, state) {
|
|
@@ -10198,11 +10286,15 @@ ${input.slice(result.pos)}
|
|
|
10198
10286
|
function Trimmed_(ctx, state) {
|
|
10199
10287
|
return $EVENT(ctx, state, "Trimmed_", Trimmed_$0);
|
|
10200
10288
|
}
|
|
10201
|
-
var __$0 = $Q($C(Whitespace, Comment))
|
|
10289
|
+
var __$0 = $T($S($EXPECT($R63, "__ /(?=\\s|\\/|#)/"), $Q($C(Whitespace, Comment))), function(value) {
|
|
10290
|
+
return value[1];
|
|
10291
|
+
});
|
|
10292
|
+
var __$1 = $EXPECT($L0, '__ ""');
|
|
10293
|
+
var __$$ = [__$0, __$1];
|
|
10202
10294
|
function __(ctx, state) {
|
|
10203
|
-
return $
|
|
10295
|
+
return $EVENT_C(ctx, state, "__", __$$);
|
|
10204
10296
|
}
|
|
10205
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
10297
|
+
var Whitespace$0 = $TR($EXPECT($R40, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
10206
10298
|
return { $loc, token: $0 };
|
|
10207
10299
|
});
|
|
10208
10300
|
function Whitespace(ctx, state) {
|
|
@@ -10225,9 +10317,9 @@ ${input.slice(result.pos)}
|
|
|
10225
10317
|
return $EVENT_C(ctx, state, "SimpleStatementDelimiter", SimpleStatementDelimiter$$);
|
|
10226
10318
|
}
|
|
10227
10319
|
var StatementDelimiter$0 = SemicolonDelimiter;
|
|
10228
|
-
var StatementDelimiter$1 = $S($Y($S(Nested, $C($EXPECT($L4, 'StatementDelimiter "("'), $EXPECT($
|
|
10320
|
+
var StatementDelimiter$1 = $S($Y($S(Nested, $C($EXPECT($L4, 'StatementDelimiter "("'), $EXPECT($L111, 'StatementDelimiter "["'), $EXPECT($L112, 'StatementDelimiter "`"'), $EXPECT($L58, 'StatementDelimiter "+"'), $EXPECT($L18, 'StatementDelimiter "-"'), $EXPECT($L54, 'StatementDelimiter "*"'), $EXPECT($L55, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, FatArrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L4, 'StatementDelimiter "("'))))), InsertSemicolon);
|
|
10229
10321
|
var StatementDelimiter$2 = $Y(EOS);
|
|
10230
|
-
var StatementDelimiter$3 = $Y($S($Q(_), $C($EXPECT($L25, 'StatementDelimiter "}"'), $EXPECT($
|
|
10322
|
+
var StatementDelimiter$3 = $Y($S($Q(_), $C($EXPECT($L25, 'StatementDelimiter "}"'), $EXPECT($L113, 'StatementDelimiter ")"'), $EXPECT($L34, 'StatementDelimiter "]"'))));
|
|
10231
10323
|
var StatementDelimiter$$ = [StatementDelimiter$0, StatementDelimiter$1, StatementDelimiter$2, StatementDelimiter$3];
|
|
10232
10324
|
function StatementDelimiter(ctx, state) {
|
|
10233
10325
|
return $EVENT_C(ctx, state, "StatementDelimiter", StatementDelimiter$$);
|
|
@@ -10241,7 +10333,7 @@ ${input.slice(result.pos)}
|
|
|
10241
10333
|
function SemicolonDelimiter(ctx, state) {
|
|
10242
10334
|
return $EVENT(ctx, state, "SemicolonDelimiter", SemicolonDelimiter$0);
|
|
10243
10335
|
}
|
|
10244
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
10336
|
+
var NonIdContinue$0 = $R$0($EXPECT($R64, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
10245
10337
|
function NonIdContinue(ctx, state) {
|
|
10246
10338
|
return $EVENT(ctx, state, "NonIdContinue", NonIdContinue$0);
|
|
10247
10339
|
}
|
|
@@ -10251,73 +10343,73 @@ ${input.slice(result.pos)}
|
|
|
10251
10343
|
function Loc(ctx, state) {
|
|
10252
10344
|
return $EVENT(ctx, state, "Loc", Loc$0);
|
|
10253
10345
|
}
|
|
10254
|
-
var Abstract$0 = $TV($TEXT($S($EXPECT($
|
|
10346
|
+
var Abstract$0 = $TV($TEXT($S($EXPECT($L114, 'Abstract "abstract"'), NonIdContinue, $E($EXPECT($L12, 'Abstract " "')))), function($skip, $loc, $0, $1) {
|
|
10255
10347
|
return { $loc, token: $1, ts: true };
|
|
10256
10348
|
});
|
|
10257
10349
|
function Abstract(ctx, state) {
|
|
10258
10350
|
return $EVENT(ctx, state, "Abstract", Abstract$0);
|
|
10259
10351
|
}
|
|
10260
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
10352
|
+
var Ampersand$0 = $TV($EXPECT($L97, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
10261
10353
|
return { $loc, token: $1 };
|
|
10262
10354
|
});
|
|
10263
10355
|
function Ampersand(ctx, state) {
|
|
10264
10356
|
return $EVENT(ctx, state, "Ampersand", Ampersand$0);
|
|
10265
10357
|
}
|
|
10266
|
-
var As$0 = $TS($S($EXPECT($
|
|
10358
|
+
var As$0 = $TS($S($EXPECT($L115, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10267
10359
|
return { $loc, token: $1 };
|
|
10268
10360
|
});
|
|
10269
10361
|
function As(ctx, state) {
|
|
10270
10362
|
return $EVENT(ctx, state, "As", As$0);
|
|
10271
10363
|
}
|
|
10272
|
-
var At$0 = $TV($EXPECT($
|
|
10364
|
+
var At$0 = $TV($EXPECT($L116, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
10273
10365
|
return { $loc, token: $1 };
|
|
10274
10366
|
});
|
|
10275
10367
|
function At(ctx, state) {
|
|
10276
10368
|
return $EVENT(ctx, state, "At", At$0);
|
|
10277
10369
|
}
|
|
10278
|
-
var AtAt$0 = $TV($EXPECT($
|
|
10370
|
+
var AtAt$0 = $TV($EXPECT($L117, 'AtAt "@@"'), function($skip, $loc, $0, $1) {
|
|
10279
10371
|
return { $loc, token: "@" };
|
|
10280
10372
|
});
|
|
10281
10373
|
function AtAt(ctx, state) {
|
|
10282
10374
|
return $EVENT(ctx, state, "AtAt", AtAt$0);
|
|
10283
10375
|
}
|
|
10284
|
-
var Async$0 = $TS($S($EXPECT($
|
|
10376
|
+
var Async$0 = $TS($S($EXPECT($L118, 'Async "async"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10285
10377
|
return { $loc, token: $1, type: "Async" };
|
|
10286
10378
|
});
|
|
10287
10379
|
function Async(ctx, state) {
|
|
10288
10380
|
return $EVENT(ctx, state, "Async", Async$0);
|
|
10289
10381
|
}
|
|
10290
|
-
var Await$0 = $TS($S($EXPECT($
|
|
10382
|
+
var Await$0 = $TS($S($EXPECT($L119, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10291
10383
|
return { $loc, token: $1, type: "Await" };
|
|
10292
10384
|
});
|
|
10293
10385
|
function Await(ctx, state) {
|
|
10294
10386
|
return $EVENT(ctx, state, "Await", Await$0);
|
|
10295
10387
|
}
|
|
10296
|
-
var Backtick$0 = $TV($EXPECT($
|
|
10388
|
+
var Backtick$0 = $TV($EXPECT($L112, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
10297
10389
|
return { $loc, token: $1 };
|
|
10298
10390
|
});
|
|
10299
10391
|
function Backtick(ctx, state) {
|
|
10300
10392
|
return $EVENT(ctx, state, "Backtick", Backtick$0);
|
|
10301
10393
|
}
|
|
10302
|
-
var By$0 = $TS($S($EXPECT($
|
|
10394
|
+
var By$0 = $TS($S($EXPECT($L120, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10303
10395
|
return { $loc, token: $1 };
|
|
10304
10396
|
});
|
|
10305
10397
|
function By(ctx, state) {
|
|
10306
10398
|
return $EVENT(ctx, state, "By", By$0);
|
|
10307
10399
|
}
|
|
10308
|
-
var Case$0 = $TS($S($EXPECT($
|
|
10400
|
+
var Case$0 = $TS($S($EXPECT($L121, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10309
10401
|
return { $loc, token: $1 };
|
|
10310
10402
|
});
|
|
10311
10403
|
function Case(ctx, state) {
|
|
10312
10404
|
return $EVENT(ctx, state, "Case", Case$0);
|
|
10313
10405
|
}
|
|
10314
|
-
var Catch$0 = $TS($S($EXPECT($
|
|
10406
|
+
var Catch$0 = $TS($S($EXPECT($L122, 'Catch "catch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10315
10407
|
return { $loc, token: $1 };
|
|
10316
10408
|
});
|
|
10317
10409
|
function Catch(ctx, state) {
|
|
10318
10410
|
return $EVENT(ctx, state, "Catch", Catch$0);
|
|
10319
10411
|
}
|
|
10320
|
-
var Class$0 = $TS($S($EXPECT($
|
|
10412
|
+
var Class$0 = $TS($S($EXPECT($L123, 'Class "class"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10321
10413
|
return { $loc, token: $1 };
|
|
10322
10414
|
});
|
|
10323
10415
|
function Class(ctx, state) {
|
|
@@ -10335,19 +10427,19 @@ ${input.slice(result.pos)}
|
|
|
10335
10427
|
function CloseBracket(ctx, state) {
|
|
10336
10428
|
return $EVENT(ctx, state, "CloseBracket", CloseBracket$0);
|
|
10337
10429
|
}
|
|
10338
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
10430
|
+
var CloseParen$0 = $TV($EXPECT($L113, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
10339
10431
|
return { $loc, token: $1 };
|
|
10340
10432
|
});
|
|
10341
10433
|
function CloseParen(ctx, state) {
|
|
10342
10434
|
return $EVENT(ctx, state, "CloseParen", CloseParen$0);
|
|
10343
10435
|
}
|
|
10344
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
10436
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L124, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
10345
10437
|
return { $loc, token: "${" };
|
|
10346
10438
|
});
|
|
10347
10439
|
function CoffeeSubstitutionStart(ctx, state) {
|
|
10348
10440
|
return $EVENT(ctx, state, "CoffeeSubstitutionStart", CoffeeSubstitutionStart$0);
|
|
10349
10441
|
}
|
|
10350
|
-
var Colon$0 = $TS($S($EXPECT($
|
|
10442
|
+
var Colon$0 = $TS($S($EXPECT($L11, 'Colon ":"'), $N($EXPECT($L3, 'Colon "="'))), function($skip, $loc, $0, $1, $2) {
|
|
10351
10443
|
return { $loc, token: $1 };
|
|
10352
10444
|
});
|
|
10353
10445
|
function Colon(ctx, state) {
|
|
@@ -10359,31 +10451,31 @@ ${input.slice(result.pos)}
|
|
|
10359
10451
|
function Comma(ctx, state) {
|
|
10360
10452
|
return $EVENT(ctx, state, "Comma", Comma$0);
|
|
10361
10453
|
}
|
|
10362
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
10454
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L116, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
10363
10455
|
return { $loc, token: "constructor" };
|
|
10364
10456
|
});
|
|
10365
10457
|
function ConstructorShorthand(ctx, state) {
|
|
10366
10458
|
return $EVENT(ctx, state, "ConstructorShorthand", ConstructorShorthand$0);
|
|
10367
10459
|
}
|
|
10368
|
-
var Declare$0 = $TS($S($EXPECT($
|
|
10460
|
+
var Declare$0 = $TS($S($EXPECT($L125, 'Declare "declare"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10369
10461
|
return { $loc, token: $1 };
|
|
10370
10462
|
});
|
|
10371
10463
|
function Declare(ctx, state) {
|
|
10372
10464
|
return $EVENT(ctx, state, "Declare", Declare$0);
|
|
10373
10465
|
}
|
|
10374
|
-
var Default$0 = $TS($S($EXPECT($
|
|
10466
|
+
var Default$0 = $TS($S($EXPECT($L126, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10375
10467
|
return { $loc, token: $1 };
|
|
10376
10468
|
});
|
|
10377
10469
|
function Default(ctx, state) {
|
|
10378
10470
|
return $EVENT(ctx, state, "Default", Default$0);
|
|
10379
10471
|
}
|
|
10380
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
10472
|
+
var Delete$0 = $TS($S($EXPECT($L127, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10381
10473
|
return { $loc, token: $1 };
|
|
10382
10474
|
});
|
|
10383
10475
|
function Delete(ctx, state) {
|
|
10384
10476
|
return $EVENT(ctx, state, "Delete", Delete$0);
|
|
10385
10477
|
}
|
|
10386
|
-
var Do$0 = $TS($S($EXPECT($
|
|
10478
|
+
var Do$0 = $TS($S($EXPECT($L128, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10387
10479
|
return { $loc, token: $1 };
|
|
10388
10480
|
});
|
|
10389
10481
|
function Do(ctx, state) {
|
|
@@ -10392,7 +10484,7 @@ ${input.slice(result.pos)}
|
|
|
10392
10484
|
var Dot$0 = $TV($EXPECT($L6, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
10393
10485
|
return { $loc, token: $1 };
|
|
10394
10486
|
});
|
|
10395
|
-
var Dot$1 = $TS($S($EXPECT($
|
|
10487
|
+
var Dot$1 = $TS($S($EXPECT($R65, "Dot /['\u2019]s/"), _), function($skip, $loc, $0, $1, $2) {
|
|
10396
10488
|
var ws = $2;
|
|
10397
10489
|
return [
|
|
10398
10490
|
{ $loc, token: "." },
|
|
@@ -10403,45 +10495,45 @@ ${input.slice(result.pos)}
|
|
|
10403
10495
|
function Dot(ctx, state) {
|
|
10404
10496
|
return $EVENT_C(ctx, state, "Dot", Dot$$);
|
|
10405
10497
|
}
|
|
10406
|
-
var DotDot$0 = $TS($S($EXPECT($
|
|
10498
|
+
var DotDot$0 = $TS($S($EXPECT($L129, 'DotDot ".."'), $N($EXPECT($L6, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
|
|
10407
10499
|
return { $loc, token: $1 };
|
|
10408
10500
|
});
|
|
10409
|
-
var DotDot$1 = $TV($EXPECT($
|
|
10501
|
+
var DotDot$1 = $TV($EXPECT($L130, 'DotDot "\u2025"'), function($skip, $loc, $0, $1) {
|
|
10410
10502
|
return { $loc, token: ".." };
|
|
10411
10503
|
});
|
|
10412
10504
|
var DotDot$$ = [DotDot$0, DotDot$1];
|
|
10413
10505
|
function DotDot(ctx, state) {
|
|
10414
10506
|
return $EVENT_C(ctx, state, "DotDot", DotDot$$);
|
|
10415
10507
|
}
|
|
10416
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
10508
|
+
var DotDotDot$0 = $TV($EXPECT($L131, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
10417
10509
|
return { $loc, token: $1 };
|
|
10418
10510
|
});
|
|
10419
|
-
var DotDotDot$1 = $TV($EXPECT($
|
|
10511
|
+
var DotDotDot$1 = $TV($EXPECT($L132, 'DotDotDot "\u2026"'), function($skip, $loc, $0, $1) {
|
|
10420
10512
|
return { $loc, token: "..." };
|
|
10421
10513
|
});
|
|
10422
10514
|
var DotDotDot$$ = [DotDotDot$0, DotDotDot$1];
|
|
10423
10515
|
function DotDotDot(ctx, state) {
|
|
10424
10516
|
return $EVENT_C(ctx, state, "DotDotDot", DotDotDot$$);
|
|
10425
10517
|
}
|
|
10426
|
-
var DoubleColon$0 = $TV($EXPECT($
|
|
10518
|
+
var DoubleColon$0 = $TV($EXPECT($L133, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
|
|
10427
10519
|
return { $loc, token: $1 };
|
|
10428
10520
|
});
|
|
10429
10521
|
function DoubleColon(ctx, state) {
|
|
10430
10522
|
return $EVENT(ctx, state, "DoubleColon", DoubleColon$0);
|
|
10431
10523
|
}
|
|
10432
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
10524
|
+
var DoubleQuote$0 = $TV($EXPECT($L134, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
10433
10525
|
return { $loc, token: $1 };
|
|
10434
10526
|
});
|
|
10435
10527
|
function DoubleQuote(ctx, state) {
|
|
10436
10528
|
return $EVENT(ctx, state, "DoubleQuote", DoubleQuote$0);
|
|
10437
10529
|
}
|
|
10438
|
-
var Each$0 = $TS($S($EXPECT($
|
|
10530
|
+
var Each$0 = $TS($S($EXPECT($L135, 'Each "each"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10439
10531
|
return { $loc, token: $1 };
|
|
10440
10532
|
});
|
|
10441
10533
|
function Each(ctx, state) {
|
|
10442
10534
|
return $EVENT(ctx, state, "Each", Each$0);
|
|
10443
10535
|
}
|
|
10444
|
-
var Else$0 = $TS($S($EXPECT($
|
|
10536
|
+
var Else$0 = $TS($S($EXPECT($L136, 'Else "else"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10445
10537
|
return { $loc, token: $1 };
|
|
10446
10538
|
});
|
|
10447
10539
|
function Else(ctx, state) {
|
|
@@ -10453,85 +10545,85 @@ ${input.slice(result.pos)}
|
|
|
10453
10545
|
function Equals(ctx, state) {
|
|
10454
10546
|
return $EVENT(ctx, state, "Equals", Equals$0);
|
|
10455
10547
|
}
|
|
10456
|
-
var Export$0 = $TS($S($EXPECT($
|
|
10548
|
+
var Export$0 = $TS($S($EXPECT($L137, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10457
10549
|
return { $loc, token: $1 };
|
|
10458
10550
|
});
|
|
10459
10551
|
function Export(ctx, state) {
|
|
10460
10552
|
return $EVENT(ctx, state, "Export", Export$0);
|
|
10461
10553
|
}
|
|
10462
|
-
var Extends$0 = $TS($S($EXPECT($
|
|
10554
|
+
var Extends$0 = $TS($S($EXPECT($L138, 'Extends "extends"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10463
10555
|
return { $loc, token: $1 };
|
|
10464
10556
|
});
|
|
10465
10557
|
function Extends(ctx, state) {
|
|
10466
10558
|
return $EVENT(ctx, state, "Extends", Extends$0);
|
|
10467
10559
|
}
|
|
10468
|
-
var Finally$0 = $TS($S($EXPECT($
|
|
10560
|
+
var Finally$0 = $TS($S($EXPECT($L139, 'Finally "finally"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10469
10561
|
return { $loc, token: $1 };
|
|
10470
10562
|
});
|
|
10471
10563
|
function Finally(ctx, state) {
|
|
10472
10564
|
return $EVENT(ctx, state, "Finally", Finally$0);
|
|
10473
10565
|
}
|
|
10474
|
-
var For$0 = $TS($S($EXPECT($
|
|
10566
|
+
var For$0 = $TS($S($EXPECT($L140, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10475
10567
|
return { $loc, token: $1 };
|
|
10476
10568
|
});
|
|
10477
10569
|
function For(ctx, state) {
|
|
10478
10570
|
return $EVENT(ctx, state, "For", For$0);
|
|
10479
10571
|
}
|
|
10480
|
-
var From$0 = $TS($S($EXPECT($
|
|
10572
|
+
var From$0 = $TS($S($EXPECT($L141, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10481
10573
|
return { $loc, token: $1 };
|
|
10482
10574
|
});
|
|
10483
10575
|
function From(ctx, state) {
|
|
10484
10576
|
return $EVENT(ctx, state, "From", From$0);
|
|
10485
10577
|
}
|
|
10486
|
-
var Function$0 = $TS($S($EXPECT($
|
|
10578
|
+
var Function$0 = $TS($S($EXPECT($L142, 'Function "function"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10487
10579
|
return { $loc, token: $1 };
|
|
10488
10580
|
});
|
|
10489
10581
|
function Function(ctx, state) {
|
|
10490
10582
|
return $EVENT(ctx, state, "Function", Function$0);
|
|
10491
10583
|
}
|
|
10492
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
10584
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L143, 'GetOrSet "get"'), $EXPECT($L144, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10493
10585
|
return { $loc, token: $1, type: "GetOrSet" };
|
|
10494
10586
|
});
|
|
10495
10587
|
function GetOrSet(ctx, state) {
|
|
10496
10588
|
return $EVENT(ctx, state, "GetOrSet", GetOrSet$0);
|
|
10497
10589
|
}
|
|
10498
|
-
var Hash$0 = $TV($EXPECT($
|
|
10590
|
+
var Hash$0 = $TV($EXPECT($L145, 'Hash "#"'), function($skip, $loc, $0, $1) {
|
|
10499
10591
|
return { $loc, token: $1 };
|
|
10500
10592
|
});
|
|
10501
10593
|
function Hash(ctx, state) {
|
|
10502
10594
|
return $EVENT(ctx, state, "Hash", Hash$0);
|
|
10503
10595
|
}
|
|
10504
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
10596
|
+
var If$0 = $TV($TEXT($S($EXPECT($L146, 'If "if"'), NonIdContinue, $E($EXPECT($L12, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
10505
10597
|
return { $loc, token: $1 };
|
|
10506
10598
|
});
|
|
10507
10599
|
function If(ctx, state) {
|
|
10508
10600
|
return $EVENT(ctx, state, "If", If$0);
|
|
10509
10601
|
}
|
|
10510
|
-
var Import$0 = $TS($S($EXPECT($L15, 'Import "import"'), $Y($EXPECT($
|
|
10602
|
+
var Import$0 = $TS($S($EXPECT($L15, 'Import "import"'), $Y($EXPECT($R66, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
10511
10603
|
return { $loc, token: $1 };
|
|
10512
10604
|
});
|
|
10513
10605
|
function Import(ctx, state) {
|
|
10514
10606
|
return $EVENT(ctx, state, "Import", Import$0);
|
|
10515
10607
|
}
|
|
10516
|
-
var In$0 = $TS($S($EXPECT($
|
|
10608
|
+
var In$0 = $TS($S($EXPECT($L147, 'In "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10517
10609
|
return { $loc, token: $1 };
|
|
10518
10610
|
});
|
|
10519
10611
|
function In(ctx, state) {
|
|
10520
10612
|
return $EVENT(ctx, state, "In", In$0);
|
|
10521
10613
|
}
|
|
10522
|
-
var LetOrConst$0 = $TS($S($C($EXPECT($
|
|
10614
|
+
var LetOrConst$0 = $TS($S($C($EXPECT($L148, 'LetOrConst "let"'), $EXPECT($L149, 'LetOrConst "const"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10523
10615
|
return { $loc, token: $1 };
|
|
10524
10616
|
});
|
|
10525
10617
|
function LetOrConst(ctx, state) {
|
|
10526
10618
|
return $EVENT(ctx, state, "LetOrConst", LetOrConst$0);
|
|
10527
10619
|
}
|
|
10528
|
-
var Const$0 = $TS($S($EXPECT($
|
|
10620
|
+
var Const$0 = $TS($S($EXPECT($L149, 'Const "const"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10529
10621
|
return { $loc, token: $1 };
|
|
10530
10622
|
});
|
|
10531
10623
|
function Const(ctx, state) {
|
|
10532
10624
|
return $EVENT(ctx, state, "Const", Const$0);
|
|
10533
10625
|
}
|
|
10534
|
-
var Is$0 = $TS($S($EXPECT($
|
|
10626
|
+
var Is$0 = $TS($S($EXPECT($L150, 'Is "is"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10535
10627
|
return { $loc, token: $1 };
|
|
10536
10628
|
});
|
|
10537
10629
|
function Is(ctx, state) {
|
|
@@ -10543,25 +10635,25 @@ ${input.slice(result.pos)}
|
|
|
10543
10635
|
function LetOrConstOrVar(ctx, state) {
|
|
10544
10636
|
return $EVENT_C(ctx, state, "LetOrConstOrVar", LetOrConstOrVar$$);
|
|
10545
10637
|
}
|
|
10546
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
10638
|
+
var Loop$0 = $TS($S($EXPECT($L151, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10547
10639
|
return { $loc, token: "while(true)" };
|
|
10548
10640
|
});
|
|
10549
10641
|
function Loop(ctx, state) {
|
|
10550
10642
|
return $EVENT(ctx, state, "Loop", Loop$0);
|
|
10551
10643
|
}
|
|
10552
|
-
var New$0 = $TS($S($EXPECT($
|
|
10644
|
+
var New$0 = $TS($S($EXPECT($L152, 'New "new"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10553
10645
|
return { $loc, token: $1 };
|
|
10554
10646
|
});
|
|
10555
10647
|
function New(ctx, state) {
|
|
10556
10648
|
return $EVENT(ctx, state, "New", New$0);
|
|
10557
10649
|
}
|
|
10558
|
-
var Not$0 = $TS($S($EXPECT($
|
|
10650
|
+
var Not$0 = $TS($S($EXPECT($L153, 'Not "not"'), NonIdContinue, $N($S($E(_), $EXPECT($L11, 'Not ":"')))), function($skip, $loc, $0, $1, $2, $3) {
|
|
10559
10651
|
return { $loc, token: "!" };
|
|
10560
10652
|
});
|
|
10561
10653
|
function Not(ctx, state) {
|
|
10562
10654
|
return $EVENT(ctx, state, "Not", Not$0);
|
|
10563
10655
|
}
|
|
10564
|
-
var Of$0 = $TS($S($EXPECT($
|
|
10656
|
+
var Of$0 = $TS($S($EXPECT($L154, 'Of "of"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10565
10657
|
return { $loc, token: $1 };
|
|
10566
10658
|
});
|
|
10567
10659
|
function Of(ctx, state) {
|
|
@@ -10579,7 +10671,7 @@ ${input.slice(result.pos)}
|
|
|
10579
10671
|
function OpenBrace(ctx, state) {
|
|
10580
10672
|
return $EVENT(ctx, state, "OpenBrace", OpenBrace$0);
|
|
10581
10673
|
}
|
|
10582
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
10674
|
+
var OpenBracket$0 = $TV($EXPECT($L111, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
10583
10675
|
return { $loc, token: $1 };
|
|
10584
10676
|
});
|
|
10585
10677
|
function OpenBracket(ctx, state) {
|
|
@@ -10658,7 +10750,7 @@ ${input.slice(result.pos)}
|
|
|
10658
10750
|
function Satisfies(ctx, state) {
|
|
10659
10751
|
return $EVENT(ctx, state, "Satisfies", Satisfies$0);
|
|
10660
10752
|
}
|
|
10661
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
10753
|
+
var Semicolon$0 = $TV($EXPECT($L99, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
10662
10754
|
return { $loc, token: $1 };
|
|
10663
10755
|
});
|
|
10664
10756
|
function Semicolon(ctx, state) {
|
|
@@ -10679,7 +10771,7 @@ ${input.slice(result.pos)}
|
|
|
10679
10771
|
var Static$0 = $TS($S($EXPECT($L171, 'Static "static"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
10680
10772
|
return { $loc, token: $1 };
|
|
10681
10773
|
});
|
|
10682
|
-
var Static$1 = $TS($S($EXPECT($
|
|
10774
|
+
var Static$1 = $TS($S($EXPECT($L116, 'Static "@"'), $N($C($EXPECT($L4, 'Static "("'), $EXPECT($L116, 'Static "@"')))), function($skip, $loc, $0, $1, $2) {
|
|
10683
10775
|
return { $loc, token: "static " };
|
|
10684
10776
|
});
|
|
10685
10777
|
var Static$$ = [Static$0, Static$1];
|
|
@@ -10968,7 +11060,7 @@ ${input.slice(result.pos)}
|
|
|
10968
11060
|
function JSXClosingFragment(ctx, state) {
|
|
10969
11061
|
return $EVENT(ctx, state, "JSXClosingFragment", JSXClosingFragment$0);
|
|
10970
11062
|
}
|
|
10971
|
-
var JSXElementName$0 = $TV($Y($S($C($EXPECT($
|
|
11063
|
+
var JSXElementName$0 = $TV($Y($S($C($EXPECT($L145, 'JSXElementName "#"'), Dot), JSXShorthandString)), function($skip, $loc, $0, $1) {
|
|
10972
11064
|
return module.config.defaultElement;
|
|
10973
11065
|
});
|
|
10974
11066
|
var JSXElementName$1 = $TEXT($S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName)))));
|
|
@@ -10976,7 +11068,7 @@ ${input.slice(result.pos)}
|
|
|
10976
11068
|
function JSXElementName(ctx, state) {
|
|
10977
11069
|
return $EVENT_C(ctx, state, "JSXElementName", JSXElementName$$);
|
|
10978
11070
|
}
|
|
10979
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
11071
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R67, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
10980
11072
|
function JSXIdentifierName(ctx, state) {
|
|
10981
11073
|
return $EVENT(ctx, state, "JSXIdentifierName", JSXIdentifierName$0);
|
|
10982
11074
|
}
|
|
@@ -11140,7 +11232,7 @@ ${input.slice(result.pos)}
|
|
|
11140
11232
|
}
|
|
11141
11233
|
return $skip;
|
|
11142
11234
|
});
|
|
11143
|
-
var JSXAttribute$5 = $TS($S($EXPECT($
|
|
11235
|
+
var JSXAttribute$5 = $TS($S($EXPECT($L145, 'JSXAttribute "#"'), JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
11144
11236
|
return [" ", "id=", $2];
|
|
11145
11237
|
});
|
|
11146
11238
|
var JSXAttribute$6 = $TS($S(Dot, JSXShorthandString), function($skip, $loc, $0, $1, $2) {
|
|
@@ -11149,7 +11241,7 @@ ${input.slice(result.pos)}
|
|
|
11149
11241
|
class: $2
|
|
11150
11242
|
};
|
|
11151
11243
|
});
|
|
11152
|
-
var JSXAttribute$7 = $TS($S($TEXT($EXPECT($
|
|
11244
|
+
var JSXAttribute$7 = $TS($S($TEXT($EXPECT($R14, "JSXAttribute /[!+-]/")), JSXAttributeName, $Y(JSXAttributeSpace)), function($skip, $loc, $0, $1, $2, $3) {
|
|
11153
11245
|
var toggle = $1;
|
|
11154
11246
|
var id = $2;
|
|
11155
11247
|
const value = toggle === "+" ? "true" : "false";
|
|
@@ -11159,11 +11251,11 @@ ${input.slice(result.pos)}
|
|
|
11159
11251
|
function JSXAttribute(ctx, state) {
|
|
11160
11252
|
return $EVENT_C(ctx, state, "JSXAttribute", JSXAttribute$$);
|
|
11161
11253
|
}
|
|
11162
|
-
var JSXAttributeSpace$0 = $R$0($EXPECT($
|
|
11254
|
+
var JSXAttributeSpace$0 = $R$0($EXPECT($R68, "JSXAttributeSpace /[\\s>]|\\/>/"));
|
|
11163
11255
|
function JSXAttributeSpace(ctx, state) {
|
|
11164
11256
|
return $EVENT(ctx, state, "JSXAttributeSpace", JSXAttributeSpace$0);
|
|
11165
11257
|
}
|
|
11166
|
-
var JSXShorthandString$0 = $TR($EXPECT($
|
|
11258
|
+
var JSXShorthandString$0 = $TR($EXPECT($R69, "JSXShorthandString /(?:[\\w\\-:]+|\\([^()]*\\)|\\[[^\\[\\]]*\\])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11167
11259
|
return quoteString($0);
|
|
11168
11260
|
});
|
|
11169
11261
|
var JSXShorthandString$1 = $TS($S(TemplateLiteral), function($skip, $loc, $0, $1) {
|
|
@@ -11197,7 +11289,7 @@ ${input.slice(result.pos)}
|
|
|
11197
11289
|
}
|
|
11198
11290
|
return [open, value, close];
|
|
11199
11291
|
});
|
|
11200
|
-
var JSXAttributeValue$4 = $R$0($EXPECT($
|
|
11292
|
+
var JSXAttributeValue$4 = $R$0($EXPECT($R70, `JSXAttributeValue /"[^"]*"|'[^']*'/`));
|
|
11201
11293
|
var JSXAttributeValue$$ = [JSXAttributeValue$0, JSXAttributeValue$1, JSXAttributeValue$2, JSXAttributeValue$3, JSXAttributeValue$4];
|
|
11202
11294
|
function JSXAttributeValue(ctx, state) {
|
|
11203
11295
|
return $EVENT_C(ctx, state, "JSXAttributeValue", JSXAttributeValue$$);
|
|
@@ -11210,7 +11302,7 @@ ${input.slice(result.pos)}
|
|
|
11210
11302
|
function InlineJSXAttributeValue(ctx, state) {
|
|
11211
11303
|
return $EVENT(ctx, state, "InlineJSXAttributeValue", InlineJSXAttributeValue$0);
|
|
11212
11304
|
}
|
|
11213
|
-
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($
|
|
11305
|
+
var InlineJSXBinaryOpRHS$0 = $TS($S($N($EXPECT($R71, "InlineJSXBinaryOpRHS /[<>]/")), BinaryOp, InlineJSXUnaryExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
11214
11306
|
var op = $2;
|
|
11215
11307
|
var rhs = $3;
|
|
11216
11308
|
return [[], op, [], rhs];
|
|
@@ -11227,7 +11319,7 @@ ${input.slice(result.pos)}
|
|
|
11227
11319
|
function InlineJSXUnaryExpression(ctx, state) {
|
|
11228
11320
|
return $EVENT(ctx, state, "InlineJSXUnaryExpression", InlineJSXUnaryExpression$0);
|
|
11229
11321
|
}
|
|
11230
|
-
var InlineJSXUnaryOp$0 = $TR($EXPECT($
|
|
11322
|
+
var InlineJSXUnaryOp$0 = $TR($EXPECT($R72, "InlineJSXUnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11231
11323
|
return { $loc, token: $0 };
|
|
11232
11324
|
});
|
|
11233
11325
|
function InlineJSXUnaryOp(ctx, state) {
|
|
@@ -11294,7 +11386,7 @@ ${input.slice(result.pos)}
|
|
|
11294
11386
|
}
|
|
11295
11387
|
return $1;
|
|
11296
11388
|
});
|
|
11297
|
-
var InlineJSXCallExpressionRest$2 = $TS($S($E(
|
|
11389
|
+
var InlineJSXCallExpressionRest$2 = $TS($S($E(OptionalShorthand), ExplicitArguments), function($skip, $loc, $0, $1, $2) {
|
|
11298
11390
|
var args = $2;
|
|
11299
11391
|
args = { type: "Call", children: args };
|
|
11300
11392
|
if (!$1)
|
|
@@ -11318,7 +11410,7 @@ ${input.slice(result.pos)}
|
|
|
11318
11410
|
function InlineJSXMemberExpression(ctx, state) {
|
|
11319
11411
|
return $EVENT(ctx, state, "InlineJSXMemberExpression", InlineJSXMemberExpression$0);
|
|
11320
11412
|
}
|
|
11321
|
-
var InlineJSXMemberExpressionRest$0 = $TS($S($E(
|
|
11413
|
+
var InlineJSXMemberExpressionRest$0 = $TS($S($E(OptionalShorthand), MemberBracketContent), function($skip, $loc, $0, $1, $2) {
|
|
11322
11414
|
if ($1) {
|
|
11323
11415
|
if ($1.type === "Optional" && $2.type === "SliceExpression") {
|
|
11324
11416
|
return [$1.children[0], $2];
|
|
@@ -11439,13 +11531,13 @@ ${input.slice(result.pos)}
|
|
|
11439
11531
|
function JSXComment(ctx, state) {
|
|
11440
11532
|
return $EVENT(ctx, state, "JSXComment", JSXComment$0);
|
|
11441
11533
|
}
|
|
11442
|
-
var JSXCommentContent$0 = $TR($EXPECT($
|
|
11534
|
+
var JSXCommentContent$0 = $TR($EXPECT($R73, "JSXCommentContent /(?:-[^-]|[^-]*)*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11443
11535
|
return { $loc, token: $0.replace(/\*\//g, "* /") };
|
|
11444
11536
|
});
|
|
11445
11537
|
function JSXCommentContent(ctx, state) {
|
|
11446
11538
|
return $EVENT(ctx, state, "JSXCommentContent", JSXCommentContent$0);
|
|
11447
11539
|
}
|
|
11448
|
-
var JSXText$0 = $TR($EXPECT($
|
|
11540
|
+
var JSXText$0 = $TR($EXPECT($R74, "JSXText /[^{}<>\\r\\n]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
11449
11541
|
return {
|
|
11450
11542
|
type: "JSXText",
|
|
11451
11543
|
token: $0,
|
|
@@ -11810,7 +11902,7 @@ ${input.slice(result.pos)}
|
|
|
11810
11902
|
function TypeProperty(ctx, state) {
|
|
11811
11903
|
return $EVENT(ctx, state, "TypeProperty", TypeProperty$0);
|
|
11812
11904
|
}
|
|
11813
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
11905
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R75, "TypeIndexSignature /[+-]?/")), Readonly, NotDedented)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R76, "TypeIndexSignature /[+-]/")), $Y($S($E(_), QuestionMark)))));
|
|
11814
11906
|
function TypeIndexSignature(ctx, state) {
|
|
11815
11907
|
return $EVENT(ctx, state, "TypeIndexSignature", TypeIndexSignature$0);
|
|
11816
11908
|
}
|
|
@@ -11861,7 +11953,7 @@ ${input.slice(result.pos)}
|
|
|
11861
11953
|
function ReturnType(ctx, state) {
|
|
11862
11954
|
return $EVENT(ctx, state, "ReturnType", ReturnType$0);
|
|
11863
11955
|
}
|
|
11864
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
11956
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L150, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
11865
11957
|
var lhs = $1;
|
|
11866
11958
|
var rhs = $2;
|
|
11867
11959
|
if (!rhs)
|
|
@@ -12023,7 +12115,7 @@ ${input.slice(result.pos)}
|
|
|
12023
12115
|
function NestedType(ctx, state) {
|
|
12024
12116
|
return $EVENT(ctx, state, "NestedType", NestedType$0);
|
|
12025
12117
|
}
|
|
12026
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
12118
|
+
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) {
|
|
12027
12119
|
if ($2)
|
|
12028
12120
|
return $0;
|
|
12029
12121
|
return $1;
|
|
@@ -12083,16 +12175,16 @@ ${input.slice(result.pos)}
|
|
|
12083
12175
|
var InlineInterfacePropertyDelimiter$1 = $T($S($Y($S($C(IndentedFurther, $E(_)), InlineBasicInterfaceProperty)), InsertComma), function(value) {
|
|
12084
12176
|
return value[1];
|
|
12085
12177
|
});
|
|
12086
|
-
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($
|
|
12178
|
+
var InlineInterfacePropertyDelimiter$2 = $Y($S(__, $C($EXPECT($L11, 'InlineInterfacePropertyDelimiter ":"'), $EXPECT($L113, 'InlineInterfacePropertyDelimiter ")"'), $EXPECT($L34, 'InlineInterfacePropertyDelimiter "]"'), $EXPECT($L25, 'InlineInterfacePropertyDelimiter "}"'))));
|
|
12087
12179
|
var InlineInterfacePropertyDelimiter$3 = $Y(EOS);
|
|
12088
12180
|
var InlineInterfacePropertyDelimiter$$ = [InlineInterfacePropertyDelimiter$0, InlineInterfacePropertyDelimiter$1, InlineInterfacePropertyDelimiter$2, InlineInterfacePropertyDelimiter$3];
|
|
12089
12181
|
function InlineInterfacePropertyDelimiter(ctx, state) {
|
|
12090
12182
|
return $EVENT_C(ctx, state, "InlineInterfacePropertyDelimiter", InlineInterfacePropertyDelimiter$$);
|
|
12091
12183
|
}
|
|
12092
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
12184
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L98, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
12093
12185
|
return { $loc, token: "|" };
|
|
12094
12186
|
});
|
|
12095
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
12187
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L97, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
12096
12188
|
return { $loc, token: "&" };
|
|
12097
12189
|
});
|
|
12098
12190
|
var TypeBinaryOp$$ = [TypeBinaryOp$0, TypeBinaryOp$1];
|
|
@@ -12142,11 +12234,11 @@ ${input.slice(result.pos)}
|
|
|
12142
12234
|
function TypeParameters(ctx, state) {
|
|
12143
12235
|
return $EVENT(ctx, state, "TypeParameters", TypeParameters$0);
|
|
12144
12236
|
}
|
|
12145
|
-
var TypeParameter$0 = $S(__, $E($S($EXPECT($
|
|
12237
|
+
var TypeParameter$0 = $S(__, $E($S($EXPECT($L149, 'TypeParameter "const"'), $E(_))), Identifier, $E(TypeConstraint), $E(TypeInitializer), TypeParameterDelimiter);
|
|
12146
12238
|
function TypeParameter(ctx, state) {
|
|
12147
12239
|
return $EVENT(ctx, state, "TypeParameter", TypeParameter$0);
|
|
12148
12240
|
}
|
|
12149
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
12241
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L138, 'TypeConstraint "extends"'), NonIdContinue, Type);
|
|
12150
12242
|
function TypeConstraint(ctx, state) {
|
|
12151
12243
|
return $EVENT(ctx, state, "TypeConstraint", TypeConstraint$0);
|
|
12152
12244
|
}
|
|
@@ -12169,15 +12261,15 @@ ${input.slice(result.pos)}
|
|
|
12169
12261
|
function ThisType(ctx, state) {
|
|
12170
12262
|
return $EVENT(ctx, state, "ThisType", ThisType$0);
|
|
12171
12263
|
}
|
|
12172
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
12264
|
+
var Shebang$0 = $S($R$0($EXPECT($R77, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
12173
12265
|
function Shebang(ctx, state) {
|
|
12174
12266
|
return $EVENT(ctx, state, "Shebang", Shebang$0);
|
|
12175
12267
|
}
|
|
12176
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
12268
|
+
var CivetPrologue$0 = $T($S($EXPECT($R78, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, SimpleStatementDelimiter, $E(EOS)), function(value) {
|
|
12177
12269
|
var content = value[2];
|
|
12178
12270
|
return content;
|
|
12179
12271
|
});
|
|
12180
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
12272
|
+
var CivetPrologue$1 = $T($S($EXPECT($R78, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, SimpleStatementDelimiter, $E(EOS)), function(value) {
|
|
12181
12273
|
var content = value[2];
|
|
12182
12274
|
return content;
|
|
12183
12275
|
});
|
|
@@ -12185,7 +12277,7 @@ ${input.slice(result.pos)}
|
|
|
12185
12277
|
function CivetPrologue(ctx, state) {
|
|
12186
12278
|
return $EVENT_C(ctx, state, "CivetPrologue", CivetPrologue$$);
|
|
12187
12279
|
}
|
|
12188
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($
|
|
12280
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L210, 'CivetPrologueContent "civet"'), NonIdContinue, $Q(CivetOption), $EXPECT($R79, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
12189
12281
|
var options = $3;
|
|
12190
12282
|
return {
|
|
12191
12283
|
type: "CivetPrologue",
|
|
@@ -12196,7 +12288,7 @@ ${input.slice(result.pos)}
|
|
|
12196
12288
|
function CivetPrologueContent(ctx, state) {
|
|
12197
12289
|
return $EVENT(ctx, state, "CivetPrologueContent", CivetPrologueContent$0);
|
|
12198
12290
|
}
|
|
12199
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
12291
|
+
var CivetOption$0 = $TR($EXPECT($R80, "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) {
|
|
12200
12292
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
12201
12293
|
if (l)
|
|
12202
12294
|
return l.toUpperCase();
|
|
@@ -12213,11 +12305,11 @@ ${input.slice(result.pos)}
|
|
|
12213
12305
|
function CivetOption(ctx, state) {
|
|
12214
12306
|
return $EVENT(ctx, state, "CivetOption", CivetOption$0);
|
|
12215
12307
|
}
|
|
12216
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
12308
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R78, "UnknownPrologue /[\\t ]*/")), StringLiteral, $TEXT(SimpleStatementDelimiter), EOS);
|
|
12217
12309
|
function UnknownPrologue(ctx, state) {
|
|
12218
12310
|
return $EVENT(ctx, state, "UnknownPrologue", UnknownPrologue$0);
|
|
12219
12311
|
}
|
|
12220
|
-
var TripleSlashDirective$0 = $S($R$0($EXPECT($
|
|
12312
|
+
var TripleSlashDirective$0 = $S($R$0($EXPECT($R81, "TripleSlashDirective /\\/\\/\\/[^\\r\\n]*/")), $E(EOS));
|
|
12221
12313
|
function TripleSlashDirective(ctx, state) {
|
|
12222
12314
|
return $EVENT(ctx, state, "TripleSlashDirective", TripleSlashDirective$0);
|
|
12223
12315
|
}
|
|
@@ -12231,13 +12323,13 @@ ${input.slice(result.pos)}
|
|
|
12231
12323
|
function PrologueString(ctx, state) {
|
|
12232
12324
|
return $EVENT_C(ctx, state, "PrologueString", PrologueString$$);
|
|
12233
12325
|
}
|
|
12234
|
-
var EOS$0 = $T($S($EXPECT($
|
|
12326
|
+
var EOS$0 = $T($S($EXPECT($R82, "EOS /(?=[ \\t\\r\\n\\/#]|$)/"), $P(RestOfLine)), function(value) {
|
|
12235
12327
|
return value[1];
|
|
12236
12328
|
});
|
|
12237
12329
|
function EOS(ctx, state) {
|
|
12238
12330
|
return $EVENT(ctx, state, "EOS", EOS$0);
|
|
12239
12331
|
}
|
|
12240
|
-
var EOL$0 = $TR($EXPECT($
|
|
12332
|
+
var EOL$0 = $TR($EXPECT($R83, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12241
12333
|
return { $loc, token: $0 };
|
|
12242
12334
|
});
|
|
12243
12335
|
function EOL(ctx, state) {
|
|
@@ -12731,7 +12823,7 @@ ${input.slice(result.pos)}
|
|
|
12731
12823
|
function Init(ctx, state) {
|
|
12732
12824
|
return $EVENT(ctx, state, "Init", Init$0);
|
|
12733
12825
|
}
|
|
12734
|
-
var Indent$0 = $TR($EXPECT($
|
|
12826
|
+
var Indent$0 = $TR($EXPECT($R84, "Indent /[ \\t]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
12735
12827
|
const level = getIndentLevel($0, module.config.tab);
|
|
12736
12828
|
return {
|
|
12737
12829
|
$loc,
|
|
@@ -12853,6 +12945,7 @@ ${input.slice(result.pos)}
|
|
|
12853
12945
|
exports.NestedNonAssignmentExtendedExpression = NestedNonAssignmentExtendedExpression;
|
|
12854
12946
|
exports.ExpressionizedStatementWithTrailingCallExpressions = ExpressionizedStatementWithTrailingCallExpressions;
|
|
12855
12947
|
exports.ExpressionizedStatement = ExpressionizedStatement;
|
|
12948
|
+
exports._ExpressionizedStatement = _ExpressionizedStatement;
|
|
12856
12949
|
exports.Expression = Expression;
|
|
12857
12950
|
exports.Arguments = Arguments;
|
|
12858
12951
|
exports.ImplicitArguments = ImplicitArguments;
|
|
@@ -12944,6 +13037,7 @@ ${input.slice(result.pos)}
|
|
|
12944
13037
|
exports.MemberBracketContent = MemberBracketContent;
|
|
12945
13038
|
exports.SliceParameters = SliceParameters;
|
|
12946
13039
|
exports.AccessStart = AccessStart;
|
|
13040
|
+
exports.PropertyAccessModifier = PropertyAccessModifier;
|
|
12947
13041
|
exports.PropertyAccess = PropertyAccess;
|
|
12948
13042
|
exports.PropertyGlob = PropertyGlob;
|
|
12949
13043
|
exports.PropertyBind = PropertyBind;
|
|
@@ -13014,12 +13108,14 @@ ${input.slice(result.pos)}
|
|
|
13014
13108
|
exports.LiteralContent = LiteralContent;
|
|
13015
13109
|
exports.NullLiteral = NullLiteral;
|
|
13016
13110
|
exports.BooleanLiteral = BooleanLiteral;
|
|
13111
|
+
exports._BooleanLiteral = _BooleanLiteral;
|
|
13017
13112
|
exports.CoffeeScriptBooleanLiteral = CoffeeScriptBooleanLiteral;
|
|
13018
13113
|
exports.Identifier = Identifier;
|
|
13019
13114
|
exports.IdentifierName = IdentifierName;
|
|
13020
13115
|
exports.IdentifierReference = IdentifierReference;
|
|
13021
13116
|
exports.UpcomingAssignment = UpcomingAssignment;
|
|
13022
13117
|
exports.ArrayLiteral = ArrayLiteral;
|
|
13118
|
+
exports._ArrayLiteral = _ArrayLiteral;
|
|
13023
13119
|
exports.RangeExpression = RangeExpression;
|
|
13024
13120
|
exports.ArrayLiteralContent = ArrayLiteralContent;
|
|
13025
13121
|
exports.NestedElementList = NestedElementList;
|
|
@@ -13061,6 +13157,8 @@ ${input.slice(result.pos)}
|
|
|
13061
13157
|
exports.IdentifierBinaryOp = IdentifierBinaryOp;
|
|
13062
13158
|
exports.BinaryOp = BinaryOp;
|
|
13063
13159
|
exports.BinaryOpSymbol = BinaryOpSymbol;
|
|
13160
|
+
exports.CoffeeOfOp = CoffeeOfOp;
|
|
13161
|
+
exports.NotOp = NotOp;
|
|
13064
13162
|
exports.Xor = Xor;
|
|
13065
13163
|
exports.Xnor = Xnor;
|
|
13066
13164
|
exports.UnaryOp = UnaryOp;
|
|
@@ -13071,6 +13169,7 @@ ${input.slice(result.pos)}
|
|
|
13071
13169
|
exports.PostfixedExpression = PostfixedExpression;
|
|
13072
13170
|
exports.NonPipelinePostfixedExpression = NonPipelinePostfixedExpression;
|
|
13073
13171
|
exports.PostfixStatement = PostfixStatement;
|
|
13172
|
+
exports._PostfixStatement = _PostfixStatement;
|
|
13074
13173
|
exports.Statement = Statement;
|
|
13075
13174
|
exports.EmptyStatement = EmptyStatement;
|
|
13076
13175
|
exports.BlockStatement = BlockStatement;
|
|
@@ -13090,6 +13189,7 @@ ${input.slice(result.pos)}
|
|
|
13090
13189
|
exports.NestedBlockExpression = NestedBlockExpression;
|
|
13091
13190
|
exports.BlockExpressionPart = BlockExpressionPart;
|
|
13092
13191
|
exports.IterationStatement = IterationStatement;
|
|
13192
|
+
exports._IterationStatement = _IterationStatement;
|
|
13093
13193
|
exports.IterationExpression = IterationExpression;
|
|
13094
13194
|
exports.LoopStatement = LoopStatement;
|
|
13095
13195
|
exports.LoopClause = LoopClause;
|
|
@@ -13226,6 +13326,7 @@ ${input.slice(result.pos)}
|
|
|
13226
13326
|
exports.RegExpCharacter = RegExpCharacter;
|
|
13227
13327
|
exports.RegularExpressionFlags = RegularExpressionFlags;
|
|
13228
13328
|
exports.TemplateLiteral = TemplateLiteral;
|
|
13329
|
+
exports._TemplateLiteral = _TemplateLiteral;
|
|
13229
13330
|
exports.TemplateSubstitution = TemplateSubstitution;
|
|
13230
13331
|
exports.TemplateCharacters = TemplateCharacters;
|
|
13231
13332
|
exports.TemplateBlockCharacters = TemplateBlockCharacters;
|
|
@@ -14182,7 +14283,8 @@ ${counts}`;
|
|
|
14182
14283
|
return;
|
|
14183
14284
|
}
|
|
14184
14285
|
;
|
|
14185
|
-
const
|
|
14286
|
+
const [stateKey, tagKey] = getStateKey();
|
|
14287
|
+
const key = [tagKey, stateKey, state.pos, ruleName];
|
|
14186
14288
|
if (stateCache.has(key)) {
|
|
14187
14289
|
if (trace) {
|
|
14188
14290
|
logs.push("".padStart(stack.length * 2, " ") + ruleName + ":" + state.pos + "\u{1F4B0}");
|
|
@@ -14203,12 +14305,9 @@ ${counts}`;
|
|
|
14203
14305
|
({ getStateKey } = result.value);
|
|
14204
14306
|
}
|
|
14205
14307
|
if (!uncacheable.has(ruleName)) {
|
|
14206
|
-
const
|
|
14207
|
-
|
|
14208
|
-
|
|
14209
|
-
} else {
|
|
14210
|
-
stateCache.set(key, result);
|
|
14211
|
-
}
|
|
14308
|
+
const [stateKey, tagKey] = getStateKey();
|
|
14309
|
+
const key = [tagKey, stateKey, state.pos, ruleName];
|
|
14310
|
+
stateCache.set(key, result);
|
|
14212
14311
|
}
|
|
14213
14312
|
if (parse.config.verbose && result) {
|
|
14214
14313
|
console.log(`Parsed ${JSON.stringify(state.input.slice(state.pos, result.pos))} [pos ${state.pos}-${result.pos}] as ${ruleName}`);
|