@danielx/civet 0.2.15 → 0.3.1
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/README.md +9 -7
- package/dist/browser.js +730 -350
- package/dist/browser.js.map +3 -3
- package/dist/civet +14 -13
- package/dist/cli.js.map +4 -4
- package/dist/main.js +735 -355
- package/dist/types.d.ts +24 -5
- package/package.json +8 -1
- package/register.mjs +37 -10
package/dist/main.js
CHANGED
|
@@ -416,8 +416,10 @@ var require_parser = __commonJS({
|
|
|
416
416
|
UnaryExpression,
|
|
417
417
|
UnaryPostfix,
|
|
418
418
|
UpdateExpression,
|
|
419
|
+
UpdateExpressionSymbol,
|
|
419
420
|
AssignmentExpression,
|
|
420
421
|
AssignmentExpressionRest,
|
|
422
|
+
AwaitExpression,
|
|
421
423
|
YieldExpression,
|
|
422
424
|
ArrowFunction,
|
|
423
425
|
FatArrow,
|
|
@@ -427,14 +429,17 @@ var require_parser = __commonJS({
|
|
|
427
429
|
PrimaryExpression,
|
|
428
430
|
ClassDeclaration,
|
|
429
431
|
ClassExpression,
|
|
432
|
+
Class,
|
|
430
433
|
ClassHeritage,
|
|
431
434
|
ExtendsToken,
|
|
432
435
|
ClassBody,
|
|
433
436
|
NestedClassElements,
|
|
434
437
|
NestedClassElement,
|
|
435
438
|
ClassElement,
|
|
439
|
+
Static,
|
|
436
440
|
FieldDefinition,
|
|
437
441
|
This,
|
|
442
|
+
AtAccessor,
|
|
438
443
|
LeftHandSideExpression,
|
|
439
444
|
NewExpression,
|
|
440
445
|
CallExpression,
|
|
@@ -462,13 +467,17 @@ var require_parser = __commonJS({
|
|
|
462
467
|
FunctionDeclaration,
|
|
463
468
|
FunctionExpression,
|
|
464
469
|
ThinArrowFunction,
|
|
470
|
+
Arrow,
|
|
465
471
|
Block,
|
|
472
|
+
BracedOrEmptyBlock,
|
|
466
473
|
BracedBlock,
|
|
467
474
|
SingleNestedExpression,
|
|
468
475
|
SingleNestedBlockStatement,
|
|
469
476
|
NestedBlockExpressions,
|
|
470
477
|
BlockExpression,
|
|
471
478
|
Literal,
|
|
479
|
+
NullLiteral,
|
|
480
|
+
BooleanLiteral,
|
|
472
481
|
Comma,
|
|
473
482
|
Identifier,
|
|
474
483
|
IdentifierName,
|
|
@@ -498,7 +507,9 @@ var require_parser = __commonJS({
|
|
|
498
507
|
AsyncGeneratorMethod,
|
|
499
508
|
AsyncGeneratorBody,
|
|
500
509
|
AssignmentOp,
|
|
510
|
+
AssignmentOpSymbol,
|
|
501
511
|
BinaryOp,
|
|
512
|
+
BinaryOpSymbol,
|
|
502
513
|
UnaryOp,
|
|
503
514
|
ModuleItem,
|
|
504
515
|
StatementListItem,
|
|
@@ -514,7 +525,9 @@ var require_parser = __commonJS({
|
|
|
514
525
|
WhileClause,
|
|
515
526
|
ForStatement,
|
|
516
527
|
ForInOfStatement,
|
|
528
|
+
For,
|
|
517
529
|
ForDeclaration,
|
|
530
|
+
LetOrConst,
|
|
518
531
|
ForBinding,
|
|
519
532
|
SwitchStatement,
|
|
520
533
|
CaseBlock,
|
|
@@ -534,10 +547,12 @@ var require_parser = __commonJS({
|
|
|
534
547
|
MaybeNestedExpression,
|
|
535
548
|
Return,
|
|
536
549
|
ImportDeclaration,
|
|
550
|
+
Import,
|
|
537
551
|
ImportClause,
|
|
538
552
|
NameSpaceImport,
|
|
539
553
|
NamedImports,
|
|
540
554
|
FromClause,
|
|
555
|
+
From,
|
|
541
556
|
ImportSpecifier,
|
|
542
557
|
ModuleExportName,
|
|
543
558
|
ModuleSpecifier,
|
|
@@ -558,6 +573,7 @@ var require_parser = __commonJS({
|
|
|
558
573
|
VariableDeclarationList,
|
|
559
574
|
VariableDeclaration,
|
|
560
575
|
NumericLiteral,
|
|
576
|
+
NumericLiteralKind,
|
|
561
577
|
DecimalBigIntegerLiteral,
|
|
562
578
|
DecimalLiteral,
|
|
563
579
|
BinaryIntegerLiteral,
|
|
@@ -567,7 +583,7 @@ var require_parser = __commonJS({
|
|
|
567
583
|
DoubleStringCharacter,
|
|
568
584
|
SingleStringCharacter,
|
|
569
585
|
TripleDoubleStringCharacter,
|
|
570
|
-
|
|
586
|
+
TripleSingleStringCharacter,
|
|
571
587
|
RegularExpressionLiteral,
|
|
572
588
|
RegularExpressionBody,
|
|
573
589
|
RegExpCharacter,
|
|
@@ -662,37 +678,37 @@ var require_parser = __commonJS({
|
|
|
662
678
|
var $L5 = $L("++");
|
|
663
679
|
var $L6 = $L("--");
|
|
664
680
|
var $L7 = $L("async");
|
|
665
|
-
var $L8 = $L("
|
|
666
|
-
var $L9 = $L("
|
|
667
|
-
var $L10 = $L("
|
|
668
|
-
var $L11 = $L("
|
|
669
|
-
var $L12 = $L("
|
|
670
|
-
var $L13 = $L("
|
|
671
|
-
var $L14 = $L("
|
|
672
|
-
var $L15 = $L("
|
|
673
|
-
var $L16 = $L("
|
|
674
|
-
var $L17 = $L("
|
|
675
|
-
var $L18 = $L("
|
|
676
|
-
var $L19 = $L("
|
|
681
|
+
var $L8 = $L("await");
|
|
682
|
+
var $L9 = $L("yield");
|
|
683
|
+
var $L10 = $L("*");
|
|
684
|
+
var $L11 = $L("=>");
|
|
685
|
+
var $L12 = $L("{");
|
|
686
|
+
var $L13 = $L(":");
|
|
687
|
+
var $L14 = $L("class");
|
|
688
|
+
var $L15 = $L("<");
|
|
689
|
+
var $L16 = $L("extends");
|
|
690
|
+
var $L17 = $L("}");
|
|
691
|
+
var $L18 = $L("static");
|
|
692
|
+
var $L19 = $L("this");
|
|
677
693
|
var $L20 = $L("#");
|
|
678
|
-
var $L21 = $L("
|
|
679
|
-
var $L22 = $L("
|
|
680
|
-
var $L23 = $L("
|
|
681
|
-
var $L24 = $L("
|
|
682
|
-
var $L25 = $L("
|
|
683
|
-
var $L26 = $L("
|
|
684
|
-
var $L27 = $L("
|
|
685
|
-
var $L28 = $L("
|
|
686
|
-
var $L29 = $L("
|
|
687
|
-
var $L30 = $L("
|
|
688
|
-
var $L31 = $L("");
|
|
689
|
-
var $L32 = $L("
|
|
690
|
-
var $L33 = $L("
|
|
691
|
-
var $L34 = $L("
|
|
692
|
-
var $L35 = $L("
|
|
693
|
-
var $L36 = $L("
|
|
694
|
-
var $L37 = $L("
|
|
695
|
-
var $L38 = $L("
|
|
694
|
+
var $L21 = $L("@");
|
|
695
|
+
var $L22 = $L("new");
|
|
696
|
+
var $L23 = $L("super");
|
|
697
|
+
var $L24 = $L("import");
|
|
698
|
+
var $L25 = $L(".");
|
|
699
|
+
var $L26 = $L("[");
|
|
700
|
+
var $L27 = $L("]");
|
|
701
|
+
var $L28 = $L("::");
|
|
702
|
+
var $L29 = $L("super[");
|
|
703
|
+
var $L30 = $L("new.target");
|
|
704
|
+
var $L31 = $L("import.meta");
|
|
705
|
+
var $L32 = $L("");
|
|
706
|
+
var $L33 = $L("...");
|
|
707
|
+
var $L34 = $L("function");
|
|
708
|
+
var $L35 = $L("->");
|
|
709
|
+
var $L36 = $L("null");
|
|
710
|
+
var $L37 = $L("true");
|
|
711
|
+
var $L38 = $L("false");
|
|
696
712
|
var $L39 = $L("get");
|
|
697
713
|
var $L40 = $L("set");
|
|
698
714
|
var $L41 = $L("**=");
|
|
@@ -748,48 +764,47 @@ var require_parser = __commonJS({
|
|
|
748
764
|
var $L91 = $L("do");
|
|
749
765
|
var $L92 = $L("while");
|
|
750
766
|
var $L93 = $L("until");
|
|
751
|
-
var $L94 = $L("
|
|
752
|
-
var $L95 = $L("
|
|
753
|
-
var $L96 = $L("
|
|
754
|
-
var $L97 = $L("
|
|
755
|
-
var $L98 = $L("
|
|
756
|
-
var $L99 = $L("
|
|
757
|
-
var $L100 = $L("
|
|
758
|
-
var $L101 = $L("
|
|
759
|
-
var $L102 = $L("
|
|
760
|
-
var $L103 = $L("
|
|
761
|
-
var $L104 = $L("
|
|
762
|
-
var $L105 = $L("
|
|
763
|
-
var $L106 = $L("
|
|
764
|
-
var $L107 = $L("
|
|
765
|
-
var $L108 = $L("
|
|
766
|
-
var $L109 = $L("
|
|
767
|
-
var $L110 = $L("
|
|
768
|
-
var $L111 = $L("
|
|
769
|
-
var $L112 = $L("
|
|
770
|
-
var $L113 = $L("
|
|
771
|
-
var $L114 = $L("
|
|
772
|
-
var $L115 = $L("
|
|
773
|
-
var $L116 = $L('"
|
|
767
|
+
var $L94 = $L("var");
|
|
768
|
+
var $L95 = $L("of");
|
|
769
|
+
var $L96 = $L("for");
|
|
770
|
+
var $L97 = $L("let");
|
|
771
|
+
var $L98 = $L("const");
|
|
772
|
+
var $L99 = $L("switch");
|
|
773
|
+
var $L100 = $L("case");
|
|
774
|
+
var $L101 = $L("default");
|
|
775
|
+
var $L102 = $L("when");
|
|
776
|
+
var $L103 = $L("try");
|
|
777
|
+
var $L104 = $L("catch");
|
|
778
|
+
var $L105 = $L("finally");
|
|
779
|
+
var $L106 = $L("break");
|
|
780
|
+
var $L107 = $L("continue");
|
|
781
|
+
var $L108 = $L("debugger");
|
|
782
|
+
var $L109 = $L("throw");
|
|
783
|
+
var $L110 = $L("return");
|
|
784
|
+
var $L111 = $L("import type");
|
|
785
|
+
var $L112 = $L("from");
|
|
786
|
+
var $L113 = $L("export");
|
|
787
|
+
var $L114 = $L(":=");
|
|
788
|
+
var $L115 = $L('"""');
|
|
789
|
+
var $L116 = $L("'''");
|
|
774
790
|
var $L117 = $L('"');
|
|
775
791
|
var $L118 = $L("'");
|
|
776
|
-
var $L119 = $L("
|
|
777
|
-
var $L120 = $L("
|
|
778
|
-
var $L121 = $L("
|
|
779
|
-
var $L122 = $L("
|
|
780
|
-
var $L123 = $L("
|
|
781
|
-
var $L124 = $L("
|
|
782
|
-
var $L125 = $L("
|
|
783
|
-
var $L126 = $L("
|
|
784
|
-
var $L127 = $L("
|
|
785
|
-
var $L128 = $L("
|
|
786
|
-
var $L129 = $L("
|
|
787
|
-
var $L130 = $L("
|
|
788
|
-
var $L131 = $L("
|
|
789
|
-
var $L132 = $L("
|
|
790
|
-
var $L133 = $L("
|
|
791
|
-
var $L134 = $L("
|
|
792
|
-
var $L135 = $L(" ");
|
|
792
|
+
var $L119 = $L("`");
|
|
793
|
+
var $L120 = $L("${");
|
|
794
|
+
var $L121 = $L("/*");
|
|
795
|
+
var $L122 = $L("*/");
|
|
796
|
+
var $L123 = $L("###");
|
|
797
|
+
var $L124 = $L("/>");
|
|
798
|
+
var $L125 = $L("</");
|
|
799
|
+
var $L126 = $L("<>");
|
|
800
|
+
var $L127 = $L("</>");
|
|
801
|
+
var $L128 = $L("readonly");
|
|
802
|
+
var $L129 = $L("asserts");
|
|
803
|
+
var $L130 = $L("keyof");
|
|
804
|
+
var $L131 = $L("infer");
|
|
805
|
+
var $L132 = $L("[]");
|
|
806
|
+
var $L133 = $L(" ");
|
|
807
|
+
var $L134 = $L(" ");
|
|
793
808
|
var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
794
809
|
var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
795
810
|
var $R2 = $R(new RegExp("[!~+-]", "suy"));
|
|
@@ -798,33 +813,34 @@ var require_parser = __commonJS({
|
|
|
798
813
|
var $R5 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
|
|
799
814
|
var $R6 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
|
|
800
815
|
var $R7 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
|
|
801
|
-
var $R8 = $R(new RegExp('[^"
|
|
802
|
-
var $R9 = $R(new RegExp("[^'
|
|
816
|
+
var $R8 = $R(new RegExp('(?:\\\\.|[^"])+', "suy"));
|
|
817
|
+
var $R9 = $R(new RegExp("(?:\\\\.|[^'])+", "suy"));
|
|
803
818
|
var $R10 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
|
|
804
|
-
var $R11 = $R(new RegExp("
|
|
819
|
+
var $R11 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])+", "suy"));
|
|
805
820
|
var $R12 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
|
|
806
|
-
var $R13 = $R(new RegExp("[^\\/\\r\\n]+", "suy"));
|
|
807
|
-
var $R14 = $R(new RegExp("(
|
|
821
|
+
var $R13 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
|
|
822
|
+
var $R14 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
808
823
|
var $R15 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
809
824
|
var $R16 = $R(new RegExp("(?:and|as|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|new|null|or|return|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
810
825
|
var $R17 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
811
|
-
var $R18 = $R(new RegExp("
|
|
812
|
-
var $R19 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
813
|
-
var $R20 = $R(new RegExp("[\\
|
|
814
|
-
var $R21 = $R(new RegExp("[\\
|
|
815
|
-
var $R22 = $R(new RegExp("
|
|
816
|
-
var $R23 = $R(new RegExp("(
|
|
817
|
-
var $R24 = $R(new RegExp(
|
|
818
|
-
var $R25 = $R(new RegExp("
|
|
819
|
-
var $R26 = $R(new RegExp("[^
|
|
820
|
-
var $R27 = $R(new RegExp("
|
|
821
|
-
var $R28 = $R(new RegExp("
|
|
822
|
-
var $R29 = $R(new RegExp("
|
|
823
|
-
var $R30 = $R(new RegExp("[+-]", "suy"));
|
|
824
|
-
var $R31 = $R(new RegExp("
|
|
825
|
-
var $R32 = $R(new RegExp("[\\
|
|
826
|
-
var $R33 = $R(new RegExp("\\
|
|
827
|
-
var $R34 = $R(new RegExp("
|
|
826
|
+
var $R18 = $R(new RegExp(".", "suy"));
|
|
827
|
+
var $R19 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
828
|
+
var $R20 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
829
|
+
var $R21 = $R(new RegExp("[\\t ]+", "suy"));
|
|
830
|
+
var $R22 = $R(new RegExp("[\\s]+", "suy"));
|
|
831
|
+
var $R23 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
832
|
+
var $R24 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
833
|
+
var $R25 = $R(new RegExp('"[^"]*"', "suy"));
|
|
834
|
+
var $R26 = $R(new RegExp("'[^']*'", "suy"));
|
|
835
|
+
var $R27 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
836
|
+
var $R28 = $R(new RegExp("type(?!\\p{ID_Continue})", "suy"));
|
|
837
|
+
var $R29 = $R(new RegExp("interface(?!\\p{ID_Continue})", "suy"));
|
|
838
|
+
var $R30 = $R(new RegExp("[+-]?", "suy"));
|
|
839
|
+
var $R31 = $R(new RegExp("[+-]", "suy"));
|
|
840
|
+
var $R32 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
841
|
+
var $R33 = $R(new RegExp("[\\t ]*", "suy"));
|
|
842
|
+
var $R34 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
843
|
+
var $R35 = $R(new RegExp("$", "suy"));
|
|
828
844
|
var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
|
|
829
845
|
function Program(state) {
|
|
830
846
|
if (state.verbose)
|
|
@@ -948,8 +964,8 @@ var require_parser = __commonJS({
|
|
|
948
964
|
return UnaryPostfix$0(state) || UnaryPostfix$1(state);
|
|
949
965
|
}
|
|
950
966
|
}
|
|
951
|
-
var UpdateExpression$0 = $S(
|
|
952
|
-
var UpdateExpression$1 = $S(LeftHandSideExpression, $E(
|
|
967
|
+
var UpdateExpression$0 = $S(UpdateExpressionSymbol, UnaryExpression);
|
|
968
|
+
var UpdateExpression$1 = $S(LeftHandSideExpression, $E(UpdateExpressionSymbol));
|
|
953
969
|
function UpdateExpression(state) {
|
|
954
970
|
if (state.tokenize) {
|
|
955
971
|
return $TOKEN("UpdateExpression", state, UpdateExpression$0(state) || UpdateExpression$1(state));
|
|
@@ -957,6 +973,18 @@ var require_parser = __commonJS({
|
|
|
957
973
|
return UpdateExpression$0(state) || UpdateExpression$1(state);
|
|
958
974
|
}
|
|
959
975
|
}
|
|
976
|
+
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L5, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L6, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
|
|
977
|
+
return { $loc, token: $1 };
|
|
978
|
+
});
|
|
979
|
+
function UpdateExpressionSymbol(state) {
|
|
980
|
+
if (state.verbose)
|
|
981
|
+
console.log("ENTER:", "UpdateExpressionSymbol");
|
|
982
|
+
if (state.tokenize) {
|
|
983
|
+
return $TOKEN("UpdateExpressionSymbol", state, UpdateExpressionSymbol$0(state));
|
|
984
|
+
} else {
|
|
985
|
+
return UpdateExpressionSymbol$0(state);
|
|
986
|
+
}
|
|
987
|
+
}
|
|
960
988
|
var AssignmentExpression$0 = $S($Q(TrailingComment), AssignmentExpressionRest);
|
|
961
989
|
var AssignmentExpression$1 = $S(__, AssignmentExpressionRest);
|
|
962
990
|
function AssignmentExpression(state) {
|
|
@@ -966,18 +994,29 @@ var require_parser = __commonJS({
|
|
|
966
994
|
return AssignmentExpression$0(state) || AssignmentExpression$1(state);
|
|
967
995
|
}
|
|
968
996
|
}
|
|
969
|
-
var AssignmentExpressionRest$0 =
|
|
970
|
-
var AssignmentExpressionRest$1 =
|
|
971
|
-
var AssignmentExpressionRest$2 = $S($
|
|
972
|
-
var AssignmentExpressionRest$3 =
|
|
997
|
+
var AssignmentExpressionRest$0 = AwaitExpression;
|
|
998
|
+
var AssignmentExpressionRest$1 = YieldExpression;
|
|
999
|
+
var AssignmentExpressionRest$2 = $S($E($S($EXPECT($L7, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
|
|
1000
|
+
var AssignmentExpressionRest$3 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), Expression);
|
|
1001
|
+
var AssignmentExpressionRest$4 = ConditionalExpression;
|
|
973
1002
|
function AssignmentExpressionRest(state) {
|
|
974
1003
|
if (state.tokenize) {
|
|
975
|
-
return $TOKEN("AssignmentExpressionRest", state, AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state));
|
|
1004
|
+
return $TOKEN("AssignmentExpressionRest", state, AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state) || AssignmentExpressionRest$4(state));
|
|
1005
|
+
} else {
|
|
1006
|
+
return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state) || AssignmentExpressionRest$4(state);
|
|
1007
|
+
}
|
|
1008
|
+
}
|
|
1009
|
+
var AwaitExpression$0 = $S($EXPECT($L8, fail, 'AwaitExpression "await"'), NonIdContinue, $Q(TrailingComment), AssignmentExpression);
|
|
1010
|
+
function AwaitExpression(state) {
|
|
1011
|
+
if (state.verbose)
|
|
1012
|
+
console.log("ENTER:", "AwaitExpression");
|
|
1013
|
+
if (state.tokenize) {
|
|
1014
|
+
return $TOKEN("AwaitExpression", state, AwaitExpression$0(state));
|
|
976
1015
|
} else {
|
|
977
|
-
return
|
|
1016
|
+
return AwaitExpression$0(state);
|
|
978
1017
|
}
|
|
979
1018
|
}
|
|
980
|
-
var YieldExpression$0 = $S($EXPECT($
|
|
1019
|
+
var YieldExpression$0 = $S($EXPECT($L9, fail, 'YieldExpression "yield"'), NonIdContinue, $E($S($Q(TrailingComment), $EXPECT($L10, fail, 'YieldExpression "*"'))), AssignmentExpression);
|
|
981
1020
|
function YieldExpression(state) {
|
|
982
1021
|
if (state.verbose)
|
|
983
1022
|
console.log("ENTER:", "YieldExpression");
|
|
@@ -996,7 +1035,7 @@ var require_parser = __commonJS({
|
|
|
996
1035
|
return ArrowFunction$0(state) || ArrowFunction$1(state);
|
|
997
1036
|
}
|
|
998
1037
|
}
|
|
999
|
-
var FatArrow$0 = $TS($S(__, $EXPECT($
|
|
1038
|
+
var FatArrow$0 = $TS($S(__, $EXPECT($L11, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
|
|
1000
1039
|
var ws = $1;
|
|
1001
1040
|
if (!ws.length)
|
|
1002
1041
|
return " =>";
|
|
@@ -1012,7 +1051,7 @@ var require_parser = __commonJS({
|
|
|
1012
1051
|
}
|
|
1013
1052
|
}
|
|
1014
1053
|
var ConciseBody$0 = $S(EOS, SingleNestedBlockStatement);
|
|
1015
|
-
var ConciseBody$1 = $S($N($S($Q(_), $EXPECT($
|
|
1054
|
+
var ConciseBody$1 = $S($N($S($Q(_), $EXPECT($L12, fail, 'ConciseBody "{"'))), AssignmentExpression);
|
|
1016
1055
|
var ConciseBody$2 = BracedBlock;
|
|
1017
1056
|
function ConciseBody(state) {
|
|
1018
1057
|
if (state.tokenize) {
|
|
@@ -1021,7 +1060,7 @@ var require_parser = __commonJS({
|
|
|
1021
1060
|
return ConciseBody$0(state) || ConciseBody$1(state) || ConciseBody$2(state);
|
|
1022
1061
|
}
|
|
1023
1062
|
}
|
|
1024
|
-
var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($
|
|
1063
|
+
var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L13, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
|
|
1025
1064
|
function ConditionalExpression(state) {
|
|
1026
1065
|
if (state.verbose)
|
|
1027
1066
|
console.log("ENTER:", "ConditionalExpression");
|
|
@@ -1070,7 +1109,7 @@ var require_parser = __commonJS({
|
|
|
1070
1109
|
return ClassDeclaration$0(state);
|
|
1071
1110
|
}
|
|
1072
1111
|
}
|
|
1073
|
-
var ClassExpression$0 = $S(
|
|
1112
|
+
var ClassExpression$0 = $S(Class, $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
|
|
1074
1113
|
function ClassExpression(state) {
|
|
1075
1114
|
if (state.verbose)
|
|
1076
1115
|
console.log("ENTER:", "ClassExpression");
|
|
@@ -1080,6 +1119,18 @@ var require_parser = __commonJS({
|
|
|
1080
1119
|
return ClassExpression$0(state);
|
|
1081
1120
|
}
|
|
1082
1121
|
}
|
|
1122
|
+
var Class$0 = $TV($EXPECT($L14, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
1123
|
+
return { $loc, token: $0 };
|
|
1124
|
+
});
|
|
1125
|
+
function Class(state) {
|
|
1126
|
+
if (state.verbose)
|
|
1127
|
+
console.log("ENTER:", "Class");
|
|
1128
|
+
if (state.tokenize) {
|
|
1129
|
+
return $TOKEN("Class", state, Class$0(state));
|
|
1130
|
+
} else {
|
|
1131
|
+
return Class$0(state);
|
|
1132
|
+
}
|
|
1133
|
+
}
|
|
1083
1134
|
var ClassHeritage$0 = $S(ExtendsToken, __, MemberExpression);
|
|
1084
1135
|
function ClassHeritage(state) {
|
|
1085
1136
|
if (state.verbose)
|
|
@@ -1090,10 +1141,12 @@ var require_parser = __commonJS({
|
|
|
1090
1141
|
return ClassHeritage$0(state);
|
|
1091
1142
|
}
|
|
1092
1143
|
}
|
|
1093
|
-
var ExtendsToken$0 = $
|
|
1094
|
-
return "extends";
|
|
1144
|
+
var ExtendsToken$0 = $TV($EXPECT($L15, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
|
|
1145
|
+
return { $loc, token: "extends" };
|
|
1146
|
+
});
|
|
1147
|
+
var ExtendsToken$1 = $TV($EXPECT($L16, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
|
|
1148
|
+
return { $loc, token: $1 };
|
|
1095
1149
|
});
|
|
1096
|
-
var ExtendsToken$1 = $EXPECT($L15, fail, 'ExtendsToken "extends"');
|
|
1097
1150
|
function ExtendsToken(state) {
|
|
1098
1151
|
if (state.tokenize) {
|
|
1099
1152
|
return $TOKEN("ExtendsToken", state, ExtendsToken$0(state) || ExtendsToken$1(state));
|
|
@@ -1101,7 +1154,7 @@ var require_parser = __commonJS({
|
|
|
1101
1154
|
return ExtendsToken$0(state) || ExtendsToken$1(state);
|
|
1102
1155
|
}
|
|
1103
1156
|
}
|
|
1104
|
-
var ClassBody$0 = $S(__, $EXPECT($
|
|
1157
|
+
var ClassBody$0 = $S(__, $EXPECT($L12, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L17, fail, 'ClassBody "}"'));
|
|
1105
1158
|
var ClassBody$1 = $S(InsertOpenBrace, EOS, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1106
1159
|
function ClassBody(state) {
|
|
1107
1160
|
if (state.tokenize) {
|
|
@@ -1135,8 +1188,8 @@ var require_parser = __commonJS({
|
|
|
1135
1188
|
return NestedClassElement$0(state);
|
|
1136
1189
|
}
|
|
1137
1190
|
}
|
|
1138
|
-
var ClassElement$0 = $S(
|
|
1139
|
-
var ClassElement$1 = $S($E($S(
|
|
1191
|
+
var ClassElement$0 = $S(Static, BracedBlock);
|
|
1192
|
+
var ClassElement$1 = $S($E($S(Static, __)), $C(MethodDefinition, FieldDefinition));
|
|
1140
1193
|
function ClassElement(state) {
|
|
1141
1194
|
if (state.tokenize) {
|
|
1142
1195
|
return $TOKEN("ClassElement", state, ClassElement$0(state) || ClassElement$1(state));
|
|
@@ -1144,6 +1197,18 @@ var require_parser = __commonJS({
|
|
|
1144
1197
|
return ClassElement$0(state) || ClassElement$1(state);
|
|
1145
1198
|
}
|
|
1146
1199
|
}
|
|
1200
|
+
var Static$0 = $TV($EXPECT($L18, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
1201
|
+
return { $loc, token: $0 };
|
|
1202
|
+
});
|
|
1203
|
+
function Static(state) {
|
|
1204
|
+
if (state.verbose)
|
|
1205
|
+
console.log("ENTER:", "Static");
|
|
1206
|
+
if (state.tokenize) {
|
|
1207
|
+
return $TOKEN("Static", state, Static$0(state));
|
|
1208
|
+
} else {
|
|
1209
|
+
return Static$0(state);
|
|
1210
|
+
}
|
|
1211
|
+
}
|
|
1147
1212
|
var FieldDefinition$0 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
|
|
1148
1213
|
function FieldDefinition(state) {
|
|
1149
1214
|
if (state.verbose)
|
|
@@ -1154,12 +1219,11 @@ var require_parser = __commonJS({
|
|
|
1154
1219
|
return FieldDefinition$0(state);
|
|
1155
1220
|
}
|
|
1156
1221
|
}
|
|
1157
|
-
var This$0 = $EXPECT($
|
|
1158
|
-
|
|
1159
|
-
var ref = value[1];
|
|
1160
|
-
return ["this.", ref];
|
|
1222
|
+
var This$0 = $TV($EXPECT($L19, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
1223
|
+
return { $loc, token: $0 };
|
|
1161
1224
|
});
|
|
1162
|
-
var This$
|
|
1225
|
+
var This$1 = $S(AtAccessor, $S($E($EXPECT($L20, fail, 'This "#"')), IdentifierName));
|
|
1226
|
+
var This$2 = $TV($EXPECT($L21, fail, 'This "@"'), function($skip, $loc, $0, $1) {
|
|
1163
1227
|
return { $loc, token: "this" };
|
|
1164
1228
|
});
|
|
1165
1229
|
function This(state) {
|
|
@@ -1169,6 +1233,18 @@ var require_parser = __commonJS({
|
|
|
1169
1233
|
return This$0(state) || This$1(state) || This$2(state);
|
|
1170
1234
|
}
|
|
1171
1235
|
}
|
|
1236
|
+
var AtAccessor$0 = $TV($EXPECT($L21, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
|
|
1237
|
+
return { $loc, token: "this." };
|
|
1238
|
+
});
|
|
1239
|
+
function AtAccessor(state) {
|
|
1240
|
+
if (state.verbose)
|
|
1241
|
+
console.log("ENTER:", "AtAccessor");
|
|
1242
|
+
if (state.tokenize) {
|
|
1243
|
+
return $TOKEN("AtAccessor", state, AtAccessor$0(state));
|
|
1244
|
+
} else {
|
|
1245
|
+
return AtAccessor$0(state);
|
|
1246
|
+
}
|
|
1247
|
+
}
|
|
1172
1248
|
var LeftHandSideExpression$0 = NewExpression;
|
|
1173
1249
|
var LeftHandSideExpression$1 = CallExpression;
|
|
1174
1250
|
function LeftHandSideExpression(state) {
|
|
@@ -1178,7 +1254,7 @@ var require_parser = __commonJS({
|
|
|
1178
1254
|
return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
|
|
1179
1255
|
}
|
|
1180
1256
|
}
|
|
1181
|
-
var NewExpression$0 = $S($P($S($EXPECT($
|
|
1257
|
+
var NewExpression$0 = $S($P($S($EXPECT($L22, fail, 'NewExpression "new"'), __)), CallExpression);
|
|
1182
1258
|
function NewExpression(state) {
|
|
1183
1259
|
if (state.verbose)
|
|
1184
1260
|
console.log("ENTER:", "NewExpression");
|
|
@@ -1188,8 +1264,8 @@ var require_parser = __commonJS({
|
|
|
1188
1264
|
return NewExpression$0(state);
|
|
1189
1265
|
}
|
|
1190
1266
|
}
|
|
1191
|
-
var CallExpression$0 = $S($EXPECT($
|
|
1192
|
-
var CallExpression$1 = $S($EXPECT($
|
|
1267
|
+
var CallExpression$0 = $S($EXPECT($L23, fail, 'CallExpression "super"'), __, Arguments);
|
|
1268
|
+
var CallExpression$1 = $S($EXPECT($L24, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
|
|
1193
1269
|
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
|
|
1194
1270
|
function CallExpression(state) {
|
|
1195
1271
|
if (state.tokenize) {
|
|
@@ -1209,7 +1285,7 @@ var require_parser = __commonJS({
|
|
|
1209
1285
|
return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
|
|
1210
1286
|
}
|
|
1211
1287
|
}
|
|
1212
|
-
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($
|
|
1288
|
+
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L25, fail, 'OptionalShorthand "."'), InsertDot));
|
|
1213
1289
|
function OptionalShorthand(state) {
|
|
1214
1290
|
if (state.verbose)
|
|
1215
1291
|
console.log("ENTER:", "OptionalShorthand");
|
|
@@ -1263,9 +1339,9 @@ var require_parser = __commonJS({
|
|
|
1263
1339
|
return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
|
|
1264
1340
|
}
|
|
1265
1341
|
}
|
|
1266
|
-
var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($
|
|
1342
|
+
var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L26, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L27, fail, 'MemberExpressionRest "]"'));
|
|
1267
1343
|
var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
|
|
1268
|
-
var MemberExpressionRest$2 = $TS($S($EXPECT($
|
|
1344
|
+
var MemberExpressionRest$2 = $TS($S($EXPECT($L28, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
|
|
1269
1345
|
var id = $2;
|
|
1270
1346
|
if (id)
|
|
1271
1347
|
return [".prototype.", id];
|
|
@@ -1278,7 +1354,7 @@ var require_parser = __commonJS({
|
|
|
1278
1354
|
return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state);
|
|
1279
1355
|
}
|
|
1280
1356
|
}
|
|
1281
|
-
var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($
|
|
1357
|
+
var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L25, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
|
|
1282
1358
|
function PropertyAccess(state) {
|
|
1283
1359
|
if (state.verbose)
|
|
1284
1360
|
console.log("ENTER:", "PropertyAccess");
|
|
@@ -1288,7 +1364,7 @@ var require_parser = __commonJS({
|
|
|
1288
1364
|
return PropertyAccess$0(state);
|
|
1289
1365
|
}
|
|
1290
1366
|
}
|
|
1291
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
1367
|
+
var SuperProperty$0 = $S($EXPECT($L29, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L27, fail, 'SuperProperty "]"'));
|
|
1292
1368
|
function SuperProperty(state) {
|
|
1293
1369
|
if (state.verbose)
|
|
1294
1370
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1298,8 +1374,8 @@ var require_parser = __commonJS({
|
|
|
1298
1374
|
return SuperProperty$0(state);
|
|
1299
1375
|
}
|
|
1300
1376
|
}
|
|
1301
|
-
var MetaProperty$0 = $EXPECT($
|
|
1302
|
-
var MetaProperty$1 = $EXPECT($
|
|
1377
|
+
var MetaProperty$0 = $EXPECT($L30, fail, 'MetaProperty "new.target"');
|
|
1378
|
+
var MetaProperty$1 = $EXPECT($L31, fail, 'MetaProperty "import.meta"');
|
|
1303
1379
|
function MetaProperty(state) {
|
|
1304
1380
|
if (state.tokenize) {
|
|
1305
1381
|
return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
|
|
@@ -1308,7 +1384,7 @@ var require_parser = __commonJS({
|
|
|
1308
1384
|
}
|
|
1309
1385
|
}
|
|
1310
1386
|
var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
|
|
1311
|
-
var Parameters$1 = $T($EXPECT($
|
|
1387
|
+
var Parameters$1 = $T($EXPECT($L32, fail, 'Parameters ""'), function(value) {
|
|
1312
1388
|
return "()";
|
|
1313
1389
|
});
|
|
1314
1390
|
function Parameters(state) {
|
|
@@ -1362,7 +1438,7 @@ var require_parser = __commonJS({
|
|
|
1362
1438
|
return BindingPattern$0(state) || BindingPattern$1(state);
|
|
1363
1439
|
}
|
|
1364
1440
|
}
|
|
1365
|
-
var ObjectBindingPattern$0 = $S($EXPECT($
|
|
1441
|
+
var ObjectBindingPattern$0 = $S($EXPECT($L12, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L17, fail, 'ObjectBindingPattern "}"'));
|
|
1366
1442
|
function ObjectBindingPattern(state) {
|
|
1367
1443
|
if (state.verbose)
|
|
1368
1444
|
console.log("ENTER:", "ObjectBindingPattern");
|
|
@@ -1372,7 +1448,7 @@ var require_parser = __commonJS({
|
|
|
1372
1448
|
return ObjectBindingPattern$0(state);
|
|
1373
1449
|
}
|
|
1374
1450
|
}
|
|
1375
|
-
var ArrayBindingPattern$0 = $S($EXPECT($
|
|
1451
|
+
var ArrayBindingPattern$0 = $S($EXPECT($L26, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L27, fail, 'ArrayBindingPattern "]"'));
|
|
1376
1452
|
function ArrayBindingPattern(state) {
|
|
1377
1453
|
if (state.verbose)
|
|
1378
1454
|
console.log("ENTER:", "ArrayBindingPattern");
|
|
@@ -1382,7 +1458,7 @@ var require_parser = __commonJS({
|
|
|
1382
1458
|
return ArrayBindingPattern$0(state);
|
|
1383
1459
|
}
|
|
1384
1460
|
}
|
|
1385
|
-
var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($
|
|
1461
|
+
var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L13, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
|
|
1386
1462
|
var BindingProperty$1 = $S(__, BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
|
|
1387
1463
|
function BindingProperty(state) {
|
|
1388
1464
|
if (state.tokenize) {
|
|
@@ -1391,7 +1467,7 @@ var require_parser = __commonJS({
|
|
|
1391
1467
|
return BindingProperty$0(state) || BindingProperty$1(state);
|
|
1392
1468
|
}
|
|
1393
1469
|
}
|
|
1394
|
-
var BindingRestProperty$0 = $S($EXPECT($
|
|
1470
|
+
var BindingRestProperty$0 = $S($EXPECT($L33, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
|
|
1395
1471
|
function BindingRestProperty(state) {
|
|
1396
1472
|
if (state.verbose)
|
|
1397
1473
|
console.log("ENTER:", "BindingRestProperty");
|
|
@@ -1411,7 +1487,7 @@ var require_parser = __commonJS({
|
|
|
1411
1487
|
return BindingElement$0(state);
|
|
1412
1488
|
}
|
|
1413
1489
|
}
|
|
1414
|
-
var BindingRestElement$0 = $S($EXPECT($
|
|
1490
|
+
var BindingRestElement$0 = $S($EXPECT($L33, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
|
|
1415
1491
|
function BindingRestElement(state) {
|
|
1416
1492
|
if (state.verbose)
|
|
1417
1493
|
console.log("ENTER:", "BindingRestElement");
|
|
@@ -1432,7 +1508,7 @@ var require_parser = __commonJS({
|
|
|
1432
1508
|
}
|
|
1433
1509
|
}
|
|
1434
1510
|
var FunctionExpression$0 = ThinArrowFunction;
|
|
1435
|
-
var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($
|
|
1511
|
+
var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L34, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L10, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
|
|
1436
1512
|
function FunctionExpression(state) {
|
|
1437
1513
|
if (state.tokenize) {
|
|
1438
1514
|
return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
|
|
@@ -1440,11 +1516,17 @@ var require_parser = __commonJS({
|
|
|
1440
1516
|
return FunctionExpression$0(state) || FunctionExpression$1(state);
|
|
1441
1517
|
}
|
|
1442
1518
|
}
|
|
1443
|
-
var ThinArrowFunction$0 = $
|
|
1444
|
-
var params =
|
|
1445
|
-
var suffix =
|
|
1446
|
-
var
|
|
1447
|
-
|
|
1519
|
+
var ThinArrowFunction$0 = $TS($S(Parameters, $E(ReturnTypeSuffix), __, Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1520
|
+
var params = $1;
|
|
1521
|
+
var suffix = $2;
|
|
1522
|
+
var arrow = $4;
|
|
1523
|
+
var block = $5;
|
|
1524
|
+
return [
|
|
1525
|
+
{ $loc: arrow.$loc, token: "function" },
|
|
1526
|
+
params,
|
|
1527
|
+
suffix,
|
|
1528
|
+
block
|
|
1529
|
+
];
|
|
1448
1530
|
});
|
|
1449
1531
|
function ThinArrowFunction(state) {
|
|
1450
1532
|
if (state.verbose)
|
|
@@ -1455,7 +1537,19 @@ var require_parser = __commonJS({
|
|
|
1455
1537
|
return ThinArrowFunction$0(state);
|
|
1456
1538
|
}
|
|
1457
1539
|
}
|
|
1458
|
-
var
|
|
1540
|
+
var Arrow$0 = $TV($EXPECT($L35, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
1541
|
+
return { $loc, token: $1 };
|
|
1542
|
+
});
|
|
1543
|
+
function Arrow(state) {
|
|
1544
|
+
if (state.verbose)
|
|
1545
|
+
console.log("ENTER:", "Arrow");
|
|
1546
|
+
if (state.tokenize) {
|
|
1547
|
+
return $TOKEN("Arrow", state, Arrow$0(state));
|
|
1548
|
+
} else {
|
|
1549
|
+
return Arrow$0(state);
|
|
1550
|
+
}
|
|
1551
|
+
}
|
|
1552
|
+
var Block$0 = $S(__, $EXPECT($L12, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L17, fail, 'Block "}"'));
|
|
1459
1553
|
var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1460
1554
|
var Block$2 = Statement;
|
|
1461
1555
|
var Block$3 = $S(__, Statement);
|
|
@@ -1466,7 +1560,16 @@ var require_parser = __commonJS({
|
|
|
1466
1560
|
return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
|
|
1467
1561
|
}
|
|
1468
1562
|
}
|
|
1469
|
-
var
|
|
1563
|
+
var BracedOrEmptyBlock$0 = BracedBlock;
|
|
1564
|
+
var BracedOrEmptyBlock$1 = $S(InsertOpenBrace, InsertCloseBrace);
|
|
1565
|
+
function BracedOrEmptyBlock(state) {
|
|
1566
|
+
if (state.tokenize) {
|
|
1567
|
+
return $TOKEN("BracedOrEmptyBlock", state, BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state));
|
|
1568
|
+
} else {
|
|
1569
|
+
return BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state);
|
|
1570
|
+
}
|
|
1571
|
+
}
|
|
1572
|
+
var BracedBlock$0 = $S(__, $EXPECT($L12, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L17, fail, 'BracedBlock "}"'));
|
|
1470
1573
|
var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1471
1574
|
var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
|
|
1472
1575
|
function BracedBlock(state) {
|
|
@@ -1531,17 +1634,39 @@ var require_parser = __commonJS({
|
|
|
1531
1634
|
return BlockExpression$0(state);
|
|
1532
1635
|
}
|
|
1533
1636
|
}
|
|
1534
|
-
var Literal$0 =
|
|
1535
|
-
var Literal$1 =
|
|
1536
|
-
var Literal$2 =
|
|
1537
|
-
var Literal$3 =
|
|
1538
|
-
var Literal$4 = $EXPECT($L37, fail, 'Literal "null"');
|
|
1539
|
-
var Literal$5 = $EXPECT($L38, fail, 'Literal "undefined"');
|
|
1637
|
+
var Literal$0 = NullLiteral;
|
|
1638
|
+
var Literal$1 = BooleanLiteral;
|
|
1639
|
+
var Literal$2 = NumericLiteral;
|
|
1640
|
+
var Literal$3 = StringLiteral;
|
|
1540
1641
|
function Literal(state) {
|
|
1541
1642
|
if (state.tokenize) {
|
|
1542
|
-
return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state)
|
|
1643
|
+
return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state));
|
|
1644
|
+
} else {
|
|
1645
|
+
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
|
|
1646
|
+
}
|
|
1647
|
+
}
|
|
1648
|
+
var NullLiteral$0 = $TV($EXPECT($L36, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
1649
|
+
return { $loc, token: $1 };
|
|
1650
|
+
});
|
|
1651
|
+
function NullLiteral(state) {
|
|
1652
|
+
if (state.verbose)
|
|
1653
|
+
console.log("ENTER:", "NullLiteral");
|
|
1654
|
+
if (state.tokenize) {
|
|
1655
|
+
return $TOKEN("NullLiteral", state, NullLiteral$0(state));
|
|
1543
1656
|
} else {
|
|
1544
|
-
return
|
|
1657
|
+
return NullLiteral$0(state);
|
|
1658
|
+
}
|
|
1659
|
+
}
|
|
1660
|
+
var BooleanLiteral$0 = $TV($C($EXPECT($L37, fail, 'BooleanLiteral "true"'), $EXPECT($L38, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
|
|
1661
|
+
return { $loc, token: $1 };
|
|
1662
|
+
});
|
|
1663
|
+
function BooleanLiteral(state) {
|
|
1664
|
+
if (state.verbose)
|
|
1665
|
+
console.log("ENTER:", "BooleanLiteral");
|
|
1666
|
+
if (state.tokenize) {
|
|
1667
|
+
return $TOKEN("BooleanLiteral", state, BooleanLiteral$0(state));
|
|
1668
|
+
} else {
|
|
1669
|
+
return BooleanLiteral$0(state);
|
|
1545
1670
|
}
|
|
1546
1671
|
}
|
|
1547
1672
|
var Comma$0 = $S($Q(_), $EXPECT($L0, fail, 'Comma ","'), $Q(_));
|
|
@@ -1589,8 +1714,8 @@ var require_parser = __commonJS({
|
|
|
1589
1714
|
return IdentifierReference$0(state);
|
|
1590
1715
|
}
|
|
1591
1716
|
}
|
|
1592
|
-
var ArrayLiteral$0 = $S($EXPECT($
|
|
1593
|
-
var ArrayLiteral$1 = $S($EXPECT($
|
|
1717
|
+
var ArrayLiteral$0 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
|
|
1718
|
+
var ArrayLiteral$1 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
|
|
1594
1719
|
function ArrayLiteral(state) {
|
|
1595
1720
|
if (state.tokenize) {
|
|
1596
1721
|
return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
|
|
@@ -1624,8 +1749,8 @@ var require_parser = __commonJS({
|
|
|
1624
1749
|
}
|
|
1625
1750
|
}
|
|
1626
1751
|
var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
|
|
1627
|
-
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1628
|
-
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
1752
|
+
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L27, fail, 'ArrayElementDelimiter "]"')));
|
|
1753
|
+
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L27, fail, 'ArrayElementDelimiter "]"'))), function(value) {
|
|
1629
1754
|
return ",";
|
|
1630
1755
|
});
|
|
1631
1756
|
var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1658,7 +1783,7 @@ var require_parser = __commonJS({
|
|
|
1658
1783
|
return InlineElementList$0(state);
|
|
1659
1784
|
}
|
|
1660
1785
|
}
|
|
1661
|
-
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($
|
|
1786
|
+
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L33, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
|
|
1662
1787
|
function ArrayElementExpression(state) {
|
|
1663
1788
|
if (state.verbose)
|
|
1664
1789
|
console.log("ENTER:", "ArrayElementExpression");
|
|
@@ -1678,9 +1803,9 @@ var require_parser = __commonJS({
|
|
|
1678
1803
|
return Elision$0(state);
|
|
1679
1804
|
}
|
|
1680
1805
|
}
|
|
1681
|
-
var ObjectLiteral$0 = $S($EXPECT($
|
|
1682
|
-
var ObjectLiteral$1 = $S($EXPECT($
|
|
1683
|
-
var ObjectLiteral$2 = $S($EXPECT($
|
|
1806
|
+
var ObjectLiteral$0 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L17, fail, 'ObjectLiteral "}"'));
|
|
1807
|
+
var ObjectLiteral$1 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L17, fail, 'ObjectLiteral "}"'));
|
|
1808
|
+
var ObjectLiteral$2 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), __, $EXPECT($L17, fail, 'ObjectLiteral "}"'));
|
|
1684
1809
|
var ObjectLiteral$3 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1685
1810
|
function ObjectLiteral(state) {
|
|
1686
1811
|
if (state.tokenize) {
|
|
@@ -1715,8 +1840,8 @@ var require_parser = __commonJS({
|
|
|
1715
1840
|
}
|
|
1716
1841
|
}
|
|
1717
1842
|
var ObjectPropertyDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ObjectPropertyDelimiter ","'));
|
|
1718
|
-
var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1719
|
-
var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
1843
|
+
var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L17, fail, 'ObjectPropertyDelimiter "}"')));
|
|
1844
|
+
var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L17, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
|
|
1720
1845
|
return ",";
|
|
1721
1846
|
});
|
|
1722
1847
|
var ObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1739,9 +1864,9 @@ var require_parser = __commonJS({
|
|
|
1739
1864
|
return PropertyDefinitionList$0(state);
|
|
1740
1865
|
}
|
|
1741
1866
|
}
|
|
1742
|
-
var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($
|
|
1867
|
+
var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L13, fail, 'PropertyDefinition ":"'), AssignmentExpression);
|
|
1743
1868
|
var PropertyDefinition$1 = MethodDefinition;
|
|
1744
|
-
var PropertyDefinition$2 = $S($EXPECT($
|
|
1869
|
+
var PropertyDefinition$2 = $S($EXPECT($L33, fail, 'PropertyDefinition "..."'), AssignmentExpression);
|
|
1745
1870
|
var PropertyDefinition$3 = IdentifierReference;
|
|
1746
1871
|
function PropertyDefinition(state) {
|
|
1747
1872
|
if (state.tokenize) {
|
|
@@ -1753,7 +1878,7 @@ var require_parser = __commonJS({
|
|
|
1753
1878
|
var PropertyName$0 = NumericLiteral;
|
|
1754
1879
|
var PropertyName$1 = StringLiteral;
|
|
1755
1880
|
var PropertyName$2 = IdentifierName;
|
|
1756
|
-
var PropertyName$3 = $S($EXPECT($
|
|
1881
|
+
var PropertyName$3 = $S($EXPECT($L26, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L27, fail, 'PropertyName "]"'));
|
|
1757
1882
|
function PropertyName(state) {
|
|
1758
1883
|
if (state.tokenize) {
|
|
1759
1884
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -1793,7 +1918,7 @@ var require_parser = __commonJS({
|
|
|
1793
1918
|
return PrivateIdentifier$0(state);
|
|
1794
1919
|
}
|
|
1795
1920
|
}
|
|
1796
|
-
var GeneratorMethod$0 = $S($EXPECT($
|
|
1921
|
+
var GeneratorMethod$0 = $S($EXPECT($L10, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
|
|
1797
1922
|
function GeneratorMethod(state) {
|
|
1798
1923
|
if (state.verbose)
|
|
1799
1924
|
console.log("ENTER:", "GeneratorMethod");
|
|
@@ -1833,7 +1958,7 @@ var require_parser = __commonJS({
|
|
|
1833
1958
|
return AsyncFunctionBody$0(state);
|
|
1834
1959
|
}
|
|
1835
1960
|
}
|
|
1836
|
-
var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($
|
|
1961
|
+
var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L10, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
|
|
1837
1962
|
function AsyncGeneratorMethod(state) {
|
|
1838
1963
|
if (state.verbose)
|
|
1839
1964
|
console.log("ENTER:", "AsyncGeneratorMethod");
|
|
@@ -1853,76 +1978,100 @@ var require_parser = __commonJS({
|
|
|
1853
1978
|
return AsyncGeneratorBody$0(state);
|
|
1854
1979
|
}
|
|
1855
1980
|
}
|
|
1856
|
-
var AssignmentOp$0 = $
|
|
1857
|
-
|
|
1858
|
-
|
|
1859
|
-
var AssignmentOp$3 = $EXPECT($L44, fail, 'AssignmentOp "%="');
|
|
1860
|
-
var AssignmentOp$4 = $EXPECT($L45, fail, 'AssignmentOp "+="');
|
|
1861
|
-
var AssignmentOp$5 = $EXPECT($L46, fail, 'AssignmentOp "-="');
|
|
1862
|
-
var AssignmentOp$6 = $EXPECT($L47, fail, 'AssignmentOp "<<="');
|
|
1863
|
-
var AssignmentOp$7 = $EXPECT($L48, fail, 'AssignmentOp ">>>="');
|
|
1864
|
-
var AssignmentOp$8 = $EXPECT($L49, fail, 'AssignmentOp ">>="');
|
|
1865
|
-
var AssignmentOp$9 = $EXPECT($L50, fail, 'AssignmentOp "&&="');
|
|
1866
|
-
var AssignmentOp$10 = $EXPECT($L51, fail, 'AssignmentOp "&="');
|
|
1867
|
-
var AssignmentOp$11 = $EXPECT($L52, fail, 'AssignmentOp "^="');
|
|
1868
|
-
var AssignmentOp$12 = $EXPECT($L53, fail, 'AssignmentOp "||="');
|
|
1869
|
-
var AssignmentOp$13 = $EXPECT($L54, fail, 'AssignmentOp "|="');
|
|
1870
|
-
var AssignmentOp$14 = $EXPECT($L55, fail, 'AssignmentOp "??="');
|
|
1871
|
-
var AssignmentOp$15 = $EXPECT($L56, fail, 'AssignmentOp "="');
|
|
1981
|
+
var AssignmentOp$0 = $TS($S(AssignmentOpSymbol), function($skip, $loc, $0, $1) {
|
|
1982
|
+
return { $loc, token: $1 };
|
|
1983
|
+
});
|
|
1872
1984
|
function AssignmentOp(state) {
|
|
1985
|
+
if (state.verbose)
|
|
1986
|
+
console.log("ENTER:", "AssignmentOp");
|
|
1987
|
+
if (state.tokenize) {
|
|
1988
|
+
return $TOKEN("AssignmentOp", state, AssignmentOp$0(state));
|
|
1989
|
+
} else {
|
|
1990
|
+
return AssignmentOp$0(state);
|
|
1991
|
+
}
|
|
1992
|
+
}
|
|
1993
|
+
var AssignmentOpSymbol$0 = $EXPECT($L41, fail, 'AssignmentOpSymbol "**="');
|
|
1994
|
+
var AssignmentOpSymbol$1 = $EXPECT($L42, fail, 'AssignmentOpSymbol "*="');
|
|
1995
|
+
var AssignmentOpSymbol$2 = $EXPECT($L43, fail, 'AssignmentOpSymbol "/="');
|
|
1996
|
+
var AssignmentOpSymbol$3 = $EXPECT($L44, fail, 'AssignmentOpSymbol "%="');
|
|
1997
|
+
var AssignmentOpSymbol$4 = $EXPECT($L45, fail, 'AssignmentOpSymbol "+="');
|
|
1998
|
+
var AssignmentOpSymbol$5 = $EXPECT($L46, fail, 'AssignmentOpSymbol "-="');
|
|
1999
|
+
var AssignmentOpSymbol$6 = $EXPECT($L47, fail, 'AssignmentOpSymbol "<<="');
|
|
2000
|
+
var AssignmentOpSymbol$7 = $EXPECT($L48, fail, 'AssignmentOpSymbol ">>>="');
|
|
2001
|
+
var AssignmentOpSymbol$8 = $EXPECT($L49, fail, 'AssignmentOpSymbol ">>="');
|
|
2002
|
+
var AssignmentOpSymbol$9 = $EXPECT($L50, fail, 'AssignmentOpSymbol "&&="');
|
|
2003
|
+
var AssignmentOpSymbol$10 = $EXPECT($L51, fail, 'AssignmentOpSymbol "&="');
|
|
2004
|
+
var AssignmentOpSymbol$11 = $EXPECT($L52, fail, 'AssignmentOpSymbol "^="');
|
|
2005
|
+
var AssignmentOpSymbol$12 = $EXPECT($L53, fail, 'AssignmentOpSymbol "||="');
|
|
2006
|
+
var AssignmentOpSymbol$13 = $EXPECT($L54, fail, 'AssignmentOpSymbol "|="');
|
|
2007
|
+
var AssignmentOpSymbol$14 = $EXPECT($L55, fail, 'AssignmentOpSymbol "??="');
|
|
2008
|
+
var AssignmentOpSymbol$15 = $EXPECT($L56, fail, 'AssignmentOpSymbol "="');
|
|
2009
|
+
function AssignmentOpSymbol(state) {
|
|
2010
|
+
if (state.tokenize) {
|
|
2011
|
+
return $TOKEN("AssignmentOpSymbol", state, AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state));
|
|
2012
|
+
} else {
|
|
2013
|
+
return AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state);
|
|
2014
|
+
}
|
|
2015
|
+
}
|
|
2016
|
+
var BinaryOp$0 = $TS($S(BinaryOpSymbol), function($skip, $loc, $0, $1) {
|
|
2017
|
+
return { $loc, token: $1 };
|
|
2018
|
+
});
|
|
2019
|
+
function BinaryOp(state) {
|
|
2020
|
+
if (state.verbose)
|
|
2021
|
+
console.log("ENTER:", "BinaryOp");
|
|
1873
2022
|
if (state.tokenize) {
|
|
1874
|
-
return $TOKEN("
|
|
1875
|
-
} else {
|
|
1876
|
-
return
|
|
1877
|
-
}
|
|
1878
|
-
}
|
|
1879
|
-
var
|
|
1880
|
-
var
|
|
1881
|
-
var
|
|
1882
|
-
var
|
|
1883
|
-
var
|
|
1884
|
-
var
|
|
1885
|
-
var
|
|
1886
|
-
var
|
|
1887
|
-
var
|
|
1888
|
-
var
|
|
1889
|
-
var
|
|
1890
|
-
var
|
|
1891
|
-
var
|
|
1892
|
-
var
|
|
1893
|
-
var
|
|
2023
|
+
return $TOKEN("BinaryOp", state, BinaryOp$0(state));
|
|
2024
|
+
} else {
|
|
2025
|
+
return BinaryOp$0(state);
|
|
2026
|
+
}
|
|
2027
|
+
}
|
|
2028
|
+
var BinaryOpSymbol$0 = $EXPECT($L57, fail, 'BinaryOpSymbol "**"');
|
|
2029
|
+
var BinaryOpSymbol$1 = $EXPECT($L10, fail, 'BinaryOpSymbol "*"');
|
|
2030
|
+
var BinaryOpSymbol$2 = $EXPECT($L58, fail, 'BinaryOpSymbol "/"');
|
|
2031
|
+
var BinaryOpSymbol$3 = $EXPECT($L59, fail, 'BinaryOpSymbol "%"');
|
|
2032
|
+
var BinaryOpSymbol$4 = $EXPECT($L60, fail, 'BinaryOpSymbol "+"');
|
|
2033
|
+
var BinaryOpSymbol$5 = $EXPECT($L61, fail, 'BinaryOpSymbol "-"');
|
|
2034
|
+
var BinaryOpSymbol$6 = $EXPECT($L62, fail, 'BinaryOpSymbol "<="');
|
|
2035
|
+
var BinaryOpSymbol$7 = $EXPECT($L63, fail, 'BinaryOpSymbol ">="');
|
|
2036
|
+
var BinaryOpSymbol$8 = $EXPECT($L64, fail, 'BinaryOpSymbol "<<"');
|
|
2037
|
+
var BinaryOpSymbol$9 = $EXPECT($L15, fail, 'BinaryOpSymbol "<"');
|
|
2038
|
+
var BinaryOpSymbol$10 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>>"');
|
|
2039
|
+
var BinaryOpSymbol$11 = $EXPECT($L66, fail, 'BinaryOpSymbol ">>"');
|
|
2040
|
+
var BinaryOpSymbol$12 = $EXPECT($L67, fail, 'BinaryOpSymbol ">"');
|
|
2041
|
+
var BinaryOpSymbol$13 = $EXPECT($L68, fail, 'BinaryOpSymbol "!=="');
|
|
2042
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L69, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
1894
2043
|
if (global.coffeeCompat)
|
|
1895
2044
|
return "!==";
|
|
1896
2045
|
return $1;
|
|
1897
2046
|
});
|
|
1898
|
-
var
|
|
2047
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L70, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
1899
2048
|
return "===";
|
|
1900
2049
|
});
|
|
1901
|
-
var
|
|
1902
|
-
var
|
|
2050
|
+
var BinaryOpSymbol$16 = $EXPECT($L71, fail, 'BinaryOpSymbol "==="');
|
|
2051
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L72, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
1903
2052
|
if (global.coffeeCompat)
|
|
1904
2053
|
return "===";
|
|
1905
2054
|
return $1;
|
|
1906
2055
|
});
|
|
1907
|
-
var
|
|
2056
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L73, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
1908
2057
|
return "&&";
|
|
1909
2058
|
});
|
|
1910
|
-
var
|
|
1911
|
-
var
|
|
2059
|
+
var BinaryOpSymbol$19 = $EXPECT($L74, fail, 'BinaryOpSymbol "&&"');
|
|
2060
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L75, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
1912
2061
|
return "||";
|
|
1913
2062
|
});
|
|
1914
|
-
var
|
|
1915
|
-
var
|
|
1916
|
-
var
|
|
1917
|
-
var
|
|
1918
|
-
var
|
|
1919
|
-
var
|
|
1920
|
-
var
|
|
1921
|
-
function
|
|
2063
|
+
var BinaryOpSymbol$21 = $EXPECT($L76, fail, 'BinaryOpSymbol "||"');
|
|
2064
|
+
var BinaryOpSymbol$22 = $EXPECT($L77, fail, 'BinaryOpSymbol "??"');
|
|
2065
|
+
var BinaryOpSymbol$23 = $S($EXPECT($L78, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue);
|
|
2066
|
+
var BinaryOpSymbol$24 = $S($EXPECT($L79, fail, 'BinaryOpSymbol "in"'), NonIdContinue);
|
|
2067
|
+
var BinaryOpSymbol$25 = $EXPECT($L80, fail, 'BinaryOpSymbol "&"');
|
|
2068
|
+
var BinaryOpSymbol$26 = $EXPECT($L81, fail, 'BinaryOpSymbol "^"');
|
|
2069
|
+
var BinaryOpSymbol$27 = $EXPECT($L82, fail, 'BinaryOpSymbol "|"');
|
|
2070
|
+
function BinaryOpSymbol(state) {
|
|
1922
2071
|
if (state.tokenize) {
|
|
1923
|
-
return $TOKEN("
|
|
2072
|
+
return $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state));
|
|
1924
2073
|
} else {
|
|
1925
|
-
return
|
|
2074
|
+
return BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state);
|
|
1926
2075
|
}
|
|
1927
2076
|
}
|
|
1928
2077
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
@@ -2003,7 +2152,7 @@ var require_parser = __commonJS({
|
|
|
2003
2152
|
return EmptyStatement$0(state);
|
|
2004
2153
|
}
|
|
2005
2154
|
}
|
|
2006
|
-
var BlockStatement$0 = $S(__, $EXPECT($
|
|
2155
|
+
var BlockStatement$0 = $S(__, $EXPECT($L12, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L17, fail, 'BlockStatement "}"'));
|
|
2007
2156
|
function BlockStatement(state) {
|
|
2008
2157
|
if (state.verbose)
|
|
2009
2158
|
console.log("ENTER:", "BlockStatement");
|
|
@@ -2096,7 +2245,7 @@ var require_parser = __commonJS({
|
|
|
2096
2245
|
return WhileClause$0(state);
|
|
2097
2246
|
}
|
|
2098
2247
|
}
|
|
2099
|
-
var ForStatement$0 = $S(
|
|
2248
|
+
var ForStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L88, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L88, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
|
|
2100
2249
|
function ForStatement(state) {
|
|
2101
2250
|
if (state.verbose)
|
|
2102
2251
|
console.log("ENTER:", "ForStatement");
|
|
@@ -2106,10 +2255,10 @@ var require_parser = __commonJS({
|
|
|
2106
2255
|
return ForStatement$0(state);
|
|
2107
2256
|
}
|
|
2108
2257
|
}
|
|
2109
|
-
var ForInOfStatement$0 = $S(
|
|
2110
|
-
var ForInOfStatement$1 = $S(
|
|
2111
|
-
var ForInOfStatement$2 = $S(
|
|
2112
|
-
var ForInOfStatement$3 = $S(
|
|
2258
|
+
var ForInOfStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
|
|
2259
|
+
var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
|
|
2260
|
+
var ForInOfStatement$2 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
|
|
2261
|
+
var ForInOfStatement$3 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
|
|
2113
2262
|
function ForInOfStatement(state) {
|
|
2114
2263
|
if (state.tokenize) {
|
|
2115
2264
|
return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
|
|
@@ -2117,7 +2266,19 @@ var require_parser = __commonJS({
|
|
|
2117
2266
|
return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
|
|
2118
2267
|
}
|
|
2119
2268
|
}
|
|
2120
|
-
var
|
|
2269
|
+
var For$0 = $TS($S($EXPECT($L96, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2270
|
+
return { $loc, token: $1 };
|
|
2271
|
+
});
|
|
2272
|
+
function For(state) {
|
|
2273
|
+
if (state.verbose)
|
|
2274
|
+
console.log("ENTER:", "For");
|
|
2275
|
+
if (state.tokenize) {
|
|
2276
|
+
return $TOKEN("For", state, For$0(state));
|
|
2277
|
+
} else {
|
|
2278
|
+
return For$0(state);
|
|
2279
|
+
}
|
|
2280
|
+
}
|
|
2281
|
+
var ForDeclaration$0 = $S(LetOrConst, NonIdContinue, __, ForBinding);
|
|
2121
2282
|
function ForDeclaration(state) {
|
|
2122
2283
|
if (state.verbose)
|
|
2123
2284
|
console.log("ENTER:", "ForDeclaration");
|
|
@@ -2127,6 +2288,18 @@ var require_parser = __commonJS({
|
|
|
2127
2288
|
return ForDeclaration$0(state);
|
|
2128
2289
|
}
|
|
2129
2290
|
}
|
|
2291
|
+
var LetOrConst$0 = $TV($C($EXPECT($L97, fail, 'LetOrConst "let"'), $EXPECT($L98, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
2292
|
+
return { $loc, token: $1 };
|
|
2293
|
+
});
|
|
2294
|
+
function LetOrConst(state) {
|
|
2295
|
+
if (state.verbose)
|
|
2296
|
+
console.log("ENTER:", "LetOrConst");
|
|
2297
|
+
if (state.tokenize) {
|
|
2298
|
+
return $TOKEN("LetOrConst", state, LetOrConst$0(state));
|
|
2299
|
+
} else {
|
|
2300
|
+
return LetOrConst$0(state);
|
|
2301
|
+
}
|
|
2302
|
+
}
|
|
2130
2303
|
var ForBinding$0 = BindingIdentifier;
|
|
2131
2304
|
var ForBinding$1 = BindingPattern;
|
|
2132
2305
|
function ForBinding(state) {
|
|
@@ -2136,7 +2309,7 @@ var require_parser = __commonJS({
|
|
|
2136
2309
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
2137
2310
|
}
|
|
2138
2311
|
}
|
|
2139
|
-
var SwitchStatement$0 = $S($EXPECT($
|
|
2312
|
+
var SwitchStatement$0 = $S($EXPECT($L99, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
|
|
2140
2313
|
function SwitchStatement(state) {
|
|
2141
2314
|
if (state.verbose)
|
|
2142
2315
|
console.log("ENTER:", "SwitchStatement");
|
|
@@ -2146,7 +2319,7 @@ var require_parser = __commonJS({
|
|
|
2146
2319
|
return SwitchStatement$0(state);
|
|
2147
2320
|
}
|
|
2148
2321
|
}
|
|
2149
|
-
var CaseBlock$0 = $S(__, $EXPECT($
|
|
2322
|
+
var CaseBlock$0 = $S(__, $EXPECT($L12, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L17, fail, 'CaseBlock "}"'));
|
|
2150
2323
|
var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
|
|
2151
2324
|
function CaseBlock(state) {
|
|
2152
2325
|
if (state.tokenize) {
|
|
@@ -2180,9 +2353,9 @@ var require_parser = __commonJS({
|
|
|
2180
2353
|
return NestedCaseClause$0(state);
|
|
2181
2354
|
}
|
|
2182
2355
|
}
|
|
2183
|
-
var CaseClause$0 = $S($EXPECT($
|
|
2356
|
+
var CaseClause$0 = $S($EXPECT($L100, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
|
|
2184
2357
|
var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
|
|
2185
|
-
var CaseClause$2 = $S($EXPECT($
|
|
2358
|
+
var CaseClause$2 = $S($EXPECT($L101, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
|
|
2186
2359
|
function CaseClause(state) {
|
|
2187
2360
|
if (state.tokenize) {
|
|
2188
2361
|
return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
|
|
@@ -2190,7 +2363,7 @@ var require_parser = __commonJS({
|
|
|
2190
2363
|
return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
|
|
2191
2364
|
}
|
|
2192
2365
|
}
|
|
2193
|
-
var When$0 = $T($S($EXPECT($
|
|
2366
|
+
var When$0 = $T($S($EXPECT($L102, fail, 'When "when"'), NonIdContinue), function(value) {
|
|
2194
2367
|
return "case";
|
|
2195
2368
|
});
|
|
2196
2369
|
function When(state) {
|
|
@@ -2202,8 +2375,8 @@ var require_parser = __commonJS({
|
|
|
2202
2375
|
return When$0(state);
|
|
2203
2376
|
}
|
|
2204
2377
|
}
|
|
2205
|
-
var ImpliedColon$0 = $S(__, $EXPECT($
|
|
2206
|
-
var ImpliedColon$1 = $T($EXPECT($
|
|
2378
|
+
var ImpliedColon$0 = $S(__, $EXPECT($L13, fail, 'ImpliedColon ":"'));
|
|
2379
|
+
var ImpliedColon$1 = $T($EXPECT($L32, fail, 'ImpliedColon ""'), function(value) {
|
|
2207
2380
|
return ":";
|
|
2208
2381
|
});
|
|
2209
2382
|
function ImpliedColon(state) {
|
|
@@ -2213,7 +2386,7 @@ var require_parser = __commonJS({
|
|
|
2213
2386
|
return ImpliedColon$0(state) || ImpliedColon$1(state);
|
|
2214
2387
|
}
|
|
2215
2388
|
}
|
|
2216
|
-
var TryStatement$0 = $TS($S($EXPECT($
|
|
2389
|
+
var TryStatement$0 = $TS($S($EXPECT($L103, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2217
2390
|
var c = $3;
|
|
2218
2391
|
var f = $4;
|
|
2219
2392
|
if (!c && !f) {
|
|
@@ -2230,7 +2403,7 @@ var require_parser = __commonJS({
|
|
|
2230
2403
|
return TryStatement$0(state);
|
|
2231
2404
|
}
|
|
2232
2405
|
}
|
|
2233
|
-
var Catch$0 = $S(__, $EXPECT($
|
|
2406
|
+
var Catch$0 = $S(__, $EXPECT($L104, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
|
|
2234
2407
|
function Catch(state) {
|
|
2235
2408
|
if (state.verbose)
|
|
2236
2409
|
console.log("ENTER:", "Catch");
|
|
@@ -2249,7 +2422,7 @@ var require_parser = __commonJS({
|
|
|
2249
2422
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2250
2423
|
}
|
|
2251
2424
|
}
|
|
2252
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2425
|
+
var Finally$0 = $S(__, $EXPECT($L105, fail, 'Finally "finally"'), BracedBlock);
|
|
2253
2426
|
function Finally(state) {
|
|
2254
2427
|
if (state.verbose)
|
|
2255
2428
|
console.log("ENTER:", "Finally");
|
|
@@ -2287,11 +2460,11 @@ var require_parser = __commonJS({
|
|
|
2287
2460
|
return ExpressionStatement$0(state);
|
|
2288
2461
|
}
|
|
2289
2462
|
}
|
|
2290
|
-
var KeywordStatement$0 = $S($EXPECT($
|
|
2291
|
-
var KeywordStatement$1 = $S($EXPECT($
|
|
2292
|
-
var KeywordStatement$2 = $S($EXPECT($
|
|
2463
|
+
var KeywordStatement$0 = $S($EXPECT($L106, fail, 'KeywordStatement "break"'), NonIdContinue);
|
|
2464
|
+
var KeywordStatement$1 = $S($EXPECT($L107, fail, 'KeywordStatement "continue"'), NonIdContinue);
|
|
2465
|
+
var KeywordStatement$2 = $S($EXPECT($L108, fail, 'KeywordStatement "debugger"'), NonIdContinue);
|
|
2293
2466
|
var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
|
|
2294
|
-
var KeywordStatement$4 = $S($EXPECT($
|
|
2467
|
+
var KeywordStatement$4 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
|
|
2295
2468
|
function KeywordStatement(state) {
|
|
2296
2469
|
if (state.tokenize) {
|
|
2297
2470
|
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
|
|
@@ -2308,7 +2481,9 @@ var require_parser = __commonJS({
|
|
|
2308
2481
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2309
2482
|
}
|
|
2310
2483
|
}
|
|
2311
|
-
var Return$0 = $S($EXPECT($
|
|
2484
|
+
var Return$0 = $TS($S($EXPECT($L110, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2485
|
+
return { $loc, token: $1 };
|
|
2486
|
+
});
|
|
2312
2487
|
function Return(state) {
|
|
2313
2488
|
if (state.verbose)
|
|
2314
2489
|
console.log("ENTER:", "Return");
|
|
@@ -2318,11 +2493,11 @@ var require_parser = __commonJS({
|
|
|
2318
2493
|
return Return$0(state);
|
|
2319
2494
|
}
|
|
2320
2495
|
}
|
|
2321
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2496
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L111, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2322
2497
|
return { "ts": true, "children": value };
|
|
2323
2498
|
});
|
|
2324
|
-
var ImportDeclaration$1 = $S(
|
|
2325
|
-
var ImportDeclaration$2 = $S(
|
|
2499
|
+
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
2500
|
+
var ImportDeclaration$2 = $S(Import, __, ModuleSpecifier);
|
|
2326
2501
|
function ImportDeclaration(state) {
|
|
2327
2502
|
if (state.tokenize) {
|
|
2328
2503
|
return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
|
|
@@ -2330,6 +2505,18 @@ var require_parser = __commonJS({
|
|
|
2330
2505
|
return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state);
|
|
2331
2506
|
}
|
|
2332
2507
|
}
|
|
2508
|
+
var Import$0 = $TS($S($EXPECT($L24, fail, 'Import "import"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2509
|
+
return { $loc, token: $1 };
|
|
2510
|
+
});
|
|
2511
|
+
function Import(state) {
|
|
2512
|
+
if (state.verbose)
|
|
2513
|
+
console.log("ENTER:", "Import");
|
|
2514
|
+
if (state.tokenize) {
|
|
2515
|
+
return $TOKEN("Import", state, Import$0(state));
|
|
2516
|
+
} else {
|
|
2517
|
+
return Import$0(state);
|
|
2518
|
+
}
|
|
2519
|
+
}
|
|
2333
2520
|
var ImportClause$0 = $S(ImportedBinding, $E($S(__, $EXPECT($L0, fail, 'ImportClause ","'), __, $C(NameSpaceImport, NamedImports))));
|
|
2334
2521
|
var ImportClause$1 = NameSpaceImport;
|
|
2335
2522
|
var ImportClause$2 = NamedImports;
|
|
@@ -2340,7 +2527,7 @@ var require_parser = __commonJS({
|
|
|
2340
2527
|
return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
|
|
2341
2528
|
}
|
|
2342
2529
|
}
|
|
2343
|
-
var NameSpaceImport$0 = $S($EXPECT($
|
|
2530
|
+
var NameSpaceImport$0 = $S($EXPECT($L10, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), NonIdContinue, __, ImportedBinding);
|
|
2344
2531
|
function NameSpaceImport(state) {
|
|
2345
2532
|
if (state.verbose)
|
|
2346
2533
|
console.log("ENTER:", "NameSpaceImport");
|
|
@@ -2350,7 +2537,7 @@ var require_parser = __commonJS({
|
|
|
2350
2537
|
return NameSpaceImport$0(state);
|
|
2351
2538
|
}
|
|
2352
2539
|
}
|
|
2353
|
-
var NamedImports$0 = $S($EXPECT($
|
|
2540
|
+
var NamedImports$0 = $S($EXPECT($L12, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L17, fail, 'NamedImports "}"'));
|
|
2354
2541
|
function NamedImports(state) {
|
|
2355
2542
|
if (state.verbose)
|
|
2356
2543
|
console.log("ENTER:", "NamedImports");
|
|
@@ -2360,7 +2547,7 @@ var require_parser = __commonJS({
|
|
|
2360
2547
|
return NamedImports$0(state);
|
|
2361
2548
|
}
|
|
2362
2549
|
}
|
|
2363
|
-
var FromClause$0 = $S(
|
|
2550
|
+
var FromClause$0 = $S(From, __, ModuleSpecifier);
|
|
2364
2551
|
function FromClause(state) {
|
|
2365
2552
|
if (state.verbose)
|
|
2366
2553
|
console.log("ENTER:", "FromClause");
|
|
@@ -2370,6 +2557,18 @@ var require_parser = __commonJS({
|
|
|
2370
2557
|
return FromClause$0(state);
|
|
2371
2558
|
}
|
|
2372
2559
|
}
|
|
2560
|
+
var From$0 = $TS($S($EXPECT($L112, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2561
|
+
return { $loc, token: $1 };
|
|
2562
|
+
});
|
|
2563
|
+
function From(state) {
|
|
2564
|
+
if (state.verbose)
|
|
2565
|
+
console.log("ENTER:", "From");
|
|
2566
|
+
if (state.tokenize) {
|
|
2567
|
+
return $TOKEN("From", state, From$0(state));
|
|
2568
|
+
} else {
|
|
2569
|
+
return From$0(state);
|
|
2570
|
+
}
|
|
2571
|
+
}
|
|
2373
2572
|
var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
|
|
2374
2573
|
var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
|
|
2375
2574
|
function ImportSpecifier(state) {
|
|
@@ -2408,7 +2607,7 @@ var require_parser = __commonJS({
|
|
|
2408
2607
|
return ImportedBinding$0(state);
|
|
2409
2608
|
}
|
|
2410
2609
|
}
|
|
2411
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
2610
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L101, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2412
2611
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
2413
2612
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
2414
2613
|
function ExportDeclaration(state) {
|
|
@@ -2428,7 +2627,7 @@ var require_parser = __commonJS({
|
|
|
2428
2627
|
return As$0(state);
|
|
2429
2628
|
}
|
|
2430
2629
|
}
|
|
2431
|
-
var Export$0 = $S($EXPECT($
|
|
2630
|
+
var Export$0 = $S($EXPECT($L113, fail, 'Export "export"'), NonIdContinue);
|
|
2432
2631
|
function Export(state) {
|
|
2433
2632
|
if (state.verbose)
|
|
2434
2633
|
console.log("ENTER:", "Export");
|
|
@@ -2438,7 +2637,7 @@ var require_parser = __commonJS({
|
|
|
2438
2637
|
return Export$0(state);
|
|
2439
2638
|
}
|
|
2440
2639
|
}
|
|
2441
|
-
var ExportFromClause$0 = $S($EXPECT($
|
|
2640
|
+
var ExportFromClause$0 = $S($EXPECT($L10, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), NonIdContinue, __, ModuleExportName)));
|
|
2442
2641
|
var ExportFromClause$1 = NamedExports;
|
|
2443
2642
|
function ExportFromClause(state) {
|
|
2444
2643
|
if (state.tokenize) {
|
|
@@ -2447,7 +2646,7 @@ var require_parser = __commonJS({
|
|
|
2447
2646
|
return ExportFromClause$0(state) || ExportFromClause$1(state);
|
|
2448
2647
|
}
|
|
2449
2648
|
}
|
|
2450
|
-
var NamedExports$0 = $S($EXPECT($
|
|
2649
|
+
var NamedExports$0 = $S($EXPECT($L12, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L17, fail, 'NamedExports "}"'));
|
|
2451
2650
|
function NamedExports(state) {
|
|
2452
2651
|
if (state.verbose)
|
|
2453
2652
|
console.log("ENTER:", "NamedExports");
|
|
@@ -2488,7 +2687,7 @@ var require_parser = __commonJS({
|
|
|
2488
2687
|
return HoistableDeclaration$0(state);
|
|
2489
2688
|
}
|
|
2490
2689
|
}
|
|
2491
|
-
var LexicalDeclaration$0 = $S(
|
|
2690
|
+
var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
|
|
2492
2691
|
var LexicalDeclaration$1 = $TS($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
2493
2692
|
var bind = $1;
|
|
2494
2693
|
var suffix = $2;
|
|
@@ -2512,7 +2711,7 @@ var require_parser = __commonJS({
|
|
|
2512
2711
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
2513
2712
|
}
|
|
2514
2713
|
}
|
|
2515
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
2714
|
+
var ConstAssignment$0 = $TV($EXPECT($L114, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
2516
2715
|
return { $loc, token: $0 };
|
|
2517
2716
|
});
|
|
2518
2717
|
function ConstAssignment(state) {
|
|
@@ -2543,7 +2742,7 @@ var require_parser = __commonJS({
|
|
|
2543
2742
|
return Initializer$0(state);
|
|
2544
2743
|
}
|
|
2545
2744
|
}
|
|
2546
|
-
var VariableStatement$0 = $S($EXPECT($
|
|
2745
|
+
var VariableStatement$0 = $S($EXPECT($L94, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
|
|
2547
2746
|
function VariableStatement(state) {
|
|
2548
2747
|
if (state.verbose)
|
|
2549
2748
|
console.log("ENTER:", "VariableStatement");
|
|
@@ -2572,16 +2771,28 @@ var require_parser = __commonJS({
|
|
|
2572
2771
|
return VariableDeclaration$0(state) || VariableDeclaration$1(state);
|
|
2573
2772
|
}
|
|
2574
2773
|
}
|
|
2575
|
-
var NumericLiteral$0 =
|
|
2576
|
-
|
|
2577
|
-
|
|
2578
|
-
var NumericLiteral$3 = HexLiteral;
|
|
2579
|
-
var NumericLiteral$4 = DecimalLiteral;
|
|
2774
|
+
var NumericLiteral$0 = $TS($S(NumericLiteralKind), function($skip, $loc, $0, $1) {
|
|
2775
|
+
return { $loc, token: $1 };
|
|
2776
|
+
});
|
|
2580
2777
|
function NumericLiteral(state) {
|
|
2778
|
+
if (state.verbose)
|
|
2779
|
+
console.log("ENTER:", "NumericLiteral");
|
|
2780
|
+
if (state.tokenize) {
|
|
2781
|
+
return $TOKEN("NumericLiteral", state, NumericLiteral$0(state));
|
|
2782
|
+
} else {
|
|
2783
|
+
return NumericLiteral$0(state);
|
|
2784
|
+
}
|
|
2785
|
+
}
|
|
2786
|
+
var NumericLiteralKind$0 = DecimalBigIntegerLiteral;
|
|
2787
|
+
var NumericLiteralKind$1 = BinaryIntegerLiteral;
|
|
2788
|
+
var NumericLiteralKind$2 = OctalIntegerLiteral;
|
|
2789
|
+
var NumericLiteralKind$3 = HexLiteral;
|
|
2790
|
+
var NumericLiteralKind$4 = DecimalLiteral;
|
|
2791
|
+
function NumericLiteralKind(state) {
|
|
2581
2792
|
if (state.tokenize) {
|
|
2582
|
-
return $TOKEN("
|
|
2793
|
+
return $TOKEN("NumericLiteralKind", state, NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state));
|
|
2583
2794
|
} else {
|
|
2584
|
-
return
|
|
2795
|
+
return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
|
|
2585
2796
|
}
|
|
2586
2797
|
}
|
|
2587
2798
|
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R3, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
@@ -2634,34 +2845,45 @@ var require_parser = __commonJS({
|
|
|
2634
2845
|
return HexLiteral$0(state);
|
|
2635
2846
|
}
|
|
2636
2847
|
}
|
|
2637
|
-
var StringLiteral$0 = $
|
|
2638
|
-
|
|
2848
|
+
var StringLiteral$0 = $TS($S($EXPECT($L115, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L115, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
2849
|
+
var str = $2;
|
|
2850
|
+
return { $loc, token: "`" + module2.dedentBlockString(str) + "`" };
|
|
2851
|
+
});
|
|
2852
|
+
var StringLiteral$1 = $TS($S($EXPECT($L116, fail, `StringLiteral "'''"`), $TEXT($Q(TripleSingleStringCharacter)), $EXPECT($L116, fail, `StringLiteral "'''"`)), function($skip, $loc, $0, $1, $2, $3) {
|
|
2853
|
+
var str = $2;
|
|
2854
|
+
return { $loc, token: "`" + module2.dedentBlockString(str) + "`" };
|
|
2855
|
+
});
|
|
2856
|
+
var StringLiteral$2 = $TV($TEXT($S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
|
|
2857
|
+
return { $loc, token: $1 };
|
|
2858
|
+
});
|
|
2859
|
+
var StringLiteral$3 = $TV($TEXT($S($EXPECT($L118, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L118, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
|
|
2860
|
+
return { $loc, token: $1 };
|
|
2639
2861
|
});
|
|
2640
|
-
var StringLiteral$1 = $S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'));
|
|
2641
|
-
var StringLiteral$2 = $S($EXPECT($L118, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L118, fail, `StringLiteral "\\\\'"`));
|
|
2642
2862
|
function StringLiteral(state) {
|
|
2643
2863
|
if (state.tokenize) {
|
|
2644
|
-
return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state));
|
|
2864
|
+
return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state));
|
|
2645
2865
|
} else {
|
|
2646
|
-
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
|
|
2866
|
+
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
|
|
2647
2867
|
}
|
|
2648
2868
|
}
|
|
2649
|
-
var DoubleStringCharacter$0 = $R$0($EXPECT($R8, fail, 'DoubleStringCharacter /[^"
|
|
2650
|
-
var DoubleStringCharacter$1 = EscapeSequence;
|
|
2869
|
+
var DoubleStringCharacter$0 = $R$0($EXPECT($R8, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
|
|
2651
2870
|
function DoubleStringCharacter(state) {
|
|
2871
|
+
if (state.verbose)
|
|
2872
|
+
console.log("ENTER:", "DoubleStringCharacter");
|
|
2652
2873
|
if (state.tokenize) {
|
|
2653
|
-
return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state)
|
|
2874
|
+
return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state));
|
|
2654
2875
|
} else {
|
|
2655
|
-
return DoubleStringCharacter$0(state)
|
|
2876
|
+
return DoubleStringCharacter$0(state);
|
|
2656
2877
|
}
|
|
2657
2878
|
}
|
|
2658
|
-
var SingleStringCharacter$0 = $R$0($EXPECT($R9, fail, "SingleStringCharacter /[^'
|
|
2659
|
-
var SingleStringCharacter$1 = EscapeSequence;
|
|
2879
|
+
var SingleStringCharacter$0 = $R$0($EXPECT($R9, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
|
|
2660
2880
|
function SingleStringCharacter(state) {
|
|
2881
|
+
if (state.verbose)
|
|
2882
|
+
console.log("ENTER:", "SingleStringCharacter");
|
|
2661
2883
|
if (state.tokenize) {
|
|
2662
|
-
return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state)
|
|
2884
|
+
return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state));
|
|
2663
2885
|
} else {
|
|
2664
|
-
return SingleStringCharacter$0(state)
|
|
2886
|
+
return SingleStringCharacter$0(state);
|
|
2665
2887
|
}
|
|
2666
2888
|
}
|
|
2667
2889
|
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
|
|
@@ -2674,17 +2896,19 @@ var require_parser = __commonJS({
|
|
|
2674
2896
|
return TripleDoubleStringCharacter$0(state);
|
|
2675
2897
|
}
|
|
2676
2898
|
}
|
|
2677
|
-
var
|
|
2678
|
-
function
|
|
2899
|
+
var TripleSingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "TripleSingleStringCharacter /(?:'(?!'')|\\\\.|[^'])+/"));
|
|
2900
|
+
function TripleSingleStringCharacter(state) {
|
|
2679
2901
|
if (state.verbose)
|
|
2680
|
-
console.log("ENTER:", "
|
|
2902
|
+
console.log("ENTER:", "TripleSingleStringCharacter");
|
|
2681
2903
|
if (state.tokenize) {
|
|
2682
|
-
return $TOKEN("
|
|
2904
|
+
return $TOKEN("TripleSingleStringCharacter", state, TripleSingleStringCharacter$0(state));
|
|
2683
2905
|
} else {
|
|
2684
|
-
return
|
|
2906
|
+
return TripleSingleStringCharacter$0(state);
|
|
2685
2907
|
}
|
|
2686
2908
|
}
|
|
2687
|
-
var RegularExpressionLiteral$0 = $S($EXPECT($L58, fail, 'RegularExpressionLiteral "/"'),
|
|
2909
|
+
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
2910
|
+
return { $loc, token: $1 };
|
|
2911
|
+
});
|
|
2688
2912
|
function RegularExpressionLiteral(state) {
|
|
2689
2913
|
if (state.verbose)
|
|
2690
2914
|
console.log("ENTER:", "RegularExpressionLiteral");
|
|
@@ -2704,16 +2928,17 @@ var require_parser = __commonJS({
|
|
|
2704
2928
|
return RegularExpressionBody$0(state);
|
|
2705
2929
|
}
|
|
2706
2930
|
}
|
|
2707
|
-
var RegExpCharacter$0 = $R$0($EXPECT($R13, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
|
|
2708
|
-
var RegExpCharacter$1 = EscapeSequence;
|
|
2931
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R13, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
2709
2932
|
function RegExpCharacter(state) {
|
|
2933
|
+
if (state.verbose)
|
|
2934
|
+
console.log("ENTER:", "RegExpCharacter");
|
|
2710
2935
|
if (state.tokenize) {
|
|
2711
|
-
return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state)
|
|
2936
|
+
return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state));
|
|
2712
2937
|
} else {
|
|
2713
|
-
return RegExpCharacter$0(state)
|
|
2938
|
+
return RegExpCharacter$0(state);
|
|
2714
2939
|
}
|
|
2715
2940
|
}
|
|
2716
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($R14, fail, "RegularExpressionFlags /(
|
|
2941
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R14, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
2717
2942
|
function RegularExpressionFlags(state) {
|
|
2718
2943
|
if (state.verbose)
|
|
2719
2944
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -2723,7 +2948,7 @@ var require_parser = __commonJS({
|
|
|
2723
2948
|
return RegularExpressionFlags$0(state);
|
|
2724
2949
|
}
|
|
2725
2950
|
}
|
|
2726
|
-
var TemplateLiteral$0 = $S($EXPECT($
|
|
2951
|
+
var TemplateLiteral$0 = $S($EXPECT($L119, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L119, fail, 'TemplateLiteral "`"'));
|
|
2727
2952
|
function TemplateLiteral(state) {
|
|
2728
2953
|
if (state.verbose)
|
|
2729
2954
|
console.log("ENTER:", "TemplateLiteral");
|
|
@@ -2733,7 +2958,7 @@ var require_parser = __commonJS({
|
|
|
2733
2958
|
return TemplateLiteral$0(state);
|
|
2734
2959
|
}
|
|
2735
2960
|
}
|
|
2736
|
-
var TemplateSubstitution$0 = $S($EXPECT($
|
|
2961
|
+
var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L17, fail, 'TemplateSubstitution "}"'));
|
|
2737
2962
|
function TemplateSubstitution(state) {
|
|
2738
2963
|
if (state.verbose)
|
|
2739
2964
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -2790,7 +3015,7 @@ var require_parser = __commonJS({
|
|
|
2790
3015
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
2791
3016
|
}
|
|
2792
3017
|
}
|
|
2793
|
-
var JSMultiLineComment$0 = $S($EXPECT($
|
|
3018
|
+
var JSMultiLineComment$0 = $S($EXPECT($L121, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'JSMultiLineComment "*/"')), $EXPECT($R18, fail, "JSMultiLineComment /./")))), $EXPECT($L122, fail, 'JSMultiLineComment "*/"'));
|
|
2794
3019
|
function JSMultiLineComment(state) {
|
|
2795
3020
|
if (state.verbose)
|
|
2796
3021
|
console.log("ENTER:", "JSMultiLineComment");
|
|
@@ -2800,7 +3025,7 @@ var require_parser = __commonJS({
|
|
|
2800
3025
|
return JSMultiLineComment$0(state);
|
|
2801
3026
|
}
|
|
2802
3027
|
}
|
|
2803
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
3028
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R19, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
2804
3029
|
if (!global.coffeeCompat)
|
|
2805
3030
|
return $skip;
|
|
2806
3031
|
return ["//", $1];
|
|
@@ -2814,7 +3039,7 @@ var require_parser = __commonJS({
|
|
|
2814
3039
|
return CoffeeSingleLineComment$0(state);
|
|
2815
3040
|
}
|
|
2816
3041
|
}
|
|
2817
|
-
var CoffeeMultiLineComment$0 = $T($S($EXPECT($
|
|
3042
|
+
var CoffeeMultiLineComment$0 = $T($S($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R18, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), function(value) {
|
|
2818
3043
|
return ["/*", value[1], "*/"];
|
|
2819
3044
|
});
|
|
2820
3045
|
function CoffeeMultiLineComment(state) {
|
|
@@ -2826,7 +3051,7 @@ var require_parser = __commonJS({
|
|
|
2826
3051
|
return CoffeeMultiLineComment$0(state);
|
|
2827
3052
|
}
|
|
2828
3053
|
}
|
|
2829
|
-
var InlineComment$0 = $S($EXPECT($
|
|
3054
|
+
var InlineComment$0 = $S($EXPECT($L121, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'InlineComment "*/"')), $EXPECT($R20, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L122, fail, 'InlineComment "*/"'));
|
|
2830
3055
|
function InlineComment(state) {
|
|
2831
3056
|
if (state.verbose)
|
|
2832
3057
|
console.log("ENTER:", "InlineComment");
|
|
@@ -2846,7 +3071,7 @@ var require_parser = __commonJS({
|
|
|
2846
3071
|
return RestOfLine$0(state);
|
|
2847
3072
|
}
|
|
2848
3073
|
}
|
|
2849
|
-
var TrailingComment$0 = $R$0($EXPECT($
|
|
3074
|
+
var TrailingComment$0 = $R$0($EXPECT($R21, fail, "TrailingComment /[\\t ]+/"));
|
|
2850
3075
|
var TrailingComment$1 = InlineComment;
|
|
2851
3076
|
var TrailingComment$2 = SingleLineComment;
|
|
2852
3077
|
function TrailingComment(state) {
|
|
@@ -2856,7 +3081,7 @@ var require_parser = __commonJS({
|
|
|
2856
3081
|
return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
|
|
2857
3082
|
}
|
|
2858
3083
|
}
|
|
2859
|
-
var _$0 = $P($C($R$0($EXPECT($
|
|
3084
|
+
var _$0 = $P($C($R$0($EXPECT($R21, fail, "_ /[\\t ]+/")), Comment));
|
|
2860
3085
|
function _(state) {
|
|
2861
3086
|
if (state.verbose)
|
|
2862
3087
|
console.log("ENTER:", "_");
|
|
@@ -2866,7 +3091,7 @@ var require_parser = __commonJS({
|
|
|
2866
3091
|
return _$0(state);
|
|
2867
3092
|
}
|
|
2868
3093
|
}
|
|
2869
|
-
var __$0 = $Q($C($R$0($EXPECT($
|
|
3094
|
+
var __$0 = $Q($C($R$0($EXPECT($R22, fail, "__ /[\\s]+/")), Comment));
|
|
2870
3095
|
function __(state) {
|
|
2871
3096
|
if (state.verbose)
|
|
2872
3097
|
console.log("ENTER:", "__");
|
|
@@ -2887,7 +3112,7 @@ var require_parser = __commonJS({
|
|
|
2887
3112
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
2888
3113
|
}
|
|
2889
3114
|
}
|
|
2890
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3115
|
+
var NonIdContinue$0 = $R$0($EXPECT($R23, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
2891
3116
|
function NonIdContinue(state) {
|
|
2892
3117
|
if (state.verbose)
|
|
2893
3118
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -2911,7 +3136,7 @@ var require_parser = __commonJS({
|
|
|
2911
3136
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
2912
3137
|
}
|
|
2913
3138
|
}
|
|
2914
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($
|
|
3139
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L15, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L124, fail, 'JSXSelfClosingElement "/>"'));
|
|
2915
3140
|
function JSXSelfClosingElement(state) {
|
|
2916
3141
|
if (state.verbose)
|
|
2917
3142
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -2921,7 +3146,7 @@ var require_parser = __commonJS({
|
|
|
2921
3146
|
return JSXSelfClosingElement$0(state);
|
|
2922
3147
|
}
|
|
2923
3148
|
}
|
|
2924
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
3149
|
+
var JSXOpeningElement$0 = $S($EXPECT($L15, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L67, fail, 'JSXOpeningElement ">"'));
|
|
2925
3150
|
function JSXOpeningElement(state) {
|
|
2926
3151
|
if (state.verbose)
|
|
2927
3152
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -2931,7 +3156,7 @@ var require_parser = __commonJS({
|
|
|
2931
3156
|
return JSXOpeningElement$0(state);
|
|
2932
3157
|
}
|
|
2933
3158
|
}
|
|
2934
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
3159
|
+
var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L67, fail, 'JSXClosingElement ">"'));
|
|
2935
3160
|
function JSXClosingElement(state) {
|
|
2936
3161
|
if (state.verbose)
|
|
2937
3162
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -2941,7 +3166,7 @@ var require_parser = __commonJS({
|
|
|
2941
3166
|
return JSXClosingElement$0(state);
|
|
2942
3167
|
}
|
|
2943
3168
|
}
|
|
2944
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
3169
|
+
var JSXFragment$0 = $S($EXPECT($L126, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L127, fail, 'JSXFragment "</>"'));
|
|
2945
3170
|
function JSXFragment(state) {
|
|
2946
3171
|
if (state.verbose)
|
|
2947
3172
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -2951,7 +3176,7 @@ var require_parser = __commonJS({
|
|
|
2951
3176
|
return JSXFragment$0(state);
|
|
2952
3177
|
}
|
|
2953
3178
|
}
|
|
2954
|
-
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($
|
|
3179
|
+
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L13, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L25, fail, 'JSXElementName "."'), JSXIdentifierName))));
|
|
2955
3180
|
function JSXElementName(state) {
|
|
2956
3181
|
if (state.verbose)
|
|
2957
3182
|
console.log("ENTER:", "JSXElementName");
|
|
@@ -2961,7 +3186,7 @@ var require_parser = __commonJS({
|
|
|
2961
3186
|
return JSXElementName$0(state);
|
|
2962
3187
|
}
|
|
2963
3188
|
}
|
|
2964
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
3189
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R24, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
2965
3190
|
function JSXIdentifierName(state) {
|
|
2966
3191
|
if (state.verbose)
|
|
2967
3192
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -2981,7 +3206,7 @@ var require_parser = __commonJS({
|
|
|
2981
3206
|
return JSXAttributes$0(state);
|
|
2982
3207
|
}
|
|
2983
3208
|
}
|
|
2984
|
-
var JSXAttribute$0 = $S($EXPECT($
|
|
3209
|
+
var JSXAttribute$0 = $S($EXPECT($L12, fail, 'JSXAttribute "{"'), __, $EXPECT($L33, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L17, fail, 'JSXAttribute "}"'));
|
|
2985
3210
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
2986
3211
|
function JSXAttribute(state) {
|
|
2987
3212
|
if (state.tokenize) {
|
|
@@ -2990,7 +3215,7 @@ var require_parser = __commonJS({
|
|
|
2990
3215
|
return JSXAttribute$0(state) || JSXAttribute$1(state);
|
|
2991
3216
|
}
|
|
2992
3217
|
}
|
|
2993
|
-
var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($
|
|
3218
|
+
var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L13, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
|
|
2994
3219
|
function JSXAttributeName(state) {
|
|
2995
3220
|
if (state.verbose)
|
|
2996
3221
|
console.log("ENTER:", "JSXAttributeName");
|
|
@@ -3010,9 +3235,9 @@ var require_parser = __commonJS({
|
|
|
3010
3235
|
return JSXAttributeInitializer$0(state);
|
|
3011
3236
|
}
|
|
3012
3237
|
}
|
|
3013
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
3014
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
3015
|
-
var JSXAttributeValue$2 = $S($EXPECT($
|
|
3238
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R25, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
3239
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R26, fail, "JSXAttributeValue /'[^']*'/"));
|
|
3240
|
+
var JSXAttributeValue$2 = $S($EXPECT($L12, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L17, fail, 'JSXAttributeValue "}"'));
|
|
3016
3241
|
var JSXAttributeValue$3 = JSXElement;
|
|
3017
3242
|
var JSXAttributeValue$4 = JSXFragment;
|
|
3018
3243
|
function JSXAttributeValue(state) {
|
|
@@ -3035,7 +3260,7 @@ var require_parser = __commonJS({
|
|
|
3035
3260
|
var JSXChild$0 = JSXText;
|
|
3036
3261
|
var JSXChild$1 = JSXElement;
|
|
3037
3262
|
var JSXChild$2 = JSXFragment;
|
|
3038
|
-
var JSXChild$3 = $S($EXPECT($
|
|
3263
|
+
var JSXChild$3 = $S($EXPECT($L12, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L17, fail, 'JSXChild "}"'));
|
|
3039
3264
|
function JSXChild(state) {
|
|
3040
3265
|
if (state.tokenize) {
|
|
3041
3266
|
return $TOKEN("JSXChild", state, JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state));
|
|
@@ -3043,7 +3268,7 @@ var require_parser = __commonJS({
|
|
|
3043
3268
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
3044
3269
|
}
|
|
3045
3270
|
}
|
|
3046
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
3271
|
+
var JSXText$0 = $R$0($EXPECT($R27, fail, "JSXText /[^{}<>]+/"));
|
|
3047
3272
|
function JSXText(state) {
|
|
3048
3273
|
if (state.verbose)
|
|
3049
3274
|
console.log("ENTER:", "JSXText");
|
|
@@ -3053,7 +3278,7 @@ var require_parser = __commonJS({
|
|
|
3053
3278
|
return JSXText$0(state);
|
|
3054
3279
|
}
|
|
3055
3280
|
}
|
|
3056
|
-
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($
|
|
3281
|
+
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L33, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
|
|
3057
3282
|
function JSXChildExpression(state) {
|
|
3058
3283
|
if (state.verbose)
|
|
3059
3284
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -3063,10 +3288,10 @@ var require_parser = __commonJS({
|
|
|
3063
3288
|
return JSXChildExpression$0(state);
|
|
3064
3289
|
}
|
|
3065
3290
|
}
|
|
3066
|
-
var TypeDeclaration$0 = $T($S($EXPECT($
|
|
3291
|
+
var TypeDeclaration$0 = $T($S($EXPECT($R28, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L56, fail, 'TypeDeclaration "="'), __, Type), function(value) {
|
|
3067
3292
|
return { "ts": true, "children": value };
|
|
3068
3293
|
});
|
|
3069
|
-
var TypeDeclaration$1 = $T($S($EXPECT($
|
|
3294
|
+
var TypeDeclaration$1 = $T($S($EXPECT($R29, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
|
|
3070
3295
|
return { "ts": true, "children": value };
|
|
3071
3296
|
});
|
|
3072
3297
|
function TypeDeclaration(state) {
|
|
@@ -3076,8 +3301,8 @@ var require_parser = __commonJS({
|
|
|
3076
3301
|
return TypeDeclaration$0(state) || TypeDeclaration$1(state);
|
|
3077
3302
|
}
|
|
3078
3303
|
}
|
|
3079
|
-
var InterfaceBlock$0 = $S(__, $EXPECT($
|
|
3080
|
-
var InterfaceBlock$1 = $S(__, $EXPECT($
|
|
3304
|
+
var InterfaceBlock$0 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L17, fail, 'InterfaceBlock "}"'));
|
|
3305
|
+
var InterfaceBlock$1 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), $Q($S(__, InterfaceProperty)), __, $EXPECT($L17, fail, 'InterfaceBlock "}"'));
|
|
3081
3306
|
var InterfaceBlock$2 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
3082
3307
|
function InterfaceBlock(state) {
|
|
3083
3308
|
if (state.tokenize) {
|
|
@@ -3122,8 +3347,8 @@ var require_parser = __commonJS({
|
|
|
3122
3347
|
}
|
|
3123
3348
|
}
|
|
3124
3349
|
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L88, fail, 'InterfacePropertyDelimiter ";"'));
|
|
3125
|
-
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
3126
|
-
var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
3350
|
+
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L17, fail, 'InterfacePropertyDelimiter "}"')));
|
|
3351
|
+
var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L17, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
|
|
3127
3352
|
return ";";
|
|
3128
3353
|
});
|
|
3129
3354
|
var InterfacePropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -3136,7 +3361,7 @@ var require_parser = __commonJS({
|
|
|
3136
3361
|
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
|
|
3137
3362
|
}
|
|
3138
3363
|
}
|
|
3139
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
3364
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L128, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L26, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L27, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
|
|
3140
3365
|
function TypeIndexSignature(state) {
|
|
3141
3366
|
if (state.verbose)
|
|
3142
3367
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -3155,7 +3380,7 @@ var require_parser = __commonJS({
|
|
|
3155
3380
|
return TypeIndex$0(state) || TypeIndex$1(state);
|
|
3156
3381
|
}
|
|
3157
3382
|
}
|
|
3158
|
-
var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($
|
|
3383
|
+
var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L13, fail, 'TypeSuffix ":"'), Type), function(value) {
|
|
3159
3384
|
return { "ts": true, "children": value };
|
|
3160
3385
|
});
|
|
3161
3386
|
function TypeSuffix(state) {
|
|
@@ -3167,7 +3392,7 @@ var require_parser = __commonJS({
|
|
|
3167
3392
|
return TypeSuffix$0(state);
|
|
3168
3393
|
}
|
|
3169
3394
|
}
|
|
3170
|
-
var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($
|
|
3395
|
+
var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L13, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L129, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
|
|
3171
3396
|
return { "ts": true, "children": value };
|
|
3172
3397
|
});
|
|
3173
3398
|
function ReturnTypeSuffix(state) {
|
|
@@ -3229,9 +3454,9 @@ var require_parser = __commonJS({
|
|
|
3229
3454
|
return TypeUnarySuffix$0(state);
|
|
3230
3455
|
}
|
|
3231
3456
|
}
|
|
3232
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
3457
|
+
var TypeUnaryOp$0 = $EXPECT($L130, fail, 'TypeUnaryOp "keyof"');
|
|
3233
3458
|
var TypeUnaryOp$1 = $EXPECT($L85, fail, 'TypeUnaryOp "typeof"');
|
|
3234
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
3459
|
+
var TypeUnaryOp$2 = $EXPECT($L131, fail, 'TypeUnaryOp "infer"');
|
|
3235
3460
|
function TypeUnaryOp(state) {
|
|
3236
3461
|
if (state.tokenize) {
|
|
3237
3462
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -3239,7 +3464,7 @@ var require_parser = __commonJS({
|
|
|
3239
3464
|
return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
|
|
3240
3465
|
}
|
|
3241
3466
|
}
|
|
3242
|
-
var TypeIndexedAccess$0 = $S(__, $EXPECT($
|
|
3467
|
+
var TypeIndexedAccess$0 = $S(__, $EXPECT($L26, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L27, fail, 'TypeIndexedAccess "]"'));
|
|
3243
3468
|
function TypeIndexedAccess(state) {
|
|
3244
3469
|
if (state.verbose)
|
|
3245
3470
|
console.log("ENTER:", "TypeIndexedAccess");
|
|
@@ -3252,7 +3477,7 @@ var require_parser = __commonJS({
|
|
|
3252
3477
|
var TypePrimary$0 = InterfaceBlock;
|
|
3253
3478
|
var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
|
|
3254
3479
|
var TypePrimary$2 = $S($Q(_), FunctionType);
|
|
3255
|
-
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($
|
|
3480
|
+
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L25, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
|
|
3256
3481
|
var TypePrimary$4 = $S($Q(_), TypeLiteral);
|
|
3257
3482
|
function TypePrimary(state) {
|
|
3258
3483
|
if (state.tokenize) {
|
|
@@ -3261,7 +3486,7 @@ var require_parser = __commonJS({
|
|
|
3261
3486
|
return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
|
|
3262
3487
|
}
|
|
3263
3488
|
}
|
|
3264
|
-
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($
|
|
3489
|
+
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L16, fail, 'TypeConditional "extends"'), Type, $E($S(__, $EXPECT($L3, fail, 'TypeConditional "?"'), Type, __, $EXPECT($L13, fail, 'TypeConditional ":"'), Type)))));
|
|
3265
3490
|
function TypeConditional(state) {
|
|
3266
3491
|
if (state.verbose)
|
|
3267
3492
|
console.log("ENTER:", "TypeConditional");
|
|
@@ -3273,7 +3498,7 @@ var require_parser = __commonJS({
|
|
|
3273
3498
|
}
|
|
3274
3499
|
var TypeLiteral$0 = Literal;
|
|
3275
3500
|
var TypeLiteral$1 = $EXPECT($L84, fail, 'TypeLiteral "void"');
|
|
3276
|
-
var TypeLiteral$2 = $EXPECT($
|
|
3501
|
+
var TypeLiteral$2 = $EXPECT($L132, fail, 'TypeLiteral "[]"');
|
|
3277
3502
|
function TypeLiteral(state) {
|
|
3278
3503
|
if (state.tokenize) {
|
|
3279
3504
|
return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
|
|
@@ -3290,7 +3515,7 @@ var require_parser = __commonJS({
|
|
|
3290
3515
|
return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
|
|
3291
3516
|
}
|
|
3292
3517
|
}
|
|
3293
|
-
var FunctionType$0 = $S(Parameters, __, $EXPECT($
|
|
3518
|
+
var FunctionType$0 = $S(Parameters, __, $EXPECT($L11, fail, 'FunctionType "=>"'), Type);
|
|
3294
3519
|
function FunctionType(state) {
|
|
3295
3520
|
if (state.verbose)
|
|
3296
3521
|
console.log("ENTER:", "FunctionType");
|
|
@@ -3300,7 +3525,7 @@ var require_parser = __commonJS({
|
|
|
3300
3525
|
return FunctionType$0(state);
|
|
3301
3526
|
}
|
|
3302
3527
|
}
|
|
3303
|
-
var TypeArguments$0 = $S(__, $EXPECT($
|
|
3528
|
+
var TypeArguments$0 = $S(__, $EXPECT($L15, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L67, fail, 'TypeArguments ">"'));
|
|
3304
3529
|
function TypeArguments(state) {
|
|
3305
3530
|
if (state.verbose)
|
|
3306
3531
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -3310,7 +3535,7 @@ var require_parser = __commonJS({
|
|
|
3310
3535
|
return TypeArguments$0(state);
|
|
3311
3536
|
}
|
|
3312
3537
|
}
|
|
3313
|
-
var TypeParameters$0 = $S(__, $EXPECT($
|
|
3538
|
+
var TypeParameters$0 = $S(__, $EXPECT($L15, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L67, fail, 'TypeParameters ">"'));
|
|
3314
3539
|
function TypeParameters(state) {
|
|
3315
3540
|
if (state.verbose)
|
|
3316
3541
|
console.log("ENTER:", "TypeParameters");
|
|
@@ -3330,7 +3555,7 @@ var require_parser = __commonJS({
|
|
|
3330
3555
|
return TypeParameter$0(state);
|
|
3331
3556
|
}
|
|
3332
3557
|
}
|
|
3333
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
3558
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L16, fail, 'TypeConstraint "extends"'), Type);
|
|
3334
3559
|
function TypeConstraint(state) {
|
|
3335
3560
|
if (state.verbose)
|
|
3336
3561
|
console.log("ENTER:", "TypeConstraint");
|
|
@@ -3355,7 +3580,7 @@ var require_parser = __commonJS({
|
|
|
3355
3580
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
3356
3581
|
}
|
|
3357
3582
|
}
|
|
3358
|
-
var Shebang$0 = $R$0($EXPECT($
|
|
3583
|
+
var Shebang$0 = $R$0($EXPECT($R32, fail, "Shebang /#![^\\r\\n]*/"));
|
|
3359
3584
|
function Shebang(state) {
|
|
3360
3585
|
if (state.verbose)
|
|
3361
3586
|
console.log("ENTER:", "Shebang");
|
|
@@ -3365,7 +3590,7 @@ var require_parser = __commonJS({
|
|
|
3365
3590
|
return Shebang$0(state);
|
|
3366
3591
|
}
|
|
3367
3592
|
}
|
|
3368
|
-
var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($
|
|
3593
|
+
var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R33, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
|
|
3369
3594
|
return $0.map((p) => p.join(""));
|
|
3370
3595
|
});
|
|
3371
3596
|
function DirectivePrologue(state) {
|
|
@@ -3387,7 +3612,7 @@ var require_parser = __commonJS({
|
|
|
3387
3612
|
return EOS$0(state);
|
|
3388
3613
|
}
|
|
3389
3614
|
}
|
|
3390
|
-
var EOL$0 = $R$0($EXPECT($
|
|
3615
|
+
var EOL$0 = $R$0($EXPECT($R34, fail, "EOL /\\r\\n|\\n|\\r|$/"));
|
|
3391
3616
|
function EOL(state) {
|
|
3392
3617
|
if (state.verbose)
|
|
3393
3618
|
console.log("ENTER:", "EOL");
|
|
@@ -3397,7 +3622,7 @@ var require_parser = __commonJS({
|
|
|
3397
3622
|
return EOL$0(state);
|
|
3398
3623
|
}
|
|
3399
3624
|
}
|
|
3400
|
-
var EOF$0 = $R$0($EXPECT($
|
|
3625
|
+
var EOF$0 = $R$0($EXPECT($R35, fail, "EOF /$/"));
|
|
3401
3626
|
function EOF(state) {
|
|
3402
3627
|
if (state.verbose)
|
|
3403
3628
|
console.log("ENTER:", "EOF");
|
|
@@ -3407,7 +3632,7 @@ var require_parser = __commonJS({
|
|
|
3407
3632
|
return EOF$0(state);
|
|
3408
3633
|
}
|
|
3409
3634
|
}
|
|
3410
|
-
var Debugger$0 = $TV($EXPECT($
|
|
3635
|
+
var Debugger$0 = $TV($EXPECT($L32, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
3411
3636
|
debugger;
|
|
3412
3637
|
});
|
|
3413
3638
|
function Debugger(state) {
|
|
@@ -3419,7 +3644,7 @@ var require_parser = __commonJS({
|
|
|
3419
3644
|
return Debugger$0(state);
|
|
3420
3645
|
}
|
|
3421
3646
|
}
|
|
3422
|
-
var InsertOpenParen$0 = $T($EXPECT($
|
|
3647
|
+
var InsertOpenParen$0 = $T($EXPECT($L32, fail, 'InsertOpenParen ""'), function(value) {
|
|
3423
3648
|
return "(";
|
|
3424
3649
|
});
|
|
3425
3650
|
function InsertOpenParen(state) {
|
|
@@ -3431,7 +3656,7 @@ var require_parser = __commonJS({
|
|
|
3431
3656
|
return InsertOpenParen$0(state);
|
|
3432
3657
|
}
|
|
3433
3658
|
}
|
|
3434
|
-
var InsertCloseParen$0 = $T($EXPECT($
|
|
3659
|
+
var InsertCloseParen$0 = $T($EXPECT($L32, fail, 'InsertCloseParen ""'), function(value) {
|
|
3435
3660
|
return ")";
|
|
3436
3661
|
});
|
|
3437
3662
|
function InsertCloseParen(state) {
|
|
@@ -3443,7 +3668,7 @@ var require_parser = __commonJS({
|
|
|
3443
3668
|
return InsertCloseParen$0(state);
|
|
3444
3669
|
}
|
|
3445
3670
|
}
|
|
3446
|
-
var InsertOpenBrace$0 = $T($EXPECT($
|
|
3671
|
+
var InsertOpenBrace$0 = $T($EXPECT($L32, fail, 'InsertOpenBrace ""'), function(value) {
|
|
3447
3672
|
return " {";
|
|
3448
3673
|
});
|
|
3449
3674
|
function InsertOpenBrace(state) {
|
|
@@ -3455,7 +3680,7 @@ var require_parser = __commonJS({
|
|
|
3455
3680
|
return InsertOpenBrace$0(state);
|
|
3456
3681
|
}
|
|
3457
3682
|
}
|
|
3458
|
-
var InsertCloseBrace$0 = $T($EXPECT($
|
|
3683
|
+
var InsertCloseBrace$0 = $T($EXPECT($L32, fail, 'InsertCloseBrace ""'), function(value) {
|
|
3459
3684
|
return "}";
|
|
3460
3685
|
});
|
|
3461
3686
|
function InsertCloseBrace(state) {
|
|
@@ -3467,7 +3692,7 @@ var require_parser = __commonJS({
|
|
|
3467
3692
|
return InsertCloseBrace$0(state);
|
|
3468
3693
|
}
|
|
3469
3694
|
}
|
|
3470
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
3695
|
+
var InsertNewline$0 = $TV($EXPECT($L32, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
3471
3696
|
return "\n";
|
|
3472
3697
|
});
|
|
3473
3698
|
function InsertNewline(state) {
|
|
@@ -3479,7 +3704,7 @@ var require_parser = __commonJS({
|
|
|
3479
3704
|
return InsertNewline$0(state);
|
|
3480
3705
|
}
|
|
3481
3706
|
}
|
|
3482
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
3707
|
+
var InsertIndent$0 = $TV($EXPECT($L32, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
3483
3708
|
return "".padStart(global.currentIndent * 2);
|
|
3484
3709
|
});
|
|
3485
3710
|
function InsertIndent(state) {
|
|
@@ -3491,7 +3716,7 @@ var require_parser = __commonJS({
|
|
|
3491
3716
|
return InsertIndent$0(state);
|
|
3492
3717
|
}
|
|
3493
3718
|
}
|
|
3494
|
-
var InsertSpace$0 = $T($EXPECT($
|
|
3719
|
+
var InsertSpace$0 = $T($EXPECT($L32, fail, 'InsertSpace ""'), function(value) {
|
|
3495
3720
|
return " ";
|
|
3496
3721
|
});
|
|
3497
3722
|
function InsertSpace(state) {
|
|
@@ -3503,7 +3728,7 @@ var require_parser = __commonJS({
|
|
|
3503
3728
|
return InsertSpace$0(state);
|
|
3504
3729
|
}
|
|
3505
3730
|
}
|
|
3506
|
-
var InsertDot$0 = $T($EXPECT($
|
|
3731
|
+
var InsertDot$0 = $T($EXPECT($L32, fail, 'InsertDot ""'), function(value) {
|
|
3507
3732
|
return ".";
|
|
3508
3733
|
});
|
|
3509
3734
|
function InsertDot(state) {
|
|
@@ -3515,7 +3740,7 @@ var require_parser = __commonJS({
|
|
|
3515
3740
|
return InsertDot$0(state);
|
|
3516
3741
|
}
|
|
3517
3742
|
}
|
|
3518
|
-
var InsertBreak$0 = $T($EXPECT($
|
|
3743
|
+
var InsertBreak$0 = $T($EXPECT($L32, fail, 'InsertBreak ""'), function(value) {
|
|
3519
3744
|
return "break;";
|
|
3520
3745
|
});
|
|
3521
3746
|
function InsertBreak(state) {
|
|
@@ -3527,7 +3752,7 @@ var require_parser = __commonJS({
|
|
|
3527
3752
|
return InsertBreak$0(state);
|
|
3528
3753
|
}
|
|
3529
3754
|
}
|
|
3530
|
-
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($
|
|
3755
|
+
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L32, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3531
3756
|
var directives = $2;
|
|
3532
3757
|
global.currentIndent = 0;
|
|
3533
3758
|
global.indentLevels = [0];
|
|
@@ -3536,6 +3761,15 @@ var require_parser = __commonJS({
|
|
|
3536
3761
|
const compatRe = /use coffee-compat/;
|
|
3537
3762
|
global.coffeeCompat = directives.some((d) => d.match(compatRe));
|
|
3538
3763
|
}
|
|
3764
|
+
module2.dedentBlockString = function(str) {
|
|
3765
|
+
const spacing = str.match(/^(\r?\n|\n)\s+/);
|
|
3766
|
+
if (spacing) {
|
|
3767
|
+
str = str.replaceAll(spacing[0], "\n");
|
|
3768
|
+
}
|
|
3769
|
+
str = str.replace(/^(\r?\n|\n)/, "");
|
|
3770
|
+
str = str.replace(/(\r?\n|\n)$/, "");
|
|
3771
|
+
return str;
|
|
3772
|
+
};
|
|
3539
3773
|
return $0;
|
|
3540
3774
|
});
|
|
3541
3775
|
function Init(state) {
|
|
@@ -3547,7 +3781,7 @@ var require_parser = __commonJS({
|
|
|
3547
3781
|
return Init$0(state);
|
|
3548
3782
|
}
|
|
3549
3783
|
}
|
|
3550
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
3784
|
+
var Indent$0 = $TV($Q($C($EXPECT($L133, fail, 'Indent " "'), $EXPECT($L134, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
3551
3785
|
return $1.length;
|
|
3552
3786
|
});
|
|
3553
3787
|
function Indent(state) {
|
|
@@ -3559,7 +3793,7 @@ var require_parser = __commonJS({
|
|
|
3559
3793
|
return Indent$0(state);
|
|
3560
3794
|
}
|
|
3561
3795
|
}
|
|
3562
|
-
var PushIndent$0 = $TV($EXPECT($
|
|
3796
|
+
var PushIndent$0 = $TV($EXPECT($L32, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
|
|
3563
3797
|
global.currentIndent++;
|
|
3564
3798
|
if (global.verbose) {
|
|
3565
3799
|
console.log("pushing indent", global.currentIndent);
|
|
@@ -3576,7 +3810,7 @@ var require_parser = __commonJS({
|
|
|
3576
3810
|
return PushIndent$0(state);
|
|
3577
3811
|
}
|
|
3578
3812
|
}
|
|
3579
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
3813
|
+
var PopIndent$0 = $TV($EXPECT($L32, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
3580
3814
|
if (global.verbose) {
|
|
3581
3815
|
console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
|
|
3582
3816
|
}
|
|
@@ -3653,7 +3887,7 @@ var require_parser = __commonJS({
|
|
|
3653
3887
|
var require_generate = __commonJS({
|
|
3654
3888
|
"source/generate.coffee"(exports2, module2) {
|
|
3655
3889
|
var gen2;
|
|
3656
|
-
var
|
|
3890
|
+
var prune2;
|
|
3657
3891
|
gen2 = function(node, options) {
|
|
3658
3892
|
var $loc, token;
|
|
3659
3893
|
if (node === null || node === void 0) {
|
|
@@ -3693,7 +3927,7 @@ var require_generate = __commonJS({
|
|
|
3693
3927
|
throw new Error("Unknown node", JSON.stringify(node));
|
|
3694
3928
|
};
|
|
3695
3929
|
module2.exports = gen2;
|
|
3696
|
-
|
|
3930
|
+
prune2 = function(node) {
|
|
3697
3931
|
var a;
|
|
3698
3932
|
if (node === null || node === void 0) {
|
|
3699
3933
|
return;
|
|
@@ -3703,7 +3937,7 @@ var require_generate = __commonJS({
|
|
|
3703
3937
|
}
|
|
3704
3938
|
if (Array.isArray(node)) {
|
|
3705
3939
|
a = node.map(function(n) {
|
|
3706
|
-
return
|
|
3940
|
+
return prune2(n);
|
|
3707
3941
|
}).filter(function(n) {
|
|
3708
3942
|
return !!n;
|
|
3709
3943
|
});
|
|
@@ -3716,26 +3950,172 @@ var require_generate = __commonJS({
|
|
|
3716
3950
|
return;
|
|
3717
3951
|
}
|
|
3718
3952
|
if (node.children != null) {
|
|
3719
|
-
node.children =
|
|
3953
|
+
node.children = prune2(node.children);
|
|
3720
3954
|
return node;
|
|
3721
3955
|
}
|
|
3722
3956
|
return node;
|
|
3723
3957
|
};
|
|
3724
|
-
gen2.prune =
|
|
3958
|
+
gen2.prune = prune2;
|
|
3959
|
+
}
|
|
3960
|
+
});
|
|
3961
|
+
|
|
3962
|
+
// source/util.coffee
|
|
3963
|
+
var require_util = __commonJS({
|
|
3964
|
+
"source/util.coffee"(exports2, module2) {
|
|
3965
|
+
var BASE64_CHARS;
|
|
3966
|
+
var SourceMap2;
|
|
3967
|
+
var VLQ_CONTINUATION_BIT;
|
|
3968
|
+
var VLQ_SHIFT;
|
|
3969
|
+
var VLQ_VALUE_MASK;
|
|
3970
|
+
var encodeBase64;
|
|
3971
|
+
var encodeVlq;
|
|
3972
|
+
var locationTable;
|
|
3973
|
+
var lookupLineColumn;
|
|
3974
|
+
locationTable = function(input) {
|
|
3975
|
+
var line, lines, linesRe, pos, result;
|
|
3976
|
+
linesRe = /([^\r\n]*)(\r\n|\r|\n|$)/y;
|
|
3977
|
+
lines = [];
|
|
3978
|
+
line = 0;
|
|
3979
|
+
pos = 0;
|
|
3980
|
+
while (result = linesRe.exec(input)) {
|
|
3981
|
+
pos += result[0].length;
|
|
3982
|
+
lines[line++] = pos;
|
|
3983
|
+
if (pos === input.length) {
|
|
3984
|
+
break;
|
|
3985
|
+
}
|
|
3986
|
+
}
|
|
3987
|
+
return lines;
|
|
3988
|
+
};
|
|
3989
|
+
lookupLineColumn = function(table, pos) {
|
|
3990
|
+
var l, prevEnd;
|
|
3991
|
+
l = 0;
|
|
3992
|
+
prevEnd = 0;
|
|
3993
|
+
while (table[l] <= pos) {
|
|
3994
|
+
prevEnd = table[l++];
|
|
3995
|
+
}
|
|
3996
|
+
return [l, pos - prevEnd];
|
|
3997
|
+
};
|
|
3998
|
+
SourceMap2 = function(sourceString) {
|
|
3999
|
+
var EOL, sm, srcTable;
|
|
4000
|
+
srcTable = locationTable(sourceString);
|
|
4001
|
+
sm = {
|
|
4002
|
+
lines: [[]],
|
|
4003
|
+
lineNum: 0,
|
|
4004
|
+
colOffset: 0,
|
|
4005
|
+
srcTable
|
|
4006
|
+
};
|
|
4007
|
+
EOL = /\r?\n|\r/;
|
|
4008
|
+
return {
|
|
4009
|
+
data: sm,
|
|
4010
|
+
renderMappings: function() {
|
|
4011
|
+
var lastSourceColumn, lastSourceLine;
|
|
4012
|
+
lastSourceLine = 0;
|
|
4013
|
+
lastSourceColumn = 0;
|
|
4014
|
+
return sm.lines.map(function(line) {
|
|
4015
|
+
return line.map(function(entry) {
|
|
4016
|
+
var colDelta, lineDelta, sourceFileIndex, srcCol, srcLine;
|
|
4017
|
+
if (entry.length === 4) {
|
|
4018
|
+
[colDelta, sourceFileIndex, srcLine, srcCol] = entry;
|
|
4019
|
+
lineDelta = srcLine - lastSourceLine;
|
|
4020
|
+
colDelta = srcCol - lastSourceColumn;
|
|
4021
|
+
lastSourceLine = srcLine;
|
|
4022
|
+
lastSourceColumn = srcCol;
|
|
4023
|
+
return `${encodeVlq(entry[0])}${encodeVlq(sourceFileIndex)}${encodeVlq(lineDelta)}${encodeVlq(colDelta)}`;
|
|
4024
|
+
} else {
|
|
4025
|
+
return encodeVlq(entry[0]);
|
|
4026
|
+
}
|
|
4027
|
+
}).join(",");
|
|
4028
|
+
}).join(";");
|
|
4029
|
+
},
|
|
4030
|
+
json: function(srcFileName, outFileName) {
|
|
4031
|
+
return {
|
|
4032
|
+
version: 3,
|
|
4033
|
+
file: outFileName,
|
|
4034
|
+
sources: [srcFileName],
|
|
4035
|
+
mappings: this.renderMappings(),
|
|
4036
|
+
names: [],
|
|
4037
|
+
sourcesContent: [sourceString]
|
|
4038
|
+
};
|
|
4039
|
+
},
|
|
4040
|
+
updateSourceMap: function(outputStr, inputPos) {
|
|
4041
|
+
var outLines;
|
|
4042
|
+
outLines = outputStr.split(EOL);
|
|
4043
|
+
outLines.forEach(function(line, i) {
|
|
4044
|
+
var l, srcCol, srcLine;
|
|
4045
|
+
if (i > 0) {
|
|
4046
|
+
sm.lineNum++;
|
|
4047
|
+
sm.colOffset = 0;
|
|
4048
|
+
sm.lines[sm.lineNum] = [];
|
|
4049
|
+
}
|
|
4050
|
+
l = sm.colOffset;
|
|
4051
|
+
sm.colOffset = line.length;
|
|
4052
|
+
if (inputPos != null) {
|
|
4053
|
+
[srcLine, srcCol] = lookupLineColumn(srcTable, inputPos);
|
|
4054
|
+
return sm.lines[sm.lineNum].push([l, 0, srcLine, srcCol]);
|
|
4055
|
+
} else if (l !== 0) {
|
|
4056
|
+
return sm.lines[sm.lineNum].push([l]);
|
|
4057
|
+
}
|
|
4058
|
+
});
|
|
4059
|
+
}
|
|
4060
|
+
};
|
|
4061
|
+
};
|
|
4062
|
+
VLQ_SHIFT = 5;
|
|
4063
|
+
VLQ_CONTINUATION_BIT = 1 << VLQ_SHIFT;
|
|
4064
|
+
VLQ_VALUE_MASK = VLQ_CONTINUATION_BIT - 1;
|
|
4065
|
+
encodeVlq = function(value) {
|
|
4066
|
+
var answer, nextChunk, signBit, valueToEncode;
|
|
4067
|
+
answer = "";
|
|
4068
|
+
signBit = value < 0 ? 1 : 0;
|
|
4069
|
+
valueToEncode = (Math.abs(value) << 1) + signBit;
|
|
4070
|
+
while (valueToEncode || !answer) {
|
|
4071
|
+
nextChunk = valueToEncode & VLQ_VALUE_MASK;
|
|
4072
|
+
valueToEncode = valueToEncode >> VLQ_SHIFT;
|
|
4073
|
+
if (valueToEncode) {
|
|
4074
|
+
nextChunk |= VLQ_CONTINUATION_BIT;
|
|
4075
|
+
}
|
|
4076
|
+
answer += encodeBase64(nextChunk);
|
|
4077
|
+
}
|
|
4078
|
+
return answer;
|
|
4079
|
+
};
|
|
4080
|
+
BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
4081
|
+
encodeBase64 = function(value) {
|
|
4082
|
+
return BASE64_CHARS[value] || function() {
|
|
4083
|
+
throw new Error(`Cannot Base64 encode value: ${value}`);
|
|
4084
|
+
}();
|
|
4085
|
+
};
|
|
4086
|
+
module2.exports = { locationTable, lookupLineColumn, SourceMap: SourceMap2 };
|
|
3725
4087
|
}
|
|
3726
4088
|
});
|
|
3727
4089
|
|
|
3728
4090
|
// source/main.coffee
|
|
4091
|
+
var SourceMap;
|
|
4092
|
+
var defaultOptions;
|
|
3729
4093
|
var gen;
|
|
3730
4094
|
var parse;
|
|
4095
|
+
var prune;
|
|
4096
|
+
var util;
|
|
3731
4097
|
({ parse } = require_parser());
|
|
3732
|
-
gen = require_generate();
|
|
4098
|
+
({ prune } = gen = require_generate());
|
|
4099
|
+
({ SourceMap } = util = require_util());
|
|
4100
|
+
defaultOptions = {};
|
|
3733
4101
|
module.exports = {
|
|
3734
4102
|
parse,
|
|
3735
|
-
compile: function(src, options) {
|
|
3736
|
-
|
|
3737
|
-
|
|
3738
|
-
|
|
4103
|
+
compile: function(src, options = defaultOptions) {
|
|
4104
|
+
var ast, code, sm;
|
|
4105
|
+
ast = prune(parse(src, {
|
|
4106
|
+
filename: options.filename
|
|
4107
|
+
}));
|
|
4108
|
+
if (options.sourceMap) {
|
|
4109
|
+
sm = SourceMap(src);
|
|
4110
|
+
options.updateSourceMap = sm.updateSourceMap;
|
|
4111
|
+
code = gen(ast, options);
|
|
4112
|
+
return {
|
|
4113
|
+
code,
|
|
4114
|
+
sourceMap: sm
|
|
4115
|
+
};
|
|
4116
|
+
}
|
|
4117
|
+
return gen(ast, options);
|
|
3739
4118
|
},
|
|
3740
|
-
generate: gen
|
|
4119
|
+
generate: gen,
|
|
4120
|
+
util
|
|
3741
4121
|
};
|