@danielx/civet 0.2.1 → 0.2.2
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 +421 -441
- package/dist/browser.js.map +2 -2
- package/dist/civet +7 -7
- package/dist/cli.js.map +3 -3
- package/dist/main.js +421 -441
- 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,
|
|
@@ -602,10 +596,14 @@ var require_parser = __commonJS({
|
|
|
602
596
|
NestedInterfaceProperties,
|
|
603
597
|
NestedInterfaceProperty,
|
|
604
598
|
TypeSuffix,
|
|
599
|
+
ReturnTypeSuffix,
|
|
600
|
+
TypePredicate,
|
|
605
601
|
Type,
|
|
606
602
|
TypeBinary,
|
|
607
603
|
TypeUnary,
|
|
604
|
+
TypeUnarySuffix,
|
|
608
605
|
TypeUnaryOp,
|
|
606
|
+
TypeIndexedAccess,
|
|
609
607
|
TypePrimary,
|
|
610
608
|
TypeConditional,
|
|
611
609
|
TypeLiteral,
|
|
@@ -640,113 +638,113 @@ var require_parser = __commonJS({
|
|
|
640
638
|
var $L1 = $L("(");
|
|
641
639
|
var $L2 = $L(")");
|
|
642
640
|
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("
|
|
641
|
+
var $L4 = $L("as");
|
|
642
|
+
var $L5 = $L("++");
|
|
643
|
+
var $L6 = $L("--");
|
|
644
|
+
var $L7 = $L("async");
|
|
645
|
+
var $L8 = $L("yield");
|
|
646
|
+
var $L9 = $L("*");
|
|
647
|
+
var $L10 = $L("=>");
|
|
648
|
+
var $L11 = $L("{");
|
|
649
|
+
var $L12 = $L(":");
|
|
650
|
+
var $L13 = $L("class");
|
|
651
|
+
var $L14 = $L("<");
|
|
652
|
+
var $L15 = $L("extends");
|
|
653
|
+
var $L16 = $L("}");
|
|
654
|
+
var $L17 = $L("static");
|
|
655
|
+
var $L18 = $L("this");
|
|
656
|
+
var $L19 = $L("@");
|
|
657
|
+
var $L20 = $L("#");
|
|
658
|
+
var $L21 = $L("new");
|
|
659
|
+
var $L22 = $L("super");
|
|
660
|
+
var $L23 = $L("import");
|
|
661
|
+
var $L24 = $L("[");
|
|
662
|
+
var $L25 = $L("]");
|
|
663
|
+
var $L26 = $L(".");
|
|
664
|
+
var $L27 = $L("super[");
|
|
665
|
+
var $L28 = $L("new.target");
|
|
666
|
+
var $L29 = $L("import.meta");
|
|
667
|
+
var $L30 = $L("");
|
|
668
|
+
var $L31 = $L("...");
|
|
669
|
+
var $L32 = $L("function");
|
|
670
|
+
var $L33 = $L("->");
|
|
671
|
+
var $L34 = $L("true");
|
|
672
|
+
var $L35 = $L("false");
|
|
673
|
+
var $L36 = $L("null");
|
|
674
|
+
var $L37 = $L("undefined");
|
|
675
|
+
var $L38 = $L("get");
|
|
676
|
+
var $L39 = $L("set");
|
|
677
|
+
var $L40 = $L("**=");
|
|
678
|
+
var $L41 = $L("*=");
|
|
679
|
+
var $L42 = $L("/=");
|
|
680
|
+
var $L43 = $L("%=");
|
|
681
|
+
var $L44 = $L("+=");
|
|
682
|
+
var $L45 = $L("-=");
|
|
683
|
+
var $L46 = $L("<<=");
|
|
684
|
+
var $L47 = $L(">>>=");
|
|
685
|
+
var $L48 = $L(">>=");
|
|
686
|
+
var $L49 = $L("&&=");
|
|
687
|
+
var $L50 = $L("&=");
|
|
688
|
+
var $L51 = $L("^=");
|
|
689
|
+
var $L52 = $L("||=");
|
|
690
|
+
var $L53 = $L("|=");
|
|
691
|
+
var $L54 = $L("??=");
|
|
692
|
+
var $L55 = $L("=");
|
|
693
|
+
var $L56 = $L("**");
|
|
694
|
+
var $L57 = $L("/");
|
|
695
|
+
var $L58 = $L("%");
|
|
696
|
+
var $L59 = $L("+");
|
|
697
|
+
var $L60 = $L("-");
|
|
698
|
+
var $L61 = $L("<=");
|
|
699
|
+
var $L62 = $L(">=");
|
|
700
|
+
var $L63 = $L("<<");
|
|
701
|
+
var $L64 = $L(">>>");
|
|
702
|
+
var $L65 = $L(">>");
|
|
703
|
+
var $L66 = $L(">");
|
|
704
|
+
var $L67 = $L("!==");
|
|
705
|
+
var $L68 = $L("!=");
|
|
706
|
+
var $L69 = $L("is");
|
|
707
|
+
var $L70 = $L("===");
|
|
708
|
+
var $L71 = $L("==");
|
|
709
|
+
var $L72 = $L("and");
|
|
710
|
+
var $L73 = $L("&&");
|
|
711
|
+
var $L74 = $L("or");
|
|
712
|
+
var $L75 = $L("||");
|
|
713
|
+
var $L76 = $L("??");
|
|
714
|
+
var $L77 = $L("instanceof");
|
|
715
|
+
var $L78 = $L("in");
|
|
716
|
+
var $L79 = $L("&");
|
|
717
|
+
var $L80 = $L("^");
|
|
718
|
+
var $L81 = $L("|");
|
|
719
|
+
var $L82 = $L("delete");
|
|
720
|
+
var $L83 = $L("void");
|
|
721
|
+
var $L84 = $L("typeof");
|
|
722
|
+
var $L85 = $L(";");
|
|
723
|
+
var $L86 = $L("if");
|
|
724
|
+
var $L87 = $L("else");
|
|
725
|
+
var $L88 = $L("unless");
|
|
726
|
+
var $L89 = $L("loop");
|
|
727
|
+
var $L90 = $L("do");
|
|
728
|
+
var $L91 = $L("while");
|
|
729
|
+
var $L92 = $L("for");
|
|
730
|
+
var $L93 = $L("var");
|
|
731
|
+
var $L94 = $L("await");
|
|
732
|
+
var $L95 = $L("of");
|
|
733
|
+
var $L96 = $L("let");
|
|
734
|
+
var $L97 = $L("const");
|
|
735
|
+
var $L98 = $L("switch");
|
|
736
|
+
var $L99 = $L("case");
|
|
737
|
+
var $L100 = $L("default");
|
|
738
|
+
var $L101 = $L("when");
|
|
739
|
+
var $L102 = $L("try");
|
|
740
|
+
var $L103 = $L("catch");
|
|
741
|
+
var $L104 = $L("finally");
|
|
742
|
+
var $L105 = $L("break");
|
|
743
|
+
var $L106 = $L("continue");
|
|
744
|
+
var $L107 = $L("debugger");
|
|
745
|
+
var $L108 = $L("return");
|
|
746
|
+
var $L109 = $L("throw");
|
|
747
|
+
var $L110 = $L("import type");
|
|
750
748
|
var $L111 = $L("from");
|
|
751
749
|
var $L112 = $L("export");
|
|
752
750
|
var $L113 = $L(":=");
|
|
@@ -763,40 +761,42 @@ var require_parser = __commonJS({
|
|
|
763
761
|
var $L124 = $L("</");
|
|
764
762
|
var $L125 = $L("<>");
|
|
765
763
|
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 $
|
|
764
|
+
var $L127 = $L("asserts");
|
|
765
|
+
var $L128 = $L("keyof");
|
|
766
|
+
var $L129 = $L("infer");
|
|
767
|
+
var $L130 = $L("[]");
|
|
768
|
+
var $L131 = $L(" ");
|
|
769
|
+
var $L132 = $L(" ");
|
|
770
|
+
var $R0 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
771
|
+
var $R1 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
772
|
+
var $R2 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
773
|
+
var $R3 = $R(new RegExp("\\p{ID_Continue}", "suy"));
|
|
774
|
+
var $R4 = $R(new RegExp("[!~+-]", "suy"));
|
|
775
|
+
var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
776
|
+
var $R6 = $R(new RegExp("\\d+(?:\\.\\d*)?", "suy"));
|
|
777
|
+
var $R7 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
|
|
778
|
+
var $R8 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
|
|
779
|
+
var $R9 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
|
|
780
|
+
var $R10 = $R(new RegExp('[^"\\\\]+', "suy"));
|
|
781
|
+
var $R11 = $R(new RegExp("[^'\\\\]+", "suy"));
|
|
782
|
+
var $R12 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
|
|
783
|
+
var $R13 = $R(new RegExp(".", "suy"));
|
|
784
|
+
var $R14 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
|
|
785
|
+
var $R15 = $R(new RegExp("[^\\/\\r\\n]+", "suy"));
|
|
786
|
+
var $R16 = $R(new RegExp("(:?\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
787
|
+
var $R17 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
788
|
+
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"));
|
|
789
|
+
var $R19 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
790
|
+
var $R20 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
791
|
+
var $R21 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
792
|
+
var $R22 = $R(new RegExp("[\\t ]+", "suy"));
|
|
793
|
+
var $R23 = $R(new RegExp("[\\s]+", "suy"));
|
|
794
|
+
var $R24 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
795
|
+
var $R25 = $R(new RegExp('"[^"]*"', "suy"));
|
|
796
|
+
var $R26 = $R(new RegExp("'[^']*'", "suy"));
|
|
797
|
+
var $R27 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
798
|
+
var $R28 = $R(new RegExp("type(?!\\p{ID_Continue})", "suy"));
|
|
799
|
+
var $R29 = $R(new RegExp("interface(?!\\p{ID_Continue})", "suy"));
|
|
800
800
|
var $R30 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
801
801
|
var $R31 = $R(new RegExp("[\\t ]*", "suy"));
|
|
802
802
|
var $R32 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
@@ -899,10 +899,10 @@ var require_parser = __commonJS({
|
|
|
899
899
|
var pre = $1;
|
|
900
900
|
var exp = $2;
|
|
901
901
|
var post = $3;
|
|
902
|
-
if (post) {
|
|
902
|
+
if (post === "?") {
|
|
903
903
|
return ["(", pre, , "(", exp, ") != null)"];
|
|
904
904
|
}
|
|
905
|
-
return [pre, exp];
|
|
905
|
+
return [pre, exp, post];
|
|
906
906
|
});
|
|
907
907
|
function UnaryExpression(state) {
|
|
908
908
|
if (state.verbose)
|
|
@@ -914,17 +914,16 @@ var require_parser = __commonJS({
|
|
|
914
914
|
}
|
|
915
915
|
}
|
|
916
916
|
var UnaryPostfix$0 = $EXPECT($L3, fail, 'UnaryPostfix "?"');
|
|
917
|
+
var UnaryPostfix$1 = $S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), $R$0($EXPECT($R0, fail, "UnaryPostfix /(?!\\p{ID_Continue})/")), Type);
|
|
917
918
|
function UnaryPostfix(state) {
|
|
918
|
-
if (state.verbose)
|
|
919
|
-
console.log("ENTER:", "UnaryPostfix");
|
|
920
919
|
if (state.tokenize) {
|
|
921
|
-
return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state));
|
|
920
|
+
return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state));
|
|
922
921
|
} else {
|
|
923
|
-
return UnaryPostfix$0(state);
|
|
922
|
+
return UnaryPostfix$0(state) || UnaryPostfix$1(state);
|
|
924
923
|
}
|
|
925
924
|
}
|
|
926
|
-
var UpdateExpression$0 = $S($C($EXPECT($
|
|
927
|
-
var UpdateExpression$1 = $S(LeftHandSideExpression, $E($C($EXPECT($
|
|
925
|
+
var UpdateExpression$0 = $S($C($EXPECT($L5, fail, 'UpdateExpression "++"'), $EXPECT($L6, fail, 'UpdateExpression "--"')), UnaryExpression);
|
|
926
|
+
var UpdateExpression$1 = $S(LeftHandSideExpression, $E($C($EXPECT($L5, fail, 'UpdateExpression "++"'), $EXPECT($L6, fail, 'UpdateExpression "--"'))));
|
|
928
927
|
function UpdateExpression(state) {
|
|
929
928
|
if (state.tokenize) {
|
|
930
929
|
return $TOKEN("UpdateExpression", state, UpdateExpression$0(state) || UpdateExpression$1(state));
|
|
@@ -942,7 +941,7 @@ var require_parser = __commonJS({
|
|
|
942
941
|
}
|
|
943
942
|
}
|
|
944
943
|
var AssignmentExpressionRest$0 = YieldExpression;
|
|
945
|
-
var AssignmentExpressionRest$1 = $S($E($S($EXPECT($
|
|
944
|
+
var AssignmentExpressionRest$1 = $S($E($S($EXPECT($L7, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
|
|
946
945
|
var AssignmentExpressionRest$2 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), $C($S($Q(_), Expression), $S(__, Expression)));
|
|
947
946
|
var AssignmentExpressionRest$3 = ConditionalExpression;
|
|
948
947
|
function AssignmentExpressionRest(state) {
|
|
@@ -952,7 +951,7 @@ var require_parser = __commonJS({
|
|
|
952
951
|
return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state);
|
|
953
952
|
}
|
|
954
953
|
}
|
|
955
|
-
var YieldExpression$0 = $S($EXPECT($
|
|
954
|
+
var YieldExpression$0 = $S($EXPECT($L8, fail, 'YieldExpression "yield"'), $E($S($Q(TrailingComment), $EXPECT($L9, fail, 'YieldExpression "*"'))), AssignmentExpression);
|
|
956
955
|
function YieldExpression(state) {
|
|
957
956
|
if (state.verbose)
|
|
958
957
|
console.log("ENTER:", "YieldExpression");
|
|
@@ -963,7 +962,7 @@ var require_parser = __commonJS({
|
|
|
963
962
|
}
|
|
964
963
|
}
|
|
965
964
|
var ArrowFunction$0 = ThinArrowFunction;
|
|
966
|
-
var ArrowFunction$1 = $S($C(BindingIdentifier, Parameters), __, $EXPECT($
|
|
965
|
+
var ArrowFunction$1 = $S($C(BindingIdentifier, Parameters), __, $EXPECT($L10, fail, 'ArrowFunction "=>"'), ConciseBody);
|
|
967
966
|
function ArrowFunction(state) {
|
|
968
967
|
if (state.tokenize) {
|
|
969
968
|
return $TOKEN("ArrowFunction", state, ArrowFunction$0(state) || ArrowFunction$1(state));
|
|
@@ -971,7 +970,7 @@ var require_parser = __commonJS({
|
|
|
971
970
|
return ArrowFunction$0(state) || ArrowFunction$1(state);
|
|
972
971
|
}
|
|
973
972
|
}
|
|
974
|
-
var ConciseBody$0 = $S($N($S($Q(_), $EXPECT($
|
|
973
|
+
var ConciseBody$0 = $S($N($S($Q(_), $EXPECT($L11, fail, 'ConciseBody "{"'))), AssignmentExpression);
|
|
975
974
|
var ConciseBody$1 = $S(EOS, SingleNestedBlockExpression);
|
|
976
975
|
var ConciseBody$2 = BracedBlock;
|
|
977
976
|
function ConciseBody(state) {
|
|
@@ -981,7 +980,7 @@ var require_parser = __commonJS({
|
|
|
981
980
|
return ConciseBody$0(state) || ConciseBody$1(state) || ConciseBody$2(state);
|
|
982
981
|
}
|
|
983
982
|
}
|
|
984
|
-
var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($
|
|
983
|
+
var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L12, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
|
|
985
984
|
function ConditionalExpression(state) {
|
|
986
985
|
if (state.verbose)
|
|
987
986
|
console.log("ENTER:", "ConditionalExpression");
|
|
@@ -1030,7 +1029,7 @@ var require_parser = __commonJS({
|
|
|
1030
1029
|
return ClassDeclaration$0(state);
|
|
1031
1030
|
}
|
|
1032
1031
|
}
|
|
1033
|
-
var ClassExpression$0 = $S($EXPECT($
|
|
1032
|
+
var ClassExpression$0 = $S($EXPECT($L13, fail, 'ClassExpression "class"'), $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
|
|
1034
1033
|
function ClassExpression(state) {
|
|
1035
1034
|
if (state.verbose)
|
|
1036
1035
|
console.log("ENTER:", "ClassExpression");
|
|
@@ -1050,10 +1049,10 @@ var require_parser = __commonJS({
|
|
|
1050
1049
|
return ClassHeritage$0(state);
|
|
1051
1050
|
}
|
|
1052
1051
|
}
|
|
1053
|
-
var ExtendsToken$0 = $T($EXPECT($
|
|
1052
|
+
var ExtendsToken$0 = $T($EXPECT($L14, fail, 'ExtendsToken "<"'), function(value) {
|
|
1054
1053
|
return "extends";
|
|
1055
1054
|
});
|
|
1056
|
-
var ExtendsToken$1 = $EXPECT($
|
|
1055
|
+
var ExtendsToken$1 = $EXPECT($L15, fail, 'ExtendsToken "extends"');
|
|
1057
1056
|
function ExtendsToken(state) {
|
|
1058
1057
|
if (state.tokenize) {
|
|
1059
1058
|
return $TOKEN("ExtendsToken", state, ExtendsToken$0(state) || ExtendsToken$1(state));
|
|
@@ -1061,7 +1060,7 @@ var require_parser = __commonJS({
|
|
|
1061
1060
|
return ExtendsToken$0(state) || ExtendsToken$1(state);
|
|
1062
1061
|
}
|
|
1063
1062
|
}
|
|
1064
|
-
var ClassBody$0 = $S(__, $EXPECT($
|
|
1063
|
+
var ClassBody$0 = $S(__, $EXPECT($L11, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L16, fail, 'ClassBody "}"'));
|
|
1065
1064
|
var ClassBody$1 = $S(InsertOpenBrace, EOS, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1066
1065
|
function ClassBody(state) {
|
|
1067
1066
|
if (state.tokenize) {
|
|
@@ -1095,8 +1094,8 @@ var require_parser = __commonJS({
|
|
|
1095
1094
|
return NestedClassElement$0(state);
|
|
1096
1095
|
}
|
|
1097
1096
|
}
|
|
1098
|
-
var ClassElement$0 = $S($EXPECT($
|
|
1099
|
-
var ClassElement$1 = $S($E($S($EXPECT($
|
|
1097
|
+
var ClassElement$0 = $S($EXPECT($L17, fail, 'ClassElement "static"'), BracedBlock);
|
|
1098
|
+
var ClassElement$1 = $S($E($S($EXPECT($L17, fail, 'ClassElement "static"'), __)), $C(MethodDefinition, FieldDefinition));
|
|
1100
1099
|
function ClassElement(state) {
|
|
1101
1100
|
if (state.tokenize) {
|
|
1102
1101
|
return $TOKEN("ClassElement", state, ClassElement$0(state) || ClassElement$1(state));
|
|
@@ -1114,12 +1113,12 @@ var require_parser = __commonJS({
|
|
|
1114
1113
|
return FieldDefinition$0(state);
|
|
1115
1114
|
}
|
|
1116
1115
|
}
|
|
1117
|
-
var This$0 = $EXPECT($
|
|
1118
|
-
var This$1 = $T($S($EXPECT($
|
|
1116
|
+
var This$0 = $EXPECT($L18, fail, 'This "this"');
|
|
1117
|
+
var This$1 = $T($S($EXPECT($L19, fail, 'This "@"'), $S($E($EXPECT($L20, fail, 'This "#"')), IdentifierName)), function(value) {
|
|
1119
1118
|
var ref = value[1];
|
|
1120
1119
|
return ["this.", ref];
|
|
1121
1120
|
});
|
|
1122
|
-
var This$2 = $T($EXPECT($
|
|
1121
|
+
var This$2 = $T($EXPECT($L19, fail, 'This "@"'), function(value) {
|
|
1123
1122
|
return "this";
|
|
1124
1123
|
});
|
|
1125
1124
|
function This(state) {
|
|
@@ -1138,7 +1137,7 @@ var require_parser = __commonJS({
|
|
|
1138
1137
|
return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
|
|
1139
1138
|
}
|
|
1140
1139
|
}
|
|
1141
|
-
var NewExpression$0 = $S($P($S($EXPECT($
|
|
1140
|
+
var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)), MemberExpression);
|
|
1142
1141
|
function NewExpression(state) {
|
|
1143
1142
|
if (state.verbose)
|
|
1144
1143
|
console.log("ENTER:", "NewExpression");
|
|
@@ -1148,8 +1147,8 @@ var require_parser = __commonJS({
|
|
|
1148
1147
|
return NewExpression$0(state);
|
|
1149
1148
|
}
|
|
1150
1149
|
}
|
|
1151
|
-
var CallExpression$0 = $S($EXPECT($
|
|
1152
|
-
var CallExpression$1 = $S($EXPECT($
|
|
1150
|
+
var CallExpression$0 = $S($EXPECT($L22, fail, 'CallExpression "super"'), __, Arguments);
|
|
1151
|
+
var CallExpression$1 = $S($EXPECT($L23, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
|
|
1153
1152
|
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest), $E(SpacedApplication));
|
|
1154
1153
|
function CallExpression(state) {
|
|
1155
1154
|
if (state.tokenize) {
|
|
@@ -1159,8 +1158,8 @@ var require_parser = __commonJS({
|
|
|
1159
1158
|
}
|
|
1160
1159
|
}
|
|
1161
1160
|
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($
|
|
1161
|
+
var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($L24, fail, 'CallExpressionRest "["'), __, Expression, __, $EXPECT($L25, fail, 'CallExpressionRest "]"'));
|
|
1162
|
+
var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($L26, fail, 'CallExpressionRest "."'), $C(IdentifierName, PrivateIdentifier));
|
|
1164
1163
|
var CallExpressionRest$3 = TemplateLiteral;
|
|
1165
1164
|
function CallExpressionRest(state) {
|
|
1166
1165
|
if (state.tokenize) {
|
|
@@ -1169,7 +1168,7 @@ var require_parser = __commonJS({
|
|
|
1169
1168
|
return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
|
|
1170
1169
|
}
|
|
1171
1170
|
}
|
|
1172
|
-
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($
|
|
1171
|
+
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L26, fail, 'OptionalShorthand "."'), InsertDot));
|
|
1173
1172
|
function OptionalShorthand(state) {
|
|
1174
1173
|
if (state.verbose)
|
|
1175
1174
|
console.log("ENTER:", "OptionalShorthand");
|
|
@@ -1203,7 +1202,7 @@ var require_parser = __commonJS({
|
|
|
1203
1202
|
return ApplicationStart$0(state);
|
|
1204
1203
|
}
|
|
1205
1204
|
}
|
|
1206
|
-
var AdditionalReservedWords$0 = $R$0($EXPECT($
|
|
1205
|
+
var AdditionalReservedWords$0 = $R$0($EXPECT($R1, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue})/"));
|
|
1207
1206
|
function AdditionalReservedWords(state) {
|
|
1208
1207
|
if (state.verbose)
|
|
1209
1208
|
console.log("ENTER:", "AdditionalReservedWords");
|
|
@@ -1223,7 +1222,7 @@ var require_parser = __commonJS({
|
|
|
1223
1222
|
return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
|
|
1224
1223
|
}
|
|
1225
1224
|
}
|
|
1226
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
1225
|
+
var SuperProperty$0 = $S($EXPECT($L27, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L25, fail, 'SuperProperty "]"'));
|
|
1227
1226
|
function SuperProperty(state) {
|
|
1228
1227
|
if (state.verbose)
|
|
1229
1228
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1233,8 +1232,8 @@ var require_parser = __commonJS({
|
|
|
1233
1232
|
return SuperProperty$0(state);
|
|
1234
1233
|
}
|
|
1235
1234
|
}
|
|
1236
|
-
var MetaProperty$0 = $EXPECT($
|
|
1237
|
-
var MetaProperty$1 = $EXPECT($
|
|
1235
|
+
var MetaProperty$0 = $EXPECT($L28, fail, 'MetaProperty "new.target"');
|
|
1236
|
+
var MetaProperty$1 = $EXPECT($L29, fail, 'MetaProperty "import.meta"');
|
|
1238
1237
|
function MetaProperty(state) {
|
|
1239
1238
|
if (state.tokenize) {
|
|
1240
1239
|
return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
|
|
@@ -1243,7 +1242,7 @@ var require_parser = __commonJS({
|
|
|
1243
1242
|
}
|
|
1244
1243
|
}
|
|
1245
1244
|
var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
|
|
1246
|
-
var Parameters$1 = $T($EXPECT($
|
|
1245
|
+
var Parameters$1 = $T($EXPECT($L30, fail, 'Parameters ""'), function(value) {
|
|
1247
1246
|
return "()";
|
|
1248
1247
|
});
|
|
1249
1248
|
function Parameters(state) {
|
|
@@ -1297,7 +1296,7 @@ var require_parser = __commonJS({
|
|
|
1297
1296
|
return BindingPattern$0(state) || BindingPattern$1(state);
|
|
1298
1297
|
}
|
|
1299
1298
|
}
|
|
1300
|
-
var ObjectBindingPattern$0 = $S($EXPECT($
|
|
1299
|
+
var ObjectBindingPattern$0 = $S($EXPECT($L11, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L16, fail, 'ObjectBindingPattern "}"'));
|
|
1301
1300
|
function ObjectBindingPattern(state) {
|
|
1302
1301
|
if (state.verbose)
|
|
1303
1302
|
console.log("ENTER:", "ObjectBindingPattern");
|
|
@@ -1307,7 +1306,7 @@ var require_parser = __commonJS({
|
|
|
1307
1306
|
return ObjectBindingPattern$0(state);
|
|
1308
1307
|
}
|
|
1309
1308
|
}
|
|
1310
|
-
var ArrayBindingPattern$0 = $S($EXPECT($
|
|
1309
|
+
var ArrayBindingPattern$0 = $S($EXPECT($L24, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L25, fail, 'ArrayBindingPattern "]"'));
|
|
1311
1310
|
function ArrayBindingPattern(state) {
|
|
1312
1311
|
if (state.verbose)
|
|
1313
1312
|
console.log("ENTER:", "ArrayBindingPattern");
|
|
@@ -1317,7 +1316,7 @@ var require_parser = __commonJS({
|
|
|
1317
1316
|
return ArrayBindingPattern$0(state);
|
|
1318
1317
|
}
|
|
1319
1318
|
}
|
|
1320
|
-
var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($
|
|
1319
|
+
var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L12, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
|
|
1321
1320
|
var BindingProperty$1 = $S(__, BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
|
|
1322
1321
|
function BindingProperty(state) {
|
|
1323
1322
|
if (state.tokenize) {
|
|
@@ -1326,7 +1325,7 @@ var require_parser = __commonJS({
|
|
|
1326
1325
|
return BindingProperty$0(state) || BindingProperty$1(state);
|
|
1327
1326
|
}
|
|
1328
1327
|
}
|
|
1329
|
-
var BindingRestProperty$0 = $S($EXPECT($
|
|
1328
|
+
var BindingRestProperty$0 = $S($EXPECT($L31, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
|
|
1330
1329
|
function BindingRestProperty(state) {
|
|
1331
1330
|
if (state.verbose)
|
|
1332
1331
|
console.log("ENTER:", "BindingRestProperty");
|
|
@@ -1346,7 +1345,7 @@ var require_parser = __commonJS({
|
|
|
1346
1345
|
return BindingElement$0(state);
|
|
1347
1346
|
}
|
|
1348
1347
|
}
|
|
1349
|
-
var BindingRestElement$0 = $S($EXPECT($
|
|
1348
|
+
var BindingRestElement$0 = $S($EXPECT($L31, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
|
|
1350
1349
|
function BindingRestElement(state) {
|
|
1351
1350
|
if (state.verbose)
|
|
1352
1351
|
console.log("ENTER:", "BindingRestElement");
|
|
@@ -1367,7 +1366,7 @@ var require_parser = __commonJS({
|
|
|
1367
1366
|
}
|
|
1368
1367
|
}
|
|
1369
1368
|
var FunctionExpression$0 = ThinArrowFunction;
|
|
1370
|
-
var FunctionExpression$1 = $S($EXPECT($
|
|
1369
|
+
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
1370
|
function FunctionExpression(state) {
|
|
1372
1371
|
if (state.tokenize) {
|
|
1373
1372
|
return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
|
|
@@ -1375,7 +1374,7 @@ var require_parser = __commonJS({
|
|
|
1375
1374
|
return FunctionExpression$0(state) || FunctionExpression$1(state);
|
|
1376
1375
|
}
|
|
1377
1376
|
}
|
|
1378
|
-
var ThinArrowFunction$0 = $T($S(Parameters, $E(
|
|
1377
|
+
var ThinArrowFunction$0 = $T($S(Parameters, $E(ReturnTypeSuffix), __, $EXPECT($L33, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
|
|
1379
1378
|
var params = value[0];
|
|
1380
1379
|
var suffix = value[1];
|
|
1381
1380
|
var block = value[4];
|
|
@@ -1390,7 +1389,7 @@ var require_parser = __commonJS({
|
|
|
1390
1389
|
return ThinArrowFunction$0(state);
|
|
1391
1390
|
}
|
|
1392
1391
|
}
|
|
1393
|
-
var Block$0 = $S(__, $EXPECT($
|
|
1392
|
+
var Block$0 = $S(__, $EXPECT($L11, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'Block "}"'));
|
|
1394
1393
|
var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1395
1394
|
var Block$2 = Statement;
|
|
1396
1395
|
var Block$3 = $S(__, Statement);
|
|
@@ -1401,7 +1400,7 @@ var require_parser = __commonJS({
|
|
|
1401
1400
|
return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
|
|
1402
1401
|
}
|
|
1403
1402
|
}
|
|
1404
|
-
var BracedBlock$0 = $S(__, $EXPECT($
|
|
1403
|
+
var BracedBlock$0 = $S(__, $EXPECT($L11, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BracedBlock "}"'));
|
|
1405
1404
|
var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1406
1405
|
var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
|
|
1407
1406
|
function BracedBlock(state) {
|
|
@@ -1453,10 +1452,10 @@ var require_parser = __commonJS({
|
|
|
1453
1452
|
}
|
|
1454
1453
|
var Literal$0 = StringLiteral;
|
|
1455
1454
|
var Literal$1 = NumericLiteral;
|
|
1456
|
-
var Literal$2 = $EXPECT($
|
|
1457
|
-
var Literal$3 = $EXPECT($
|
|
1458
|
-
var Literal$4 = $EXPECT($
|
|
1459
|
-
var Literal$5 = $EXPECT($
|
|
1455
|
+
var Literal$2 = $EXPECT($L34, fail, 'Literal "true"');
|
|
1456
|
+
var Literal$3 = $EXPECT($L35, fail, 'Literal "false"');
|
|
1457
|
+
var Literal$4 = $EXPECT($L36, fail, 'Literal "null"');
|
|
1458
|
+
var Literal$5 = $EXPECT($L37, fail, 'Literal "undefined"');
|
|
1460
1459
|
function Literal(state) {
|
|
1461
1460
|
if (state.tokenize) {
|
|
1462
1461
|
return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state) || Literal$4(state) || Literal$5(state));
|
|
@@ -1484,7 +1483,7 @@ var require_parser = __commonJS({
|
|
|
1484
1483
|
return Identifier$0(state);
|
|
1485
1484
|
}
|
|
1486
1485
|
}
|
|
1487
|
-
var IdentifierName$0 = $R$0($EXPECT($
|
|
1486
|
+
var IdentifierName$0 = $R$0($EXPECT($R2, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
1488
1487
|
function IdentifierName(state) {
|
|
1489
1488
|
if (state.verbose)
|
|
1490
1489
|
console.log("ENTER:", "IdentifierName");
|
|
@@ -1504,8 +1503,8 @@ var require_parser = __commonJS({
|
|
|
1504
1503
|
return IdentifierReference$0(state);
|
|
1505
1504
|
}
|
|
1506
1505
|
}
|
|
1507
|
-
var ArrayLiteral$0 = $S($EXPECT($
|
|
1508
|
-
var ArrayLiteral$1 = $S($EXPECT($
|
|
1506
|
+
var ArrayLiteral$0 = $S($EXPECT($L24, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L25, fail, 'ArrayLiteral "]"'));
|
|
1507
|
+
var ArrayLiteral$1 = $S($EXPECT($L24, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L25, fail, 'ArrayLiteral "]"'));
|
|
1509
1508
|
function ArrayLiteral(state) {
|
|
1510
1509
|
if (state.tokenize) {
|
|
1511
1510
|
return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
|
|
@@ -1539,8 +1538,8 @@ var require_parser = __commonJS({
|
|
|
1539
1538
|
}
|
|
1540
1539
|
}
|
|
1541
1540
|
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($
|
|
1541
|
+
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
|
|
1542
|
+
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"'))), function(value) {
|
|
1544
1543
|
return ",";
|
|
1545
1544
|
});
|
|
1546
1545
|
var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1563,7 +1562,7 @@ var require_parser = __commonJS({
|
|
|
1563
1562
|
return ElementList$0(state);
|
|
1564
1563
|
}
|
|
1565
1564
|
}
|
|
1566
|
-
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($
|
|
1565
|
+
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L31, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
|
|
1567
1566
|
function ArrayElementExpression(state) {
|
|
1568
1567
|
if (state.verbose)
|
|
1569
1568
|
console.log("ENTER:", "ArrayElementExpression");
|
|
@@ -1583,9 +1582,9 @@ var require_parser = __commonJS({
|
|
|
1583
1582
|
return Elision$0(state);
|
|
1584
1583
|
}
|
|
1585
1584
|
}
|
|
1586
|
-
var ObjectLiteral$0 = $S($EXPECT($
|
|
1587
|
-
var ObjectLiteral$1 = $S($EXPECT($
|
|
1588
|
-
var ObjectLiteral$2 = $S($EXPECT($
|
|
1585
|
+
var ObjectLiteral$0 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L16, fail, 'ObjectLiteral "}"'));
|
|
1586
|
+
var ObjectLiteral$1 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L16, fail, 'ObjectLiteral "}"'));
|
|
1587
|
+
var ObjectLiteral$2 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), __, $EXPECT($L16, fail, 'ObjectLiteral "}"'));
|
|
1589
1588
|
var ObjectLiteral$3 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1590
1589
|
function ObjectLiteral(state) {
|
|
1591
1590
|
if (state.tokenize) {
|
|
@@ -1620,8 +1619,8 @@ var require_parser = __commonJS({
|
|
|
1620
1619
|
}
|
|
1621
1620
|
}
|
|
1622
1621
|
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($
|
|
1622
|
+
var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'ObjectPropertyDelimiter "}"')));
|
|
1623
|
+
var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
|
|
1625
1624
|
return ",";
|
|
1626
1625
|
});
|
|
1627
1626
|
var ObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1644,9 +1643,9 @@ var require_parser = __commonJS({
|
|
|
1644
1643
|
return PropertyDefinitionList$0(state);
|
|
1645
1644
|
}
|
|
1646
1645
|
}
|
|
1647
|
-
var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($
|
|
1646
|
+
var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L12, fail, 'PropertyDefinition ":"'), AssignmentExpression);
|
|
1648
1647
|
var PropertyDefinition$1 = MethodDefinition;
|
|
1649
|
-
var PropertyDefinition$2 = $S($EXPECT($
|
|
1648
|
+
var PropertyDefinition$2 = $S($EXPECT($L31, fail, 'PropertyDefinition "..."'), AssignmentExpression);
|
|
1650
1649
|
var PropertyDefinition$3 = IdentifierReference;
|
|
1651
1650
|
function PropertyDefinition(state) {
|
|
1652
1651
|
if (state.tokenize) {
|
|
@@ -1658,7 +1657,7 @@ var require_parser = __commonJS({
|
|
|
1658
1657
|
var PropertyName$0 = NumericLiteral;
|
|
1659
1658
|
var PropertyName$1 = StringLiteral;
|
|
1660
1659
|
var PropertyName$2 = IdentifierName;
|
|
1661
|
-
var PropertyName$3 = $S($EXPECT($
|
|
1660
|
+
var PropertyName$3 = $S($EXPECT($L24, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L25, fail, 'PropertyName "]"'));
|
|
1662
1661
|
function PropertyName(state) {
|
|
1663
1662
|
if (state.tokenize) {
|
|
1664
1663
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -1666,8 +1665,8 @@ var require_parser = __commonJS({
|
|
|
1666
1665
|
return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
|
|
1667
1666
|
}
|
|
1668
1667
|
}
|
|
1669
|
-
var MethodDefinition$0 = $S($EXPECT($
|
|
1670
|
-
var MethodDefinition$1 = $S($EXPECT($
|
|
1668
|
+
var MethodDefinition$0 = $S($EXPECT($L38, fail, 'MethodDefinition "get"'), $N($R$0($EXPECT($R3, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1669
|
+
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
1670
|
var MethodDefinition$2 = AsyncGeneratorMethod;
|
|
1672
1671
|
var MethodDefinition$3 = AsyncMethod;
|
|
1673
1672
|
var MethodDefinition$4 = GeneratorMethod;
|
|
@@ -1688,7 +1687,7 @@ var require_parser = __commonJS({
|
|
|
1688
1687
|
return ClassElementName$0(state) || ClassElementName$1(state);
|
|
1689
1688
|
}
|
|
1690
1689
|
}
|
|
1691
|
-
var PrivateIdentifier$0 = $S($EXPECT($
|
|
1690
|
+
var PrivateIdentifier$0 = $S($EXPECT($L20, fail, 'PrivateIdentifier "#"'), IdentifierName);
|
|
1692
1691
|
function PrivateIdentifier(state) {
|
|
1693
1692
|
if (state.verbose)
|
|
1694
1693
|
console.log("ENTER:", "PrivateIdentifier");
|
|
@@ -1698,27 +1697,7 @@ var require_parser = __commonJS({
|
|
|
1698
1697
|
return PrivateIdentifier$0(state);
|
|
1699
1698
|
}
|
|
1700
1699
|
}
|
|
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);
|
|
1700
|
+
var GeneratorMethod$0 = $S($EXPECT($L9, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
|
|
1722
1701
|
function GeneratorMethod(state) {
|
|
1723
1702
|
if (state.verbose)
|
|
1724
1703
|
console.log("ENTER:", "GeneratorMethod");
|
|
@@ -1738,27 +1717,7 @@ var require_parser = __commonJS({
|
|
|
1738
1717
|
return GeneratorBody$0(state);
|
|
1739
1718
|
}
|
|
1740
1719
|
}
|
|
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);
|
|
1720
|
+
var AsyncMethod$0 = $S($EXPECT($L7, fail, 'AsyncMethod "async"'), $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
|
|
1762
1721
|
function AsyncMethod(state) {
|
|
1763
1722
|
if (state.verbose)
|
|
1764
1723
|
console.log("ENTER:", "AsyncMethod");
|
|
@@ -1778,27 +1737,7 @@ var require_parser = __commonJS({
|
|
|
1778
1737
|
return AsyncFunctionBody$0(state);
|
|
1779
1738
|
}
|
|
1780
1739
|
}
|
|
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);
|
|
1740
|
+
var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L9, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
|
|
1802
1741
|
function AsyncGeneratorMethod(state) {
|
|
1803
1742
|
if (state.verbose)
|
|
1804
1743
|
console.log("ENTER:", "AsyncGeneratorMethod");
|
|
@@ -1818,22 +1757,22 @@ var require_parser = __commonJS({
|
|
|
1818
1757
|
return AsyncGeneratorBody$0(state);
|
|
1819
1758
|
}
|
|
1820
1759
|
}
|
|
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($
|
|
1760
|
+
var AssignmentOp$0 = $EXPECT($L40, fail, 'AssignmentOp "**="');
|
|
1761
|
+
var AssignmentOp$1 = $EXPECT($L41, fail, 'AssignmentOp "*="');
|
|
1762
|
+
var AssignmentOp$2 = $EXPECT($L42, fail, 'AssignmentOp "/="');
|
|
1763
|
+
var AssignmentOp$3 = $EXPECT($L43, fail, 'AssignmentOp "%="');
|
|
1764
|
+
var AssignmentOp$4 = $EXPECT($L44, fail, 'AssignmentOp "+="');
|
|
1765
|
+
var AssignmentOp$5 = $EXPECT($L45, fail, 'AssignmentOp "-="');
|
|
1766
|
+
var AssignmentOp$6 = $EXPECT($L46, fail, 'AssignmentOp "<<="');
|
|
1767
|
+
var AssignmentOp$7 = $EXPECT($L47, fail, 'AssignmentOp ">>>="');
|
|
1768
|
+
var AssignmentOp$8 = $EXPECT($L48, fail, 'AssignmentOp ">>="');
|
|
1769
|
+
var AssignmentOp$9 = $EXPECT($L49, fail, 'AssignmentOp "&&="');
|
|
1770
|
+
var AssignmentOp$10 = $EXPECT($L50, fail, 'AssignmentOp "&="');
|
|
1771
|
+
var AssignmentOp$11 = $EXPECT($L51, fail, 'AssignmentOp "^="');
|
|
1772
|
+
var AssignmentOp$12 = $EXPECT($L52, fail, 'AssignmentOp "||="');
|
|
1773
|
+
var AssignmentOp$13 = $EXPECT($L53, fail, 'AssignmentOp "|="');
|
|
1774
|
+
var AssignmentOp$14 = $EXPECT($L54, fail, 'AssignmentOp "??="');
|
|
1775
|
+
var AssignmentOp$15 = $EXPECT($L55, fail, 'AssignmentOp "="');
|
|
1837
1776
|
function AssignmentOp(state) {
|
|
1838
1777
|
if (state.tokenize) {
|
|
1839
1778
|
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 +1780,48 @@ var require_parser = __commonJS({
|
|
|
1841
1780
|
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
1781
|
}
|
|
1843
1782
|
}
|
|
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($
|
|
1783
|
+
var BinaryOp$0 = $EXPECT($L56, fail, 'BinaryOp "**"');
|
|
1784
|
+
var BinaryOp$1 = $EXPECT($L9, fail, 'BinaryOp "*"');
|
|
1785
|
+
var BinaryOp$2 = $EXPECT($L57, fail, 'BinaryOp "/"');
|
|
1786
|
+
var BinaryOp$3 = $EXPECT($L58, fail, 'BinaryOp "%"');
|
|
1787
|
+
var BinaryOp$4 = $EXPECT($L59, fail, 'BinaryOp "+"');
|
|
1788
|
+
var BinaryOp$5 = $EXPECT($L60, fail, 'BinaryOp "-"');
|
|
1789
|
+
var BinaryOp$6 = $EXPECT($L61, fail, 'BinaryOp "<="');
|
|
1790
|
+
var BinaryOp$7 = $EXPECT($L62, fail, 'BinaryOp ">="');
|
|
1791
|
+
var BinaryOp$8 = $EXPECT($L63, fail, 'BinaryOp "<<"');
|
|
1792
|
+
var BinaryOp$9 = $EXPECT($L14, fail, 'BinaryOp "<"');
|
|
1793
|
+
var BinaryOp$10 = $EXPECT($L64, fail, 'BinaryOp ">>>"');
|
|
1794
|
+
var BinaryOp$11 = $EXPECT($L65, fail, 'BinaryOp ">>"');
|
|
1795
|
+
var BinaryOp$12 = $EXPECT($L66, fail, 'BinaryOp ">"');
|
|
1796
|
+
var BinaryOp$13 = $EXPECT($L67, fail, 'BinaryOp "!=="');
|
|
1797
|
+
var BinaryOp$14 = $TV($EXPECT($L68, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
|
|
1859
1798
|
if (global.coffeeCompat)
|
|
1860
1799
|
return "!==";
|
|
1861
1800
|
return $1;
|
|
1862
1801
|
});
|
|
1863
|
-
var BinaryOp$15 = $T($EXPECT($
|
|
1802
|
+
var BinaryOp$15 = $T($EXPECT($L69, fail, 'BinaryOp "is"'), function(value) {
|
|
1864
1803
|
return "===";
|
|
1865
1804
|
});
|
|
1866
|
-
var BinaryOp$16 = $EXPECT($
|
|
1867
|
-
var BinaryOp$17 = $TV($EXPECT($
|
|
1805
|
+
var BinaryOp$16 = $EXPECT($L70, fail, 'BinaryOp "==="');
|
|
1806
|
+
var BinaryOp$17 = $TV($EXPECT($L71, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
|
|
1868
1807
|
if (global.coffeeCompat)
|
|
1869
1808
|
return "===";
|
|
1870
1809
|
return $1;
|
|
1871
1810
|
});
|
|
1872
|
-
var BinaryOp$18 = $T($EXPECT($
|
|
1811
|
+
var BinaryOp$18 = $T($EXPECT($L72, fail, 'BinaryOp "and"'), function(value) {
|
|
1873
1812
|
return "&&";
|
|
1874
1813
|
});
|
|
1875
|
-
var BinaryOp$19 = $EXPECT($
|
|
1876
|
-
var BinaryOp$20 = $T($EXPECT($
|
|
1814
|
+
var BinaryOp$19 = $EXPECT($L73, fail, 'BinaryOp "&&"');
|
|
1815
|
+
var BinaryOp$20 = $T($EXPECT($L74, fail, 'BinaryOp "or"'), function(value) {
|
|
1877
1816
|
return "||";
|
|
1878
1817
|
});
|
|
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($
|
|
1818
|
+
var BinaryOp$21 = $EXPECT($L75, fail, 'BinaryOp "||"');
|
|
1819
|
+
var BinaryOp$22 = $EXPECT($L76, fail, 'BinaryOp "??"');
|
|
1820
|
+
var BinaryOp$23 = $EXPECT($L77, fail, 'BinaryOp "instanceof"');
|
|
1821
|
+
var BinaryOp$24 = $EXPECT($L78, fail, 'BinaryOp "in"');
|
|
1822
|
+
var BinaryOp$25 = $EXPECT($L79, fail, 'BinaryOp "&"');
|
|
1823
|
+
var BinaryOp$26 = $EXPECT($L80, fail, 'BinaryOp "^"');
|
|
1824
|
+
var BinaryOp$27 = $EXPECT($L81, fail, 'BinaryOp "|"');
|
|
1886
1825
|
function BinaryOp(state) {
|
|
1887
1826
|
if (state.tokenize) {
|
|
1888
1827
|
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 +1829,8 @@ var require_parser = __commonJS({
|
|
|
1890
1829
|
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
1830
|
}
|
|
1892
1831
|
}
|
|
1893
|
-
var UnaryOp$0 = $R$0($EXPECT($
|
|
1894
|
-
var UnaryOp$1 = $S($C($EXPECT($
|
|
1832
|
+
var UnaryOp$0 = $R$0($EXPECT($R4, fail, "UnaryOp /[!~+-]/"));
|
|
1833
|
+
var UnaryOp$1 = $S($C($EXPECT($L82, fail, 'UnaryOp "delete"'), $EXPECT($L83, fail, 'UnaryOp "void"'), $EXPECT($L84, fail, 'UnaryOp "typeof"')), $P(_));
|
|
1895
1834
|
function UnaryOp(state) {
|
|
1896
1835
|
if (state.tokenize) {
|
|
1897
1836
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -1926,7 +1865,7 @@ var require_parser = __commonJS({
|
|
|
1926
1865
|
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
1866
|
}
|
|
1928
1867
|
}
|
|
1929
|
-
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($
|
|
1868
|
+
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L85, fail, 'EmptyStatement ";"')));
|
|
1930
1869
|
function EmptyStatement(state) {
|
|
1931
1870
|
if (state.verbose)
|
|
1932
1871
|
console.log("ENTER:", "EmptyStatement");
|
|
@@ -1936,7 +1875,7 @@ var require_parser = __commonJS({
|
|
|
1936
1875
|
return EmptyStatement$0(state);
|
|
1937
1876
|
}
|
|
1938
1877
|
}
|
|
1939
|
-
var BlockStatement$0 = $S(__, $EXPECT($
|
|
1878
|
+
var BlockStatement$0 = $S(__, $EXPECT($L11, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BlockStatement "}"'));
|
|
1940
1879
|
function BlockStatement(state) {
|
|
1941
1880
|
if (state.verbose)
|
|
1942
1881
|
console.log("ENTER:", "BlockStatement");
|
|
@@ -1946,8 +1885,8 @@ var require_parser = __commonJS({
|
|
|
1946
1885
|
return BlockStatement$0(state);
|
|
1947
1886
|
}
|
|
1948
1887
|
}
|
|
1949
|
-
var IfStatement$0 = $S($EXPECT($
|
|
1950
|
-
var IfStatement$1 = $TS($S($EXPECT($
|
|
1888
|
+
var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L87, fail, 'IfStatement "else"'), Block)));
|
|
1889
|
+
var IfStatement$1 = $TS($S($EXPECT($L88, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
|
|
1951
1890
|
var condition = $2;
|
|
1952
1891
|
var block = $3;
|
|
1953
1892
|
return ["if", condition.map((c) => {
|
|
@@ -1977,7 +1916,7 @@ var require_parser = __commonJS({
|
|
|
1977
1916
|
return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
|
|
1978
1917
|
}
|
|
1979
1918
|
}
|
|
1980
|
-
var LoopStatement$0 = $TS($S($EXPECT($
|
|
1919
|
+
var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), Block), function($skip, $loc, $0, $1, $2) {
|
|
1981
1920
|
var b = $2;
|
|
1982
1921
|
return ["while(true)", b];
|
|
1983
1922
|
});
|
|
@@ -1990,7 +1929,7 @@ var require_parser = __commonJS({
|
|
|
1990
1929
|
return LoopStatement$0(state);
|
|
1991
1930
|
}
|
|
1992
1931
|
}
|
|
1993
|
-
var DoWhileStatement$0 = $S($EXPECT($
|
|
1932
|
+
var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), Block, __, $EXPECT($L91, fail, 'DoWhileStatement "while"'), Condition);
|
|
1994
1933
|
function DoWhileStatement(state) {
|
|
1995
1934
|
if (state.verbose)
|
|
1996
1935
|
console.log("ENTER:", "DoWhileStatement");
|
|
@@ -2000,7 +1939,7 @@ var require_parser = __commonJS({
|
|
|
2000
1939
|
return DoWhileStatement$0(state);
|
|
2001
1940
|
}
|
|
2002
1941
|
}
|
|
2003
|
-
var WhileStatement$0 = $S($EXPECT($
|
|
1942
|
+
var WhileStatement$0 = $S($EXPECT($L91, fail, 'WhileStatement "while"'), Condition, Block);
|
|
2004
1943
|
function WhileStatement(state) {
|
|
2005
1944
|
if (state.verbose)
|
|
2006
1945
|
console.log("ENTER:", "WhileStatement");
|
|
@@ -2010,7 +1949,7 @@ var require_parser = __commonJS({
|
|
|
2010
1949
|
return WhileStatement$0(state);
|
|
2011
1950
|
}
|
|
2012
1951
|
}
|
|
2013
|
-
var ForStatement$0 = $S($EXPECT($
|
|
1952
|
+
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
1953
|
function ForStatement(state) {
|
|
2015
1954
|
if (state.verbose)
|
|
2016
1955
|
console.log("ENTER:", "ForStatement");
|
|
@@ -2020,10 +1959,10 @@ var require_parser = __commonJS({
|
|
|
2020
1959
|
return ForStatement$0(state);
|
|
2021
1960
|
}
|
|
2022
1961
|
}
|
|
2023
|
-
var ForInOfStatement$0 = $S($EXPECT($
|
|
2024
|
-
var ForInOfStatement$1 = $S($EXPECT($
|
|
2025
|
-
var ForInOfStatement$2 = $S($EXPECT($
|
|
2026
|
-
var ForInOfStatement$3 = $S($EXPECT($
|
|
1962
|
+
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);
|
|
1963
|
+
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);
|
|
1964
|
+
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);
|
|
1965
|
+
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
1966
|
function ForInOfStatement(state) {
|
|
2028
1967
|
if (state.tokenize) {
|
|
2029
1968
|
return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
|
|
@@ -2031,7 +1970,7 @@ var require_parser = __commonJS({
|
|
|
2031
1970
|
return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
|
|
2032
1971
|
}
|
|
2033
1972
|
}
|
|
2034
|
-
var ForDeclaration$0 = $S($C($EXPECT($
|
|
1973
|
+
var ForDeclaration$0 = $S($C($EXPECT($L96, fail, 'ForDeclaration "let"'), $EXPECT($L97, fail, 'ForDeclaration "const"')), __, ForBinding);
|
|
2035
1974
|
function ForDeclaration(state) {
|
|
2036
1975
|
if (state.verbose)
|
|
2037
1976
|
console.log("ENTER:", "ForDeclaration");
|
|
@@ -2050,7 +1989,7 @@ var require_parser = __commonJS({
|
|
|
2050
1989
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
2051
1990
|
}
|
|
2052
1991
|
}
|
|
2053
|
-
var SwitchStatement$0 = $S($EXPECT($
|
|
1992
|
+
var SwitchStatement$0 = $S($EXPECT($L98, fail, 'SwitchStatement "switch"'), Condition, CaseBlock);
|
|
2054
1993
|
function SwitchStatement(state) {
|
|
2055
1994
|
if (state.verbose)
|
|
2056
1995
|
console.log("ENTER:", "SwitchStatement");
|
|
@@ -2060,7 +1999,7 @@ var require_parser = __commonJS({
|
|
|
2060
1999
|
return SwitchStatement$0(state);
|
|
2061
2000
|
}
|
|
2062
2001
|
}
|
|
2063
|
-
var CaseBlock$0 = $S(__, $EXPECT($
|
|
2002
|
+
var CaseBlock$0 = $S(__, $EXPECT($L11, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L16, fail, 'CaseBlock "}"'));
|
|
2064
2003
|
var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
|
|
2065
2004
|
function CaseBlock(state) {
|
|
2066
2005
|
if (state.tokenize) {
|
|
@@ -2094,9 +2033,9 @@ var require_parser = __commonJS({
|
|
|
2094
2033
|
return NestedCaseClause$0(state);
|
|
2095
2034
|
}
|
|
2096
2035
|
}
|
|
2097
|
-
var CaseClause$0 = $S($EXPECT($
|
|
2036
|
+
var CaseClause$0 = $S($EXPECT($L99, fail, 'CaseClause "case"'), $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
|
|
2098
2037
|
var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
|
|
2099
|
-
var CaseClause$2 = $S($EXPECT($
|
|
2038
|
+
var CaseClause$2 = $S($EXPECT($L100, fail, 'CaseClause "default"'), ImpliedColon, NestedBlockExpressions);
|
|
2100
2039
|
function CaseClause(state) {
|
|
2101
2040
|
if (state.tokenize) {
|
|
2102
2041
|
return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
|
|
@@ -2104,7 +2043,7 @@ var require_parser = __commonJS({
|
|
|
2104
2043
|
return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
|
|
2105
2044
|
}
|
|
2106
2045
|
}
|
|
2107
|
-
var When$0 = $T($EXPECT($
|
|
2046
|
+
var When$0 = $T($EXPECT($L101, fail, 'When "when"'), function(value) {
|
|
2108
2047
|
return "case";
|
|
2109
2048
|
});
|
|
2110
2049
|
function When(state) {
|
|
@@ -2116,8 +2055,8 @@ var require_parser = __commonJS({
|
|
|
2116
2055
|
return When$0(state);
|
|
2117
2056
|
}
|
|
2118
2057
|
}
|
|
2119
|
-
var ImpliedColon$0 = $S(__, $EXPECT($
|
|
2120
|
-
var ImpliedColon$1 = $T($EXPECT($
|
|
2058
|
+
var ImpliedColon$0 = $S(__, $EXPECT($L12, fail, 'ImpliedColon ":"'));
|
|
2059
|
+
var ImpliedColon$1 = $T($EXPECT($L30, fail, 'ImpliedColon ""'), function(value) {
|
|
2121
2060
|
return ":";
|
|
2122
2061
|
});
|
|
2123
2062
|
function ImpliedColon(state) {
|
|
@@ -2127,7 +2066,7 @@ var require_parser = __commonJS({
|
|
|
2127
2066
|
return ImpliedColon$0(state) || ImpliedColon$1(state);
|
|
2128
2067
|
}
|
|
2129
2068
|
}
|
|
2130
|
-
var TryStatement$0 = $TS($S($EXPECT($
|
|
2069
|
+
var TryStatement$0 = $TS($S($EXPECT($L102, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2131
2070
|
var c = $3;
|
|
2132
2071
|
var f = $4;
|
|
2133
2072
|
if (!c && !f) {
|
|
@@ -2144,7 +2083,7 @@ var require_parser = __commonJS({
|
|
|
2144
2083
|
return TryStatement$0(state);
|
|
2145
2084
|
}
|
|
2146
2085
|
}
|
|
2147
|
-
var Catch$0 = $S(__, $EXPECT($
|
|
2086
|
+
var Catch$0 = $S(__, $EXPECT($L103, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
|
|
2148
2087
|
function Catch(state) {
|
|
2149
2088
|
if (state.verbose)
|
|
2150
2089
|
console.log("ENTER:", "Catch");
|
|
@@ -2163,7 +2102,7 @@ var require_parser = __commonJS({
|
|
|
2163
2102
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2164
2103
|
}
|
|
2165
2104
|
}
|
|
2166
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2105
|
+
var Finally$0 = $S(__, $EXPECT($L104, fail, 'Finally "finally"'), BracedBlock);
|
|
2167
2106
|
function Finally(state) {
|
|
2168
2107
|
if (state.verbose)
|
|
2169
2108
|
console.log("ENTER:", "Finally");
|
|
@@ -2201,12 +2140,12 @@ var require_parser = __commonJS({
|
|
|
2201
2140
|
return ExpressionStatement$0(state);
|
|
2202
2141
|
}
|
|
2203
2142
|
}
|
|
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($
|
|
2143
|
+
var KeywordStatement$0 = $EXPECT($L105, fail, 'KeywordStatement "break"');
|
|
2144
|
+
var KeywordStatement$1 = $EXPECT($L106, fail, 'KeywordStatement "continue"');
|
|
2145
|
+
var KeywordStatement$2 = $EXPECT($L107, fail, 'KeywordStatement "debugger"');
|
|
2146
|
+
var KeywordStatement$3 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), Expression);
|
|
2147
|
+
var KeywordStatement$4 = $EXPECT($L108, fail, 'KeywordStatement "return"');
|
|
2148
|
+
var KeywordStatement$5 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), Expression);
|
|
2210
2149
|
function KeywordStatement(state) {
|
|
2211
2150
|
if (state.tokenize) {
|
|
2212
2151
|
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state));
|
|
@@ -2214,11 +2153,11 @@ var require_parser = __commonJS({
|
|
|
2214
2153
|
return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state);
|
|
2215
2154
|
}
|
|
2216
2155
|
}
|
|
2217
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2156
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L110, fail, 'ImportDeclaration "import type"'), __, ImportClause, __, FromClause), function(value) {
|
|
2218
2157
|
return { "ts": true, "children": value };
|
|
2219
2158
|
});
|
|
2220
|
-
var ImportDeclaration$1 = $S($EXPECT($
|
|
2221
|
-
var ImportDeclaration$2 = $S($EXPECT($
|
|
2159
|
+
var ImportDeclaration$1 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), __, ImportClause, __, FromClause);
|
|
2160
|
+
var ImportDeclaration$2 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), __, ModuleSpecifier);
|
|
2222
2161
|
function ImportDeclaration(state) {
|
|
2223
2162
|
if (state.tokenize) {
|
|
2224
2163
|
return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
|
|
@@ -2236,7 +2175,7 @@ var require_parser = __commonJS({
|
|
|
2236
2175
|
return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
|
|
2237
2176
|
}
|
|
2238
2177
|
}
|
|
2239
|
-
var NameSpaceImport$0 = $S($EXPECT($
|
|
2178
|
+
var NameSpaceImport$0 = $S($EXPECT($L9, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), __, ImportedBinding);
|
|
2240
2179
|
function NameSpaceImport(state) {
|
|
2241
2180
|
if (state.verbose)
|
|
2242
2181
|
console.log("ENTER:", "NameSpaceImport");
|
|
@@ -2246,7 +2185,7 @@ var require_parser = __commonJS({
|
|
|
2246
2185
|
return NameSpaceImport$0(state);
|
|
2247
2186
|
}
|
|
2248
2187
|
}
|
|
2249
|
-
var NamedImports$0 = $S($EXPECT($
|
|
2188
|
+
var NamedImports$0 = $S($EXPECT($L11, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L16, fail, 'NamedImports "}"'));
|
|
2250
2189
|
function NamedImports(state) {
|
|
2251
2190
|
if (state.verbose)
|
|
2252
2191
|
console.log("ENTER:", "NamedImports");
|
|
@@ -2266,7 +2205,7 @@ var require_parser = __commonJS({
|
|
|
2266
2205
|
return FromClause$0(state);
|
|
2267
2206
|
}
|
|
2268
2207
|
}
|
|
2269
|
-
var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($
|
|
2208
|
+
var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), __, ImportedBinding, ObjectPropertyDelimiter);
|
|
2270
2209
|
var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
|
|
2271
2210
|
function ImportSpecifier(state) {
|
|
2272
2211
|
if (state.tokenize) {
|
|
@@ -2304,7 +2243,7 @@ var require_parser = __commonJS({
|
|
|
2304
2243
|
return ImportedBinding$0(state);
|
|
2305
2244
|
}
|
|
2306
2245
|
}
|
|
2307
|
-
var ExportDeclaration$0 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $EXPECT($
|
|
2246
|
+
var ExportDeclaration$0 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $EXPECT($L100, fail, 'ExportDeclaration "default"'), __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2308
2247
|
var ExportDeclaration$1 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, ExportFromClause, __, FromClause);
|
|
2309
2248
|
var ExportDeclaration$2 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $C(NamedExports, VariableStatement, Declaration));
|
|
2310
2249
|
function ExportDeclaration(state) {
|
|
@@ -2314,7 +2253,7 @@ var require_parser = __commonJS({
|
|
|
2314
2253
|
return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
|
|
2315
2254
|
}
|
|
2316
2255
|
}
|
|
2317
|
-
var ExportFromClause$0 = $S($EXPECT($
|
|
2256
|
+
var ExportFromClause$0 = $S($EXPECT($L9, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), __, ModuleExportName)));
|
|
2318
2257
|
var ExportFromClause$1 = NamedExports;
|
|
2319
2258
|
function ExportFromClause(state) {
|
|
2320
2259
|
if (state.tokenize) {
|
|
@@ -2323,7 +2262,7 @@ var require_parser = __commonJS({
|
|
|
2323
2262
|
return ExportFromClause$0(state) || ExportFromClause$1(state);
|
|
2324
2263
|
}
|
|
2325
2264
|
}
|
|
2326
|
-
var NamedExports$0 = $S($EXPECT($
|
|
2265
|
+
var NamedExports$0 = $S($EXPECT($L11, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L16, fail, 'NamedExports "}"'));
|
|
2327
2266
|
function NamedExports(state) {
|
|
2328
2267
|
if (state.verbose)
|
|
2329
2268
|
console.log("ENTER:", "NamedExports");
|
|
@@ -2333,7 +2272,7 @@ var require_parser = __commonJS({
|
|
|
2333
2272
|
return NamedExports$0(state);
|
|
2334
2273
|
}
|
|
2335
2274
|
}
|
|
2336
|
-
var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, $EXPECT($
|
|
2275
|
+
var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, $EXPECT($L4, fail, 'ExportSpecifier "as"'), __, ModuleExportName)), ObjectPropertyDelimiter);
|
|
2337
2276
|
function ExportSpecifier(state) {
|
|
2338
2277
|
if (state.verbose)
|
|
2339
2278
|
console.log("ENTER:", "ExportSpecifier");
|
|
@@ -2354,18 +2293,17 @@ var require_parser = __commonJS({
|
|
|
2354
2293
|
return Declaration$0(state) || Declaration$1(state) || Declaration$2(state) || Declaration$3(state);
|
|
2355
2294
|
}
|
|
2356
2295
|
}
|
|
2357
|
-
var HoistableDeclaration$0 =
|
|
2358
|
-
var HoistableDeclaration$1 = AsyncFunctionDeclaration;
|
|
2359
|
-
var HoistableDeclaration$2 = GeneratorDeclaration;
|
|
2360
|
-
var HoistableDeclaration$3 = FunctionDeclaration;
|
|
2296
|
+
var HoistableDeclaration$0 = FunctionDeclaration;
|
|
2361
2297
|
function HoistableDeclaration(state) {
|
|
2298
|
+
if (state.verbose)
|
|
2299
|
+
console.log("ENTER:", "HoistableDeclaration");
|
|
2362
2300
|
if (state.tokenize) {
|
|
2363
|
-
return $TOKEN("HoistableDeclaration", state, HoistableDeclaration$0(state)
|
|
2301
|
+
return $TOKEN("HoistableDeclaration", state, HoistableDeclaration$0(state));
|
|
2364
2302
|
} else {
|
|
2365
|
-
return HoistableDeclaration$0(state)
|
|
2303
|
+
return HoistableDeclaration$0(state);
|
|
2366
2304
|
}
|
|
2367
2305
|
}
|
|
2368
|
-
var LexicalDeclaration$0 = $S($C($EXPECT($
|
|
2306
|
+
var LexicalDeclaration$0 = $S($C($EXPECT($L96, fail, 'LexicalDeclaration "let"'), $EXPECT($L97, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
|
|
2369
2307
|
var LexicalDeclaration$1 = $T($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, $EXPECT($L113, fail, 'LexicalDeclaration ":="'), AssignmentExpression), function(value) {
|
|
2370
2308
|
var bind = value[0];
|
|
2371
2309
|
var suffix = value[1];
|
|
@@ -2389,7 +2327,7 @@ var require_parser = __commonJS({
|
|
|
2389
2327
|
return LexicalBinding$0(state) || LexicalBinding$1(state);
|
|
2390
2328
|
}
|
|
2391
2329
|
}
|
|
2392
|
-
var Initializer$0 = $S(__, $EXPECT($
|
|
2330
|
+
var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
|
|
2393
2331
|
function Initializer(state) {
|
|
2394
2332
|
if (state.verbose)
|
|
2395
2333
|
console.log("ENTER:", "Initializer");
|
|
@@ -2399,7 +2337,7 @@ var require_parser = __commonJS({
|
|
|
2399
2337
|
return Initializer$0(state);
|
|
2400
2338
|
}
|
|
2401
2339
|
}
|
|
2402
|
-
var VariableStatement$0 = $S($EXPECT($
|
|
2340
|
+
var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
|
|
2403
2341
|
function VariableStatement(state) {
|
|
2404
2342
|
if (state.verbose)
|
|
2405
2343
|
console.log("ENTER:", "VariableStatement");
|
|
@@ -2440,7 +2378,7 @@ var require_parser = __commonJS({
|
|
|
2440
2378
|
return NumericLiteral$0(state) || NumericLiteral$1(state) || NumericLiteral$2(state) || NumericLiteral$3(state) || NumericLiteral$4(state);
|
|
2441
2379
|
}
|
|
2442
2380
|
}
|
|
2443
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
2381
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
2444
2382
|
function DecimalBigIntegerLiteral(state) {
|
|
2445
2383
|
if (state.verbose)
|
|
2446
2384
|
console.log("ENTER:", "DecimalBigIntegerLiteral");
|
|
@@ -2450,7 +2388,7 @@ var require_parser = __commonJS({
|
|
|
2450
2388
|
return DecimalBigIntegerLiteral$0(state);
|
|
2451
2389
|
}
|
|
2452
2390
|
}
|
|
2453
|
-
var DecimalLiteral$0 = $R$0($EXPECT($
|
|
2391
|
+
var DecimalLiteral$0 = $R$0($EXPECT($R6, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
|
|
2454
2392
|
function DecimalLiteral(state) {
|
|
2455
2393
|
if (state.verbose)
|
|
2456
2394
|
console.log("ENTER:", "DecimalLiteral");
|
|
@@ -2460,7 +2398,7 @@ var require_parser = __commonJS({
|
|
|
2460
2398
|
return DecimalLiteral$0(state);
|
|
2461
2399
|
}
|
|
2462
2400
|
}
|
|
2463
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
2401
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
|
|
2464
2402
|
function BinaryIntegerLiteral(state) {
|
|
2465
2403
|
if (state.verbose)
|
|
2466
2404
|
console.log("ENTER:", "BinaryIntegerLiteral");
|
|
@@ -2470,7 +2408,7 @@ var require_parser = __commonJS({
|
|
|
2470
2408
|
return BinaryIntegerLiteral$0(state);
|
|
2471
2409
|
}
|
|
2472
2410
|
}
|
|
2473
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
2411
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R8, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*/"));
|
|
2474
2412
|
function OctalIntegerLiteral(state) {
|
|
2475
2413
|
if (state.verbose)
|
|
2476
2414
|
console.log("ENTER:", "OctalIntegerLiteral");
|
|
@@ -2480,7 +2418,7 @@ var require_parser = __commonJS({
|
|
|
2480
2418
|
return OctalIntegerLiteral$0(state);
|
|
2481
2419
|
}
|
|
2482
2420
|
}
|
|
2483
|
-
var HexLiteral$0 = $R$0($EXPECT($
|
|
2421
|
+
var HexLiteral$0 = $R$0($EXPECT($R9, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*/"));
|
|
2484
2422
|
function HexLiteral(state) {
|
|
2485
2423
|
if (state.verbose)
|
|
2486
2424
|
console.log("ENTER:", "HexLiteral");
|
|
@@ -2502,7 +2440,7 @@ var require_parser = __commonJS({
|
|
|
2502
2440
|
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
|
|
2503
2441
|
}
|
|
2504
2442
|
}
|
|
2505
|
-
var DoubleStringCharacter$0 = $R$0($EXPECT($
|
|
2443
|
+
var DoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'DoubleStringCharacter /[^"\\\\]+/'));
|
|
2506
2444
|
var DoubleStringCharacter$1 = EscapeSequence;
|
|
2507
2445
|
function DoubleStringCharacter(state) {
|
|
2508
2446
|
if (state.tokenize) {
|
|
@@ -2511,7 +2449,7 @@ var require_parser = __commonJS({
|
|
|
2511
2449
|
return DoubleStringCharacter$0(state) || DoubleStringCharacter$1(state);
|
|
2512
2450
|
}
|
|
2513
2451
|
}
|
|
2514
|
-
var SingleStringCharacter$0 = $R$0($EXPECT($
|
|
2452
|
+
var SingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "SingleStringCharacter /[^'\\\\]+/"));
|
|
2515
2453
|
var SingleStringCharacter$1 = EscapeSequence;
|
|
2516
2454
|
function SingleStringCharacter(state) {
|
|
2517
2455
|
if (state.tokenize) {
|
|
@@ -2520,7 +2458,7 @@ var require_parser = __commonJS({
|
|
|
2520
2458
|
return SingleStringCharacter$0(state) || SingleStringCharacter$1(state);
|
|
2521
2459
|
}
|
|
2522
2460
|
}
|
|
2523
|
-
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($
|
|
2461
|
+
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R12, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
|
|
2524
2462
|
function TripleDoubleStringCharacter(state) {
|
|
2525
2463
|
if (state.verbose)
|
|
2526
2464
|
console.log("ENTER:", "TripleDoubleStringCharacter");
|
|
@@ -2530,7 +2468,7 @@ var require_parser = __commonJS({
|
|
|
2530
2468
|
return TripleDoubleStringCharacter$0(state);
|
|
2531
2469
|
}
|
|
2532
2470
|
}
|
|
2533
|
-
var EscapeSequence$0 = $TEXT($S($EXPECT($L117, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($
|
|
2471
|
+
var EscapeSequence$0 = $TEXT($S($EXPECT($L117, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R13, fail, "EscapeSequence /./")));
|
|
2534
2472
|
function EscapeSequence(state) {
|
|
2535
2473
|
if (state.verbose)
|
|
2536
2474
|
console.log("ENTER:", "EscapeSequence");
|
|
@@ -2540,7 +2478,7 @@ var require_parser = __commonJS({
|
|
|
2540
2478
|
return EscapeSequence$0(state);
|
|
2541
2479
|
}
|
|
2542
2480
|
}
|
|
2543
|
-
var RegularExpressionLiteral$0 = $S($EXPECT($
|
|
2481
|
+
var RegularExpressionLiteral$0 = $S($EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
|
|
2544
2482
|
function RegularExpressionLiteral(state) {
|
|
2545
2483
|
if (state.verbose)
|
|
2546
2484
|
console.log("ENTER:", "RegularExpressionLiteral");
|
|
@@ -2550,7 +2488,7 @@ var require_parser = __commonJS({
|
|
|
2550
2488
|
return RegularExpressionLiteral$0(state);
|
|
2551
2489
|
}
|
|
2552
2490
|
}
|
|
2553
|
-
var RegularExpressionBody$0 = $S($R$0($EXPECT($
|
|
2491
|
+
var RegularExpressionBody$0 = $S($R$0($EXPECT($R14, fail, "RegularExpressionBody /[^*\\/\\r\\n]/")), $Q(RegExpCharacter));
|
|
2554
2492
|
function RegularExpressionBody(state) {
|
|
2555
2493
|
if (state.verbose)
|
|
2556
2494
|
console.log("ENTER:", "RegularExpressionBody");
|
|
@@ -2560,7 +2498,7 @@ var require_parser = __commonJS({
|
|
|
2560
2498
|
return RegularExpressionBody$0(state);
|
|
2561
2499
|
}
|
|
2562
2500
|
}
|
|
2563
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
2501
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R15, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
|
|
2564
2502
|
var RegExpCharacter$1 = EscapeSequence;
|
|
2565
2503
|
function RegExpCharacter(state) {
|
|
2566
2504
|
if (state.tokenize) {
|
|
@@ -2569,7 +2507,7 @@ var require_parser = __commonJS({
|
|
|
2569
2507
|
return RegExpCharacter$0(state) || RegExpCharacter$1(state);
|
|
2570
2508
|
}
|
|
2571
2509
|
}
|
|
2572
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
2510
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R16, fail, "RegularExpressionFlags /(:?\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
2573
2511
|
function RegularExpressionFlags(state) {
|
|
2574
2512
|
if (state.verbose)
|
|
2575
2513
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -2589,7 +2527,7 @@ var require_parser = __commonJS({
|
|
|
2589
2527
|
return TemplateLiteral$0(state);
|
|
2590
2528
|
}
|
|
2591
2529
|
}
|
|
2592
|
-
var TemplateSubstitution$0 = $S($EXPECT($L119, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($
|
|
2530
|
+
var TemplateSubstitution$0 = $S($EXPECT($L119, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
|
|
2593
2531
|
function TemplateSubstitution(state) {
|
|
2594
2532
|
if (state.verbose)
|
|
2595
2533
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -2599,7 +2537,7 @@ var require_parser = __commonJS({
|
|
|
2599
2537
|
return TemplateSubstitution$0(state);
|
|
2600
2538
|
}
|
|
2601
2539
|
}
|
|
2602
|
-
var TemplateCharacters$0 = $R$0($EXPECT($
|
|
2540
|
+
var TemplateCharacters$0 = $R$0($EXPECT($R17, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
|
|
2603
2541
|
function TemplateCharacters(state) {
|
|
2604
2542
|
if (state.verbose)
|
|
2605
2543
|
console.log("ENTER:", "TemplateCharacters");
|
|
@@ -2609,7 +2547,7 @@ var require_parser = __commonJS({
|
|
|
2609
2547
|
return TemplateCharacters$0(state);
|
|
2610
2548
|
}
|
|
2611
2549
|
}
|
|
2612
|
-
var ReservedWord$0 = $R$0($EXPECT($
|
|
2550
|
+
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
2551
|
function ReservedWord(state) {
|
|
2614
2552
|
if (state.verbose)
|
|
2615
2553
|
console.log("ENTER:", "ReservedWord");
|
|
@@ -2628,7 +2566,7 @@ var require_parser = __commonJS({
|
|
|
2628
2566
|
return Comment$0(state) || Comment$1(state);
|
|
2629
2567
|
}
|
|
2630
2568
|
}
|
|
2631
|
-
var SingleLineComment$0 = $R$0($EXPECT($
|
|
2569
|
+
var SingleLineComment$0 = $R$0($EXPECT($R19, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"));
|
|
2632
2570
|
var SingleLineComment$1 = CoffeeSingleLineComment;
|
|
2633
2571
|
function SingleLineComment(state) {
|
|
2634
2572
|
if (state.tokenize) {
|
|
@@ -2646,7 +2584,7 @@ var require_parser = __commonJS({
|
|
|
2646
2584
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
2647
2585
|
}
|
|
2648
2586
|
}
|
|
2649
|
-
var JSMultiLineComment$0 = $S($EXPECT($L120, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'JSMultiLineComment "*/"')), $EXPECT($
|
|
2587
|
+
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
2588
|
function JSMultiLineComment(state) {
|
|
2651
2589
|
if (state.verbose)
|
|
2652
2590
|
console.log("ENTER:", "JSMultiLineComment");
|
|
@@ -2656,7 +2594,7 @@ var require_parser = __commonJS({
|
|
|
2656
2594
|
return JSMultiLineComment$0(state);
|
|
2657
2595
|
}
|
|
2658
2596
|
}
|
|
2659
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
2597
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R20, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
2660
2598
|
if (!global.coffeeCompat)
|
|
2661
2599
|
return $skip;
|
|
2662
2600
|
return ["//", $1];
|
|
@@ -2670,7 +2608,7 @@ var require_parser = __commonJS({
|
|
|
2670
2608
|
return CoffeeSingleLineComment$0(state);
|
|
2671
2609
|
}
|
|
2672
2610
|
}
|
|
2673
|
-
var CoffeeMultiLineComment$0 = $T($S($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($
|
|
2611
|
+
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
2612
|
return ["/*", value[1], "*/"];
|
|
2675
2613
|
});
|
|
2676
2614
|
function CoffeeMultiLineComment(state) {
|
|
@@ -2682,7 +2620,7 @@ var require_parser = __commonJS({
|
|
|
2682
2620
|
return CoffeeMultiLineComment$0(state);
|
|
2683
2621
|
}
|
|
2684
2622
|
}
|
|
2685
|
-
var InlineComment$0 = $S($EXPECT($L120, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'InlineComment "*/"')), $EXPECT($
|
|
2623
|
+
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
2624
|
function InlineComment(state) {
|
|
2687
2625
|
if (state.verbose)
|
|
2688
2626
|
console.log("ENTER:", "InlineComment");
|
|
@@ -2702,7 +2640,7 @@ var require_parser = __commonJS({
|
|
|
2702
2640
|
return RestOfLine$0(state);
|
|
2703
2641
|
}
|
|
2704
2642
|
}
|
|
2705
|
-
var TrailingComment$0 = $R$0($EXPECT($
|
|
2643
|
+
var TrailingComment$0 = $R$0($EXPECT($R22, fail, "TrailingComment /[\\t ]+/"));
|
|
2706
2644
|
var TrailingComment$1 = InlineComment;
|
|
2707
2645
|
var TrailingComment$2 = SingleLineComment;
|
|
2708
2646
|
function TrailingComment(state) {
|
|
@@ -2712,7 +2650,7 @@ var require_parser = __commonJS({
|
|
|
2712
2650
|
return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
|
|
2713
2651
|
}
|
|
2714
2652
|
}
|
|
2715
|
-
var _$0 = $P($C($R$0($EXPECT($
|
|
2653
|
+
var _$0 = $P($C($R$0($EXPECT($R22, fail, "_ /[\\t ]+/")), Comment));
|
|
2716
2654
|
function _(state) {
|
|
2717
2655
|
if (state.verbose)
|
|
2718
2656
|
console.log("ENTER:", "_");
|
|
@@ -2722,7 +2660,7 @@ var require_parser = __commonJS({
|
|
|
2722
2660
|
return _$0(state);
|
|
2723
2661
|
}
|
|
2724
2662
|
}
|
|
2725
|
-
var __$0 = $Q($C($R$0($EXPECT($
|
|
2663
|
+
var __$0 = $Q($C($R$0($EXPECT($R23, fail, "__ /[\\s]+/")), Comment));
|
|
2726
2664
|
function __(state) {
|
|
2727
2665
|
if (state.verbose)
|
|
2728
2666
|
console.log("ENTER:", "__");
|
|
@@ -2732,7 +2670,7 @@ var require_parser = __commonJS({
|
|
|
2732
2670
|
return __$0(state);
|
|
2733
2671
|
}
|
|
2734
2672
|
}
|
|
2735
|
-
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($
|
|
2673
|
+
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L85, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
|
|
2736
2674
|
var StatementDelimiter$1 = $T($Y(EOS), function(value) {
|
|
2737
2675
|
return [";", value];
|
|
2738
2676
|
});
|
|
@@ -2746,7 +2684,6 @@ var require_parser = __commonJS({
|
|
|
2746
2684
|
var JSXElement$0 = JSXSelfClosingElement;
|
|
2747
2685
|
var JSXElement$1 = $TS($S(JSXOpeningElement, $Q(JSXChildren), __, JSXClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2748
2686
|
if ($1[1] !== $4[2]) {
|
|
2749
|
-
console.log($1, $4, $loc);
|
|
2750
2687
|
throw new Error(`mismatched closing tags at ${JSON.stringify($loc)}`);
|
|
2751
2688
|
}
|
|
2752
2689
|
return $0;
|
|
@@ -2758,7 +2695,7 @@ var require_parser = __commonJS({
|
|
|
2758
2695
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
2759
2696
|
}
|
|
2760
2697
|
}
|
|
2761
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($
|
|
2698
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L123, fail, 'JSXSelfClosingElement "/>"'));
|
|
2762
2699
|
function JSXSelfClosingElement(state) {
|
|
2763
2700
|
if (state.verbose)
|
|
2764
2701
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -2768,7 +2705,7 @@ var require_parser = __commonJS({
|
|
|
2768
2705
|
return JSXSelfClosingElement$0(state);
|
|
2769
2706
|
}
|
|
2770
2707
|
}
|
|
2771
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
2708
|
+
var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L66, fail, 'JSXOpeningElement ">"'));
|
|
2772
2709
|
function JSXOpeningElement(state) {
|
|
2773
2710
|
if (state.verbose)
|
|
2774
2711
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -2778,7 +2715,7 @@ var require_parser = __commonJS({
|
|
|
2778
2715
|
return JSXOpeningElement$0(state);
|
|
2779
2716
|
}
|
|
2780
2717
|
}
|
|
2781
|
-
var JSXClosingElement$0 = $S($EXPECT($L124, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($
|
|
2718
|
+
var JSXClosingElement$0 = $S($EXPECT($L124, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
|
|
2782
2719
|
function JSXClosingElement(state) {
|
|
2783
2720
|
if (state.verbose)
|
|
2784
2721
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -2798,7 +2735,7 @@ var require_parser = __commonJS({
|
|
|
2798
2735
|
return JSXFragment$0(state);
|
|
2799
2736
|
}
|
|
2800
2737
|
}
|
|
2801
|
-
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($
|
|
2738
|
+
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L26, fail, 'JSXElementName "."'), JSXIdentifierName))));
|
|
2802
2739
|
function JSXElementName(state) {
|
|
2803
2740
|
if (state.verbose)
|
|
2804
2741
|
console.log("ENTER:", "JSXElementName");
|
|
@@ -2808,7 +2745,7 @@ var require_parser = __commonJS({
|
|
|
2808
2745
|
return JSXElementName$0(state);
|
|
2809
2746
|
}
|
|
2810
2747
|
}
|
|
2811
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
2748
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R24, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
2812
2749
|
function JSXIdentifierName(state) {
|
|
2813
2750
|
if (state.verbose)
|
|
2814
2751
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -2828,7 +2765,7 @@ var require_parser = __commonJS({
|
|
|
2828
2765
|
return JSXAttributes$0(state);
|
|
2829
2766
|
}
|
|
2830
2767
|
}
|
|
2831
|
-
var JSXAttribute$0 = $S($EXPECT($
|
|
2768
|
+
var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($L31, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttribute "}"'));
|
|
2832
2769
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
2833
2770
|
function JSXAttribute(state) {
|
|
2834
2771
|
if (state.tokenize) {
|
|
@@ -2837,7 +2774,7 @@ var require_parser = __commonJS({
|
|
|
2837
2774
|
return JSXAttribute$0(state) || JSXAttribute$1(state);
|
|
2838
2775
|
}
|
|
2839
2776
|
}
|
|
2840
|
-
var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($
|
|
2777
|
+
var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L12, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
|
|
2841
2778
|
function JSXAttributeName(state) {
|
|
2842
2779
|
if (state.verbose)
|
|
2843
2780
|
console.log("ENTER:", "JSXAttributeName");
|
|
@@ -2847,7 +2784,7 @@ var require_parser = __commonJS({
|
|
|
2847
2784
|
return JSXAttributeName$0(state);
|
|
2848
2785
|
}
|
|
2849
2786
|
}
|
|
2850
|
-
var JSXAttributeInitializer$0 = $S(__, $EXPECT($
|
|
2787
|
+
var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
|
|
2851
2788
|
function JSXAttributeInitializer(state) {
|
|
2852
2789
|
if (state.verbose)
|
|
2853
2790
|
console.log("ENTER:", "JSXAttributeInitializer");
|
|
@@ -2857,9 +2794,9 @@ var require_parser = __commonJS({
|
|
|
2857
2794
|
return JSXAttributeInitializer$0(state);
|
|
2858
2795
|
}
|
|
2859
2796
|
}
|
|
2860
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
2861
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
2862
|
-
var JSXAttributeValue$2 = $S($EXPECT($
|
|
2797
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R25, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
2798
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R26, fail, "JSXAttributeValue /'[^']*'/"));
|
|
2799
|
+
var JSXAttributeValue$2 = $S($EXPECT($L11, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttributeValue "}"'));
|
|
2863
2800
|
var JSXAttributeValue$3 = JSXElement;
|
|
2864
2801
|
var JSXAttributeValue$4 = JSXFragment;
|
|
2865
2802
|
function JSXAttributeValue(state) {
|
|
@@ -2882,7 +2819,7 @@ var require_parser = __commonJS({
|
|
|
2882
2819
|
var JSXChild$0 = JSXText;
|
|
2883
2820
|
var JSXChild$1 = JSXElement;
|
|
2884
2821
|
var JSXChild$2 = JSXFragment;
|
|
2885
|
-
var JSXChild$3 = $S($EXPECT($
|
|
2822
|
+
var JSXChild$3 = $S($EXPECT($L11, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L16, fail, 'JSXChild "}"'));
|
|
2886
2823
|
function JSXChild(state) {
|
|
2887
2824
|
if (state.tokenize) {
|
|
2888
2825
|
return $TOKEN("JSXChild", state, JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state));
|
|
@@ -2890,7 +2827,7 @@ var require_parser = __commonJS({
|
|
|
2890
2827
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
2891
2828
|
}
|
|
2892
2829
|
}
|
|
2893
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
2830
|
+
var JSXText$0 = $R$0($EXPECT($R27, fail, "JSXText /[^{}<>]+/"));
|
|
2894
2831
|
function JSXText(state) {
|
|
2895
2832
|
if (state.verbose)
|
|
2896
2833
|
console.log("ENTER:", "JSXText");
|
|
@@ -2900,7 +2837,7 @@ var require_parser = __commonJS({
|
|
|
2900
2837
|
return JSXText$0(state);
|
|
2901
2838
|
}
|
|
2902
2839
|
}
|
|
2903
|
-
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($
|
|
2840
|
+
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L31, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
|
|
2904
2841
|
function JSXChildExpression(state) {
|
|
2905
2842
|
if (state.verbose)
|
|
2906
2843
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -2910,10 +2847,10 @@ var require_parser = __commonJS({
|
|
|
2910
2847
|
return JSXChildExpression$0(state);
|
|
2911
2848
|
}
|
|
2912
2849
|
}
|
|
2913
|
-
var TypeDeclaration$0 = $T($S($EXPECT($
|
|
2850
|
+
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
2851
|
return { "ts": true, "children": value };
|
|
2915
2852
|
});
|
|
2916
|
-
var TypeDeclaration$1 = $T($S($EXPECT($
|
|
2853
|
+
var TypeDeclaration$1 = $T($S($EXPECT($R29, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
|
|
2917
2854
|
return { "ts": true, "children": value };
|
|
2918
2855
|
});
|
|
2919
2856
|
function TypeDeclaration(state) {
|
|
@@ -2923,7 +2860,7 @@ var require_parser = __commonJS({
|
|
|
2923
2860
|
return TypeDeclaration$0(state) || TypeDeclaration$1(state);
|
|
2924
2861
|
}
|
|
2925
2862
|
}
|
|
2926
|
-
var InterfaceBlock$0 = $S(__, $EXPECT($
|
|
2863
|
+
var InterfaceBlock$0 = $S(__, $EXPECT($L11, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L16, fail, 'InterfaceBlock "}"'));
|
|
2927
2864
|
var InterfaceBlock$1 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
2928
2865
|
function InterfaceBlock(state) {
|
|
2929
2866
|
if (state.tokenize) {
|
|
@@ -2957,7 +2894,7 @@ var require_parser = __commonJS({
|
|
|
2957
2894
|
return NestedInterfaceProperty$0(state);
|
|
2958
2895
|
}
|
|
2959
2896
|
}
|
|
2960
|
-
var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($
|
|
2897
|
+
var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L12, fail, 'TypeSuffix ":"'), Type), function(value) {
|
|
2961
2898
|
return { "ts": true, "children": value };
|
|
2962
2899
|
});
|
|
2963
2900
|
function TypeSuffix(state) {
|
|
@@ -2969,6 +2906,28 @@ var require_parser = __commonJS({
|
|
|
2969
2906
|
return TypeSuffix$0(state);
|
|
2970
2907
|
}
|
|
2971
2908
|
}
|
|
2909
|
+
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) {
|
|
2910
|
+
return { "ts": true, "children": value };
|
|
2911
|
+
});
|
|
2912
|
+
function ReturnTypeSuffix(state) {
|
|
2913
|
+
if (state.verbose)
|
|
2914
|
+
console.log("ENTER:", "ReturnTypeSuffix");
|
|
2915
|
+
if (state.tokenize) {
|
|
2916
|
+
return $TOKEN("ReturnTypeSuffix", state, ReturnTypeSuffix$0(state));
|
|
2917
|
+
} else {
|
|
2918
|
+
return ReturnTypeSuffix$0(state);
|
|
2919
|
+
}
|
|
2920
|
+
}
|
|
2921
|
+
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), $R$0($EXPECT($R0, fail, "TypePredicate /(?!\\p{ID_Continue})/")), Type)));
|
|
2922
|
+
function TypePredicate(state) {
|
|
2923
|
+
if (state.verbose)
|
|
2924
|
+
console.log("ENTER:", "TypePredicate");
|
|
2925
|
+
if (state.tokenize) {
|
|
2926
|
+
return $TOKEN("TypePredicate", state, TypePredicate$0(state));
|
|
2927
|
+
} else {
|
|
2928
|
+
return TypePredicate$0(state);
|
|
2929
|
+
}
|
|
2930
|
+
}
|
|
2972
2931
|
var Type$0 = TypeConditional;
|
|
2973
2932
|
function Type(state) {
|
|
2974
2933
|
if (state.verbose)
|
|
@@ -2989,7 +2948,7 @@ var require_parser = __commonJS({
|
|
|
2989
2948
|
return TypeBinary$0(state);
|
|
2990
2949
|
}
|
|
2991
2950
|
}
|
|
2992
|
-
var TypeUnary$0 = $S($Q(TypeUnaryOp), TypePrimary);
|
|
2951
|
+
var TypeUnary$0 = $S($Q($S(__, TypeUnaryOp, $R$0($EXPECT($R0, fail, "TypeUnary /(?!\\p{ID_Continue})/")))), TypePrimary, $Q(TypeUnarySuffix));
|
|
2993
2952
|
function TypeUnary(state) {
|
|
2994
2953
|
if (state.verbose)
|
|
2995
2954
|
console.log("ENTER:", "TypeUnary");
|
|
@@ -2999,19 +2958,40 @@ var require_parser = __commonJS({
|
|
|
2999
2958
|
return TypeUnary$0(state);
|
|
3000
2959
|
}
|
|
3001
2960
|
}
|
|
3002
|
-
var
|
|
3003
|
-
|
|
2961
|
+
var TypeUnarySuffix$0 = TypeIndexedAccess;
|
|
2962
|
+
function TypeUnarySuffix(state) {
|
|
2963
|
+
if (state.verbose)
|
|
2964
|
+
console.log("ENTER:", "TypeUnarySuffix");
|
|
2965
|
+
if (state.tokenize) {
|
|
2966
|
+
return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state));
|
|
2967
|
+
} else {
|
|
2968
|
+
return TypeUnarySuffix$0(state);
|
|
2969
|
+
}
|
|
2970
|
+
}
|
|
2971
|
+
var TypeUnaryOp$0 = $EXPECT($L128, fail, 'TypeUnaryOp "keyof"');
|
|
2972
|
+
var TypeUnaryOp$1 = $EXPECT($L84, fail, 'TypeUnaryOp "typeof"');
|
|
2973
|
+
var TypeUnaryOp$2 = $EXPECT($L129, fail, 'TypeUnaryOp "infer"');
|
|
3004
2974
|
function TypeUnaryOp(state) {
|
|
3005
2975
|
if (state.tokenize) {
|
|
3006
|
-
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state));
|
|
2976
|
+
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
2977
|
+
} else {
|
|
2978
|
+
return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
|
|
2979
|
+
}
|
|
2980
|
+
}
|
|
2981
|
+
var TypeIndexedAccess$0 = $S(__, $EXPECT($L24, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L25, fail, 'TypeIndexedAccess "]"'));
|
|
2982
|
+
function TypeIndexedAccess(state) {
|
|
2983
|
+
if (state.verbose)
|
|
2984
|
+
console.log("ENTER:", "TypeIndexedAccess");
|
|
2985
|
+
if (state.tokenize) {
|
|
2986
|
+
return $TOKEN("TypeIndexedAccess", state, TypeIndexedAccess$0(state));
|
|
3007
2987
|
} else {
|
|
3008
|
-
return
|
|
2988
|
+
return TypeIndexedAccess$0(state);
|
|
3009
2989
|
}
|
|
3010
2990
|
}
|
|
3011
2991
|
var TypePrimary$0 = InterfaceBlock;
|
|
3012
2992
|
var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
|
|
3013
2993
|
var TypePrimary$2 = $S($Q(_), FunctionType);
|
|
3014
|
-
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($
|
|
2994
|
+
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L26, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
|
|
3015
2995
|
var TypePrimary$4 = $S($Q(_), TypeLiteral);
|
|
3016
2996
|
function TypePrimary(state) {
|
|
3017
2997
|
if (state.tokenize) {
|
|
@@ -3020,7 +3000,7 @@ var require_parser = __commonJS({
|
|
|
3020
3000
|
return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
|
|
3021
3001
|
}
|
|
3022
3002
|
}
|
|
3023
|
-
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($
|
|
3003
|
+
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L15, fail, 'TypeConditional "extends"'), Type, __, $EXPECT($L3, fail, 'TypeConditional "?"'), Type, __, $EXPECT($L12, fail, 'TypeConditional ":"'), Type)));
|
|
3024
3004
|
function TypeConditional(state) {
|
|
3025
3005
|
if (state.verbose)
|
|
3026
3006
|
console.log("ENTER:", "TypeConditional");
|
|
@@ -3031,8 +3011,8 @@ var require_parser = __commonJS({
|
|
|
3031
3011
|
}
|
|
3032
3012
|
}
|
|
3033
3013
|
var TypeLiteral$0 = Literal;
|
|
3034
|
-
var TypeLiteral$1 = $EXPECT($
|
|
3035
|
-
var TypeLiteral$2 = $EXPECT($
|
|
3014
|
+
var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
|
|
3015
|
+
var TypeLiteral$2 = $EXPECT($L130, fail, 'TypeLiteral "[]"');
|
|
3036
3016
|
function TypeLiteral(state) {
|
|
3037
3017
|
if (state.tokenize) {
|
|
3038
3018
|
return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
|
|
@@ -3040,8 +3020,8 @@ var require_parser = __commonJS({
|
|
|
3040
3020
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
3041
3021
|
}
|
|
3042
3022
|
}
|
|
3043
|
-
var TypeBinaryOp$0 = $EXPECT($
|
|
3044
|
-
var TypeBinaryOp$1 = $EXPECT($
|
|
3023
|
+
var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
|
|
3024
|
+
var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
|
|
3045
3025
|
function TypeBinaryOp(state) {
|
|
3046
3026
|
if (state.tokenize) {
|
|
3047
3027
|
return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
|
|
@@ -3049,7 +3029,7 @@ var require_parser = __commonJS({
|
|
|
3049
3029
|
return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
|
|
3050
3030
|
}
|
|
3051
3031
|
}
|
|
3052
|
-
var FunctionType$0 = $S(Parameters, __, $EXPECT($
|
|
3032
|
+
var FunctionType$0 = $S(Parameters, __, $EXPECT($L10, fail, 'FunctionType "=>"'), Type);
|
|
3053
3033
|
function FunctionType(state) {
|
|
3054
3034
|
if (state.verbose)
|
|
3055
3035
|
console.log("ENTER:", "FunctionType");
|
|
@@ -3059,7 +3039,7 @@ var require_parser = __commonJS({
|
|
|
3059
3039
|
return FunctionType$0(state);
|
|
3060
3040
|
}
|
|
3061
3041
|
}
|
|
3062
|
-
var TypeArguments$0 = $S(__, $EXPECT($
|
|
3042
|
+
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
3043
|
function TypeArguments(state) {
|
|
3064
3044
|
if (state.verbose)
|
|
3065
3045
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -3069,7 +3049,7 @@ var require_parser = __commonJS({
|
|
|
3069
3049
|
return TypeArguments$0(state);
|
|
3070
3050
|
}
|
|
3071
3051
|
}
|
|
3072
|
-
var TypeParameters$0 = $S(__, $EXPECT($
|
|
3052
|
+
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
3053
|
function TypeParameters(state) {
|
|
3074
3054
|
if (state.verbose)
|
|
3075
3055
|
console.log("ENTER:", "TypeParameters");
|
|
@@ -3089,7 +3069,7 @@ var require_parser = __commonJS({
|
|
|
3089
3069
|
return TypeParameter$0(state);
|
|
3090
3070
|
}
|
|
3091
3071
|
}
|
|
3092
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
3072
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L15, fail, 'TypeConstraint "extends"'), Type);
|
|
3093
3073
|
function TypeConstraint(state) {
|
|
3094
3074
|
if (state.verbose)
|
|
3095
3075
|
console.log("ENTER:", "TypeConstraint");
|
|
@@ -3100,8 +3080,8 @@ var require_parser = __commonJS({
|
|
|
3100
3080
|
}
|
|
3101
3081
|
}
|
|
3102
3082
|
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($
|
|
3083
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L66, fail, 'TypeParameterDelimiter ">"')));
|
|
3084
|
+
var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L66, fail, 'TypeParameterDelimiter ">"'))), function(value) {
|
|
3105
3085
|
return ",";
|
|
3106
3086
|
});
|
|
3107
3087
|
var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -3166,7 +3146,7 @@ var require_parser = __commonJS({
|
|
|
3166
3146
|
return EOF$0(state);
|
|
3167
3147
|
}
|
|
3168
3148
|
}
|
|
3169
|
-
var InsertOpenParen$0 = $T($EXPECT($
|
|
3149
|
+
var InsertOpenParen$0 = $T($EXPECT($L30, fail, 'InsertOpenParen ""'), function(value) {
|
|
3170
3150
|
return "(";
|
|
3171
3151
|
});
|
|
3172
3152
|
function InsertOpenParen(state) {
|
|
@@ -3178,7 +3158,7 @@ var require_parser = __commonJS({
|
|
|
3178
3158
|
return InsertOpenParen$0(state);
|
|
3179
3159
|
}
|
|
3180
3160
|
}
|
|
3181
|
-
var InsertCloseParen$0 = $T($EXPECT($
|
|
3161
|
+
var InsertCloseParen$0 = $T($EXPECT($L30, fail, 'InsertCloseParen ""'), function(value) {
|
|
3182
3162
|
return ")";
|
|
3183
3163
|
});
|
|
3184
3164
|
function InsertCloseParen(state) {
|
|
@@ -3190,7 +3170,7 @@ var require_parser = __commonJS({
|
|
|
3190
3170
|
return InsertCloseParen$0(state);
|
|
3191
3171
|
}
|
|
3192
3172
|
}
|
|
3193
|
-
var InsertOpenBrace$0 = $T($EXPECT($
|
|
3173
|
+
var InsertOpenBrace$0 = $T($EXPECT($L30, fail, 'InsertOpenBrace ""'), function(value) {
|
|
3194
3174
|
return " {";
|
|
3195
3175
|
});
|
|
3196
3176
|
function InsertOpenBrace(state) {
|
|
@@ -3202,7 +3182,7 @@ var require_parser = __commonJS({
|
|
|
3202
3182
|
return InsertOpenBrace$0(state);
|
|
3203
3183
|
}
|
|
3204
3184
|
}
|
|
3205
|
-
var InsertCloseBrace$0 = $T($EXPECT($
|
|
3185
|
+
var InsertCloseBrace$0 = $T($EXPECT($L30, fail, 'InsertCloseBrace ""'), function(value) {
|
|
3206
3186
|
return "}";
|
|
3207
3187
|
});
|
|
3208
3188
|
function InsertCloseBrace(state) {
|
|
@@ -3214,7 +3194,7 @@ var require_parser = __commonJS({
|
|
|
3214
3194
|
return InsertCloseBrace$0(state);
|
|
3215
3195
|
}
|
|
3216
3196
|
}
|
|
3217
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
3197
|
+
var InsertNewline$0 = $TV($EXPECT($L30, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
3218
3198
|
return "\n";
|
|
3219
3199
|
});
|
|
3220
3200
|
function InsertNewline(state) {
|
|
@@ -3226,7 +3206,7 @@ var require_parser = __commonJS({
|
|
|
3226
3206
|
return InsertNewline$0(state);
|
|
3227
3207
|
}
|
|
3228
3208
|
}
|
|
3229
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
3209
|
+
var InsertIndent$0 = $TV($EXPECT($L30, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
3230
3210
|
return "".padStart(global.currentIndent * 2);
|
|
3231
3211
|
});
|
|
3232
3212
|
function InsertIndent(state) {
|
|
@@ -3238,7 +3218,7 @@ var require_parser = __commonJS({
|
|
|
3238
3218
|
return InsertIndent$0(state);
|
|
3239
3219
|
}
|
|
3240
3220
|
}
|
|
3241
|
-
var InsertSpace$0 = $T($EXPECT($
|
|
3221
|
+
var InsertSpace$0 = $T($EXPECT($L30, fail, 'InsertSpace ""'), function(value) {
|
|
3242
3222
|
return " ";
|
|
3243
3223
|
});
|
|
3244
3224
|
function InsertSpace(state) {
|
|
@@ -3250,7 +3230,7 @@ var require_parser = __commonJS({
|
|
|
3250
3230
|
return InsertSpace$0(state);
|
|
3251
3231
|
}
|
|
3252
3232
|
}
|
|
3253
|
-
var InsertDot$0 = $T($EXPECT($
|
|
3233
|
+
var InsertDot$0 = $T($EXPECT($L30, fail, 'InsertDot ""'), function(value) {
|
|
3254
3234
|
return ".";
|
|
3255
3235
|
});
|
|
3256
3236
|
function InsertDot(state) {
|
|
@@ -3262,7 +3242,7 @@ var require_parser = __commonJS({
|
|
|
3262
3242
|
return InsertDot$0(state);
|
|
3263
3243
|
}
|
|
3264
3244
|
}
|
|
3265
|
-
var InsertBreak$0 = $T($EXPECT($
|
|
3245
|
+
var InsertBreak$0 = $T($EXPECT($L30, fail, 'InsertBreak ""'), function(value) {
|
|
3266
3246
|
return "break;";
|
|
3267
3247
|
});
|
|
3268
3248
|
function InsertBreak(state) {
|
|
@@ -3274,7 +3254,7 @@ var require_parser = __commonJS({
|
|
|
3274
3254
|
return InsertBreak$0(state);
|
|
3275
3255
|
}
|
|
3276
3256
|
}
|
|
3277
|
-
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($
|
|
3257
|
+
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L30, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3278
3258
|
var directives = $2;
|
|
3279
3259
|
global.currentIndent = 0;
|
|
3280
3260
|
global.indentLevels = [0];
|
|
@@ -3294,7 +3274,7 @@ var require_parser = __commonJS({
|
|
|
3294
3274
|
return Init$0(state);
|
|
3295
3275
|
}
|
|
3296
3276
|
}
|
|
3297
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
3277
|
+
var Indent$0 = $TV($Q($C($EXPECT($L131, fail, 'Indent " "'), $EXPECT($L132, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
3298
3278
|
return $1.length;
|
|
3299
3279
|
});
|
|
3300
3280
|
function Indent(state) {
|
|
@@ -3306,7 +3286,7 @@ var require_parser = __commonJS({
|
|
|
3306
3286
|
return Indent$0(state);
|
|
3307
3287
|
}
|
|
3308
3288
|
}
|
|
3309
|
-
var PushIndent$0 = $TV($EXPECT($
|
|
3289
|
+
var PushIndent$0 = $TV($EXPECT($L30, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
|
|
3310
3290
|
global.currentIndent++;
|
|
3311
3291
|
if (global.verbose) {
|
|
3312
3292
|
console.log("pushing indent", global.currentIndent);
|
|
@@ -3323,7 +3303,7 @@ var require_parser = __commonJS({
|
|
|
3323
3303
|
return PushIndent$0(state);
|
|
3324
3304
|
}
|
|
3325
3305
|
}
|
|
3326
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
3306
|
+
var PopIndent$0 = $TV($EXPECT($L30, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
3327
3307
|
if (global.verbose) {
|
|
3328
3308
|
console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
|
|
3329
3309
|
}
|