@danielx/civet 0.2.0 → 0.2.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/browser.js +463 -445
- package/dist/browser.js.map +2 -2
- package/dist/civet +8 -8
- package/dist/cli.js.map +3 -3
- package/dist/main.js +463 -445
- package/package.json +1 -1
package/dist/main.js
CHANGED
|
@@ -486,16 +486,10 @@ var require_parser = __commonJS({
|
|
|
486
486
|
MethodDefinition,
|
|
487
487
|
ClassElementName,
|
|
488
488
|
PrivateIdentifier,
|
|
489
|
-
GeneratorDeclaration,
|
|
490
|
-
GeneratorExpression,
|
|
491
489
|
GeneratorMethod,
|
|
492
490
|
GeneratorBody,
|
|
493
|
-
AsyncFunctionDeclaration,
|
|
494
|
-
AsyncFunctionExpression,
|
|
495
491
|
AsyncMethod,
|
|
496
492
|
AsyncFunctionBody,
|
|
497
|
-
AsyncGeneratorDeclaration,
|
|
498
|
-
AsyncGeneratorExpression,
|
|
499
493
|
AsyncGeneratorMethod,
|
|
500
494
|
AsyncGeneratorBody,
|
|
501
495
|
AssignmentOp,
|
|
@@ -601,11 +595,18 @@ var require_parser = __commonJS({
|
|
|
601
595
|
InterfaceBlock,
|
|
602
596
|
NestedInterfaceProperties,
|
|
603
597
|
NestedInterfaceProperty,
|
|
598
|
+
InterfaceProperty,
|
|
599
|
+
InterfacePropertyDelimiter,
|
|
600
|
+
TypeIndexSignature,
|
|
604
601
|
TypeSuffix,
|
|
602
|
+
ReturnTypeSuffix,
|
|
603
|
+
TypePredicate,
|
|
605
604
|
Type,
|
|
606
605
|
TypeBinary,
|
|
607
606
|
TypeUnary,
|
|
607
|
+
TypeUnarySuffix,
|
|
608
608
|
TypeUnaryOp,
|
|
609
|
+
TypeIndexedAccess,
|
|
609
610
|
TypePrimary,
|
|
610
611
|
TypeConditional,
|
|
611
612
|
TypeLiteral,
|
|
@@ -640,113 +641,113 @@ var require_parser = __commonJS({
|
|
|
640
641
|
var $L1 = $L("(");
|
|
641
642
|
var $L2 = $L(")");
|
|
642
643
|
var $L3 = $L("?");
|
|
643
|
-
var $L4 = $L("
|
|
644
|
-
var $L5 = $L("
|
|
645
|
-
var $L6 = $L("
|
|
646
|
-
var $L7 = $L("
|
|
647
|
-
var $L8 = $L("
|
|
648
|
-
var $L9 = $L("
|
|
649
|
-
var $L10 = $L("
|
|
650
|
-
var $L11 = $L("
|
|
651
|
-
var $L12 = $L("
|
|
652
|
-
var $L13 = $L("
|
|
653
|
-
var $L14 = $L("
|
|
654
|
-
var $L15 = $L("
|
|
655
|
-
var $L16 = $L("
|
|
656
|
-
var $L17 = $L("
|
|
657
|
-
var $L18 = $L("
|
|
658
|
-
var $L19 = $L("
|
|
659
|
-
var $L20 = $L("
|
|
660
|
-
var $L21 = $L("
|
|
661
|
-
var $L22 = $L("
|
|
662
|
-
var $L23 = $L("
|
|
663
|
-
var $L24 = $L("
|
|
664
|
-
var $L25 = $L("
|
|
665
|
-
var $L26 = $L("
|
|
666
|
-
var $L27 = $L("
|
|
667
|
-
var $L28 = $L("
|
|
668
|
-
var $L29 = $L("");
|
|
669
|
-
var $L30 = $L("
|
|
670
|
-
var $L31 = $L("
|
|
671
|
-
var $L32 = $L("
|
|
672
|
-
var $L33 = $L("
|
|
673
|
-
var $L34 = $L("
|
|
674
|
-
var $L35 = $L("
|
|
675
|
-
var $L36 = $L("
|
|
676
|
-
var $L37 = $L("
|
|
677
|
-
var $L38 = $L("
|
|
678
|
-
var $L39 = $L("
|
|
679
|
-
var $L40 = $L("
|
|
680
|
-
var $L41 = $L("
|
|
681
|
-
var $L42 = $L("
|
|
682
|
-
var $L43 = $L("
|
|
683
|
-
var $L44 = $L("
|
|
684
|
-
var $L45 = $L("
|
|
685
|
-
var $L46 = $L("
|
|
686
|
-
var $L47 = $L("
|
|
687
|
-
var $L48 = $L("
|
|
688
|
-
var $L49 = $L("
|
|
689
|
-
var $L50 = $L("
|
|
690
|
-
var $L51 = $L("
|
|
691
|
-
var $L52 = $L("
|
|
692
|
-
var $L53 = $L("
|
|
693
|
-
var $L54 = $L("
|
|
694
|
-
var $L55 = $L("
|
|
695
|
-
var $L56 = $L("
|
|
696
|
-
var $L57 = $L("
|
|
697
|
-
var $L58 = $L("
|
|
698
|
-
var $L59 = $L("
|
|
699
|
-
var $L60 = $L("
|
|
700
|
-
var $L61 = $L("
|
|
701
|
-
var $L62 = $L("
|
|
702
|
-
var $L63 = $L("
|
|
703
|
-
var $L64 = $L("
|
|
704
|
-
var $L65 = $L("
|
|
705
|
-
var $L66 = $L("
|
|
706
|
-
var $L67 = $L("
|
|
707
|
-
var $L68 = $L("
|
|
708
|
-
var $L69 = $L("
|
|
709
|
-
var $L70 = $L("
|
|
710
|
-
var $L71 = $L("
|
|
711
|
-
var $L72 = $L("
|
|
712
|
-
var $L73 = $L("
|
|
713
|
-
var $L74 = $L("
|
|
714
|
-
var $L75 = $L("
|
|
715
|
-
var $L76 = $L("
|
|
716
|
-
var $L77 = $L("
|
|
717
|
-
var $L78 = $L("
|
|
718
|
-
var $L79 = $L("
|
|
719
|
-
var $L80 = $L("
|
|
720
|
-
var $L81 = $L("
|
|
721
|
-
var $L82 = $L("
|
|
722
|
-
var $L83 = $L("
|
|
723
|
-
var $L84 = $L("
|
|
724
|
-
var $L85 = $L("
|
|
725
|
-
var $L86 = $L("
|
|
726
|
-
var $L87 = $L("
|
|
727
|
-
var $L88 = $L("
|
|
728
|
-
var $L89 = $L("
|
|
729
|
-
var $L90 = $L("
|
|
730
|
-
var $L91 = $L("
|
|
731
|
-
var $L92 = $L("
|
|
732
|
-
var $L93 = $L("
|
|
733
|
-
var $L94 = $L("
|
|
734
|
-
var $L95 = $L("
|
|
735
|
-
var $L96 = $L("
|
|
736
|
-
var $L97 = $L("
|
|
737
|
-
var $L98 = $L("
|
|
738
|
-
var $L99 = $L("
|
|
739
|
-
var $L100 = $L("
|
|
740
|
-
var $L101 = $L("
|
|
741
|
-
var $L102 = $L("
|
|
742
|
-
var $L103 = $L("
|
|
743
|
-
var $L104 = $L("
|
|
744
|
-
var $L105 = $L("
|
|
745
|
-
var $L106 = $L("
|
|
746
|
-
var $L107 = $L("
|
|
747
|
-
var $L108 = $L("
|
|
748
|
-
var $L109 = $L("
|
|
749
|
-
var $L110 = $L("
|
|
644
|
+
var $L4 = $L("as");
|
|
645
|
+
var $L5 = $L("++");
|
|
646
|
+
var $L6 = $L("--");
|
|
647
|
+
var $L7 = $L("async");
|
|
648
|
+
var $L8 = $L("yield");
|
|
649
|
+
var $L9 = $L("*");
|
|
650
|
+
var $L10 = $L("=>");
|
|
651
|
+
var $L11 = $L("{");
|
|
652
|
+
var $L12 = $L(":");
|
|
653
|
+
var $L13 = $L("class");
|
|
654
|
+
var $L14 = $L("<");
|
|
655
|
+
var $L15 = $L("extends");
|
|
656
|
+
var $L16 = $L("}");
|
|
657
|
+
var $L17 = $L("static");
|
|
658
|
+
var $L18 = $L("this");
|
|
659
|
+
var $L19 = $L("@");
|
|
660
|
+
var $L20 = $L("#");
|
|
661
|
+
var $L21 = $L("new");
|
|
662
|
+
var $L22 = $L("super");
|
|
663
|
+
var $L23 = $L("import");
|
|
664
|
+
var $L24 = $L("[");
|
|
665
|
+
var $L25 = $L("]");
|
|
666
|
+
var $L26 = $L(".");
|
|
667
|
+
var $L27 = $L("super[");
|
|
668
|
+
var $L28 = $L("new.target");
|
|
669
|
+
var $L29 = $L("import.meta");
|
|
670
|
+
var $L30 = $L("");
|
|
671
|
+
var $L31 = $L("...");
|
|
672
|
+
var $L32 = $L("function");
|
|
673
|
+
var $L33 = $L("->");
|
|
674
|
+
var $L34 = $L("true");
|
|
675
|
+
var $L35 = $L("false");
|
|
676
|
+
var $L36 = $L("null");
|
|
677
|
+
var $L37 = $L("undefined");
|
|
678
|
+
var $L38 = $L("get");
|
|
679
|
+
var $L39 = $L("set");
|
|
680
|
+
var $L40 = $L("**=");
|
|
681
|
+
var $L41 = $L("*=");
|
|
682
|
+
var $L42 = $L("/=");
|
|
683
|
+
var $L43 = $L("%=");
|
|
684
|
+
var $L44 = $L("+=");
|
|
685
|
+
var $L45 = $L("-=");
|
|
686
|
+
var $L46 = $L("<<=");
|
|
687
|
+
var $L47 = $L(">>>=");
|
|
688
|
+
var $L48 = $L(">>=");
|
|
689
|
+
var $L49 = $L("&&=");
|
|
690
|
+
var $L50 = $L("&=");
|
|
691
|
+
var $L51 = $L("^=");
|
|
692
|
+
var $L52 = $L("||=");
|
|
693
|
+
var $L53 = $L("|=");
|
|
694
|
+
var $L54 = $L("??=");
|
|
695
|
+
var $L55 = $L("=");
|
|
696
|
+
var $L56 = $L("**");
|
|
697
|
+
var $L57 = $L("/");
|
|
698
|
+
var $L58 = $L("%");
|
|
699
|
+
var $L59 = $L("+");
|
|
700
|
+
var $L60 = $L("-");
|
|
701
|
+
var $L61 = $L("<=");
|
|
702
|
+
var $L62 = $L(">=");
|
|
703
|
+
var $L63 = $L("<<");
|
|
704
|
+
var $L64 = $L(">>>");
|
|
705
|
+
var $L65 = $L(">>");
|
|
706
|
+
var $L66 = $L(">");
|
|
707
|
+
var $L67 = $L("!==");
|
|
708
|
+
var $L68 = $L("!=");
|
|
709
|
+
var $L69 = $L("is");
|
|
710
|
+
var $L70 = $L("===");
|
|
711
|
+
var $L71 = $L("==");
|
|
712
|
+
var $L72 = $L("and");
|
|
713
|
+
var $L73 = $L("&&");
|
|
714
|
+
var $L74 = $L("or");
|
|
715
|
+
var $L75 = $L("||");
|
|
716
|
+
var $L76 = $L("??");
|
|
717
|
+
var $L77 = $L("instanceof");
|
|
718
|
+
var $L78 = $L("in");
|
|
719
|
+
var $L79 = $L("&");
|
|
720
|
+
var $L80 = $L("^");
|
|
721
|
+
var $L81 = $L("|");
|
|
722
|
+
var $L82 = $L("delete");
|
|
723
|
+
var $L83 = $L("void");
|
|
724
|
+
var $L84 = $L("typeof");
|
|
725
|
+
var $L85 = $L(";");
|
|
726
|
+
var $L86 = $L("if");
|
|
727
|
+
var $L87 = $L("else");
|
|
728
|
+
var $L88 = $L("unless");
|
|
729
|
+
var $L89 = $L("loop");
|
|
730
|
+
var $L90 = $L("do");
|
|
731
|
+
var $L91 = $L("while");
|
|
732
|
+
var $L92 = $L("for");
|
|
733
|
+
var $L93 = $L("var");
|
|
734
|
+
var $L94 = $L("await");
|
|
735
|
+
var $L95 = $L("of");
|
|
736
|
+
var $L96 = $L("let");
|
|
737
|
+
var $L97 = $L("const");
|
|
738
|
+
var $L98 = $L("switch");
|
|
739
|
+
var $L99 = $L("case");
|
|
740
|
+
var $L100 = $L("default");
|
|
741
|
+
var $L101 = $L("when");
|
|
742
|
+
var $L102 = $L("try");
|
|
743
|
+
var $L103 = $L("catch");
|
|
744
|
+
var $L104 = $L("finally");
|
|
745
|
+
var $L105 = $L("break");
|
|
746
|
+
var $L106 = $L("continue");
|
|
747
|
+
var $L107 = $L("debugger");
|
|
748
|
+
var $L108 = $L("return");
|
|
749
|
+
var $L109 = $L("throw");
|
|
750
|
+
var $L110 = $L("import type");
|
|
750
751
|
var $L111 = $L("from");
|
|
751
752
|
var $L112 = $L("export");
|
|
752
753
|
var $L113 = $L(":=");
|
|
@@ -763,40 +764,42 @@ var require_parser = __commonJS({
|
|
|
763
764
|
var $L124 = $L("</");
|
|
764
765
|
var $L125 = $L("<>");
|
|
765
766
|
var $L126 = $L("</>");
|
|
766
|
-
var $L127 = $L("
|
|
767
|
-
var $L128 = $L("
|
|
768
|
-
var $L129 = $L("
|
|
769
|
-
var $L130 = $L("
|
|
770
|
-
var $
|
|
771
|
-
var $
|
|
772
|
-
var $
|
|
773
|
-
var $
|
|
774
|
-
var $
|
|
775
|
-
var $
|
|
776
|
-
var $
|
|
777
|
-
var $
|
|
778
|
-
var $
|
|
779
|
-
var $
|
|
780
|
-
var $
|
|
781
|
-
var $
|
|
782
|
-
var $
|
|
783
|
-
var $
|
|
784
|
-
var $
|
|
785
|
-
var $
|
|
786
|
-
var $
|
|
787
|
-
var $
|
|
788
|
-
var $
|
|
789
|
-
var $
|
|
790
|
-
var $
|
|
791
|
-
var $
|
|
792
|
-
var $
|
|
793
|
-
var $
|
|
794
|
-
var $
|
|
795
|
-
var $
|
|
796
|
-
var $
|
|
797
|
-
var $
|
|
798
|
-
var $
|
|
799
|
-
var $
|
|
767
|
+
var $L127 = $L("asserts");
|
|
768
|
+
var $L128 = $L("keyof");
|
|
769
|
+
var $L129 = $L("infer");
|
|
770
|
+
var $L130 = $L("[]");
|
|
771
|
+
var $L131 = $L(" ");
|
|
772
|
+
var $L132 = $L(" ");
|
|
773
|
+
var $R0 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
774
|
+
var $R1 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
775
|
+
var $R2 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
776
|
+
var $R3 = $R(new RegExp("\\p{ID_Continue}", "suy"));
|
|
777
|
+
var $R4 = $R(new RegExp("[!~+-]", "suy"));
|
|
778
|
+
var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
779
|
+
var $R6 = $R(new RegExp("\\d+(?:\\.\\d*)?", "suy"));
|
|
780
|
+
var $R7 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
|
|
781
|
+
var $R8 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
|
|
782
|
+
var $R9 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
|
|
783
|
+
var $R10 = $R(new RegExp('[^"\\\\]+', "suy"));
|
|
784
|
+
var $R11 = $R(new RegExp("[^'\\\\]+", "suy"));
|
|
785
|
+
var $R12 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
|
|
786
|
+
var $R13 = $R(new RegExp(".", "suy"));
|
|
787
|
+
var $R14 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
|
|
788
|
+
var $R15 = $R(new RegExp("[^\\/\\r\\n]+", "suy"));
|
|
789
|
+
var $R16 = $R(new RegExp("(:?\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
790
|
+
var $R17 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
791
|
+
var $R18 = $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"));
|
|
792
|
+
var $R19 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
793
|
+
var $R20 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
794
|
+
var $R21 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
795
|
+
var $R22 = $R(new RegExp("[\\t ]+", "suy"));
|
|
796
|
+
var $R23 = $R(new RegExp("[\\s]+", "suy"));
|
|
797
|
+
var $R24 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
798
|
+
var $R25 = $R(new RegExp('"[^"]*"', "suy"));
|
|
799
|
+
var $R26 = $R(new RegExp("'[^']*'", "suy"));
|
|
800
|
+
var $R27 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
801
|
+
var $R28 = $R(new RegExp("type(?!\\p{ID_Continue})", "suy"));
|
|
802
|
+
var $R29 = $R(new RegExp("interface(?!\\p{ID_Continue})", "suy"));
|
|
800
803
|
var $R30 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
801
804
|
var $R31 = $R(new RegExp("[\\t ]*", "suy"));
|
|
802
805
|
var $R32 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
@@ -899,10 +902,10 @@ var require_parser = __commonJS({
|
|
|
899
902
|
var pre = $1;
|
|
900
903
|
var exp = $2;
|
|
901
904
|
var post = $3;
|
|
902
|
-
if (post) {
|
|
905
|
+
if (post === "?") {
|
|
903
906
|
return ["(", pre, , "(", exp, ") != null)"];
|
|
904
907
|
}
|
|
905
|
-
return [pre, exp];
|
|
908
|
+
return [pre, exp, post];
|
|
906
909
|
});
|
|
907
910
|
function UnaryExpression(state) {
|
|
908
911
|
if (state.verbose)
|
|
@@ -914,17 +917,16 @@ var require_parser = __commonJS({
|
|
|
914
917
|
}
|
|
915
918
|
}
|
|
916
919
|
var UnaryPostfix$0 = $EXPECT($L3, fail, 'UnaryPostfix "?"');
|
|
920
|
+
var UnaryPostfix$1 = $S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), $R$0($EXPECT($R0, fail, "UnaryPostfix /(?!\\p{ID_Continue})/")), Type);
|
|
917
921
|
function UnaryPostfix(state) {
|
|
918
|
-
if (state.verbose)
|
|
919
|
-
console.log("ENTER:", "UnaryPostfix");
|
|
920
922
|
if (state.tokenize) {
|
|
921
|
-
return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state));
|
|
923
|
+
return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state));
|
|
922
924
|
} else {
|
|
923
|
-
return UnaryPostfix$0(state);
|
|
925
|
+
return UnaryPostfix$0(state) || UnaryPostfix$1(state);
|
|
924
926
|
}
|
|
925
927
|
}
|
|
926
|
-
var UpdateExpression$0 = $S($C($EXPECT($
|
|
927
|
-
var UpdateExpression$1 = $S(LeftHandSideExpression, $E($C($EXPECT($
|
|
928
|
+
var UpdateExpression$0 = $S($C($EXPECT($L5, fail, 'UpdateExpression "++"'), $EXPECT($L6, fail, 'UpdateExpression "--"')), UnaryExpression);
|
|
929
|
+
var UpdateExpression$1 = $S(LeftHandSideExpression, $E($C($EXPECT($L5, fail, 'UpdateExpression "++"'), $EXPECT($L6, fail, 'UpdateExpression "--"'))));
|
|
928
930
|
function UpdateExpression(state) {
|
|
929
931
|
if (state.tokenize) {
|
|
930
932
|
return $TOKEN("UpdateExpression", state, UpdateExpression$0(state) || UpdateExpression$1(state));
|
|
@@ -942,7 +944,7 @@ var require_parser = __commonJS({
|
|
|
942
944
|
}
|
|
943
945
|
}
|
|
944
946
|
var AssignmentExpressionRest$0 = YieldExpression;
|
|
945
|
-
var AssignmentExpressionRest$1 = $S($E($S($EXPECT($
|
|
947
|
+
var AssignmentExpressionRest$1 = $S($E($S($EXPECT($L7, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
|
|
946
948
|
var AssignmentExpressionRest$2 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), $C($S($Q(_), Expression), $S(__, Expression)));
|
|
947
949
|
var AssignmentExpressionRest$3 = ConditionalExpression;
|
|
948
950
|
function AssignmentExpressionRest(state) {
|
|
@@ -952,7 +954,7 @@ var require_parser = __commonJS({
|
|
|
952
954
|
return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state);
|
|
953
955
|
}
|
|
954
956
|
}
|
|
955
|
-
var YieldExpression$0 = $S($EXPECT($
|
|
957
|
+
var YieldExpression$0 = $S($EXPECT($L8, fail, 'YieldExpression "yield"'), $E($S($Q(TrailingComment), $EXPECT($L9, fail, 'YieldExpression "*"'))), AssignmentExpression);
|
|
956
958
|
function YieldExpression(state) {
|
|
957
959
|
if (state.verbose)
|
|
958
960
|
console.log("ENTER:", "YieldExpression");
|
|
@@ -963,7 +965,7 @@ var require_parser = __commonJS({
|
|
|
963
965
|
}
|
|
964
966
|
}
|
|
965
967
|
var ArrowFunction$0 = ThinArrowFunction;
|
|
966
|
-
var ArrowFunction$1 = $S($C(BindingIdentifier, Parameters), __, $EXPECT($
|
|
968
|
+
var ArrowFunction$1 = $S($C(BindingIdentifier, Parameters), __, $EXPECT($L10, fail, 'ArrowFunction "=>"'), ConciseBody);
|
|
967
969
|
function ArrowFunction(state) {
|
|
968
970
|
if (state.tokenize) {
|
|
969
971
|
return $TOKEN("ArrowFunction", state, ArrowFunction$0(state) || ArrowFunction$1(state));
|
|
@@ -971,7 +973,7 @@ var require_parser = __commonJS({
|
|
|
971
973
|
return ArrowFunction$0(state) || ArrowFunction$1(state);
|
|
972
974
|
}
|
|
973
975
|
}
|
|
974
|
-
var ConciseBody$0 = $S($N($S($Q(_), $EXPECT($
|
|
976
|
+
var ConciseBody$0 = $S($N($S($Q(_), $EXPECT($L11, fail, 'ConciseBody "{"'))), AssignmentExpression);
|
|
975
977
|
var ConciseBody$1 = $S(EOS, SingleNestedBlockExpression);
|
|
976
978
|
var ConciseBody$2 = BracedBlock;
|
|
977
979
|
function ConciseBody(state) {
|
|
@@ -981,7 +983,7 @@ var require_parser = __commonJS({
|
|
|
981
983
|
return ConciseBody$0(state) || ConciseBody$1(state) || ConciseBody$2(state);
|
|
982
984
|
}
|
|
983
985
|
}
|
|
984
|
-
var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($
|
|
986
|
+
var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L12, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
|
|
985
987
|
function ConditionalExpression(state) {
|
|
986
988
|
if (state.verbose)
|
|
987
989
|
console.log("ENTER:", "ConditionalExpression");
|
|
@@ -1030,7 +1032,7 @@ var require_parser = __commonJS({
|
|
|
1030
1032
|
return ClassDeclaration$0(state);
|
|
1031
1033
|
}
|
|
1032
1034
|
}
|
|
1033
|
-
var ClassExpression$0 = $S($EXPECT($
|
|
1035
|
+
var ClassExpression$0 = $S($EXPECT($L13, fail, 'ClassExpression "class"'), $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
|
|
1034
1036
|
function ClassExpression(state) {
|
|
1035
1037
|
if (state.verbose)
|
|
1036
1038
|
console.log("ENTER:", "ClassExpression");
|
|
@@ -1050,10 +1052,10 @@ var require_parser = __commonJS({
|
|
|
1050
1052
|
return ClassHeritage$0(state);
|
|
1051
1053
|
}
|
|
1052
1054
|
}
|
|
1053
|
-
var ExtendsToken$0 = $T($EXPECT($
|
|
1055
|
+
var ExtendsToken$0 = $T($EXPECT($L14, fail, 'ExtendsToken "<"'), function(value) {
|
|
1054
1056
|
return "extends";
|
|
1055
1057
|
});
|
|
1056
|
-
var ExtendsToken$1 = $EXPECT($
|
|
1058
|
+
var ExtendsToken$1 = $EXPECT($L15, fail, 'ExtendsToken "extends"');
|
|
1057
1059
|
function ExtendsToken(state) {
|
|
1058
1060
|
if (state.tokenize) {
|
|
1059
1061
|
return $TOKEN("ExtendsToken", state, ExtendsToken$0(state) || ExtendsToken$1(state));
|
|
@@ -1061,7 +1063,7 @@ var require_parser = __commonJS({
|
|
|
1061
1063
|
return ExtendsToken$0(state) || ExtendsToken$1(state);
|
|
1062
1064
|
}
|
|
1063
1065
|
}
|
|
1064
|
-
var ClassBody$0 = $S(__, $EXPECT($
|
|
1066
|
+
var ClassBody$0 = $S(__, $EXPECT($L11, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L16, fail, 'ClassBody "}"'));
|
|
1065
1067
|
var ClassBody$1 = $S(InsertOpenBrace, EOS, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1066
1068
|
function ClassBody(state) {
|
|
1067
1069
|
if (state.tokenize) {
|
|
@@ -1095,8 +1097,8 @@ var require_parser = __commonJS({
|
|
|
1095
1097
|
return NestedClassElement$0(state);
|
|
1096
1098
|
}
|
|
1097
1099
|
}
|
|
1098
|
-
var ClassElement$0 = $S($EXPECT($
|
|
1099
|
-
var ClassElement$1 = $S($E($S($EXPECT($
|
|
1100
|
+
var ClassElement$0 = $S($EXPECT($L17, fail, 'ClassElement "static"'), BracedBlock);
|
|
1101
|
+
var ClassElement$1 = $S($E($S($EXPECT($L17, fail, 'ClassElement "static"'), __)), $C(MethodDefinition, FieldDefinition));
|
|
1100
1102
|
function ClassElement(state) {
|
|
1101
1103
|
if (state.tokenize) {
|
|
1102
1104
|
return $TOKEN("ClassElement", state, ClassElement$0(state) || ClassElement$1(state));
|
|
@@ -1114,12 +1116,12 @@ var require_parser = __commonJS({
|
|
|
1114
1116
|
return FieldDefinition$0(state);
|
|
1115
1117
|
}
|
|
1116
1118
|
}
|
|
1117
|
-
var This$0 = $EXPECT($
|
|
1118
|
-
var This$1 = $T($S($EXPECT($
|
|
1119
|
+
var This$0 = $EXPECT($L18, fail, 'This "this"');
|
|
1120
|
+
var This$1 = $T($S($EXPECT($L19, fail, 'This "@"'), $S($E($EXPECT($L20, fail, 'This "#"')), IdentifierName)), function(value) {
|
|
1119
1121
|
var ref = value[1];
|
|
1120
1122
|
return ["this.", ref];
|
|
1121
1123
|
});
|
|
1122
|
-
var This$2 = $T($EXPECT($
|
|
1124
|
+
var This$2 = $T($EXPECT($L19, fail, 'This "@"'), function(value) {
|
|
1123
1125
|
return "this";
|
|
1124
1126
|
});
|
|
1125
1127
|
function This(state) {
|
|
@@ -1138,7 +1140,7 @@ var require_parser = __commonJS({
|
|
|
1138
1140
|
return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
|
|
1139
1141
|
}
|
|
1140
1142
|
}
|
|
1141
|
-
var NewExpression$0 = $S($P($S($EXPECT($
|
|
1143
|
+
var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)), MemberExpression);
|
|
1142
1144
|
function NewExpression(state) {
|
|
1143
1145
|
if (state.verbose)
|
|
1144
1146
|
console.log("ENTER:", "NewExpression");
|
|
@@ -1148,8 +1150,8 @@ var require_parser = __commonJS({
|
|
|
1148
1150
|
return NewExpression$0(state);
|
|
1149
1151
|
}
|
|
1150
1152
|
}
|
|
1151
|
-
var CallExpression$0 = $S($EXPECT($
|
|
1152
|
-
var CallExpression$1 = $S($EXPECT($
|
|
1153
|
+
var CallExpression$0 = $S($EXPECT($L22, fail, 'CallExpression "super"'), __, Arguments);
|
|
1154
|
+
var CallExpression$1 = $S($EXPECT($L23, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
|
|
1153
1155
|
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest), $E(SpacedApplication));
|
|
1154
1156
|
function CallExpression(state) {
|
|
1155
1157
|
if (state.tokenize) {
|
|
@@ -1159,8 +1161,8 @@ var require_parser = __commonJS({
|
|
|
1159
1161
|
}
|
|
1160
1162
|
}
|
|
1161
1163
|
var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
|
|
1162
|
-
var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($
|
|
1163
|
-
var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($
|
|
1164
|
+
var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($L24, fail, 'CallExpressionRest "["'), __, Expression, __, $EXPECT($L25, fail, 'CallExpressionRest "]"'));
|
|
1165
|
+
var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($L26, fail, 'CallExpressionRest "."'), $C(IdentifierName, PrivateIdentifier));
|
|
1164
1166
|
var CallExpressionRest$3 = TemplateLiteral;
|
|
1165
1167
|
function CallExpressionRest(state) {
|
|
1166
1168
|
if (state.tokenize) {
|
|
@@ -1169,7 +1171,7 @@ var require_parser = __commonJS({
|
|
|
1169
1171
|
return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
|
|
1170
1172
|
}
|
|
1171
1173
|
}
|
|
1172
|
-
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($
|
|
1174
|
+
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L26, fail, 'OptionalShorthand "."'), InsertDot));
|
|
1173
1175
|
function OptionalShorthand(state) {
|
|
1174
1176
|
if (state.verbose)
|
|
1175
1177
|
console.log("ENTER:", "OptionalShorthand");
|
|
@@ -1203,7 +1205,7 @@ var require_parser = __commonJS({
|
|
|
1203
1205
|
return ApplicationStart$0(state);
|
|
1204
1206
|
}
|
|
1205
1207
|
}
|
|
1206
|
-
var AdditionalReservedWords$0 = $R$0($EXPECT($
|
|
1208
|
+
var AdditionalReservedWords$0 = $R$0($EXPECT($R1, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue})/"));
|
|
1207
1209
|
function AdditionalReservedWords(state) {
|
|
1208
1210
|
if (state.verbose)
|
|
1209
1211
|
console.log("ENTER:", "AdditionalReservedWords");
|
|
@@ -1223,7 +1225,7 @@ var require_parser = __commonJS({
|
|
|
1223
1225
|
return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
|
|
1224
1226
|
}
|
|
1225
1227
|
}
|
|
1226
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
1228
|
+
var SuperProperty$0 = $S($EXPECT($L27, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L25, fail, 'SuperProperty "]"'));
|
|
1227
1229
|
function SuperProperty(state) {
|
|
1228
1230
|
if (state.verbose)
|
|
1229
1231
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1233,8 +1235,8 @@ var require_parser = __commonJS({
|
|
|
1233
1235
|
return SuperProperty$0(state);
|
|
1234
1236
|
}
|
|
1235
1237
|
}
|
|
1236
|
-
var MetaProperty$0 = $EXPECT($
|
|
1237
|
-
var MetaProperty$1 = $EXPECT($
|
|
1238
|
+
var MetaProperty$0 = $EXPECT($L28, fail, 'MetaProperty "new.target"');
|
|
1239
|
+
var MetaProperty$1 = $EXPECT($L29, fail, 'MetaProperty "import.meta"');
|
|
1238
1240
|
function MetaProperty(state) {
|
|
1239
1241
|
if (state.tokenize) {
|
|
1240
1242
|
return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
|
|
@@ -1243,7 +1245,7 @@ var require_parser = __commonJS({
|
|
|
1243
1245
|
}
|
|
1244
1246
|
}
|
|
1245
1247
|
var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
|
|
1246
|
-
var Parameters$1 = $T($EXPECT($
|
|
1248
|
+
var Parameters$1 = $T($EXPECT($L30, fail, 'Parameters ""'), function(value) {
|
|
1247
1249
|
return "()";
|
|
1248
1250
|
});
|
|
1249
1251
|
function Parameters(state) {
|
|
@@ -1297,7 +1299,7 @@ var require_parser = __commonJS({
|
|
|
1297
1299
|
return BindingPattern$0(state) || BindingPattern$1(state);
|
|
1298
1300
|
}
|
|
1299
1301
|
}
|
|
1300
|
-
var ObjectBindingPattern$0 = $S($EXPECT($
|
|
1302
|
+
var ObjectBindingPattern$0 = $S($EXPECT($L11, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L16, fail, 'ObjectBindingPattern "}"'));
|
|
1301
1303
|
function ObjectBindingPattern(state) {
|
|
1302
1304
|
if (state.verbose)
|
|
1303
1305
|
console.log("ENTER:", "ObjectBindingPattern");
|
|
@@ -1307,7 +1309,7 @@ var require_parser = __commonJS({
|
|
|
1307
1309
|
return ObjectBindingPattern$0(state);
|
|
1308
1310
|
}
|
|
1309
1311
|
}
|
|
1310
|
-
var ArrayBindingPattern$0 = $S($EXPECT($
|
|
1312
|
+
var ArrayBindingPattern$0 = $S($EXPECT($L24, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L25, fail, 'ArrayBindingPattern "]"'));
|
|
1311
1313
|
function ArrayBindingPattern(state) {
|
|
1312
1314
|
if (state.verbose)
|
|
1313
1315
|
console.log("ENTER:", "ArrayBindingPattern");
|
|
@@ -1317,7 +1319,7 @@ var require_parser = __commonJS({
|
|
|
1317
1319
|
return ArrayBindingPattern$0(state);
|
|
1318
1320
|
}
|
|
1319
1321
|
}
|
|
1320
|
-
var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($
|
|
1322
|
+
var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L12, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
|
|
1321
1323
|
var BindingProperty$1 = $S(__, BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
|
|
1322
1324
|
function BindingProperty(state) {
|
|
1323
1325
|
if (state.tokenize) {
|
|
@@ -1326,7 +1328,7 @@ var require_parser = __commonJS({
|
|
|
1326
1328
|
return BindingProperty$0(state) || BindingProperty$1(state);
|
|
1327
1329
|
}
|
|
1328
1330
|
}
|
|
1329
|
-
var BindingRestProperty$0 = $S($EXPECT($
|
|
1331
|
+
var BindingRestProperty$0 = $S($EXPECT($L31, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
|
|
1330
1332
|
function BindingRestProperty(state) {
|
|
1331
1333
|
if (state.verbose)
|
|
1332
1334
|
console.log("ENTER:", "BindingRestProperty");
|
|
@@ -1346,7 +1348,7 @@ var require_parser = __commonJS({
|
|
|
1346
1348
|
return BindingElement$0(state);
|
|
1347
1349
|
}
|
|
1348
1350
|
}
|
|
1349
|
-
var BindingRestElement$0 = $S($EXPECT($
|
|
1351
|
+
var BindingRestElement$0 = $S($EXPECT($L31, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
|
|
1350
1352
|
function BindingRestElement(state) {
|
|
1351
1353
|
if (state.verbose)
|
|
1352
1354
|
console.log("ENTER:", "BindingRestElement");
|
|
@@ -1367,7 +1369,7 @@ var require_parser = __commonJS({
|
|
|
1367
1369
|
}
|
|
1368
1370
|
}
|
|
1369
1371
|
var FunctionExpression$0 = ThinArrowFunction;
|
|
1370
|
-
var FunctionExpression$1 = $S($EXPECT($
|
|
1372
|
+
var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L32, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L9, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
|
|
1371
1373
|
function FunctionExpression(state) {
|
|
1372
1374
|
if (state.tokenize) {
|
|
1373
1375
|
return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
|
|
@@ -1375,7 +1377,7 @@ var require_parser = __commonJS({
|
|
|
1375
1377
|
return FunctionExpression$0(state) || FunctionExpression$1(state);
|
|
1376
1378
|
}
|
|
1377
1379
|
}
|
|
1378
|
-
var ThinArrowFunction$0 = $T($S(Parameters, $E(
|
|
1380
|
+
var ThinArrowFunction$0 = $T($S(Parameters, $E(ReturnTypeSuffix), __, $EXPECT($L33, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
|
|
1379
1381
|
var params = value[0];
|
|
1380
1382
|
var suffix = value[1];
|
|
1381
1383
|
var block = value[4];
|
|
@@ -1390,7 +1392,7 @@ var require_parser = __commonJS({
|
|
|
1390
1392
|
return ThinArrowFunction$0(state);
|
|
1391
1393
|
}
|
|
1392
1394
|
}
|
|
1393
|
-
var Block$0 = $S(__, $EXPECT($
|
|
1395
|
+
var Block$0 = $S(__, $EXPECT($L11, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'Block "}"'));
|
|
1394
1396
|
var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1395
1397
|
var Block$2 = Statement;
|
|
1396
1398
|
var Block$3 = $S(__, Statement);
|
|
@@ -1401,7 +1403,7 @@ var require_parser = __commonJS({
|
|
|
1401
1403
|
return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
|
|
1402
1404
|
}
|
|
1403
1405
|
}
|
|
1404
|
-
var BracedBlock$0 = $S(__, $EXPECT($
|
|
1406
|
+
var BracedBlock$0 = $S(__, $EXPECT($L11, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BracedBlock "}"'));
|
|
1405
1407
|
var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1406
1408
|
var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
|
|
1407
1409
|
function BracedBlock(state) {
|
|
@@ -1453,10 +1455,10 @@ var require_parser = __commonJS({
|
|
|
1453
1455
|
}
|
|
1454
1456
|
var Literal$0 = StringLiteral;
|
|
1455
1457
|
var Literal$1 = NumericLiteral;
|
|
1456
|
-
var Literal$2 = $EXPECT($
|
|
1457
|
-
var Literal$3 = $EXPECT($
|
|
1458
|
-
var Literal$4 = $EXPECT($
|
|
1459
|
-
var Literal$5 = $EXPECT($
|
|
1458
|
+
var Literal$2 = $EXPECT($L34, fail, 'Literal "true"');
|
|
1459
|
+
var Literal$3 = $EXPECT($L35, fail, 'Literal "false"');
|
|
1460
|
+
var Literal$4 = $EXPECT($L36, fail, 'Literal "null"');
|
|
1461
|
+
var Literal$5 = $EXPECT($L37, fail, 'Literal "undefined"');
|
|
1460
1462
|
function Literal(state) {
|
|
1461
1463
|
if (state.tokenize) {
|
|
1462
1464
|
return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state) || Literal$4(state) || Literal$5(state));
|
|
@@ -1484,7 +1486,7 @@ var require_parser = __commonJS({
|
|
|
1484
1486
|
return Identifier$0(state);
|
|
1485
1487
|
}
|
|
1486
1488
|
}
|
|
1487
|
-
var IdentifierName$0 = $R$0($EXPECT($
|
|
1489
|
+
var IdentifierName$0 = $R$0($EXPECT($R2, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
1488
1490
|
function IdentifierName(state) {
|
|
1489
1491
|
if (state.verbose)
|
|
1490
1492
|
console.log("ENTER:", "IdentifierName");
|
|
@@ -1504,8 +1506,8 @@ var require_parser = __commonJS({
|
|
|
1504
1506
|
return IdentifierReference$0(state);
|
|
1505
1507
|
}
|
|
1506
1508
|
}
|
|
1507
|
-
var ArrayLiteral$0 = $S($EXPECT($
|
|
1508
|
-
var ArrayLiteral$1 = $S($EXPECT($
|
|
1509
|
+
var ArrayLiteral$0 = $S($EXPECT($L24, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L25, fail, 'ArrayLiteral "]"'));
|
|
1510
|
+
var ArrayLiteral$1 = $S($EXPECT($L24, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L25, fail, 'ArrayLiteral "]"'));
|
|
1509
1511
|
function ArrayLiteral(state) {
|
|
1510
1512
|
if (state.tokenize) {
|
|
1511
1513
|
return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
|
|
@@ -1539,8 +1541,8 @@ var require_parser = __commonJS({
|
|
|
1539
1541
|
}
|
|
1540
1542
|
}
|
|
1541
1543
|
var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
|
|
1542
|
-
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1543
|
-
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
1544
|
+
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
|
|
1545
|
+
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"'))), function(value) {
|
|
1544
1546
|
return ",";
|
|
1545
1547
|
});
|
|
1546
1548
|
var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1563,7 +1565,7 @@ var require_parser = __commonJS({
|
|
|
1563
1565
|
return ElementList$0(state);
|
|
1564
1566
|
}
|
|
1565
1567
|
}
|
|
1566
|
-
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($
|
|
1568
|
+
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L31, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
|
|
1567
1569
|
function ArrayElementExpression(state) {
|
|
1568
1570
|
if (state.verbose)
|
|
1569
1571
|
console.log("ENTER:", "ArrayElementExpression");
|
|
@@ -1583,9 +1585,9 @@ var require_parser = __commonJS({
|
|
|
1583
1585
|
return Elision$0(state);
|
|
1584
1586
|
}
|
|
1585
1587
|
}
|
|
1586
|
-
var ObjectLiteral$0 = $S($EXPECT($
|
|
1587
|
-
var ObjectLiteral$1 = $S($EXPECT($
|
|
1588
|
-
var ObjectLiteral$2 = $S($EXPECT($
|
|
1588
|
+
var ObjectLiteral$0 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L16, fail, 'ObjectLiteral "}"'));
|
|
1589
|
+
var ObjectLiteral$1 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L16, fail, 'ObjectLiteral "}"'));
|
|
1590
|
+
var ObjectLiteral$2 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), __, $EXPECT($L16, fail, 'ObjectLiteral "}"'));
|
|
1589
1591
|
var ObjectLiteral$3 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1590
1592
|
function ObjectLiteral(state) {
|
|
1591
1593
|
if (state.tokenize) {
|
|
@@ -1620,8 +1622,8 @@ var require_parser = __commonJS({
|
|
|
1620
1622
|
}
|
|
1621
1623
|
}
|
|
1622
1624
|
var ObjectPropertyDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ObjectPropertyDelimiter ","'));
|
|
1623
|
-
var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1624
|
-
var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
1625
|
+
var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'ObjectPropertyDelimiter "}"')));
|
|
1626
|
+
var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
|
|
1625
1627
|
return ",";
|
|
1626
1628
|
});
|
|
1627
1629
|
var ObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1644,9 +1646,9 @@ var require_parser = __commonJS({
|
|
|
1644
1646
|
return PropertyDefinitionList$0(state);
|
|
1645
1647
|
}
|
|
1646
1648
|
}
|
|
1647
|
-
var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($
|
|
1649
|
+
var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L12, fail, 'PropertyDefinition ":"'), AssignmentExpression);
|
|
1648
1650
|
var PropertyDefinition$1 = MethodDefinition;
|
|
1649
|
-
var PropertyDefinition$2 = $S($EXPECT($
|
|
1651
|
+
var PropertyDefinition$2 = $S($EXPECT($L31, fail, 'PropertyDefinition "..."'), AssignmentExpression);
|
|
1650
1652
|
var PropertyDefinition$3 = IdentifierReference;
|
|
1651
1653
|
function PropertyDefinition(state) {
|
|
1652
1654
|
if (state.tokenize) {
|
|
@@ -1658,7 +1660,7 @@ var require_parser = __commonJS({
|
|
|
1658
1660
|
var PropertyName$0 = NumericLiteral;
|
|
1659
1661
|
var PropertyName$1 = StringLiteral;
|
|
1660
1662
|
var PropertyName$2 = IdentifierName;
|
|
1661
|
-
var PropertyName$3 = $S($EXPECT($
|
|
1663
|
+
var PropertyName$3 = $S($EXPECT($L24, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L25, fail, 'PropertyName "]"'));
|
|
1662
1664
|
function PropertyName(state) {
|
|
1663
1665
|
if (state.tokenize) {
|
|
1664
1666
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -1666,8 +1668,8 @@ var require_parser = __commonJS({
|
|
|
1666
1668
|
return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
|
|
1667
1669
|
}
|
|
1668
1670
|
}
|
|
1669
|
-
var MethodDefinition$0 = $S($EXPECT($
|
|
1670
|
-
var MethodDefinition$1 = $S($EXPECT($
|
|
1671
|
+
var MethodDefinition$0 = $S($EXPECT($L38, fail, 'MethodDefinition "get"'), $N($R$0($EXPECT($R3, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1672
|
+
var MethodDefinition$1 = $S($EXPECT($L39, fail, 'MethodDefinition "set"'), $N($R$0($EXPECT($R3, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1671
1673
|
var MethodDefinition$2 = AsyncGeneratorMethod;
|
|
1672
1674
|
var MethodDefinition$3 = AsyncMethod;
|
|
1673
1675
|
var MethodDefinition$4 = GeneratorMethod;
|
|
@@ -1688,7 +1690,7 @@ var require_parser = __commonJS({
|
|
|
1688
1690
|
return ClassElementName$0(state) || ClassElementName$1(state);
|
|
1689
1691
|
}
|
|
1690
1692
|
}
|
|
1691
|
-
var PrivateIdentifier$0 = $S($EXPECT($
|
|
1693
|
+
var PrivateIdentifier$0 = $S($EXPECT($L20, fail, 'PrivateIdentifier "#"'), IdentifierName);
|
|
1692
1694
|
function PrivateIdentifier(state) {
|
|
1693
1695
|
if (state.verbose)
|
|
1694
1696
|
console.log("ENTER:", "PrivateIdentifier");
|
|
@@ -1698,27 +1700,7 @@ var require_parser = __commonJS({
|
|
|
1698
1700
|
return PrivateIdentifier$0(state);
|
|
1699
1701
|
}
|
|
1700
1702
|
}
|
|
1701
|
-
var
|
|
1702
|
-
function GeneratorDeclaration(state) {
|
|
1703
|
-
if (state.verbose)
|
|
1704
|
-
console.log("ENTER:", "GeneratorDeclaration");
|
|
1705
|
-
if (state.tokenize) {
|
|
1706
|
-
return $TOKEN("GeneratorDeclaration", state, GeneratorDeclaration$0(state));
|
|
1707
|
-
} else {
|
|
1708
|
-
return GeneratorDeclaration$0(state);
|
|
1709
|
-
}
|
|
1710
|
-
}
|
|
1711
|
-
var GeneratorExpression$0 = $S($EXPECT($L31, fail, 'GeneratorExpression "function"'), __, $EXPECT($L8, fail, 'GeneratorExpression "*"'), $E($S(__, BindingIdentifier)), Parameters, GeneratorBody);
|
|
1712
|
-
function GeneratorExpression(state) {
|
|
1713
|
-
if (state.verbose)
|
|
1714
|
-
console.log("ENTER:", "GeneratorExpression");
|
|
1715
|
-
if (state.tokenize) {
|
|
1716
|
-
return $TOKEN("GeneratorExpression", state, GeneratorExpression$0(state));
|
|
1717
|
-
} else {
|
|
1718
|
-
return GeneratorExpression$0(state);
|
|
1719
|
-
}
|
|
1720
|
-
}
|
|
1721
|
-
var GeneratorMethod$0 = $S($EXPECT($L8, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
|
|
1703
|
+
var GeneratorMethod$0 = $S($EXPECT($L9, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
|
|
1722
1704
|
function GeneratorMethod(state) {
|
|
1723
1705
|
if (state.verbose)
|
|
1724
1706
|
console.log("ENTER:", "GeneratorMethod");
|
|
@@ -1738,27 +1720,7 @@ var require_parser = __commonJS({
|
|
|
1738
1720
|
return GeneratorBody$0(state);
|
|
1739
1721
|
}
|
|
1740
1722
|
}
|
|
1741
|
-
var
|
|
1742
|
-
function AsyncFunctionDeclaration(state) {
|
|
1743
|
-
if (state.verbose)
|
|
1744
|
-
console.log("ENTER:", "AsyncFunctionDeclaration");
|
|
1745
|
-
if (state.tokenize) {
|
|
1746
|
-
return $TOKEN("AsyncFunctionDeclaration", state, AsyncFunctionDeclaration$0(state));
|
|
1747
|
-
} else {
|
|
1748
|
-
return AsyncFunctionDeclaration$0(state);
|
|
1749
|
-
}
|
|
1750
|
-
}
|
|
1751
|
-
var AsyncFunctionExpression$0 = $S($EXPECT($L6, fail, 'AsyncFunctionExpression "async"'), $N(EOS), __, $EXPECT($L31, fail, 'AsyncFunctionExpression "function"'), $E($S(__, BindingIdentifier)), __, Parameters, AsyncFunctionBody);
|
|
1752
|
-
function AsyncFunctionExpression(state) {
|
|
1753
|
-
if (state.verbose)
|
|
1754
|
-
console.log("ENTER:", "AsyncFunctionExpression");
|
|
1755
|
-
if (state.tokenize) {
|
|
1756
|
-
return $TOKEN("AsyncFunctionExpression", state, AsyncFunctionExpression$0(state));
|
|
1757
|
-
} else {
|
|
1758
|
-
return AsyncFunctionExpression$0(state);
|
|
1759
|
-
}
|
|
1760
|
-
}
|
|
1761
|
-
var AsyncMethod$0 = $S($EXPECT($L6, fail, 'AsyncMethod "async"'), $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
|
|
1723
|
+
var AsyncMethod$0 = $S($EXPECT($L7, fail, 'AsyncMethod "async"'), $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
|
|
1762
1724
|
function AsyncMethod(state) {
|
|
1763
1725
|
if (state.verbose)
|
|
1764
1726
|
console.log("ENTER:", "AsyncMethod");
|
|
@@ -1778,27 +1740,7 @@ var require_parser = __commonJS({
|
|
|
1778
1740
|
return AsyncFunctionBody$0(state);
|
|
1779
1741
|
}
|
|
1780
1742
|
}
|
|
1781
|
-
var
|
|
1782
|
-
function AsyncGeneratorDeclaration(state) {
|
|
1783
|
-
if (state.verbose)
|
|
1784
|
-
console.log("ENTER:", "AsyncGeneratorDeclaration");
|
|
1785
|
-
if (state.tokenize) {
|
|
1786
|
-
return $TOKEN("AsyncGeneratorDeclaration", state, AsyncGeneratorDeclaration$0(state));
|
|
1787
|
-
} else {
|
|
1788
|
-
return AsyncGeneratorDeclaration$0(state);
|
|
1789
|
-
}
|
|
1790
|
-
}
|
|
1791
|
-
var AsyncGeneratorExpression$0 = $S($EXPECT($L6, fail, 'AsyncGeneratorExpression "async"'), $N(EOS), __, $EXPECT($L31, fail, 'AsyncGeneratorExpression "function"'), __, $EXPECT($L8, fail, 'AsyncGeneratorExpression "*"'), $E($S(__, BindingIdentifier)), __, Parameters, AsyncGeneratorBody);
|
|
1792
|
-
function AsyncGeneratorExpression(state) {
|
|
1793
|
-
if (state.verbose)
|
|
1794
|
-
console.log("ENTER:", "AsyncGeneratorExpression");
|
|
1795
|
-
if (state.tokenize) {
|
|
1796
|
-
return $TOKEN("AsyncGeneratorExpression", state, AsyncGeneratorExpression$0(state));
|
|
1797
|
-
} else {
|
|
1798
|
-
return AsyncGeneratorExpression$0(state);
|
|
1799
|
-
}
|
|
1800
|
-
}
|
|
1801
|
-
var AsyncGeneratorMethod$0 = $S($EXPECT($L6, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L8, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
|
|
1743
|
+
var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L9, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
|
|
1802
1744
|
function AsyncGeneratorMethod(state) {
|
|
1803
1745
|
if (state.verbose)
|
|
1804
1746
|
console.log("ENTER:", "AsyncGeneratorMethod");
|
|
@@ -1818,22 +1760,22 @@ var require_parser = __commonJS({
|
|
|
1818
1760
|
return AsyncGeneratorBody$0(state);
|
|
1819
1761
|
}
|
|
1820
1762
|
}
|
|
1821
|
-
var AssignmentOp$0 = $EXPECT($
|
|
1822
|
-
var AssignmentOp$1 = $EXPECT($
|
|
1823
|
-
var AssignmentOp$2 = $EXPECT($
|
|
1824
|
-
var AssignmentOp$3 = $EXPECT($
|
|
1825
|
-
var AssignmentOp$4 = $EXPECT($
|
|
1826
|
-
var AssignmentOp$5 = $EXPECT($
|
|
1827
|
-
var AssignmentOp$6 = $EXPECT($
|
|
1828
|
-
var AssignmentOp$7 = $EXPECT($
|
|
1829
|
-
var AssignmentOp$8 = $EXPECT($
|
|
1830
|
-
var AssignmentOp$9 = $EXPECT($
|
|
1831
|
-
var AssignmentOp$10 = $EXPECT($
|
|
1832
|
-
var AssignmentOp$11 = $EXPECT($
|
|
1833
|
-
var AssignmentOp$12 = $EXPECT($
|
|
1834
|
-
var AssignmentOp$13 = $EXPECT($
|
|
1835
|
-
var AssignmentOp$14 = $EXPECT($
|
|
1836
|
-
var AssignmentOp$15 = $EXPECT($
|
|
1763
|
+
var AssignmentOp$0 = $EXPECT($L40, fail, 'AssignmentOp "**="');
|
|
1764
|
+
var AssignmentOp$1 = $EXPECT($L41, fail, 'AssignmentOp "*="');
|
|
1765
|
+
var AssignmentOp$2 = $EXPECT($L42, fail, 'AssignmentOp "/="');
|
|
1766
|
+
var AssignmentOp$3 = $EXPECT($L43, fail, 'AssignmentOp "%="');
|
|
1767
|
+
var AssignmentOp$4 = $EXPECT($L44, fail, 'AssignmentOp "+="');
|
|
1768
|
+
var AssignmentOp$5 = $EXPECT($L45, fail, 'AssignmentOp "-="');
|
|
1769
|
+
var AssignmentOp$6 = $EXPECT($L46, fail, 'AssignmentOp "<<="');
|
|
1770
|
+
var AssignmentOp$7 = $EXPECT($L47, fail, 'AssignmentOp ">>>="');
|
|
1771
|
+
var AssignmentOp$8 = $EXPECT($L48, fail, 'AssignmentOp ">>="');
|
|
1772
|
+
var AssignmentOp$9 = $EXPECT($L49, fail, 'AssignmentOp "&&="');
|
|
1773
|
+
var AssignmentOp$10 = $EXPECT($L50, fail, 'AssignmentOp "&="');
|
|
1774
|
+
var AssignmentOp$11 = $EXPECT($L51, fail, 'AssignmentOp "^="');
|
|
1775
|
+
var AssignmentOp$12 = $EXPECT($L52, fail, 'AssignmentOp "||="');
|
|
1776
|
+
var AssignmentOp$13 = $EXPECT($L53, fail, 'AssignmentOp "|="');
|
|
1777
|
+
var AssignmentOp$14 = $EXPECT($L54, fail, 'AssignmentOp "??="');
|
|
1778
|
+
var AssignmentOp$15 = $EXPECT($L55, fail, 'AssignmentOp "="');
|
|
1837
1779
|
function AssignmentOp(state) {
|
|
1838
1780
|
if (state.tokenize) {
|
|
1839
1781
|
return $TOKEN("AssignmentOp", state, AssignmentOp$0(state) || AssignmentOp$1(state) || AssignmentOp$2(state) || AssignmentOp$3(state) || AssignmentOp$4(state) || AssignmentOp$5(state) || AssignmentOp$6(state) || AssignmentOp$7(state) || AssignmentOp$8(state) || AssignmentOp$9(state) || AssignmentOp$10(state) || AssignmentOp$11(state) || AssignmentOp$12(state) || AssignmentOp$13(state) || AssignmentOp$14(state) || AssignmentOp$15(state));
|
|
@@ -1841,48 +1783,48 @@ var require_parser = __commonJS({
|
|
|
1841
1783
|
return AssignmentOp$0(state) || AssignmentOp$1(state) || AssignmentOp$2(state) || AssignmentOp$3(state) || AssignmentOp$4(state) || AssignmentOp$5(state) || AssignmentOp$6(state) || AssignmentOp$7(state) || AssignmentOp$8(state) || AssignmentOp$9(state) || AssignmentOp$10(state) || AssignmentOp$11(state) || AssignmentOp$12(state) || AssignmentOp$13(state) || AssignmentOp$14(state) || AssignmentOp$15(state);
|
|
1842
1784
|
}
|
|
1843
1785
|
}
|
|
1844
|
-
var BinaryOp$0 = $EXPECT($
|
|
1845
|
-
var BinaryOp$1 = $EXPECT($
|
|
1846
|
-
var BinaryOp$2 = $EXPECT($
|
|
1847
|
-
var BinaryOp$3 = $EXPECT($
|
|
1848
|
-
var BinaryOp$4 = $EXPECT($
|
|
1849
|
-
var BinaryOp$5 = $EXPECT($
|
|
1850
|
-
var BinaryOp$6 = $EXPECT($
|
|
1851
|
-
var BinaryOp$7 = $EXPECT($
|
|
1852
|
-
var BinaryOp$8 = $EXPECT($
|
|
1853
|
-
var BinaryOp$9 = $EXPECT($
|
|
1854
|
-
var BinaryOp$10 = $EXPECT($
|
|
1855
|
-
var BinaryOp$11 = $EXPECT($
|
|
1856
|
-
var BinaryOp$12 = $EXPECT($
|
|
1857
|
-
var BinaryOp$13 = $EXPECT($
|
|
1858
|
-
var BinaryOp$14 = $TV($EXPECT($
|
|
1786
|
+
var BinaryOp$0 = $EXPECT($L56, fail, 'BinaryOp "**"');
|
|
1787
|
+
var BinaryOp$1 = $EXPECT($L9, fail, 'BinaryOp "*"');
|
|
1788
|
+
var BinaryOp$2 = $EXPECT($L57, fail, 'BinaryOp "/"');
|
|
1789
|
+
var BinaryOp$3 = $EXPECT($L58, fail, 'BinaryOp "%"');
|
|
1790
|
+
var BinaryOp$4 = $EXPECT($L59, fail, 'BinaryOp "+"');
|
|
1791
|
+
var BinaryOp$5 = $EXPECT($L60, fail, 'BinaryOp "-"');
|
|
1792
|
+
var BinaryOp$6 = $EXPECT($L61, fail, 'BinaryOp "<="');
|
|
1793
|
+
var BinaryOp$7 = $EXPECT($L62, fail, 'BinaryOp ">="');
|
|
1794
|
+
var BinaryOp$8 = $EXPECT($L63, fail, 'BinaryOp "<<"');
|
|
1795
|
+
var BinaryOp$9 = $EXPECT($L14, fail, 'BinaryOp "<"');
|
|
1796
|
+
var BinaryOp$10 = $EXPECT($L64, fail, 'BinaryOp ">>>"');
|
|
1797
|
+
var BinaryOp$11 = $EXPECT($L65, fail, 'BinaryOp ">>"');
|
|
1798
|
+
var BinaryOp$12 = $EXPECT($L66, fail, 'BinaryOp ">"');
|
|
1799
|
+
var BinaryOp$13 = $EXPECT($L67, fail, 'BinaryOp "!=="');
|
|
1800
|
+
var BinaryOp$14 = $TV($EXPECT($L68, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
|
|
1859
1801
|
if (global.coffeeCompat)
|
|
1860
1802
|
return "!==";
|
|
1861
1803
|
return $1;
|
|
1862
1804
|
});
|
|
1863
|
-
var BinaryOp$15 = $T($EXPECT($
|
|
1805
|
+
var BinaryOp$15 = $T($EXPECT($L69, fail, 'BinaryOp "is"'), function(value) {
|
|
1864
1806
|
return "===";
|
|
1865
1807
|
});
|
|
1866
|
-
var BinaryOp$16 = $EXPECT($
|
|
1867
|
-
var BinaryOp$17 = $TV($EXPECT($
|
|
1808
|
+
var BinaryOp$16 = $EXPECT($L70, fail, 'BinaryOp "==="');
|
|
1809
|
+
var BinaryOp$17 = $TV($EXPECT($L71, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
|
|
1868
1810
|
if (global.coffeeCompat)
|
|
1869
1811
|
return "===";
|
|
1870
1812
|
return $1;
|
|
1871
1813
|
});
|
|
1872
|
-
var BinaryOp$18 = $T($EXPECT($
|
|
1814
|
+
var BinaryOp$18 = $T($EXPECT($L72, fail, 'BinaryOp "and"'), function(value) {
|
|
1873
1815
|
return "&&";
|
|
1874
1816
|
});
|
|
1875
|
-
var BinaryOp$19 = $EXPECT($
|
|
1876
|
-
var BinaryOp$20 = $T($EXPECT($
|
|
1817
|
+
var BinaryOp$19 = $EXPECT($L73, fail, 'BinaryOp "&&"');
|
|
1818
|
+
var BinaryOp$20 = $T($EXPECT($L74, fail, 'BinaryOp "or"'), function(value) {
|
|
1877
1819
|
return "||";
|
|
1878
1820
|
});
|
|
1879
|
-
var BinaryOp$21 = $EXPECT($
|
|
1880
|
-
var BinaryOp$22 = $EXPECT($
|
|
1881
|
-
var BinaryOp$23 = $EXPECT($
|
|
1882
|
-
var BinaryOp$24 = $EXPECT($
|
|
1883
|
-
var BinaryOp$25 = $EXPECT($
|
|
1884
|
-
var BinaryOp$26 = $EXPECT($
|
|
1885
|
-
var BinaryOp$27 = $EXPECT($
|
|
1821
|
+
var BinaryOp$21 = $EXPECT($L75, fail, 'BinaryOp "||"');
|
|
1822
|
+
var BinaryOp$22 = $EXPECT($L76, fail, 'BinaryOp "??"');
|
|
1823
|
+
var BinaryOp$23 = $EXPECT($L77, fail, 'BinaryOp "instanceof"');
|
|
1824
|
+
var BinaryOp$24 = $EXPECT($L78, fail, 'BinaryOp "in"');
|
|
1825
|
+
var BinaryOp$25 = $EXPECT($L79, fail, 'BinaryOp "&"');
|
|
1826
|
+
var BinaryOp$26 = $EXPECT($L80, fail, 'BinaryOp "^"');
|
|
1827
|
+
var BinaryOp$27 = $EXPECT($L81, fail, 'BinaryOp "|"');
|
|
1886
1828
|
function BinaryOp(state) {
|
|
1887
1829
|
if (state.tokenize) {
|
|
1888
1830
|
return $TOKEN("BinaryOp", state, BinaryOp$0(state) || BinaryOp$1(state) || BinaryOp$2(state) || BinaryOp$3(state) || BinaryOp$4(state) || BinaryOp$5(state) || BinaryOp$6(state) || BinaryOp$7(state) || BinaryOp$8(state) || BinaryOp$9(state) || BinaryOp$10(state) || BinaryOp$11(state) || BinaryOp$12(state) || BinaryOp$13(state) || BinaryOp$14(state) || BinaryOp$15(state) || BinaryOp$16(state) || BinaryOp$17(state) || BinaryOp$18(state) || BinaryOp$19(state) || BinaryOp$20(state) || BinaryOp$21(state) || BinaryOp$22(state) || BinaryOp$23(state) || BinaryOp$24(state) || BinaryOp$25(state) || BinaryOp$26(state) || BinaryOp$27(state));
|
|
@@ -1890,8 +1832,8 @@ var require_parser = __commonJS({
|
|
|
1890
1832
|
return BinaryOp$0(state) || BinaryOp$1(state) || BinaryOp$2(state) || BinaryOp$3(state) || BinaryOp$4(state) || BinaryOp$5(state) || BinaryOp$6(state) || BinaryOp$7(state) || BinaryOp$8(state) || BinaryOp$9(state) || BinaryOp$10(state) || BinaryOp$11(state) || BinaryOp$12(state) || BinaryOp$13(state) || BinaryOp$14(state) || BinaryOp$15(state) || BinaryOp$16(state) || BinaryOp$17(state) || BinaryOp$18(state) || BinaryOp$19(state) || BinaryOp$20(state) || BinaryOp$21(state) || BinaryOp$22(state) || BinaryOp$23(state) || BinaryOp$24(state) || BinaryOp$25(state) || BinaryOp$26(state) || BinaryOp$27(state);
|
|
1891
1833
|
}
|
|
1892
1834
|
}
|
|
1893
|
-
var UnaryOp$0 = $R$0($EXPECT($
|
|
1894
|
-
var UnaryOp$1 = $S($C($EXPECT($
|
|
1835
|
+
var UnaryOp$0 = $R$0($EXPECT($R4, fail, "UnaryOp /[!~+-]/"));
|
|
1836
|
+
var UnaryOp$1 = $S($C($EXPECT($L82, fail, 'UnaryOp "delete"'), $EXPECT($L83, fail, 'UnaryOp "void"'), $EXPECT($L84, fail, 'UnaryOp "typeof"')), $P(_));
|
|
1895
1837
|
function UnaryOp(state) {
|
|
1896
1838
|
if (state.tokenize) {
|
|
1897
1839
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -1926,7 +1868,7 @@ var require_parser = __commonJS({
|
|
|
1926
1868
|
return Statement$0(state) || Statement$1(state) || Statement$2(state) || Statement$3(state) || Statement$4(state) || Statement$5(state) || Statement$6(state) || Statement$7(state) || Statement$8(state);
|
|
1927
1869
|
}
|
|
1928
1870
|
}
|
|
1929
|
-
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($
|
|
1871
|
+
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L85, fail, 'EmptyStatement ";"')));
|
|
1930
1872
|
function EmptyStatement(state) {
|
|
1931
1873
|
if (state.verbose)
|
|
1932
1874
|
console.log("ENTER:", "EmptyStatement");
|
|
@@ -1936,7 +1878,7 @@ var require_parser = __commonJS({
|
|
|
1936
1878
|
return EmptyStatement$0(state);
|
|
1937
1879
|
}
|
|
1938
1880
|
}
|
|
1939
|
-
var BlockStatement$0 = $S(__, $EXPECT($
|
|
1881
|
+
var BlockStatement$0 = $S(__, $EXPECT($L11, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BlockStatement "}"'));
|
|
1940
1882
|
function BlockStatement(state) {
|
|
1941
1883
|
if (state.verbose)
|
|
1942
1884
|
console.log("ENTER:", "BlockStatement");
|
|
@@ -1946,8 +1888,8 @@ var require_parser = __commonJS({
|
|
|
1946
1888
|
return BlockStatement$0(state);
|
|
1947
1889
|
}
|
|
1948
1890
|
}
|
|
1949
|
-
var IfStatement$0 = $S($EXPECT($
|
|
1950
|
-
var IfStatement$1 = $TS($S($EXPECT($
|
|
1891
|
+
var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L87, fail, 'IfStatement "else"'), Block)));
|
|
1892
|
+
var IfStatement$1 = $TS($S($EXPECT($L88, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
|
|
1951
1893
|
var condition = $2;
|
|
1952
1894
|
var block = $3;
|
|
1953
1895
|
return ["if", condition.map((c) => {
|
|
@@ -1977,7 +1919,7 @@ var require_parser = __commonJS({
|
|
|
1977
1919
|
return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
|
|
1978
1920
|
}
|
|
1979
1921
|
}
|
|
1980
|
-
var LoopStatement$0 = $TS($S($EXPECT($
|
|
1922
|
+
var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), Block), function($skip, $loc, $0, $1, $2) {
|
|
1981
1923
|
var b = $2;
|
|
1982
1924
|
return ["while(true)", b];
|
|
1983
1925
|
});
|
|
@@ -1990,7 +1932,7 @@ var require_parser = __commonJS({
|
|
|
1990
1932
|
return LoopStatement$0(state);
|
|
1991
1933
|
}
|
|
1992
1934
|
}
|
|
1993
|
-
var DoWhileStatement$0 = $S($EXPECT($
|
|
1935
|
+
var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), Block, __, $EXPECT($L91, fail, 'DoWhileStatement "while"'), Condition);
|
|
1994
1936
|
function DoWhileStatement(state) {
|
|
1995
1937
|
if (state.verbose)
|
|
1996
1938
|
console.log("ENTER:", "DoWhileStatement");
|
|
@@ -2000,7 +1942,7 @@ var require_parser = __commonJS({
|
|
|
2000
1942
|
return DoWhileStatement$0(state);
|
|
2001
1943
|
}
|
|
2002
1944
|
}
|
|
2003
|
-
var WhileStatement$0 = $S($EXPECT($
|
|
1945
|
+
var WhileStatement$0 = $S($EXPECT($L91, fail, 'WhileStatement "while"'), Condition, Block);
|
|
2004
1946
|
function WhileStatement(state) {
|
|
2005
1947
|
if (state.verbose)
|
|
2006
1948
|
console.log("ENTER:", "WhileStatement");
|
|
@@ -2010,7 +1952,7 @@ var require_parser = __commonJS({
|
|
|
2010
1952
|
return WhileStatement$0(state);
|
|
2011
1953
|
}
|
|
2012
1954
|
}
|
|
2013
|
-
var ForStatement$0 = $S($EXPECT($
|
|
1955
|
+
var ForStatement$0 = $S($EXPECT($L92, fail, 'ForStatement "for"'), __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L85, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L85, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
|
|
2014
1956
|
function ForStatement(state) {
|
|
2015
1957
|
if (state.verbose)
|
|
2016
1958
|
console.log("ENTER:", "ForStatement");
|
|
@@ -2020,10 +1962,10 @@ var require_parser = __commonJS({
|
|
|
2020
1962
|
return ForStatement$0(state);
|
|
2021
1963
|
}
|
|
2022
1964
|
}
|
|
2023
|
-
var ForInOfStatement$0 = $S($EXPECT($
|
|
2024
|
-
var ForInOfStatement$1 = $S($EXPECT($
|
|
2025
|
-
var ForInOfStatement$2 = $S($EXPECT($
|
|
2026
|
-
var ForInOfStatement$3 = $S($EXPECT($
|
|
1965
|
+
var ForInOfStatement$0 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
|
|
1966
|
+
var ForInOfStatement$1 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
|
|
1967
|
+
var ForInOfStatement$2 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
|
|
1968
|
+
var ForInOfStatement$3 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
|
|
2027
1969
|
function ForInOfStatement(state) {
|
|
2028
1970
|
if (state.tokenize) {
|
|
2029
1971
|
return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
|
|
@@ -2031,7 +1973,7 @@ var require_parser = __commonJS({
|
|
|
2031
1973
|
return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
|
|
2032
1974
|
}
|
|
2033
1975
|
}
|
|
2034
|
-
var ForDeclaration$0 = $S($C($EXPECT($
|
|
1976
|
+
var ForDeclaration$0 = $S($C($EXPECT($L96, fail, 'ForDeclaration "let"'), $EXPECT($L97, fail, 'ForDeclaration "const"')), __, ForBinding);
|
|
2035
1977
|
function ForDeclaration(state) {
|
|
2036
1978
|
if (state.verbose)
|
|
2037
1979
|
console.log("ENTER:", "ForDeclaration");
|
|
@@ -2050,7 +1992,7 @@ var require_parser = __commonJS({
|
|
|
2050
1992
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
2051
1993
|
}
|
|
2052
1994
|
}
|
|
2053
|
-
var SwitchStatement$0 = $S($EXPECT($
|
|
1995
|
+
var SwitchStatement$0 = $S($EXPECT($L98, fail, 'SwitchStatement "switch"'), Condition, CaseBlock);
|
|
2054
1996
|
function SwitchStatement(state) {
|
|
2055
1997
|
if (state.verbose)
|
|
2056
1998
|
console.log("ENTER:", "SwitchStatement");
|
|
@@ -2060,7 +2002,7 @@ var require_parser = __commonJS({
|
|
|
2060
2002
|
return SwitchStatement$0(state);
|
|
2061
2003
|
}
|
|
2062
2004
|
}
|
|
2063
|
-
var CaseBlock$0 = $S(__, $EXPECT($
|
|
2005
|
+
var CaseBlock$0 = $S(__, $EXPECT($L11, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L16, fail, 'CaseBlock "}"'));
|
|
2064
2006
|
var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
|
|
2065
2007
|
function CaseBlock(state) {
|
|
2066
2008
|
if (state.tokenize) {
|
|
@@ -2094,9 +2036,9 @@ var require_parser = __commonJS({
|
|
|
2094
2036
|
return NestedCaseClause$0(state);
|
|
2095
2037
|
}
|
|
2096
2038
|
}
|
|
2097
|
-
var CaseClause$0 = $S($EXPECT($
|
|
2039
|
+
var CaseClause$0 = $S($EXPECT($L99, fail, 'CaseClause "case"'), $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
|
|
2098
2040
|
var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
|
|
2099
|
-
var CaseClause$2 = $S($EXPECT($
|
|
2041
|
+
var CaseClause$2 = $S($EXPECT($L100, fail, 'CaseClause "default"'), ImpliedColon, NestedBlockExpressions);
|
|
2100
2042
|
function CaseClause(state) {
|
|
2101
2043
|
if (state.tokenize) {
|
|
2102
2044
|
return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
|
|
@@ -2104,7 +2046,7 @@ var require_parser = __commonJS({
|
|
|
2104
2046
|
return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
|
|
2105
2047
|
}
|
|
2106
2048
|
}
|
|
2107
|
-
var When$0 = $T($EXPECT($
|
|
2049
|
+
var When$0 = $T($EXPECT($L101, fail, 'When "when"'), function(value) {
|
|
2108
2050
|
return "case";
|
|
2109
2051
|
});
|
|
2110
2052
|
function When(state) {
|
|
@@ -2116,8 +2058,8 @@ var require_parser = __commonJS({
|
|
|
2116
2058
|
return When$0(state);
|
|
2117
2059
|
}
|
|
2118
2060
|
}
|
|
2119
|
-
var ImpliedColon$0 = $S(__, $EXPECT($
|
|
2120
|
-
var ImpliedColon$1 = $T($EXPECT($
|
|
2061
|
+
var ImpliedColon$0 = $S(__, $EXPECT($L12, fail, 'ImpliedColon ":"'));
|
|
2062
|
+
var ImpliedColon$1 = $T($EXPECT($L30, fail, 'ImpliedColon ""'), function(value) {
|
|
2121
2063
|
return ":";
|
|
2122
2064
|
});
|
|
2123
2065
|
function ImpliedColon(state) {
|
|
@@ -2127,7 +2069,7 @@ var require_parser = __commonJS({
|
|
|
2127
2069
|
return ImpliedColon$0(state) || ImpliedColon$1(state);
|
|
2128
2070
|
}
|
|
2129
2071
|
}
|
|
2130
|
-
var TryStatement$0 = $TS($S($EXPECT($
|
|
2072
|
+
var TryStatement$0 = $TS($S($EXPECT($L102, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2131
2073
|
var c = $3;
|
|
2132
2074
|
var f = $4;
|
|
2133
2075
|
if (!c && !f) {
|
|
@@ -2144,7 +2086,7 @@ var require_parser = __commonJS({
|
|
|
2144
2086
|
return TryStatement$0(state);
|
|
2145
2087
|
}
|
|
2146
2088
|
}
|
|
2147
|
-
var Catch$0 = $S(__, $EXPECT($
|
|
2089
|
+
var Catch$0 = $S(__, $EXPECT($L103, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
|
|
2148
2090
|
function Catch(state) {
|
|
2149
2091
|
if (state.verbose)
|
|
2150
2092
|
console.log("ENTER:", "Catch");
|
|
@@ -2163,7 +2105,7 @@ var require_parser = __commonJS({
|
|
|
2163
2105
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2164
2106
|
}
|
|
2165
2107
|
}
|
|
2166
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2108
|
+
var Finally$0 = $S(__, $EXPECT($L104, fail, 'Finally "finally"'), BracedBlock);
|
|
2167
2109
|
function Finally(state) {
|
|
2168
2110
|
if (state.verbose)
|
|
2169
2111
|
console.log("ENTER:", "Finally");
|
|
@@ -2201,12 +2143,12 @@ var require_parser = __commonJS({
|
|
|
2201
2143
|
return ExpressionStatement$0(state);
|
|
2202
2144
|
}
|
|
2203
2145
|
}
|
|
2204
|
-
var KeywordStatement$0 = $EXPECT($
|
|
2205
|
-
var KeywordStatement$1 = $EXPECT($
|
|
2206
|
-
var KeywordStatement$2 = $EXPECT($
|
|
2207
|
-
var KeywordStatement$3 = $S($EXPECT($
|
|
2208
|
-
var KeywordStatement$4 = $EXPECT($
|
|
2209
|
-
var KeywordStatement$5 = $S($EXPECT($
|
|
2146
|
+
var KeywordStatement$0 = $EXPECT($L105, fail, 'KeywordStatement "break"');
|
|
2147
|
+
var KeywordStatement$1 = $EXPECT($L106, fail, 'KeywordStatement "continue"');
|
|
2148
|
+
var KeywordStatement$2 = $EXPECT($L107, fail, 'KeywordStatement "debugger"');
|
|
2149
|
+
var KeywordStatement$3 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), Expression);
|
|
2150
|
+
var KeywordStatement$4 = $EXPECT($L108, fail, 'KeywordStatement "return"');
|
|
2151
|
+
var KeywordStatement$5 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), Expression);
|
|
2210
2152
|
function KeywordStatement(state) {
|
|
2211
2153
|
if (state.tokenize) {
|
|
2212
2154
|
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state));
|
|
@@ -2214,11 +2156,11 @@ var require_parser = __commonJS({
|
|
|
2214
2156
|
return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state);
|
|
2215
2157
|
}
|
|
2216
2158
|
}
|
|
2217
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2159
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L110, fail, 'ImportDeclaration "import type"'), __, ImportClause, __, FromClause), function(value) {
|
|
2218
2160
|
return { "ts": true, "children": value };
|
|
2219
2161
|
});
|
|
2220
|
-
var ImportDeclaration$1 = $S($EXPECT($
|
|
2221
|
-
var ImportDeclaration$2 = $S($EXPECT($
|
|
2162
|
+
var ImportDeclaration$1 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), __, ImportClause, __, FromClause);
|
|
2163
|
+
var ImportDeclaration$2 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), __, ModuleSpecifier);
|
|
2222
2164
|
function ImportDeclaration(state) {
|
|
2223
2165
|
if (state.tokenize) {
|
|
2224
2166
|
return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
|
|
@@ -2236,7 +2178,7 @@ var require_parser = __commonJS({
|
|
|
2236
2178
|
return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
|
|
2237
2179
|
}
|
|
2238
2180
|
}
|
|
2239
|
-
var NameSpaceImport$0 = $S($EXPECT($
|
|
2181
|
+
var NameSpaceImport$0 = $S($EXPECT($L9, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), __, ImportedBinding);
|
|
2240
2182
|
function NameSpaceImport(state) {
|
|
2241
2183
|
if (state.verbose)
|
|
2242
2184
|
console.log("ENTER:", "NameSpaceImport");
|
|
@@ -2246,7 +2188,7 @@ var require_parser = __commonJS({
|
|
|
2246
2188
|
return NameSpaceImport$0(state);
|
|
2247
2189
|
}
|
|
2248
2190
|
}
|
|
2249
|
-
var NamedImports$0 = $S($EXPECT($
|
|
2191
|
+
var NamedImports$0 = $S($EXPECT($L11, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L16, fail, 'NamedImports "}"'));
|
|
2250
2192
|
function NamedImports(state) {
|
|
2251
2193
|
if (state.verbose)
|
|
2252
2194
|
console.log("ENTER:", "NamedImports");
|
|
@@ -2266,7 +2208,7 @@ var require_parser = __commonJS({
|
|
|
2266
2208
|
return FromClause$0(state);
|
|
2267
2209
|
}
|
|
2268
2210
|
}
|
|
2269
|
-
var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($
|
|
2211
|
+
var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), __, ImportedBinding, ObjectPropertyDelimiter);
|
|
2270
2212
|
var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
|
|
2271
2213
|
function ImportSpecifier(state) {
|
|
2272
2214
|
if (state.tokenize) {
|
|
@@ -2304,7 +2246,7 @@ var require_parser = __commonJS({
|
|
|
2304
2246
|
return ImportedBinding$0(state);
|
|
2305
2247
|
}
|
|
2306
2248
|
}
|
|
2307
|
-
var ExportDeclaration$0 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $EXPECT($
|
|
2249
|
+
var ExportDeclaration$0 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $EXPECT($L100, fail, 'ExportDeclaration "default"'), __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2308
2250
|
var ExportDeclaration$1 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, ExportFromClause, __, FromClause);
|
|
2309
2251
|
var ExportDeclaration$2 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $C(NamedExports, VariableStatement, Declaration));
|
|
2310
2252
|
function ExportDeclaration(state) {
|
|
@@ -2314,7 +2256,7 @@ var require_parser = __commonJS({
|
|
|
2314
2256
|
return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
|
|
2315
2257
|
}
|
|
2316
2258
|
}
|
|
2317
|
-
var ExportFromClause$0 = $S($EXPECT($
|
|
2259
|
+
var ExportFromClause$0 = $S($EXPECT($L9, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), __, ModuleExportName)));
|
|
2318
2260
|
var ExportFromClause$1 = NamedExports;
|
|
2319
2261
|
function ExportFromClause(state) {
|
|
2320
2262
|
if (state.tokenize) {
|
|
@@ -2323,7 +2265,7 @@ var require_parser = __commonJS({
|
|
|
2323
2265
|
return ExportFromClause$0(state) || ExportFromClause$1(state);
|
|
2324
2266
|
}
|
|
2325
2267
|
}
|
|
2326
|
-
var NamedExports$0 = $S($EXPECT($
|
|
2268
|
+
var NamedExports$0 = $S($EXPECT($L11, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L16, fail, 'NamedExports "}"'));
|
|
2327
2269
|
function NamedExports(state) {
|
|
2328
2270
|
if (state.verbose)
|
|
2329
2271
|
console.log("ENTER:", "NamedExports");
|
|
@@ -2333,7 +2275,7 @@ var require_parser = __commonJS({
|
|
|
2333
2275
|
return NamedExports$0(state);
|
|
2334
2276
|
}
|
|
2335
2277
|
}
|
|
2336
|
-
var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, $EXPECT($
|
|
2278
|
+
var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, $EXPECT($L4, fail, 'ExportSpecifier "as"'), __, ModuleExportName)), ObjectPropertyDelimiter);
|
|
2337
2279
|
function ExportSpecifier(state) {
|
|
2338
2280
|
if (state.verbose)
|
|
2339
2281
|
console.log("ENTER:", "ExportSpecifier");
|
|
@@ -2354,18 +2296,17 @@ var require_parser = __commonJS({
|
|
|
2354
2296
|
return Declaration$0(state) || Declaration$1(state) || Declaration$2(state) || Declaration$3(state);
|
|
2355
2297
|
}
|
|
2356
2298
|
}
|
|
2357
|
-
var HoistableDeclaration$0 =
|
|
2358
|
-
var HoistableDeclaration$1 = AsyncFunctionDeclaration;
|
|
2359
|
-
var HoistableDeclaration$2 = GeneratorDeclaration;
|
|
2360
|
-
var HoistableDeclaration$3 = FunctionDeclaration;
|
|
2299
|
+
var HoistableDeclaration$0 = FunctionDeclaration;
|
|
2361
2300
|
function HoistableDeclaration(state) {
|
|
2301
|
+
if (state.verbose)
|
|
2302
|
+
console.log("ENTER:", "HoistableDeclaration");
|
|
2362
2303
|
if (state.tokenize) {
|
|
2363
|
-
return $TOKEN("HoistableDeclaration", state, HoistableDeclaration$0(state)
|
|
2304
|
+
return $TOKEN("HoistableDeclaration", state, HoistableDeclaration$0(state));
|
|
2364
2305
|
} else {
|
|
2365
|
-
return HoistableDeclaration$0(state)
|
|
2306
|
+
return HoistableDeclaration$0(state);
|
|
2366
2307
|
}
|
|
2367
2308
|
}
|
|
2368
|
-
var LexicalDeclaration$0 = $S($C($EXPECT($
|
|
2309
|
+
var LexicalDeclaration$0 = $S($C($EXPECT($L96, fail, 'LexicalDeclaration "let"'), $EXPECT($L97, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
|
|
2369
2310
|
var LexicalDeclaration$1 = $T($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, $EXPECT($L113, fail, 'LexicalDeclaration ":="'), AssignmentExpression), function(value) {
|
|
2370
2311
|
var bind = value[0];
|
|
2371
2312
|
var suffix = value[1];
|
|
@@ -2389,7 +2330,7 @@ var require_parser = __commonJS({
|
|
|
2389
2330
|
return LexicalBinding$0(state) || LexicalBinding$1(state);
|
|
2390
2331
|
}
|
|
2391
2332
|
}
|
|
2392
|
-
var Initializer$0 = $S(__, $EXPECT($
|
|
2333
|
+
var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
|
|
2393
2334
|
function Initializer(state) {
|
|
2394
2335
|
if (state.verbose)
|
|
2395
2336
|
console.log("ENTER:", "Initializer");
|
|
@@ -2399,7 +2340,7 @@ var require_parser = __commonJS({
|
|
|
2399
2340
|
return Initializer$0(state);
|
|
2400
2341
|
}
|
|
2401
2342
|
}
|
|
2402
|
-
var VariableStatement$0 = $S($EXPECT($
|
|
2343
|
+
var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
|
|
2403
2344
|
function VariableStatement(state) {
|
|
2404
2345
|
if (state.verbose)
|
|
2405
2346
|
console.log("ENTER:", "VariableStatement");
|
|
@@ -2440,7 +2381,7 @@ var require_parser = __commonJS({
|
|
|
2440
2381
|
return NumericLiteral$0(state) || NumericLiteral$1(state) || NumericLiteral$2(state) || NumericLiteral$3(state) || NumericLiteral$4(state);
|
|
2441
2382
|
}
|
|
2442
2383
|
}
|
|
2443
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
2384
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
2444
2385
|
function DecimalBigIntegerLiteral(state) {
|
|
2445
2386
|
if (state.verbose)
|
|
2446
2387
|
console.log("ENTER:", "DecimalBigIntegerLiteral");
|
|
@@ -2450,7 +2391,7 @@ var require_parser = __commonJS({
|
|
|
2450
2391
|
return DecimalBigIntegerLiteral$0(state);
|
|
2451
2392
|
}
|
|
2452
2393
|
}
|
|
2453
|
-
var DecimalLiteral$0 = $R$0($EXPECT($
|
|
2394
|
+
var DecimalLiteral$0 = $R$0($EXPECT($R6, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
|
|
2454
2395
|
function DecimalLiteral(state) {
|
|
2455
2396
|
if (state.verbose)
|
|
2456
2397
|
console.log("ENTER:", "DecimalLiteral");
|
|
@@ -2460,7 +2401,7 @@ var require_parser = __commonJS({
|
|
|
2460
2401
|
return DecimalLiteral$0(state);
|
|
2461
2402
|
}
|
|
2462
2403
|
}
|
|
2463
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
2404
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
|
|
2464
2405
|
function BinaryIntegerLiteral(state) {
|
|
2465
2406
|
if (state.verbose)
|
|
2466
2407
|
console.log("ENTER:", "BinaryIntegerLiteral");
|
|
@@ -2470,7 +2411,7 @@ var require_parser = __commonJS({
|
|
|
2470
2411
|
return BinaryIntegerLiteral$0(state);
|
|
2471
2412
|
}
|
|
2472
2413
|
}
|
|
2473
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
2414
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R8, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*/"));
|
|
2474
2415
|
function OctalIntegerLiteral(state) {
|
|
2475
2416
|
if (state.verbose)
|
|
2476
2417
|
console.log("ENTER:", "OctalIntegerLiteral");
|
|
@@ -2480,7 +2421,7 @@ var require_parser = __commonJS({
|
|
|
2480
2421
|
return OctalIntegerLiteral$0(state);
|
|
2481
2422
|
}
|
|
2482
2423
|
}
|
|
2483
|
-
var HexLiteral$0 = $R$0($EXPECT($
|
|
2424
|
+
var HexLiteral$0 = $R$0($EXPECT($R9, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*/"));
|
|
2484
2425
|
function HexLiteral(state) {
|
|
2485
2426
|
if (state.verbose)
|
|
2486
2427
|
console.log("ENTER:", "HexLiteral");
|
|
@@ -2502,7 +2443,7 @@ var require_parser = __commonJS({
|
|
|
2502
2443
|
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
|
|
2503
2444
|
}
|
|
2504
2445
|
}
|
|
2505
|
-
var DoubleStringCharacter$0 = $R$0($EXPECT($
|
|
2446
|
+
var DoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'DoubleStringCharacter /[^"\\\\]+/'));
|
|
2506
2447
|
var DoubleStringCharacter$1 = EscapeSequence;
|
|
2507
2448
|
function DoubleStringCharacter(state) {
|
|
2508
2449
|
if (state.tokenize) {
|
|
@@ -2511,7 +2452,7 @@ var require_parser = __commonJS({
|
|
|
2511
2452
|
return DoubleStringCharacter$0(state) || DoubleStringCharacter$1(state);
|
|
2512
2453
|
}
|
|
2513
2454
|
}
|
|
2514
|
-
var SingleStringCharacter$0 = $R$0($EXPECT($
|
|
2455
|
+
var SingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "SingleStringCharacter /[^'\\\\]+/"));
|
|
2515
2456
|
var SingleStringCharacter$1 = EscapeSequence;
|
|
2516
2457
|
function SingleStringCharacter(state) {
|
|
2517
2458
|
if (state.tokenize) {
|
|
@@ -2520,7 +2461,7 @@ var require_parser = __commonJS({
|
|
|
2520
2461
|
return SingleStringCharacter$0(state) || SingleStringCharacter$1(state);
|
|
2521
2462
|
}
|
|
2522
2463
|
}
|
|
2523
|
-
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($
|
|
2464
|
+
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R12, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
|
|
2524
2465
|
function TripleDoubleStringCharacter(state) {
|
|
2525
2466
|
if (state.verbose)
|
|
2526
2467
|
console.log("ENTER:", "TripleDoubleStringCharacter");
|
|
@@ -2530,7 +2471,7 @@ var require_parser = __commonJS({
|
|
|
2530
2471
|
return TripleDoubleStringCharacter$0(state);
|
|
2531
2472
|
}
|
|
2532
2473
|
}
|
|
2533
|
-
var EscapeSequence$0 = $TEXT($S($EXPECT($L117, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($
|
|
2474
|
+
var EscapeSequence$0 = $TEXT($S($EXPECT($L117, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R13, fail, "EscapeSequence /./")));
|
|
2534
2475
|
function EscapeSequence(state) {
|
|
2535
2476
|
if (state.verbose)
|
|
2536
2477
|
console.log("ENTER:", "EscapeSequence");
|
|
@@ -2540,7 +2481,7 @@ var require_parser = __commonJS({
|
|
|
2540
2481
|
return EscapeSequence$0(state);
|
|
2541
2482
|
}
|
|
2542
2483
|
}
|
|
2543
|
-
var RegularExpressionLiteral$0 = $S($EXPECT($
|
|
2484
|
+
var RegularExpressionLiteral$0 = $S($EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
|
|
2544
2485
|
function RegularExpressionLiteral(state) {
|
|
2545
2486
|
if (state.verbose)
|
|
2546
2487
|
console.log("ENTER:", "RegularExpressionLiteral");
|
|
@@ -2550,7 +2491,7 @@ var require_parser = __commonJS({
|
|
|
2550
2491
|
return RegularExpressionLiteral$0(state);
|
|
2551
2492
|
}
|
|
2552
2493
|
}
|
|
2553
|
-
var RegularExpressionBody$0 = $S($R$0($EXPECT($
|
|
2494
|
+
var RegularExpressionBody$0 = $S($R$0($EXPECT($R14, fail, "RegularExpressionBody /[^*\\/\\r\\n]/")), $Q(RegExpCharacter));
|
|
2554
2495
|
function RegularExpressionBody(state) {
|
|
2555
2496
|
if (state.verbose)
|
|
2556
2497
|
console.log("ENTER:", "RegularExpressionBody");
|
|
@@ -2560,7 +2501,7 @@ var require_parser = __commonJS({
|
|
|
2560
2501
|
return RegularExpressionBody$0(state);
|
|
2561
2502
|
}
|
|
2562
2503
|
}
|
|
2563
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
2504
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R15, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
|
|
2564
2505
|
var RegExpCharacter$1 = EscapeSequence;
|
|
2565
2506
|
function RegExpCharacter(state) {
|
|
2566
2507
|
if (state.tokenize) {
|
|
@@ -2569,7 +2510,7 @@ var require_parser = __commonJS({
|
|
|
2569
2510
|
return RegExpCharacter$0(state) || RegExpCharacter$1(state);
|
|
2570
2511
|
}
|
|
2571
2512
|
}
|
|
2572
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
2513
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R16, fail, "RegularExpressionFlags /(:?\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
2573
2514
|
function RegularExpressionFlags(state) {
|
|
2574
2515
|
if (state.verbose)
|
|
2575
2516
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -2589,7 +2530,7 @@ var require_parser = __commonJS({
|
|
|
2589
2530
|
return TemplateLiteral$0(state);
|
|
2590
2531
|
}
|
|
2591
2532
|
}
|
|
2592
|
-
var TemplateSubstitution$0 = $S($EXPECT($L119, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($
|
|
2533
|
+
var TemplateSubstitution$0 = $S($EXPECT($L119, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
|
|
2593
2534
|
function TemplateSubstitution(state) {
|
|
2594
2535
|
if (state.verbose)
|
|
2595
2536
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -2599,7 +2540,7 @@ var require_parser = __commonJS({
|
|
|
2599
2540
|
return TemplateSubstitution$0(state);
|
|
2600
2541
|
}
|
|
2601
2542
|
}
|
|
2602
|
-
var TemplateCharacters$0 = $R$0($EXPECT($
|
|
2543
|
+
var TemplateCharacters$0 = $R$0($EXPECT($R17, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
|
|
2603
2544
|
function TemplateCharacters(state) {
|
|
2604
2545
|
if (state.verbose)
|
|
2605
2546
|
console.log("ENTER:", "TemplateCharacters");
|
|
@@ -2609,7 +2550,7 @@ var require_parser = __commonJS({
|
|
|
2609
2550
|
return TemplateCharacters$0(state);
|
|
2610
2551
|
}
|
|
2611
2552
|
}
|
|
2612
|
-
var ReservedWord$0 = $R$0($EXPECT($
|
|
2553
|
+
var ReservedWord$0 = $R$0($EXPECT($R18, fail, "ReservedWord /(?: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})/"));
|
|
2613
2554
|
function ReservedWord(state) {
|
|
2614
2555
|
if (state.verbose)
|
|
2615
2556
|
console.log("ENTER:", "ReservedWord");
|
|
@@ -2628,7 +2569,7 @@ var require_parser = __commonJS({
|
|
|
2628
2569
|
return Comment$0(state) || Comment$1(state);
|
|
2629
2570
|
}
|
|
2630
2571
|
}
|
|
2631
|
-
var SingleLineComment$0 = $R$0($EXPECT($
|
|
2572
|
+
var SingleLineComment$0 = $R$0($EXPECT($R19, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"));
|
|
2632
2573
|
var SingleLineComment$1 = CoffeeSingleLineComment;
|
|
2633
2574
|
function SingleLineComment(state) {
|
|
2634
2575
|
if (state.tokenize) {
|
|
@@ -2646,7 +2587,7 @@ var require_parser = __commonJS({
|
|
|
2646
2587
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
2647
2588
|
}
|
|
2648
2589
|
}
|
|
2649
|
-
var JSMultiLineComment$0 = $S($EXPECT($L120, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'JSMultiLineComment "*/"')), $EXPECT($
|
|
2590
|
+
var JSMultiLineComment$0 = $S($EXPECT($L120, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'JSMultiLineComment "*/"')), $EXPECT($R13, fail, "JSMultiLineComment /./")))), $EXPECT($L121, fail, 'JSMultiLineComment "*/"'));
|
|
2650
2591
|
function JSMultiLineComment(state) {
|
|
2651
2592
|
if (state.verbose)
|
|
2652
2593
|
console.log("ENTER:", "JSMultiLineComment");
|
|
@@ -2656,7 +2597,7 @@ var require_parser = __commonJS({
|
|
|
2656
2597
|
return JSMultiLineComment$0(state);
|
|
2657
2598
|
}
|
|
2658
2599
|
}
|
|
2659
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
2600
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R20, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
2660
2601
|
if (!global.coffeeCompat)
|
|
2661
2602
|
return $skip;
|
|
2662
2603
|
return ["//", $1];
|
|
@@ -2670,7 +2611,7 @@ var require_parser = __commonJS({
|
|
|
2670
2611
|
return CoffeeSingleLineComment$0(state);
|
|
2671
2612
|
}
|
|
2672
2613
|
}
|
|
2673
|
-
var CoffeeMultiLineComment$0 = $T($S($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($
|
|
2614
|
+
var CoffeeMultiLineComment$0 = $T($S($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R13, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), function(value) {
|
|
2674
2615
|
return ["/*", value[1], "*/"];
|
|
2675
2616
|
});
|
|
2676
2617
|
function CoffeeMultiLineComment(state) {
|
|
@@ -2682,7 +2623,7 @@ var require_parser = __commonJS({
|
|
|
2682
2623
|
return CoffeeMultiLineComment$0(state);
|
|
2683
2624
|
}
|
|
2684
2625
|
}
|
|
2685
|
-
var InlineComment$0 = $S($EXPECT($L120, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'InlineComment "*/"')), $EXPECT($
|
|
2626
|
+
var InlineComment$0 = $S($EXPECT($L120, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'InlineComment "*/"')), $EXPECT($R21, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L121, fail, 'InlineComment "*/"'));
|
|
2686
2627
|
function InlineComment(state) {
|
|
2687
2628
|
if (state.verbose)
|
|
2688
2629
|
console.log("ENTER:", "InlineComment");
|
|
@@ -2702,7 +2643,7 @@ var require_parser = __commonJS({
|
|
|
2702
2643
|
return RestOfLine$0(state);
|
|
2703
2644
|
}
|
|
2704
2645
|
}
|
|
2705
|
-
var TrailingComment$0 = $R$0($EXPECT($
|
|
2646
|
+
var TrailingComment$0 = $R$0($EXPECT($R22, fail, "TrailingComment /[\\t ]+/"));
|
|
2706
2647
|
var TrailingComment$1 = InlineComment;
|
|
2707
2648
|
var TrailingComment$2 = SingleLineComment;
|
|
2708
2649
|
function TrailingComment(state) {
|
|
@@ -2712,7 +2653,7 @@ var require_parser = __commonJS({
|
|
|
2712
2653
|
return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
|
|
2713
2654
|
}
|
|
2714
2655
|
}
|
|
2715
|
-
var _$0 = $P($C($R$0($EXPECT($
|
|
2656
|
+
var _$0 = $P($C($R$0($EXPECT($R22, fail, "_ /[\\t ]+/")), Comment));
|
|
2716
2657
|
function _(state) {
|
|
2717
2658
|
if (state.verbose)
|
|
2718
2659
|
console.log("ENTER:", "_");
|
|
@@ -2722,7 +2663,7 @@ var require_parser = __commonJS({
|
|
|
2722
2663
|
return _$0(state);
|
|
2723
2664
|
}
|
|
2724
2665
|
}
|
|
2725
|
-
var __$0 = $Q($C($R$0($EXPECT($
|
|
2666
|
+
var __$0 = $Q($C($R$0($EXPECT($R23, fail, "__ /[\\s]+/")), Comment));
|
|
2726
2667
|
function __(state) {
|
|
2727
2668
|
if (state.verbose)
|
|
2728
2669
|
console.log("ENTER:", "__");
|
|
@@ -2732,7 +2673,7 @@ var require_parser = __commonJS({
|
|
|
2732
2673
|
return __$0(state);
|
|
2733
2674
|
}
|
|
2734
2675
|
}
|
|
2735
|
-
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($
|
|
2676
|
+
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L85, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
|
|
2736
2677
|
var StatementDelimiter$1 = $T($Y(EOS), function(value) {
|
|
2737
2678
|
return [";", value];
|
|
2738
2679
|
});
|
|
@@ -2746,7 +2687,6 @@ var require_parser = __commonJS({
|
|
|
2746
2687
|
var JSXElement$0 = JSXSelfClosingElement;
|
|
2747
2688
|
var JSXElement$1 = $TS($S(JSXOpeningElement, $Q(JSXChildren), __, JSXClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2748
2689
|
if ($1[1] !== $4[2]) {
|
|
2749
|
-
console.log($1, $4, $loc);
|
|
2750
2690
|
throw new Error(`mismatched closing tags at ${JSON.stringify($loc)}`);
|
|
2751
2691
|
}
|
|
2752
2692
|
return $0;
|
|
@@ -2758,7 +2698,7 @@ var require_parser = __commonJS({
|
|
|
2758
2698
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
2759
2699
|
}
|
|
2760
2700
|
}
|
|
2761
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($
|
|
2701
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L123, fail, 'JSXSelfClosingElement "/>"'));
|
|
2762
2702
|
function JSXSelfClosingElement(state) {
|
|
2763
2703
|
if (state.verbose)
|
|
2764
2704
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -2768,7 +2708,7 @@ var require_parser = __commonJS({
|
|
|
2768
2708
|
return JSXSelfClosingElement$0(state);
|
|
2769
2709
|
}
|
|
2770
2710
|
}
|
|
2771
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
2711
|
+
var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L66, fail, 'JSXOpeningElement ">"'));
|
|
2772
2712
|
function JSXOpeningElement(state) {
|
|
2773
2713
|
if (state.verbose)
|
|
2774
2714
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -2778,7 +2718,7 @@ var require_parser = __commonJS({
|
|
|
2778
2718
|
return JSXOpeningElement$0(state);
|
|
2779
2719
|
}
|
|
2780
2720
|
}
|
|
2781
|
-
var JSXClosingElement$0 = $S($EXPECT($L124, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($
|
|
2721
|
+
var JSXClosingElement$0 = $S($EXPECT($L124, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
|
|
2782
2722
|
function JSXClosingElement(state) {
|
|
2783
2723
|
if (state.verbose)
|
|
2784
2724
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -2798,7 +2738,7 @@ var require_parser = __commonJS({
|
|
|
2798
2738
|
return JSXFragment$0(state);
|
|
2799
2739
|
}
|
|
2800
2740
|
}
|
|
2801
|
-
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($
|
|
2741
|
+
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L26, fail, 'JSXElementName "."'), JSXIdentifierName))));
|
|
2802
2742
|
function JSXElementName(state) {
|
|
2803
2743
|
if (state.verbose)
|
|
2804
2744
|
console.log("ENTER:", "JSXElementName");
|
|
@@ -2808,7 +2748,7 @@ var require_parser = __commonJS({
|
|
|
2808
2748
|
return JSXElementName$0(state);
|
|
2809
2749
|
}
|
|
2810
2750
|
}
|
|
2811
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
2751
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R24, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
2812
2752
|
function JSXIdentifierName(state) {
|
|
2813
2753
|
if (state.verbose)
|
|
2814
2754
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -2828,7 +2768,7 @@ var require_parser = __commonJS({
|
|
|
2828
2768
|
return JSXAttributes$0(state);
|
|
2829
2769
|
}
|
|
2830
2770
|
}
|
|
2831
|
-
var JSXAttribute$0 = $S($EXPECT($
|
|
2771
|
+
var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($L31, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttribute "}"'));
|
|
2832
2772
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
2833
2773
|
function JSXAttribute(state) {
|
|
2834
2774
|
if (state.tokenize) {
|
|
@@ -2837,7 +2777,7 @@ var require_parser = __commonJS({
|
|
|
2837
2777
|
return JSXAttribute$0(state) || JSXAttribute$1(state);
|
|
2838
2778
|
}
|
|
2839
2779
|
}
|
|
2840
|
-
var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($
|
|
2780
|
+
var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L12, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
|
|
2841
2781
|
function JSXAttributeName(state) {
|
|
2842
2782
|
if (state.verbose)
|
|
2843
2783
|
console.log("ENTER:", "JSXAttributeName");
|
|
@@ -2847,7 +2787,7 @@ var require_parser = __commonJS({
|
|
|
2847
2787
|
return JSXAttributeName$0(state);
|
|
2848
2788
|
}
|
|
2849
2789
|
}
|
|
2850
|
-
var JSXAttributeInitializer$0 = $S(__, $EXPECT($
|
|
2790
|
+
var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
|
|
2851
2791
|
function JSXAttributeInitializer(state) {
|
|
2852
2792
|
if (state.verbose)
|
|
2853
2793
|
console.log("ENTER:", "JSXAttributeInitializer");
|
|
@@ -2857,9 +2797,9 @@ var require_parser = __commonJS({
|
|
|
2857
2797
|
return JSXAttributeInitializer$0(state);
|
|
2858
2798
|
}
|
|
2859
2799
|
}
|
|
2860
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
2861
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
2862
|
-
var JSXAttributeValue$2 = $S($EXPECT($
|
|
2800
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R25, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
2801
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R26, fail, "JSXAttributeValue /'[^']*'/"));
|
|
2802
|
+
var JSXAttributeValue$2 = $S($EXPECT($L11, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttributeValue "}"'));
|
|
2863
2803
|
var JSXAttributeValue$3 = JSXElement;
|
|
2864
2804
|
var JSXAttributeValue$4 = JSXFragment;
|
|
2865
2805
|
function JSXAttributeValue(state) {
|
|
@@ -2882,7 +2822,7 @@ var require_parser = __commonJS({
|
|
|
2882
2822
|
var JSXChild$0 = JSXText;
|
|
2883
2823
|
var JSXChild$1 = JSXElement;
|
|
2884
2824
|
var JSXChild$2 = JSXFragment;
|
|
2885
|
-
var JSXChild$3 = $S($EXPECT($
|
|
2825
|
+
var JSXChild$3 = $S($EXPECT($L11, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L16, fail, 'JSXChild "}"'));
|
|
2886
2826
|
function JSXChild(state) {
|
|
2887
2827
|
if (state.tokenize) {
|
|
2888
2828
|
return $TOKEN("JSXChild", state, JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state));
|
|
@@ -2890,7 +2830,7 @@ var require_parser = __commonJS({
|
|
|
2890
2830
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
2891
2831
|
}
|
|
2892
2832
|
}
|
|
2893
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
2833
|
+
var JSXText$0 = $R$0($EXPECT($R27, fail, "JSXText /[^{}<>]+/"));
|
|
2894
2834
|
function JSXText(state) {
|
|
2895
2835
|
if (state.verbose)
|
|
2896
2836
|
console.log("ENTER:", "JSXText");
|
|
@@ -2900,7 +2840,7 @@ var require_parser = __commonJS({
|
|
|
2900
2840
|
return JSXText$0(state);
|
|
2901
2841
|
}
|
|
2902
2842
|
}
|
|
2903
|
-
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($
|
|
2843
|
+
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L31, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
|
|
2904
2844
|
function JSXChildExpression(state) {
|
|
2905
2845
|
if (state.verbose)
|
|
2906
2846
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -2910,10 +2850,10 @@ var require_parser = __commonJS({
|
|
|
2910
2850
|
return JSXChildExpression$0(state);
|
|
2911
2851
|
}
|
|
2912
2852
|
}
|
|
2913
|
-
var TypeDeclaration$0 = $T($S($EXPECT($
|
|
2853
|
+
var TypeDeclaration$0 = $T($S($EXPECT($R28, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L55, fail, 'TypeDeclaration "="'), __, Type), function(value) {
|
|
2914
2854
|
return { "ts": true, "children": value };
|
|
2915
2855
|
});
|
|
2916
|
-
var TypeDeclaration$1 = $T($S($EXPECT($
|
|
2856
|
+
var TypeDeclaration$1 = $T($S($EXPECT($R29, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
|
|
2917
2857
|
return { "ts": true, "children": value };
|
|
2918
2858
|
});
|
|
2919
2859
|
function TypeDeclaration(state) {
|
|
@@ -2923,13 +2863,14 @@ var require_parser = __commonJS({
|
|
|
2923
2863
|
return TypeDeclaration$0(state) || TypeDeclaration$1(state);
|
|
2924
2864
|
}
|
|
2925
2865
|
}
|
|
2926
|
-
var InterfaceBlock$0 = $S(__, $EXPECT($
|
|
2927
|
-
var InterfaceBlock$1 = $S(
|
|
2866
|
+
var InterfaceBlock$0 = $S(__, $EXPECT($L11, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L16, fail, 'InterfaceBlock "}"'));
|
|
2867
|
+
var InterfaceBlock$1 = $S(__, $EXPECT($L11, fail, 'InterfaceBlock "{"'), $Q($S(__, InterfaceProperty)), __, $EXPECT($L16, fail, 'InterfaceBlock "}"'));
|
|
2868
|
+
var InterfaceBlock$2 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
2928
2869
|
function InterfaceBlock(state) {
|
|
2929
2870
|
if (state.tokenize) {
|
|
2930
|
-
return $TOKEN("InterfaceBlock", state, InterfaceBlock$0(state) || InterfaceBlock$1(state));
|
|
2871
|
+
return $TOKEN("InterfaceBlock", state, InterfaceBlock$0(state) || InterfaceBlock$1(state) || InterfaceBlock$2(state));
|
|
2931
2872
|
} else {
|
|
2932
|
-
return InterfaceBlock$0(state) || InterfaceBlock$1(state);
|
|
2873
|
+
return InterfaceBlock$0(state) || InterfaceBlock$1(state) || InterfaceBlock$2(state);
|
|
2933
2874
|
}
|
|
2934
2875
|
}
|
|
2935
2876
|
var NestedInterfaceProperties$0 = $TS($S(PushIndent, $Q(NestedInterfaceProperty), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
@@ -2947,7 +2888,7 @@ var require_parser = __commonJS({
|
|
|
2947
2888
|
return NestedInterfaceProperties$0(state);
|
|
2948
2889
|
}
|
|
2949
2890
|
}
|
|
2950
|
-
var NestedInterfaceProperty$0 = $S(Nested,
|
|
2891
|
+
var NestedInterfaceProperty$0 = $S(Nested, InterfaceProperty);
|
|
2951
2892
|
function NestedInterfaceProperty(state) {
|
|
2952
2893
|
if (state.verbose)
|
|
2953
2894
|
console.log("ENTER:", "NestedInterfaceProperty");
|
|
@@ -2957,7 +2898,41 @@ var require_parser = __commonJS({
|
|
|
2957
2898
|
return NestedInterfaceProperty$0(state);
|
|
2958
2899
|
}
|
|
2959
2900
|
}
|
|
2960
|
-
var
|
|
2901
|
+
var InterfaceProperty$0 = $S($C(TypeIndexSignature, PropertyName), TypeSuffix, InterfacePropertyDelimiter);
|
|
2902
|
+
function InterfaceProperty(state) {
|
|
2903
|
+
if (state.verbose)
|
|
2904
|
+
console.log("ENTER:", "InterfaceProperty");
|
|
2905
|
+
if (state.tokenize) {
|
|
2906
|
+
return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state));
|
|
2907
|
+
} else {
|
|
2908
|
+
return InterfaceProperty$0(state);
|
|
2909
|
+
}
|
|
2910
|
+
}
|
|
2911
|
+
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L85, fail, 'InterfacePropertyDelimiter ";"'));
|
|
2912
|
+
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
|
|
2913
|
+
var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
|
|
2914
|
+
return ";";
|
|
2915
|
+
});
|
|
2916
|
+
var InterfacePropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
2917
|
+
return ";";
|
|
2918
|
+
});
|
|
2919
|
+
function InterfacePropertyDelimiter(state) {
|
|
2920
|
+
if (state.tokenize) {
|
|
2921
|
+
return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state));
|
|
2922
|
+
} else {
|
|
2923
|
+
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
|
|
2924
|
+
}
|
|
2925
|
+
}
|
|
2926
|
+
var TypeIndexSignature$0 = $S($EXPECT($L24, fail, 'TypeIndexSignature "["'), __, Identifier, TypeSuffix, $EXPECT($L25, fail, 'TypeIndexSignature "]"'));
|
|
2927
|
+
var TypeIndexSignature$1 = $S($EXPECT($L24, fail, 'TypeIndexSignature "["'), __, PropertyName, __, $EXPECT($L78, fail, 'TypeIndexSignature "in"'), Type, $EXPECT($L25, fail, 'TypeIndexSignature "]"'));
|
|
2928
|
+
function TypeIndexSignature(state) {
|
|
2929
|
+
if (state.tokenize) {
|
|
2930
|
+
return $TOKEN("TypeIndexSignature", state, TypeIndexSignature$0(state) || TypeIndexSignature$1(state));
|
|
2931
|
+
} else {
|
|
2932
|
+
return TypeIndexSignature$0(state) || TypeIndexSignature$1(state);
|
|
2933
|
+
}
|
|
2934
|
+
}
|
|
2935
|
+
var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L12, fail, 'TypeSuffix ":"'), Type), function(value) {
|
|
2961
2936
|
return { "ts": true, "children": value };
|
|
2962
2937
|
});
|
|
2963
2938
|
function TypeSuffix(state) {
|
|
@@ -2969,6 +2944,28 @@ var require_parser = __commonJS({
|
|
|
2969
2944
|
return TypeSuffix$0(state);
|
|
2970
2945
|
}
|
|
2971
2946
|
}
|
|
2947
|
+
var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L127, fail, 'ReturnTypeSuffix "asserts"'), $EXPECT($R0, fail, "ReturnTypeSuffix /(?!\\p{ID_Continue})/"))), TypePredicate), function(value) {
|
|
2948
|
+
return { "ts": true, "children": value };
|
|
2949
|
+
});
|
|
2950
|
+
function ReturnTypeSuffix(state) {
|
|
2951
|
+
if (state.verbose)
|
|
2952
|
+
console.log("ENTER:", "ReturnTypeSuffix");
|
|
2953
|
+
if (state.tokenize) {
|
|
2954
|
+
return $TOKEN("ReturnTypeSuffix", state, ReturnTypeSuffix$0(state));
|
|
2955
|
+
} else {
|
|
2956
|
+
return ReturnTypeSuffix$0(state);
|
|
2957
|
+
}
|
|
2958
|
+
}
|
|
2959
|
+
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), $R$0($EXPECT($R0, fail, "TypePredicate /(?!\\p{ID_Continue})/")), Type)));
|
|
2960
|
+
function TypePredicate(state) {
|
|
2961
|
+
if (state.verbose)
|
|
2962
|
+
console.log("ENTER:", "TypePredicate");
|
|
2963
|
+
if (state.tokenize) {
|
|
2964
|
+
return $TOKEN("TypePredicate", state, TypePredicate$0(state));
|
|
2965
|
+
} else {
|
|
2966
|
+
return TypePredicate$0(state);
|
|
2967
|
+
}
|
|
2968
|
+
}
|
|
2972
2969
|
var Type$0 = TypeConditional;
|
|
2973
2970
|
function Type(state) {
|
|
2974
2971
|
if (state.verbose)
|
|
@@ -2989,7 +2986,7 @@ var require_parser = __commonJS({
|
|
|
2989
2986
|
return TypeBinary$0(state);
|
|
2990
2987
|
}
|
|
2991
2988
|
}
|
|
2992
|
-
var TypeUnary$0 = $S($Q(TypeUnaryOp), TypePrimary);
|
|
2989
|
+
var TypeUnary$0 = $S($Q($S(__, TypeUnaryOp, $R$0($EXPECT($R0, fail, "TypeUnary /(?!\\p{ID_Continue})/")))), TypePrimary, $Q(TypeUnarySuffix));
|
|
2993
2990
|
function TypeUnary(state) {
|
|
2994
2991
|
if (state.verbose)
|
|
2995
2992
|
console.log("ENTER:", "TypeUnary");
|
|
@@ -2999,19 +2996,40 @@ var require_parser = __commonJS({
|
|
|
2999
2996
|
return TypeUnary$0(state);
|
|
3000
2997
|
}
|
|
3001
2998
|
}
|
|
3002
|
-
var
|
|
3003
|
-
|
|
2999
|
+
var TypeUnarySuffix$0 = TypeIndexedAccess;
|
|
3000
|
+
function TypeUnarySuffix(state) {
|
|
3001
|
+
if (state.verbose)
|
|
3002
|
+
console.log("ENTER:", "TypeUnarySuffix");
|
|
3003
|
+
if (state.tokenize) {
|
|
3004
|
+
return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state));
|
|
3005
|
+
} else {
|
|
3006
|
+
return TypeUnarySuffix$0(state);
|
|
3007
|
+
}
|
|
3008
|
+
}
|
|
3009
|
+
var TypeUnaryOp$0 = $EXPECT($L128, fail, 'TypeUnaryOp "keyof"');
|
|
3010
|
+
var TypeUnaryOp$1 = $EXPECT($L84, fail, 'TypeUnaryOp "typeof"');
|
|
3011
|
+
var TypeUnaryOp$2 = $EXPECT($L129, fail, 'TypeUnaryOp "infer"');
|
|
3004
3012
|
function TypeUnaryOp(state) {
|
|
3005
3013
|
if (state.tokenize) {
|
|
3006
|
-
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state));
|
|
3014
|
+
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
3015
|
+
} else {
|
|
3016
|
+
return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
|
|
3017
|
+
}
|
|
3018
|
+
}
|
|
3019
|
+
var TypeIndexedAccess$0 = $S(__, $EXPECT($L24, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L25, fail, 'TypeIndexedAccess "]"'));
|
|
3020
|
+
function TypeIndexedAccess(state) {
|
|
3021
|
+
if (state.verbose)
|
|
3022
|
+
console.log("ENTER:", "TypeIndexedAccess");
|
|
3023
|
+
if (state.tokenize) {
|
|
3024
|
+
return $TOKEN("TypeIndexedAccess", state, TypeIndexedAccess$0(state));
|
|
3007
3025
|
} else {
|
|
3008
|
-
return
|
|
3026
|
+
return TypeIndexedAccess$0(state);
|
|
3009
3027
|
}
|
|
3010
3028
|
}
|
|
3011
3029
|
var TypePrimary$0 = InterfaceBlock;
|
|
3012
3030
|
var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
|
|
3013
3031
|
var TypePrimary$2 = $S($Q(_), FunctionType);
|
|
3014
|
-
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($
|
|
3032
|
+
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L26, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
|
|
3015
3033
|
var TypePrimary$4 = $S($Q(_), TypeLiteral);
|
|
3016
3034
|
function TypePrimary(state) {
|
|
3017
3035
|
if (state.tokenize) {
|
|
@@ -3020,7 +3038,7 @@ var require_parser = __commonJS({
|
|
|
3020
3038
|
return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
|
|
3021
3039
|
}
|
|
3022
3040
|
}
|
|
3023
|
-
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($
|
|
3041
|
+
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L15, fail, 'TypeConditional "extends"'), Type, __, $EXPECT($L3, fail, 'TypeConditional "?"'), Type, __, $EXPECT($L12, fail, 'TypeConditional ":"'), Type)));
|
|
3024
3042
|
function TypeConditional(state) {
|
|
3025
3043
|
if (state.verbose)
|
|
3026
3044
|
console.log("ENTER:", "TypeConditional");
|
|
@@ -3031,8 +3049,8 @@ var require_parser = __commonJS({
|
|
|
3031
3049
|
}
|
|
3032
3050
|
}
|
|
3033
3051
|
var TypeLiteral$0 = Literal;
|
|
3034
|
-
var TypeLiteral$1 = $EXPECT($
|
|
3035
|
-
var TypeLiteral$2 = $EXPECT($
|
|
3052
|
+
var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
|
|
3053
|
+
var TypeLiteral$2 = $EXPECT($L130, fail, 'TypeLiteral "[]"');
|
|
3036
3054
|
function TypeLiteral(state) {
|
|
3037
3055
|
if (state.tokenize) {
|
|
3038
3056
|
return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
|
|
@@ -3040,8 +3058,8 @@ var require_parser = __commonJS({
|
|
|
3040
3058
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
3041
3059
|
}
|
|
3042
3060
|
}
|
|
3043
|
-
var TypeBinaryOp$0 = $EXPECT($
|
|
3044
|
-
var TypeBinaryOp$1 = $EXPECT($
|
|
3061
|
+
var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
|
|
3062
|
+
var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
|
|
3045
3063
|
function TypeBinaryOp(state) {
|
|
3046
3064
|
if (state.tokenize) {
|
|
3047
3065
|
return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
|
|
@@ -3049,7 +3067,7 @@ var require_parser = __commonJS({
|
|
|
3049
3067
|
return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
|
|
3050
3068
|
}
|
|
3051
3069
|
}
|
|
3052
|
-
var FunctionType$0 = $S(Parameters, __, $EXPECT($
|
|
3070
|
+
var FunctionType$0 = $S(Parameters, __, $EXPECT($L10, fail, 'FunctionType "=>"'), Type);
|
|
3053
3071
|
function FunctionType(state) {
|
|
3054
3072
|
if (state.verbose)
|
|
3055
3073
|
console.log("ENTER:", "FunctionType");
|
|
@@ -3059,7 +3077,7 @@ var require_parser = __commonJS({
|
|
|
3059
3077
|
return FunctionType$0(state);
|
|
3060
3078
|
}
|
|
3061
3079
|
}
|
|
3062
|
-
var TypeArguments$0 = $S(__, $EXPECT($
|
|
3080
|
+
var TypeArguments$0 = $S(__, $EXPECT($L14, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L66, fail, 'TypeArguments ">"'));
|
|
3063
3081
|
function TypeArguments(state) {
|
|
3064
3082
|
if (state.verbose)
|
|
3065
3083
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -3069,7 +3087,7 @@ var require_parser = __commonJS({
|
|
|
3069
3087
|
return TypeArguments$0(state);
|
|
3070
3088
|
}
|
|
3071
3089
|
}
|
|
3072
|
-
var TypeParameters$0 = $S(__, $EXPECT($
|
|
3090
|
+
var TypeParameters$0 = $S(__, $EXPECT($L14, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L66, fail, 'TypeParameters ">"'));
|
|
3073
3091
|
function TypeParameters(state) {
|
|
3074
3092
|
if (state.verbose)
|
|
3075
3093
|
console.log("ENTER:", "TypeParameters");
|
|
@@ -3089,7 +3107,7 @@ var require_parser = __commonJS({
|
|
|
3089
3107
|
return TypeParameter$0(state);
|
|
3090
3108
|
}
|
|
3091
3109
|
}
|
|
3092
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
3110
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L15, fail, 'TypeConstraint "extends"'), Type);
|
|
3093
3111
|
function TypeConstraint(state) {
|
|
3094
3112
|
if (state.verbose)
|
|
3095
3113
|
console.log("ENTER:", "TypeConstraint");
|
|
@@ -3100,8 +3118,8 @@ var require_parser = __commonJS({
|
|
|
3100
3118
|
}
|
|
3101
3119
|
}
|
|
3102
3120
|
var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
|
|
3103
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
3104
|
-
var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
3121
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L66, fail, 'TypeParameterDelimiter ">"')));
|
|
3122
|
+
var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L66, fail, 'TypeParameterDelimiter ">"'))), function(value) {
|
|
3105
3123
|
return ",";
|
|
3106
3124
|
});
|
|
3107
3125
|
var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -3166,7 +3184,7 @@ var require_parser = __commonJS({
|
|
|
3166
3184
|
return EOF$0(state);
|
|
3167
3185
|
}
|
|
3168
3186
|
}
|
|
3169
|
-
var InsertOpenParen$0 = $T($EXPECT($
|
|
3187
|
+
var InsertOpenParen$0 = $T($EXPECT($L30, fail, 'InsertOpenParen ""'), function(value) {
|
|
3170
3188
|
return "(";
|
|
3171
3189
|
});
|
|
3172
3190
|
function InsertOpenParen(state) {
|
|
@@ -3178,7 +3196,7 @@ var require_parser = __commonJS({
|
|
|
3178
3196
|
return InsertOpenParen$0(state);
|
|
3179
3197
|
}
|
|
3180
3198
|
}
|
|
3181
|
-
var InsertCloseParen$0 = $T($EXPECT($
|
|
3199
|
+
var InsertCloseParen$0 = $T($EXPECT($L30, fail, 'InsertCloseParen ""'), function(value) {
|
|
3182
3200
|
return ")";
|
|
3183
3201
|
});
|
|
3184
3202
|
function InsertCloseParen(state) {
|
|
@@ -3190,7 +3208,7 @@ var require_parser = __commonJS({
|
|
|
3190
3208
|
return InsertCloseParen$0(state);
|
|
3191
3209
|
}
|
|
3192
3210
|
}
|
|
3193
|
-
var InsertOpenBrace$0 = $T($EXPECT($
|
|
3211
|
+
var InsertOpenBrace$0 = $T($EXPECT($L30, fail, 'InsertOpenBrace ""'), function(value) {
|
|
3194
3212
|
return " {";
|
|
3195
3213
|
});
|
|
3196
3214
|
function InsertOpenBrace(state) {
|
|
@@ -3202,7 +3220,7 @@ var require_parser = __commonJS({
|
|
|
3202
3220
|
return InsertOpenBrace$0(state);
|
|
3203
3221
|
}
|
|
3204
3222
|
}
|
|
3205
|
-
var InsertCloseBrace$0 = $T($EXPECT($
|
|
3223
|
+
var InsertCloseBrace$0 = $T($EXPECT($L30, fail, 'InsertCloseBrace ""'), function(value) {
|
|
3206
3224
|
return "}";
|
|
3207
3225
|
});
|
|
3208
3226
|
function InsertCloseBrace(state) {
|
|
@@ -3214,7 +3232,7 @@ var require_parser = __commonJS({
|
|
|
3214
3232
|
return InsertCloseBrace$0(state);
|
|
3215
3233
|
}
|
|
3216
3234
|
}
|
|
3217
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
3235
|
+
var InsertNewline$0 = $TV($EXPECT($L30, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
3218
3236
|
return "\n";
|
|
3219
3237
|
});
|
|
3220
3238
|
function InsertNewline(state) {
|
|
@@ -3226,7 +3244,7 @@ var require_parser = __commonJS({
|
|
|
3226
3244
|
return InsertNewline$0(state);
|
|
3227
3245
|
}
|
|
3228
3246
|
}
|
|
3229
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
3247
|
+
var InsertIndent$0 = $TV($EXPECT($L30, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
3230
3248
|
return "".padStart(global.currentIndent * 2);
|
|
3231
3249
|
});
|
|
3232
3250
|
function InsertIndent(state) {
|
|
@@ -3238,7 +3256,7 @@ var require_parser = __commonJS({
|
|
|
3238
3256
|
return InsertIndent$0(state);
|
|
3239
3257
|
}
|
|
3240
3258
|
}
|
|
3241
|
-
var InsertSpace$0 = $T($EXPECT($
|
|
3259
|
+
var InsertSpace$0 = $T($EXPECT($L30, fail, 'InsertSpace ""'), function(value) {
|
|
3242
3260
|
return " ";
|
|
3243
3261
|
});
|
|
3244
3262
|
function InsertSpace(state) {
|
|
@@ -3250,7 +3268,7 @@ var require_parser = __commonJS({
|
|
|
3250
3268
|
return InsertSpace$0(state);
|
|
3251
3269
|
}
|
|
3252
3270
|
}
|
|
3253
|
-
var InsertDot$0 = $T($EXPECT($
|
|
3271
|
+
var InsertDot$0 = $T($EXPECT($L30, fail, 'InsertDot ""'), function(value) {
|
|
3254
3272
|
return ".";
|
|
3255
3273
|
});
|
|
3256
3274
|
function InsertDot(state) {
|
|
@@ -3262,7 +3280,7 @@ var require_parser = __commonJS({
|
|
|
3262
3280
|
return InsertDot$0(state);
|
|
3263
3281
|
}
|
|
3264
3282
|
}
|
|
3265
|
-
var InsertBreak$0 = $T($EXPECT($
|
|
3283
|
+
var InsertBreak$0 = $T($EXPECT($L30, fail, 'InsertBreak ""'), function(value) {
|
|
3266
3284
|
return "break;";
|
|
3267
3285
|
});
|
|
3268
3286
|
function InsertBreak(state) {
|
|
@@ -3274,7 +3292,7 @@ var require_parser = __commonJS({
|
|
|
3274
3292
|
return InsertBreak$0(state);
|
|
3275
3293
|
}
|
|
3276
3294
|
}
|
|
3277
|
-
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($
|
|
3295
|
+
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L30, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3278
3296
|
var directives = $2;
|
|
3279
3297
|
global.currentIndent = 0;
|
|
3280
3298
|
global.indentLevels = [0];
|
|
@@ -3294,7 +3312,7 @@ var require_parser = __commonJS({
|
|
|
3294
3312
|
return Init$0(state);
|
|
3295
3313
|
}
|
|
3296
3314
|
}
|
|
3297
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
3315
|
+
var Indent$0 = $TV($Q($C($EXPECT($L131, fail, 'Indent " "'), $EXPECT($L132, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
3298
3316
|
return $1.length;
|
|
3299
3317
|
});
|
|
3300
3318
|
function Indent(state) {
|
|
@@ -3306,7 +3324,7 @@ var require_parser = __commonJS({
|
|
|
3306
3324
|
return Indent$0(state);
|
|
3307
3325
|
}
|
|
3308
3326
|
}
|
|
3309
|
-
var PushIndent$0 = $TV($EXPECT($
|
|
3327
|
+
var PushIndent$0 = $TV($EXPECT($L30, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
|
|
3310
3328
|
global.currentIndent++;
|
|
3311
3329
|
if (global.verbose) {
|
|
3312
3330
|
console.log("pushing indent", global.currentIndent);
|
|
@@ -3323,7 +3341,7 @@ var require_parser = __commonJS({
|
|
|
3323
3341
|
return PushIndent$0(state);
|
|
3324
3342
|
}
|
|
3325
3343
|
}
|
|
3326
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
3344
|
+
var PopIndent$0 = $TV($EXPECT($L30, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
3327
3345
|
if (global.verbose) {
|
|
3328
3346
|
console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
|
|
3329
3347
|
}
|