@danielx/civet 0.2.1 → 0.2.4
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 +485 -453
- package/dist/browser.js.map +2 -2
- package/dist/civet +9 -9
- package/dist/cli.js.map +3 -3
- package/dist/main.js +485 -453
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -487,16 +487,10 @@ var Civet = (() => {
|
|
|
487
487
|
MethodDefinition,
|
|
488
488
|
ClassElementName,
|
|
489
489
|
PrivateIdentifier,
|
|
490
|
-
GeneratorDeclaration,
|
|
491
|
-
GeneratorExpression,
|
|
492
490
|
GeneratorMethod,
|
|
493
491
|
GeneratorBody,
|
|
494
|
-
AsyncFunctionDeclaration,
|
|
495
|
-
AsyncFunctionExpression,
|
|
496
492
|
AsyncMethod,
|
|
497
493
|
AsyncFunctionBody,
|
|
498
|
-
AsyncGeneratorDeclaration,
|
|
499
|
-
AsyncGeneratorExpression,
|
|
500
494
|
AsyncGeneratorMethod,
|
|
501
495
|
AsyncGeneratorBody,
|
|
502
496
|
AssignmentOp,
|
|
@@ -602,11 +596,19 @@ var Civet = (() => {
|
|
|
602
596
|
InterfaceBlock,
|
|
603
597
|
NestedInterfaceProperties,
|
|
604
598
|
NestedInterfaceProperty,
|
|
599
|
+
InterfaceProperty,
|
|
600
|
+
InterfacePropertyDelimiter,
|
|
601
|
+
TypeIndexSignature,
|
|
602
|
+
TypeIndex,
|
|
605
603
|
TypeSuffix,
|
|
604
|
+
ReturnTypeSuffix,
|
|
605
|
+
TypePredicate,
|
|
606
606
|
Type,
|
|
607
607
|
TypeBinary,
|
|
608
608
|
TypeUnary,
|
|
609
|
+
TypeUnarySuffix,
|
|
609
610
|
TypeUnaryOp,
|
|
611
|
+
TypeIndexedAccess,
|
|
610
612
|
TypePrimary,
|
|
611
613
|
TypeConditional,
|
|
612
614
|
TypeLiteral,
|
|
@@ -641,113 +643,113 @@ var Civet = (() => {
|
|
|
641
643
|
var $L1 = $L("(");
|
|
642
644
|
var $L2 = $L(")");
|
|
643
645
|
var $L3 = $L("?");
|
|
644
|
-
var $L4 = $L("
|
|
645
|
-
var $L5 = $L("
|
|
646
|
-
var $L6 = $L("
|
|
647
|
-
var $L7 = $L("
|
|
648
|
-
var $L8 = $L("
|
|
649
|
-
var $L9 = $L("
|
|
650
|
-
var $L10 = $L("
|
|
651
|
-
var $L11 = $L("
|
|
652
|
-
var $L12 = $L("
|
|
653
|
-
var $L13 = $L("
|
|
654
|
-
var $L14 = $L("
|
|
655
|
-
var $L15 = $L("
|
|
656
|
-
var $L16 = $L("
|
|
657
|
-
var $L17 = $L("
|
|
658
|
-
var $L18 = $L("
|
|
659
|
-
var $L19 = $L("
|
|
660
|
-
var $L20 = $L("
|
|
661
|
-
var $L21 = $L("
|
|
662
|
-
var $L22 = $L("
|
|
663
|
-
var $L23 = $L("
|
|
664
|
-
var $L24 = $L("
|
|
665
|
-
var $L25 = $L("
|
|
666
|
-
var $L26 = $L("
|
|
667
|
-
var $L27 = $L("
|
|
668
|
-
var $L28 = $L("
|
|
669
|
-
var $L29 = $L("");
|
|
670
|
-
var $L30 = $L("
|
|
671
|
-
var $L31 = $L("
|
|
672
|
-
var $L32 = $L("
|
|
673
|
-
var $L33 = $L("
|
|
674
|
-
var $L34 = $L("
|
|
675
|
-
var $L35 = $L("
|
|
676
|
-
var $L36 = $L("
|
|
677
|
-
var $L37 = $L("
|
|
678
|
-
var $L38 = $L("
|
|
679
|
-
var $L39 = $L("
|
|
680
|
-
var $L40 = $L("
|
|
681
|
-
var $L41 = $L("
|
|
682
|
-
var $L42 = $L("
|
|
683
|
-
var $L43 = $L("
|
|
684
|
-
var $L44 = $L("
|
|
685
|
-
var $L45 = $L("
|
|
686
|
-
var $L46 = $L("
|
|
687
|
-
var $L47 = $L("
|
|
688
|
-
var $L48 = $L("
|
|
689
|
-
var $L49 = $L("
|
|
690
|
-
var $L50 = $L("
|
|
691
|
-
var $L51 = $L("
|
|
692
|
-
var $L52 = $L("
|
|
693
|
-
var $L53 = $L("
|
|
694
|
-
var $L54 = $L("
|
|
695
|
-
var $L55 = $L("
|
|
696
|
-
var $L56 = $L("
|
|
697
|
-
var $L57 = $L("
|
|
698
|
-
var $L58 = $L("
|
|
699
|
-
var $L59 = $L("
|
|
700
|
-
var $L60 = $L("
|
|
701
|
-
var $L61 = $L("
|
|
702
|
-
var $L62 = $L("
|
|
703
|
-
var $L63 = $L("
|
|
704
|
-
var $L64 = $L("
|
|
705
|
-
var $L65 = $L("
|
|
706
|
-
var $L66 = $L("
|
|
707
|
-
var $L67 = $L("
|
|
708
|
-
var $L68 = $L("
|
|
709
|
-
var $L69 = $L("
|
|
710
|
-
var $L70 = $L("
|
|
711
|
-
var $L71 = $L("
|
|
712
|
-
var $L72 = $L("
|
|
713
|
-
var $L73 = $L("
|
|
714
|
-
var $L74 = $L("
|
|
715
|
-
var $L75 = $L("
|
|
716
|
-
var $L76 = $L("
|
|
717
|
-
var $L77 = $L("
|
|
718
|
-
var $L78 = $L("
|
|
719
|
-
var $L79 = $L("
|
|
720
|
-
var $L80 = $L("
|
|
721
|
-
var $L81 = $L("
|
|
722
|
-
var $L82 = $L("
|
|
723
|
-
var $L83 = $L("
|
|
724
|
-
var $L84 = $L("
|
|
725
|
-
var $L85 = $L("
|
|
726
|
-
var $L86 = $L("
|
|
727
|
-
var $L87 = $L("
|
|
728
|
-
var $L88 = $L("
|
|
729
|
-
var $L89 = $L("
|
|
730
|
-
var $L90 = $L("
|
|
731
|
-
var $L91 = $L("
|
|
732
|
-
var $L92 = $L("
|
|
733
|
-
var $L93 = $L("
|
|
734
|
-
var $L94 = $L("
|
|
735
|
-
var $L95 = $L("
|
|
736
|
-
var $L96 = $L("
|
|
737
|
-
var $L97 = $L("
|
|
738
|
-
var $L98 = $L("
|
|
739
|
-
var $L99 = $L("
|
|
740
|
-
var $L100 = $L("
|
|
741
|
-
var $L101 = $L("
|
|
742
|
-
var $L102 = $L("
|
|
743
|
-
var $L103 = $L("
|
|
744
|
-
var $L104 = $L("
|
|
745
|
-
var $L105 = $L("
|
|
746
|
-
var $L106 = $L("
|
|
747
|
-
var $L107 = $L("
|
|
748
|
-
var $L108 = $L("
|
|
749
|
-
var $L109 = $L("
|
|
750
|
-
var $L110 = $L("
|
|
646
|
+
var $L4 = $L("as");
|
|
647
|
+
var $L5 = $L("++");
|
|
648
|
+
var $L6 = $L("--");
|
|
649
|
+
var $L7 = $L("async");
|
|
650
|
+
var $L8 = $L("yield");
|
|
651
|
+
var $L9 = $L("*");
|
|
652
|
+
var $L10 = $L("=>");
|
|
653
|
+
var $L11 = $L("{");
|
|
654
|
+
var $L12 = $L(":");
|
|
655
|
+
var $L13 = $L("class");
|
|
656
|
+
var $L14 = $L("<");
|
|
657
|
+
var $L15 = $L("extends");
|
|
658
|
+
var $L16 = $L("}");
|
|
659
|
+
var $L17 = $L("static");
|
|
660
|
+
var $L18 = $L("this");
|
|
661
|
+
var $L19 = $L("@");
|
|
662
|
+
var $L20 = $L("#");
|
|
663
|
+
var $L21 = $L("new");
|
|
664
|
+
var $L22 = $L("super");
|
|
665
|
+
var $L23 = $L("import");
|
|
666
|
+
var $L24 = $L("[");
|
|
667
|
+
var $L25 = $L("]");
|
|
668
|
+
var $L26 = $L(".");
|
|
669
|
+
var $L27 = $L("super[");
|
|
670
|
+
var $L28 = $L("new.target");
|
|
671
|
+
var $L29 = $L("import.meta");
|
|
672
|
+
var $L30 = $L("");
|
|
673
|
+
var $L31 = $L("...");
|
|
674
|
+
var $L32 = $L("function");
|
|
675
|
+
var $L33 = $L("->");
|
|
676
|
+
var $L34 = $L("true");
|
|
677
|
+
var $L35 = $L("false");
|
|
678
|
+
var $L36 = $L("null");
|
|
679
|
+
var $L37 = $L("undefined");
|
|
680
|
+
var $L38 = $L("get");
|
|
681
|
+
var $L39 = $L("set");
|
|
682
|
+
var $L40 = $L("**=");
|
|
683
|
+
var $L41 = $L("*=");
|
|
684
|
+
var $L42 = $L("/=");
|
|
685
|
+
var $L43 = $L("%=");
|
|
686
|
+
var $L44 = $L("+=");
|
|
687
|
+
var $L45 = $L("-=");
|
|
688
|
+
var $L46 = $L("<<=");
|
|
689
|
+
var $L47 = $L(">>>=");
|
|
690
|
+
var $L48 = $L(">>=");
|
|
691
|
+
var $L49 = $L("&&=");
|
|
692
|
+
var $L50 = $L("&=");
|
|
693
|
+
var $L51 = $L("^=");
|
|
694
|
+
var $L52 = $L("||=");
|
|
695
|
+
var $L53 = $L("|=");
|
|
696
|
+
var $L54 = $L("??=");
|
|
697
|
+
var $L55 = $L("=");
|
|
698
|
+
var $L56 = $L("**");
|
|
699
|
+
var $L57 = $L("/");
|
|
700
|
+
var $L58 = $L("%");
|
|
701
|
+
var $L59 = $L("+");
|
|
702
|
+
var $L60 = $L("-");
|
|
703
|
+
var $L61 = $L("<=");
|
|
704
|
+
var $L62 = $L(">=");
|
|
705
|
+
var $L63 = $L("<<");
|
|
706
|
+
var $L64 = $L(">>>");
|
|
707
|
+
var $L65 = $L(">>");
|
|
708
|
+
var $L66 = $L(">");
|
|
709
|
+
var $L67 = $L("!==");
|
|
710
|
+
var $L68 = $L("!=");
|
|
711
|
+
var $L69 = $L("is");
|
|
712
|
+
var $L70 = $L("===");
|
|
713
|
+
var $L71 = $L("==");
|
|
714
|
+
var $L72 = $L("and");
|
|
715
|
+
var $L73 = $L("&&");
|
|
716
|
+
var $L74 = $L("or");
|
|
717
|
+
var $L75 = $L("||");
|
|
718
|
+
var $L76 = $L("??");
|
|
719
|
+
var $L77 = $L("instanceof");
|
|
720
|
+
var $L78 = $L("in");
|
|
721
|
+
var $L79 = $L("&");
|
|
722
|
+
var $L80 = $L("^");
|
|
723
|
+
var $L81 = $L("|");
|
|
724
|
+
var $L82 = $L("delete");
|
|
725
|
+
var $L83 = $L("void");
|
|
726
|
+
var $L84 = $L("typeof");
|
|
727
|
+
var $L85 = $L(";");
|
|
728
|
+
var $L86 = $L("if");
|
|
729
|
+
var $L87 = $L("else");
|
|
730
|
+
var $L88 = $L("unless");
|
|
731
|
+
var $L89 = $L("loop");
|
|
732
|
+
var $L90 = $L("do");
|
|
733
|
+
var $L91 = $L("while");
|
|
734
|
+
var $L92 = $L("for");
|
|
735
|
+
var $L93 = $L("var");
|
|
736
|
+
var $L94 = $L("await");
|
|
737
|
+
var $L95 = $L("of");
|
|
738
|
+
var $L96 = $L("let");
|
|
739
|
+
var $L97 = $L("const");
|
|
740
|
+
var $L98 = $L("switch");
|
|
741
|
+
var $L99 = $L("case");
|
|
742
|
+
var $L100 = $L("default");
|
|
743
|
+
var $L101 = $L("when");
|
|
744
|
+
var $L102 = $L("try");
|
|
745
|
+
var $L103 = $L("catch");
|
|
746
|
+
var $L104 = $L("finally");
|
|
747
|
+
var $L105 = $L("break");
|
|
748
|
+
var $L106 = $L("continue");
|
|
749
|
+
var $L107 = $L("debugger");
|
|
750
|
+
var $L108 = $L("return");
|
|
751
|
+
var $L109 = $L("throw");
|
|
752
|
+
var $L110 = $L("import type");
|
|
751
753
|
var $L111 = $L("from");
|
|
752
754
|
var $L112 = $L("export");
|
|
753
755
|
var $L113 = $L(":=");
|
|
@@ -764,44 +766,49 @@ var Civet = (() => {
|
|
|
764
766
|
var $L124 = $L("</");
|
|
765
767
|
var $L125 = $L("<>");
|
|
766
768
|
var $L126 = $L("</>");
|
|
767
|
-
var $L127 = $L("
|
|
768
|
-
var $L128 = $L("
|
|
769
|
-
var $L129 = $L("
|
|
770
|
-
var $L130 = $L("
|
|
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 $
|
|
800
|
-
var $
|
|
801
|
-
var $
|
|
802
|
-
var $
|
|
803
|
-
var $
|
|
804
|
-
var $
|
|
769
|
+
var $L127 = $L("readonly");
|
|
770
|
+
var $L128 = $L("asserts");
|
|
771
|
+
var $L129 = $L("keyof");
|
|
772
|
+
var $L130 = $L("infer");
|
|
773
|
+
var $L131 = $L("[]");
|
|
774
|
+
var $L132 = $L(" ");
|
|
775
|
+
var $L133 = $L(" ");
|
|
776
|
+
var $R0 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
777
|
+
var $R1 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
778
|
+
var $R2 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
779
|
+
var $R3 = $R(new RegExp("\\p{ID_Continue}", "suy"));
|
|
780
|
+
var $R4 = $R(new RegExp("[!~+-]", "suy"));
|
|
781
|
+
var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
782
|
+
var $R6 = $R(new RegExp("\\d+(?:\\.\\d*)?", "suy"));
|
|
783
|
+
var $R7 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
|
|
784
|
+
var $R8 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
|
|
785
|
+
var $R9 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
|
|
786
|
+
var $R10 = $R(new RegExp('[^"\\\\]+', "suy"));
|
|
787
|
+
var $R11 = $R(new RegExp("[^'\\\\]+", "suy"));
|
|
788
|
+
var $R12 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
|
|
789
|
+
var $R13 = $R(new RegExp(".", "suy"));
|
|
790
|
+
var $R14 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
|
|
791
|
+
var $R15 = $R(new RegExp("[^\\/\\r\\n]+", "suy"));
|
|
792
|
+
var $R16 = $R(new RegExp("(:?\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
793
|
+
var $R17 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
794
|
+
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"));
|
|
795
|
+
var $R19 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
796
|
+
var $R20 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
797
|
+
var $R21 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
798
|
+
var $R22 = $R(new RegExp("[\\t ]+", "suy"));
|
|
799
|
+
var $R23 = $R(new RegExp("[\\s]+", "suy"));
|
|
800
|
+
var $R24 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
801
|
+
var $R25 = $R(new RegExp('"[^"]*"', "suy"));
|
|
802
|
+
var $R26 = $R(new RegExp("'[^']*'", "suy"));
|
|
803
|
+
var $R27 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
804
|
+
var $R28 = $R(new RegExp("type(?!\\p{ID_Continue})", "suy"));
|
|
805
|
+
var $R29 = $R(new RegExp("interface(?!\\p{ID_Continue})", "suy"));
|
|
806
|
+
var $R30 = $R(new RegExp("[+-]?", "suy"));
|
|
807
|
+
var $R31 = $R(new RegExp("[+-]", "suy"));
|
|
808
|
+
var $R32 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
809
|
+
var $R33 = $R(new RegExp("[\\t ]*", "suy"));
|
|
810
|
+
var $R34 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
811
|
+
var $R35 = $R(new RegExp("$", "suy"));
|
|
805
812
|
var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
|
|
806
813
|
function Program(state) {
|
|
807
814
|
if (state.verbose)
|
|
@@ -900,10 +907,10 @@ var Civet = (() => {
|
|
|
900
907
|
var pre = $1;
|
|
901
908
|
var exp = $2;
|
|
902
909
|
var post = $3;
|
|
903
|
-
if (post) {
|
|
910
|
+
if (post === "?") {
|
|
904
911
|
return ["(", pre, , "(", exp, ") != null)"];
|
|
905
912
|
}
|
|
906
|
-
return [pre, exp];
|
|
913
|
+
return [pre, exp, post];
|
|
907
914
|
});
|
|
908
915
|
function UnaryExpression(state) {
|
|
909
916
|
if (state.verbose)
|
|
@@ -915,17 +922,16 @@ var Civet = (() => {
|
|
|
915
922
|
}
|
|
916
923
|
}
|
|
917
924
|
var UnaryPostfix$0 = $EXPECT($L3, fail, 'UnaryPostfix "?"');
|
|
925
|
+
var UnaryPostfix$1 = $S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), $R$0($EXPECT($R0, fail, "UnaryPostfix /(?!\\p{ID_Continue})/")), Type);
|
|
918
926
|
function UnaryPostfix(state) {
|
|
919
|
-
if (state.verbose)
|
|
920
|
-
console.log("ENTER:", "UnaryPostfix");
|
|
921
927
|
if (state.tokenize) {
|
|
922
|
-
return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state));
|
|
928
|
+
return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state));
|
|
923
929
|
} else {
|
|
924
|
-
return UnaryPostfix$0(state);
|
|
930
|
+
return UnaryPostfix$0(state) || UnaryPostfix$1(state);
|
|
925
931
|
}
|
|
926
932
|
}
|
|
927
|
-
var UpdateExpression$0 = $S($C($EXPECT($
|
|
928
|
-
var UpdateExpression$1 = $S(LeftHandSideExpression, $E($C($EXPECT($
|
|
933
|
+
var UpdateExpression$0 = $S($C($EXPECT($L5, fail, 'UpdateExpression "++"'), $EXPECT($L6, fail, 'UpdateExpression "--"')), UnaryExpression);
|
|
934
|
+
var UpdateExpression$1 = $S(LeftHandSideExpression, $E($C($EXPECT($L5, fail, 'UpdateExpression "++"'), $EXPECT($L6, fail, 'UpdateExpression "--"'))));
|
|
929
935
|
function UpdateExpression(state) {
|
|
930
936
|
if (state.tokenize) {
|
|
931
937
|
return $TOKEN("UpdateExpression", state, UpdateExpression$0(state) || UpdateExpression$1(state));
|
|
@@ -943,7 +949,7 @@ var Civet = (() => {
|
|
|
943
949
|
}
|
|
944
950
|
}
|
|
945
951
|
var AssignmentExpressionRest$0 = YieldExpression;
|
|
946
|
-
var AssignmentExpressionRest$1 = $S($E($S($EXPECT($
|
|
952
|
+
var AssignmentExpressionRest$1 = $S($E($S($EXPECT($L7, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
|
|
947
953
|
var AssignmentExpressionRest$2 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), $C($S($Q(_), Expression), $S(__, Expression)));
|
|
948
954
|
var AssignmentExpressionRest$3 = ConditionalExpression;
|
|
949
955
|
function AssignmentExpressionRest(state) {
|
|
@@ -953,7 +959,7 @@ var Civet = (() => {
|
|
|
953
959
|
return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state);
|
|
954
960
|
}
|
|
955
961
|
}
|
|
956
|
-
var YieldExpression$0 = $S($EXPECT($
|
|
962
|
+
var YieldExpression$0 = $S($EXPECT($L8, fail, 'YieldExpression "yield"'), $E($S($Q(TrailingComment), $EXPECT($L9, fail, 'YieldExpression "*"'))), AssignmentExpression);
|
|
957
963
|
function YieldExpression(state) {
|
|
958
964
|
if (state.verbose)
|
|
959
965
|
console.log("ENTER:", "YieldExpression");
|
|
@@ -964,7 +970,7 @@ var Civet = (() => {
|
|
|
964
970
|
}
|
|
965
971
|
}
|
|
966
972
|
var ArrowFunction$0 = ThinArrowFunction;
|
|
967
|
-
var ArrowFunction$1 = $S($C(BindingIdentifier, Parameters), __, $EXPECT($
|
|
973
|
+
var ArrowFunction$1 = $S($C(BindingIdentifier, Parameters), __, $EXPECT($L10, fail, 'ArrowFunction "=>"'), ConciseBody);
|
|
968
974
|
function ArrowFunction(state) {
|
|
969
975
|
if (state.tokenize) {
|
|
970
976
|
return $TOKEN("ArrowFunction", state, ArrowFunction$0(state) || ArrowFunction$1(state));
|
|
@@ -972,7 +978,7 @@ var Civet = (() => {
|
|
|
972
978
|
return ArrowFunction$0(state) || ArrowFunction$1(state);
|
|
973
979
|
}
|
|
974
980
|
}
|
|
975
|
-
var ConciseBody$0 = $S($N($S($Q(_), $EXPECT($
|
|
981
|
+
var ConciseBody$0 = $S($N($S($Q(_), $EXPECT($L11, fail, 'ConciseBody "{"'))), AssignmentExpression);
|
|
976
982
|
var ConciseBody$1 = $S(EOS, SingleNestedBlockExpression);
|
|
977
983
|
var ConciseBody$2 = BracedBlock;
|
|
978
984
|
function ConciseBody(state) {
|
|
@@ -982,7 +988,7 @@ var Civet = (() => {
|
|
|
982
988
|
return ConciseBody$0(state) || ConciseBody$1(state) || ConciseBody$2(state);
|
|
983
989
|
}
|
|
984
990
|
}
|
|
985
|
-
var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($
|
|
991
|
+
var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L12, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
|
|
986
992
|
function ConditionalExpression(state) {
|
|
987
993
|
if (state.verbose)
|
|
988
994
|
console.log("ENTER:", "ConditionalExpression");
|
|
@@ -1031,7 +1037,7 @@ var Civet = (() => {
|
|
|
1031
1037
|
return ClassDeclaration$0(state);
|
|
1032
1038
|
}
|
|
1033
1039
|
}
|
|
1034
|
-
var ClassExpression$0 = $S($EXPECT($
|
|
1040
|
+
var ClassExpression$0 = $S($EXPECT($L13, fail, 'ClassExpression "class"'), $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
|
|
1035
1041
|
function ClassExpression(state) {
|
|
1036
1042
|
if (state.verbose)
|
|
1037
1043
|
console.log("ENTER:", "ClassExpression");
|
|
@@ -1051,10 +1057,10 @@ var Civet = (() => {
|
|
|
1051
1057
|
return ClassHeritage$0(state);
|
|
1052
1058
|
}
|
|
1053
1059
|
}
|
|
1054
|
-
var ExtendsToken$0 = $T($EXPECT($
|
|
1060
|
+
var ExtendsToken$0 = $T($EXPECT($L14, fail, 'ExtendsToken "<"'), function(value) {
|
|
1055
1061
|
return "extends";
|
|
1056
1062
|
});
|
|
1057
|
-
var ExtendsToken$1 = $EXPECT($
|
|
1063
|
+
var ExtendsToken$1 = $EXPECT($L15, fail, 'ExtendsToken "extends"');
|
|
1058
1064
|
function ExtendsToken(state) {
|
|
1059
1065
|
if (state.tokenize) {
|
|
1060
1066
|
return $TOKEN("ExtendsToken", state, ExtendsToken$0(state) || ExtendsToken$1(state));
|
|
@@ -1062,7 +1068,7 @@ var Civet = (() => {
|
|
|
1062
1068
|
return ExtendsToken$0(state) || ExtendsToken$1(state);
|
|
1063
1069
|
}
|
|
1064
1070
|
}
|
|
1065
|
-
var ClassBody$0 = $S(__, $EXPECT($
|
|
1071
|
+
var ClassBody$0 = $S(__, $EXPECT($L11, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L16, fail, 'ClassBody "}"'));
|
|
1066
1072
|
var ClassBody$1 = $S(InsertOpenBrace, EOS, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1067
1073
|
function ClassBody(state) {
|
|
1068
1074
|
if (state.tokenize) {
|
|
@@ -1096,8 +1102,8 @@ var Civet = (() => {
|
|
|
1096
1102
|
return NestedClassElement$0(state);
|
|
1097
1103
|
}
|
|
1098
1104
|
}
|
|
1099
|
-
var ClassElement$0 = $S($EXPECT($
|
|
1100
|
-
var ClassElement$1 = $S($E($S($EXPECT($
|
|
1105
|
+
var ClassElement$0 = $S($EXPECT($L17, fail, 'ClassElement "static"'), BracedBlock);
|
|
1106
|
+
var ClassElement$1 = $S($E($S($EXPECT($L17, fail, 'ClassElement "static"'), __)), $C(MethodDefinition, FieldDefinition));
|
|
1101
1107
|
function ClassElement(state) {
|
|
1102
1108
|
if (state.tokenize) {
|
|
1103
1109
|
return $TOKEN("ClassElement", state, ClassElement$0(state) || ClassElement$1(state));
|
|
@@ -1115,12 +1121,12 @@ var Civet = (() => {
|
|
|
1115
1121
|
return FieldDefinition$0(state);
|
|
1116
1122
|
}
|
|
1117
1123
|
}
|
|
1118
|
-
var This$0 = $EXPECT($
|
|
1119
|
-
var This$1 = $T($S($EXPECT($
|
|
1124
|
+
var This$0 = $EXPECT($L18, fail, 'This "this"');
|
|
1125
|
+
var This$1 = $T($S($EXPECT($L19, fail, 'This "@"'), $S($E($EXPECT($L20, fail, 'This "#"')), IdentifierName)), function(value) {
|
|
1120
1126
|
var ref = value[1];
|
|
1121
1127
|
return ["this.", ref];
|
|
1122
1128
|
});
|
|
1123
|
-
var This$2 = $T($EXPECT($
|
|
1129
|
+
var This$2 = $T($EXPECT($L19, fail, 'This "@"'), function(value) {
|
|
1124
1130
|
return "this";
|
|
1125
1131
|
});
|
|
1126
1132
|
function This(state) {
|
|
@@ -1139,7 +1145,7 @@ var Civet = (() => {
|
|
|
1139
1145
|
return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
|
|
1140
1146
|
}
|
|
1141
1147
|
}
|
|
1142
|
-
var NewExpression$0 = $S($P($S($EXPECT($
|
|
1148
|
+
var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)), MemberExpression);
|
|
1143
1149
|
function NewExpression(state) {
|
|
1144
1150
|
if (state.verbose)
|
|
1145
1151
|
console.log("ENTER:", "NewExpression");
|
|
@@ -1149,8 +1155,8 @@ var Civet = (() => {
|
|
|
1149
1155
|
return NewExpression$0(state);
|
|
1150
1156
|
}
|
|
1151
1157
|
}
|
|
1152
|
-
var CallExpression$0 = $S($EXPECT($
|
|
1153
|
-
var CallExpression$1 = $S($EXPECT($
|
|
1158
|
+
var CallExpression$0 = $S($EXPECT($L22, fail, 'CallExpression "super"'), __, Arguments);
|
|
1159
|
+
var CallExpression$1 = $S($EXPECT($L23, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
|
|
1154
1160
|
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest), $E(SpacedApplication));
|
|
1155
1161
|
function CallExpression(state) {
|
|
1156
1162
|
if (state.tokenize) {
|
|
@@ -1160,8 +1166,8 @@ var Civet = (() => {
|
|
|
1160
1166
|
}
|
|
1161
1167
|
}
|
|
1162
1168
|
var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
|
|
1163
|
-
var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($
|
|
1164
|
-
var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($
|
|
1169
|
+
var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($L24, fail, 'CallExpressionRest "["'), __, Expression, __, $EXPECT($L25, fail, 'CallExpressionRest "]"'));
|
|
1170
|
+
var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($L26, fail, 'CallExpressionRest "."'), $C(IdentifierName, PrivateIdentifier));
|
|
1165
1171
|
var CallExpressionRest$3 = TemplateLiteral;
|
|
1166
1172
|
function CallExpressionRest(state) {
|
|
1167
1173
|
if (state.tokenize) {
|
|
@@ -1170,7 +1176,7 @@ var Civet = (() => {
|
|
|
1170
1176
|
return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
|
|
1171
1177
|
}
|
|
1172
1178
|
}
|
|
1173
|
-
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($
|
|
1179
|
+
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L26, fail, 'OptionalShorthand "."'), InsertDot));
|
|
1174
1180
|
function OptionalShorthand(state) {
|
|
1175
1181
|
if (state.verbose)
|
|
1176
1182
|
console.log("ENTER:", "OptionalShorthand");
|
|
@@ -1204,7 +1210,7 @@ var Civet = (() => {
|
|
|
1204
1210
|
return ApplicationStart$0(state);
|
|
1205
1211
|
}
|
|
1206
1212
|
}
|
|
1207
|
-
var AdditionalReservedWords$0 = $R$0($EXPECT($
|
|
1213
|
+
var AdditionalReservedWords$0 = $R$0($EXPECT($R1, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue})/"));
|
|
1208
1214
|
function AdditionalReservedWords(state) {
|
|
1209
1215
|
if (state.verbose)
|
|
1210
1216
|
console.log("ENTER:", "AdditionalReservedWords");
|
|
@@ -1224,7 +1230,7 @@ var Civet = (() => {
|
|
|
1224
1230
|
return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
|
|
1225
1231
|
}
|
|
1226
1232
|
}
|
|
1227
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
1233
|
+
var SuperProperty$0 = $S($EXPECT($L27, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L25, fail, 'SuperProperty "]"'));
|
|
1228
1234
|
function SuperProperty(state) {
|
|
1229
1235
|
if (state.verbose)
|
|
1230
1236
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1234,8 +1240,8 @@ var Civet = (() => {
|
|
|
1234
1240
|
return SuperProperty$0(state);
|
|
1235
1241
|
}
|
|
1236
1242
|
}
|
|
1237
|
-
var MetaProperty$0 = $EXPECT($
|
|
1238
|
-
var MetaProperty$1 = $EXPECT($
|
|
1243
|
+
var MetaProperty$0 = $EXPECT($L28, fail, 'MetaProperty "new.target"');
|
|
1244
|
+
var MetaProperty$1 = $EXPECT($L29, fail, 'MetaProperty "import.meta"');
|
|
1239
1245
|
function MetaProperty(state) {
|
|
1240
1246
|
if (state.tokenize) {
|
|
1241
1247
|
return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
|
|
@@ -1244,7 +1250,7 @@ var Civet = (() => {
|
|
|
1244
1250
|
}
|
|
1245
1251
|
}
|
|
1246
1252
|
var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
|
|
1247
|
-
var Parameters$1 = $T($EXPECT($
|
|
1253
|
+
var Parameters$1 = $T($EXPECT($L30, fail, 'Parameters ""'), function(value) {
|
|
1248
1254
|
return "()";
|
|
1249
1255
|
});
|
|
1250
1256
|
function Parameters(state) {
|
|
@@ -1298,7 +1304,7 @@ var Civet = (() => {
|
|
|
1298
1304
|
return BindingPattern$0(state) || BindingPattern$1(state);
|
|
1299
1305
|
}
|
|
1300
1306
|
}
|
|
1301
|
-
var ObjectBindingPattern$0 = $S($EXPECT($
|
|
1307
|
+
var ObjectBindingPattern$0 = $S($EXPECT($L11, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L16, fail, 'ObjectBindingPattern "}"'));
|
|
1302
1308
|
function ObjectBindingPattern(state) {
|
|
1303
1309
|
if (state.verbose)
|
|
1304
1310
|
console.log("ENTER:", "ObjectBindingPattern");
|
|
@@ -1308,7 +1314,7 @@ var Civet = (() => {
|
|
|
1308
1314
|
return ObjectBindingPattern$0(state);
|
|
1309
1315
|
}
|
|
1310
1316
|
}
|
|
1311
|
-
var ArrayBindingPattern$0 = $S($EXPECT($
|
|
1317
|
+
var ArrayBindingPattern$0 = $S($EXPECT($L24, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L25, fail, 'ArrayBindingPattern "]"'));
|
|
1312
1318
|
function ArrayBindingPattern(state) {
|
|
1313
1319
|
if (state.verbose)
|
|
1314
1320
|
console.log("ENTER:", "ArrayBindingPattern");
|
|
@@ -1318,7 +1324,7 @@ var Civet = (() => {
|
|
|
1318
1324
|
return ArrayBindingPattern$0(state);
|
|
1319
1325
|
}
|
|
1320
1326
|
}
|
|
1321
|
-
var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($
|
|
1327
|
+
var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L12, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
|
|
1322
1328
|
var BindingProperty$1 = $S(__, BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
|
|
1323
1329
|
function BindingProperty(state) {
|
|
1324
1330
|
if (state.tokenize) {
|
|
@@ -1327,7 +1333,7 @@ var Civet = (() => {
|
|
|
1327
1333
|
return BindingProperty$0(state) || BindingProperty$1(state);
|
|
1328
1334
|
}
|
|
1329
1335
|
}
|
|
1330
|
-
var BindingRestProperty$0 = $S($EXPECT($
|
|
1336
|
+
var BindingRestProperty$0 = $S($EXPECT($L31, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
|
|
1331
1337
|
function BindingRestProperty(state) {
|
|
1332
1338
|
if (state.verbose)
|
|
1333
1339
|
console.log("ENTER:", "BindingRestProperty");
|
|
@@ -1347,7 +1353,7 @@ var Civet = (() => {
|
|
|
1347
1353
|
return BindingElement$0(state);
|
|
1348
1354
|
}
|
|
1349
1355
|
}
|
|
1350
|
-
var BindingRestElement$0 = $S($EXPECT($
|
|
1356
|
+
var BindingRestElement$0 = $S($EXPECT($L31, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
|
|
1351
1357
|
function BindingRestElement(state) {
|
|
1352
1358
|
if (state.verbose)
|
|
1353
1359
|
console.log("ENTER:", "BindingRestElement");
|
|
@@ -1368,7 +1374,7 @@ var Civet = (() => {
|
|
|
1368
1374
|
}
|
|
1369
1375
|
}
|
|
1370
1376
|
var FunctionExpression$0 = ThinArrowFunction;
|
|
1371
|
-
var FunctionExpression$1 = $S($EXPECT($
|
|
1377
|
+
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);
|
|
1372
1378
|
function FunctionExpression(state) {
|
|
1373
1379
|
if (state.tokenize) {
|
|
1374
1380
|
return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
|
|
@@ -1376,7 +1382,7 @@ var Civet = (() => {
|
|
|
1376
1382
|
return FunctionExpression$0(state) || FunctionExpression$1(state);
|
|
1377
1383
|
}
|
|
1378
1384
|
}
|
|
1379
|
-
var ThinArrowFunction$0 = $T($S(Parameters, $E(
|
|
1385
|
+
var ThinArrowFunction$0 = $T($S(Parameters, $E(ReturnTypeSuffix), __, $EXPECT($L33, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
|
|
1380
1386
|
var params = value[0];
|
|
1381
1387
|
var suffix = value[1];
|
|
1382
1388
|
var block = value[4];
|
|
@@ -1391,7 +1397,7 @@ var Civet = (() => {
|
|
|
1391
1397
|
return ThinArrowFunction$0(state);
|
|
1392
1398
|
}
|
|
1393
1399
|
}
|
|
1394
|
-
var Block$0 = $S(__, $EXPECT($
|
|
1400
|
+
var Block$0 = $S(__, $EXPECT($L11, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'Block "}"'));
|
|
1395
1401
|
var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1396
1402
|
var Block$2 = Statement;
|
|
1397
1403
|
var Block$3 = $S(__, Statement);
|
|
@@ -1402,7 +1408,7 @@ var Civet = (() => {
|
|
|
1402
1408
|
return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
|
|
1403
1409
|
}
|
|
1404
1410
|
}
|
|
1405
|
-
var BracedBlock$0 = $S(__, $EXPECT($
|
|
1411
|
+
var BracedBlock$0 = $S(__, $EXPECT($L11, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BracedBlock "}"'));
|
|
1406
1412
|
var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1407
1413
|
var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
|
|
1408
1414
|
function BracedBlock(state) {
|
|
@@ -1454,10 +1460,10 @@ var Civet = (() => {
|
|
|
1454
1460
|
}
|
|
1455
1461
|
var Literal$0 = StringLiteral;
|
|
1456
1462
|
var Literal$1 = NumericLiteral;
|
|
1457
|
-
var Literal$2 = $EXPECT($
|
|
1458
|
-
var Literal$3 = $EXPECT($
|
|
1459
|
-
var Literal$4 = $EXPECT($
|
|
1460
|
-
var Literal$5 = $EXPECT($
|
|
1463
|
+
var Literal$2 = $EXPECT($L34, fail, 'Literal "true"');
|
|
1464
|
+
var Literal$3 = $EXPECT($L35, fail, 'Literal "false"');
|
|
1465
|
+
var Literal$4 = $EXPECT($L36, fail, 'Literal "null"');
|
|
1466
|
+
var Literal$5 = $EXPECT($L37, fail, 'Literal "undefined"');
|
|
1461
1467
|
function Literal(state) {
|
|
1462
1468
|
if (state.tokenize) {
|
|
1463
1469
|
return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state) || Literal$4(state) || Literal$5(state));
|
|
@@ -1485,7 +1491,7 @@ var Civet = (() => {
|
|
|
1485
1491
|
return Identifier$0(state);
|
|
1486
1492
|
}
|
|
1487
1493
|
}
|
|
1488
|
-
var IdentifierName$0 = $R$0($EXPECT($
|
|
1494
|
+
var IdentifierName$0 = $R$0($EXPECT($R2, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
1489
1495
|
function IdentifierName(state) {
|
|
1490
1496
|
if (state.verbose)
|
|
1491
1497
|
console.log("ENTER:", "IdentifierName");
|
|
@@ -1505,8 +1511,8 @@ var Civet = (() => {
|
|
|
1505
1511
|
return IdentifierReference$0(state);
|
|
1506
1512
|
}
|
|
1507
1513
|
}
|
|
1508
|
-
var ArrayLiteral$0 = $S($EXPECT($
|
|
1509
|
-
var ArrayLiteral$1 = $S($EXPECT($
|
|
1514
|
+
var ArrayLiteral$0 = $S($EXPECT($L24, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L25, fail, 'ArrayLiteral "]"'));
|
|
1515
|
+
var ArrayLiteral$1 = $S($EXPECT($L24, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L25, fail, 'ArrayLiteral "]"'));
|
|
1510
1516
|
function ArrayLiteral(state) {
|
|
1511
1517
|
if (state.tokenize) {
|
|
1512
1518
|
return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
|
|
@@ -1540,8 +1546,8 @@ var Civet = (() => {
|
|
|
1540
1546
|
}
|
|
1541
1547
|
}
|
|
1542
1548
|
var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
|
|
1543
|
-
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1544
|
-
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
1549
|
+
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
|
|
1550
|
+
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"'))), function(value) {
|
|
1545
1551
|
return ",";
|
|
1546
1552
|
});
|
|
1547
1553
|
var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1564,7 +1570,7 @@ var Civet = (() => {
|
|
|
1564
1570
|
return ElementList$0(state);
|
|
1565
1571
|
}
|
|
1566
1572
|
}
|
|
1567
|
-
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($
|
|
1573
|
+
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L31, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
|
|
1568
1574
|
function ArrayElementExpression(state) {
|
|
1569
1575
|
if (state.verbose)
|
|
1570
1576
|
console.log("ENTER:", "ArrayElementExpression");
|
|
@@ -1584,9 +1590,9 @@ var Civet = (() => {
|
|
|
1584
1590
|
return Elision$0(state);
|
|
1585
1591
|
}
|
|
1586
1592
|
}
|
|
1587
|
-
var ObjectLiteral$0 = $S($EXPECT($
|
|
1588
|
-
var ObjectLiteral$1 = $S($EXPECT($
|
|
1589
|
-
var ObjectLiteral$2 = $S($EXPECT($
|
|
1593
|
+
var ObjectLiteral$0 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L16, fail, 'ObjectLiteral "}"'));
|
|
1594
|
+
var ObjectLiteral$1 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L16, fail, 'ObjectLiteral "}"'));
|
|
1595
|
+
var ObjectLiteral$2 = $S($EXPECT($L11, fail, 'ObjectLiteral "{"'), __, $EXPECT($L16, fail, 'ObjectLiteral "}"'));
|
|
1590
1596
|
var ObjectLiteral$3 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1591
1597
|
function ObjectLiteral(state) {
|
|
1592
1598
|
if (state.tokenize) {
|
|
@@ -1621,8 +1627,8 @@ var Civet = (() => {
|
|
|
1621
1627
|
}
|
|
1622
1628
|
}
|
|
1623
1629
|
var ObjectPropertyDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ObjectPropertyDelimiter ","'));
|
|
1624
|
-
var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1625
|
-
var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
1630
|
+
var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'ObjectPropertyDelimiter "}"')));
|
|
1631
|
+
var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
|
|
1626
1632
|
return ",";
|
|
1627
1633
|
});
|
|
1628
1634
|
var ObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1645,9 +1651,9 @@ var Civet = (() => {
|
|
|
1645
1651
|
return PropertyDefinitionList$0(state);
|
|
1646
1652
|
}
|
|
1647
1653
|
}
|
|
1648
|
-
var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($
|
|
1654
|
+
var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L12, fail, 'PropertyDefinition ":"'), AssignmentExpression);
|
|
1649
1655
|
var PropertyDefinition$1 = MethodDefinition;
|
|
1650
|
-
var PropertyDefinition$2 = $S($EXPECT($
|
|
1656
|
+
var PropertyDefinition$2 = $S($EXPECT($L31, fail, 'PropertyDefinition "..."'), AssignmentExpression);
|
|
1651
1657
|
var PropertyDefinition$3 = IdentifierReference;
|
|
1652
1658
|
function PropertyDefinition(state) {
|
|
1653
1659
|
if (state.tokenize) {
|
|
@@ -1659,7 +1665,7 @@ var Civet = (() => {
|
|
|
1659
1665
|
var PropertyName$0 = NumericLiteral;
|
|
1660
1666
|
var PropertyName$1 = StringLiteral;
|
|
1661
1667
|
var PropertyName$2 = IdentifierName;
|
|
1662
|
-
var PropertyName$3 = $S($EXPECT($
|
|
1668
|
+
var PropertyName$3 = $S($EXPECT($L24, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L25, fail, 'PropertyName "]"'));
|
|
1663
1669
|
function PropertyName(state) {
|
|
1664
1670
|
if (state.tokenize) {
|
|
1665
1671
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -1667,8 +1673,8 @@ var Civet = (() => {
|
|
|
1667
1673
|
return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
|
|
1668
1674
|
}
|
|
1669
1675
|
}
|
|
1670
|
-
var MethodDefinition$0 = $S($EXPECT($
|
|
1671
|
-
var MethodDefinition$1 = $S($EXPECT($
|
|
1676
|
+
var MethodDefinition$0 = $S($EXPECT($L38, fail, 'MethodDefinition "get"'), $N($R$0($EXPECT($R3, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1677
|
+
var MethodDefinition$1 = $S($EXPECT($L39, fail, 'MethodDefinition "set"'), $N($R$0($EXPECT($R3, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1672
1678
|
var MethodDefinition$2 = AsyncGeneratorMethod;
|
|
1673
1679
|
var MethodDefinition$3 = AsyncMethod;
|
|
1674
1680
|
var MethodDefinition$4 = GeneratorMethod;
|
|
@@ -1689,7 +1695,7 @@ var Civet = (() => {
|
|
|
1689
1695
|
return ClassElementName$0(state) || ClassElementName$1(state);
|
|
1690
1696
|
}
|
|
1691
1697
|
}
|
|
1692
|
-
var PrivateIdentifier$0 = $S($EXPECT($
|
|
1698
|
+
var PrivateIdentifier$0 = $S($EXPECT($L20, fail, 'PrivateIdentifier "#"'), IdentifierName);
|
|
1693
1699
|
function PrivateIdentifier(state) {
|
|
1694
1700
|
if (state.verbose)
|
|
1695
1701
|
console.log("ENTER:", "PrivateIdentifier");
|
|
@@ -1699,27 +1705,7 @@ var Civet = (() => {
|
|
|
1699
1705
|
return PrivateIdentifier$0(state);
|
|
1700
1706
|
}
|
|
1701
1707
|
}
|
|
1702
|
-
var
|
|
1703
|
-
function GeneratorDeclaration(state) {
|
|
1704
|
-
if (state.verbose)
|
|
1705
|
-
console.log("ENTER:", "GeneratorDeclaration");
|
|
1706
|
-
if (state.tokenize) {
|
|
1707
|
-
return $TOKEN("GeneratorDeclaration", state, GeneratorDeclaration$0(state));
|
|
1708
|
-
} else {
|
|
1709
|
-
return GeneratorDeclaration$0(state);
|
|
1710
|
-
}
|
|
1711
|
-
}
|
|
1712
|
-
var GeneratorExpression$0 = $S($EXPECT($L31, fail, 'GeneratorExpression "function"'), __, $EXPECT($L8, fail, 'GeneratorExpression "*"'), $E($S(__, BindingIdentifier)), Parameters, GeneratorBody);
|
|
1713
|
-
function GeneratorExpression(state) {
|
|
1714
|
-
if (state.verbose)
|
|
1715
|
-
console.log("ENTER:", "GeneratorExpression");
|
|
1716
|
-
if (state.tokenize) {
|
|
1717
|
-
return $TOKEN("GeneratorExpression", state, GeneratorExpression$0(state));
|
|
1718
|
-
} else {
|
|
1719
|
-
return GeneratorExpression$0(state);
|
|
1720
|
-
}
|
|
1721
|
-
}
|
|
1722
|
-
var GeneratorMethod$0 = $S($EXPECT($L8, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
|
|
1708
|
+
var GeneratorMethod$0 = $S($EXPECT($L9, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
|
|
1723
1709
|
function GeneratorMethod(state) {
|
|
1724
1710
|
if (state.verbose)
|
|
1725
1711
|
console.log("ENTER:", "GeneratorMethod");
|
|
@@ -1739,27 +1725,7 @@ var Civet = (() => {
|
|
|
1739
1725
|
return GeneratorBody$0(state);
|
|
1740
1726
|
}
|
|
1741
1727
|
}
|
|
1742
|
-
var
|
|
1743
|
-
function AsyncFunctionDeclaration(state) {
|
|
1744
|
-
if (state.verbose)
|
|
1745
|
-
console.log("ENTER:", "AsyncFunctionDeclaration");
|
|
1746
|
-
if (state.tokenize) {
|
|
1747
|
-
return $TOKEN("AsyncFunctionDeclaration", state, AsyncFunctionDeclaration$0(state));
|
|
1748
|
-
} else {
|
|
1749
|
-
return AsyncFunctionDeclaration$0(state);
|
|
1750
|
-
}
|
|
1751
|
-
}
|
|
1752
|
-
var AsyncFunctionExpression$0 = $S($EXPECT($L6, fail, 'AsyncFunctionExpression "async"'), $N(EOS), __, $EXPECT($L31, fail, 'AsyncFunctionExpression "function"'), $E($S(__, BindingIdentifier)), __, Parameters, AsyncFunctionBody);
|
|
1753
|
-
function AsyncFunctionExpression(state) {
|
|
1754
|
-
if (state.verbose)
|
|
1755
|
-
console.log("ENTER:", "AsyncFunctionExpression");
|
|
1756
|
-
if (state.tokenize) {
|
|
1757
|
-
return $TOKEN("AsyncFunctionExpression", state, AsyncFunctionExpression$0(state));
|
|
1758
|
-
} else {
|
|
1759
|
-
return AsyncFunctionExpression$0(state);
|
|
1760
|
-
}
|
|
1761
|
-
}
|
|
1762
|
-
var AsyncMethod$0 = $S($EXPECT($L6, fail, 'AsyncMethod "async"'), $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
|
|
1728
|
+
var AsyncMethod$0 = $S($EXPECT($L7, fail, 'AsyncMethod "async"'), $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
|
|
1763
1729
|
function AsyncMethod(state) {
|
|
1764
1730
|
if (state.verbose)
|
|
1765
1731
|
console.log("ENTER:", "AsyncMethod");
|
|
@@ -1779,27 +1745,7 @@ var Civet = (() => {
|
|
|
1779
1745
|
return AsyncFunctionBody$0(state);
|
|
1780
1746
|
}
|
|
1781
1747
|
}
|
|
1782
|
-
var
|
|
1783
|
-
function AsyncGeneratorDeclaration(state) {
|
|
1784
|
-
if (state.verbose)
|
|
1785
|
-
console.log("ENTER:", "AsyncGeneratorDeclaration");
|
|
1786
|
-
if (state.tokenize) {
|
|
1787
|
-
return $TOKEN("AsyncGeneratorDeclaration", state, AsyncGeneratorDeclaration$0(state));
|
|
1788
|
-
} else {
|
|
1789
|
-
return AsyncGeneratorDeclaration$0(state);
|
|
1790
|
-
}
|
|
1791
|
-
}
|
|
1792
|
-
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);
|
|
1793
|
-
function AsyncGeneratorExpression(state) {
|
|
1794
|
-
if (state.verbose)
|
|
1795
|
-
console.log("ENTER:", "AsyncGeneratorExpression");
|
|
1796
|
-
if (state.tokenize) {
|
|
1797
|
-
return $TOKEN("AsyncGeneratorExpression", state, AsyncGeneratorExpression$0(state));
|
|
1798
|
-
} else {
|
|
1799
|
-
return AsyncGeneratorExpression$0(state);
|
|
1800
|
-
}
|
|
1801
|
-
}
|
|
1802
|
-
var AsyncGeneratorMethod$0 = $S($EXPECT($L6, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L8, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
|
|
1748
|
+
var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L9, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
|
|
1803
1749
|
function AsyncGeneratorMethod(state) {
|
|
1804
1750
|
if (state.verbose)
|
|
1805
1751
|
console.log("ENTER:", "AsyncGeneratorMethod");
|
|
@@ -1819,22 +1765,22 @@ var Civet = (() => {
|
|
|
1819
1765
|
return AsyncGeneratorBody$0(state);
|
|
1820
1766
|
}
|
|
1821
1767
|
}
|
|
1822
|
-
var AssignmentOp$0 = $EXPECT($
|
|
1823
|
-
var AssignmentOp$1 = $EXPECT($
|
|
1824
|
-
var AssignmentOp$2 = $EXPECT($
|
|
1825
|
-
var AssignmentOp$3 = $EXPECT($
|
|
1826
|
-
var AssignmentOp$4 = $EXPECT($
|
|
1827
|
-
var AssignmentOp$5 = $EXPECT($
|
|
1828
|
-
var AssignmentOp$6 = $EXPECT($
|
|
1829
|
-
var AssignmentOp$7 = $EXPECT($
|
|
1830
|
-
var AssignmentOp$8 = $EXPECT($
|
|
1831
|
-
var AssignmentOp$9 = $EXPECT($
|
|
1832
|
-
var AssignmentOp$10 = $EXPECT($
|
|
1833
|
-
var AssignmentOp$11 = $EXPECT($
|
|
1834
|
-
var AssignmentOp$12 = $EXPECT($
|
|
1835
|
-
var AssignmentOp$13 = $EXPECT($
|
|
1836
|
-
var AssignmentOp$14 = $EXPECT($
|
|
1837
|
-
var AssignmentOp$15 = $EXPECT($
|
|
1768
|
+
var AssignmentOp$0 = $EXPECT($L40, fail, 'AssignmentOp "**="');
|
|
1769
|
+
var AssignmentOp$1 = $EXPECT($L41, fail, 'AssignmentOp "*="');
|
|
1770
|
+
var AssignmentOp$2 = $EXPECT($L42, fail, 'AssignmentOp "/="');
|
|
1771
|
+
var AssignmentOp$3 = $EXPECT($L43, fail, 'AssignmentOp "%="');
|
|
1772
|
+
var AssignmentOp$4 = $EXPECT($L44, fail, 'AssignmentOp "+="');
|
|
1773
|
+
var AssignmentOp$5 = $EXPECT($L45, fail, 'AssignmentOp "-="');
|
|
1774
|
+
var AssignmentOp$6 = $EXPECT($L46, fail, 'AssignmentOp "<<="');
|
|
1775
|
+
var AssignmentOp$7 = $EXPECT($L47, fail, 'AssignmentOp ">>>="');
|
|
1776
|
+
var AssignmentOp$8 = $EXPECT($L48, fail, 'AssignmentOp ">>="');
|
|
1777
|
+
var AssignmentOp$9 = $EXPECT($L49, fail, 'AssignmentOp "&&="');
|
|
1778
|
+
var AssignmentOp$10 = $EXPECT($L50, fail, 'AssignmentOp "&="');
|
|
1779
|
+
var AssignmentOp$11 = $EXPECT($L51, fail, 'AssignmentOp "^="');
|
|
1780
|
+
var AssignmentOp$12 = $EXPECT($L52, fail, 'AssignmentOp "||="');
|
|
1781
|
+
var AssignmentOp$13 = $EXPECT($L53, fail, 'AssignmentOp "|="');
|
|
1782
|
+
var AssignmentOp$14 = $EXPECT($L54, fail, 'AssignmentOp "??="');
|
|
1783
|
+
var AssignmentOp$15 = $EXPECT($L55, fail, 'AssignmentOp "="');
|
|
1838
1784
|
function AssignmentOp(state) {
|
|
1839
1785
|
if (state.tokenize) {
|
|
1840
1786
|
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));
|
|
@@ -1842,48 +1788,48 @@ var Civet = (() => {
|
|
|
1842
1788
|
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);
|
|
1843
1789
|
}
|
|
1844
1790
|
}
|
|
1845
|
-
var BinaryOp$0 = $EXPECT($
|
|
1846
|
-
var BinaryOp$1 = $EXPECT($
|
|
1847
|
-
var BinaryOp$2 = $EXPECT($
|
|
1848
|
-
var BinaryOp$3 = $EXPECT($
|
|
1849
|
-
var BinaryOp$4 = $EXPECT($
|
|
1850
|
-
var BinaryOp$5 = $EXPECT($
|
|
1851
|
-
var BinaryOp$6 = $EXPECT($
|
|
1852
|
-
var BinaryOp$7 = $EXPECT($
|
|
1853
|
-
var BinaryOp$8 = $EXPECT($
|
|
1854
|
-
var BinaryOp$9 = $EXPECT($
|
|
1855
|
-
var BinaryOp$10 = $EXPECT($
|
|
1856
|
-
var BinaryOp$11 = $EXPECT($
|
|
1857
|
-
var BinaryOp$12 = $EXPECT($
|
|
1858
|
-
var BinaryOp$13 = $EXPECT($
|
|
1859
|
-
var BinaryOp$14 = $TV($EXPECT($
|
|
1791
|
+
var BinaryOp$0 = $EXPECT($L56, fail, 'BinaryOp "**"');
|
|
1792
|
+
var BinaryOp$1 = $EXPECT($L9, fail, 'BinaryOp "*"');
|
|
1793
|
+
var BinaryOp$2 = $EXPECT($L57, fail, 'BinaryOp "/"');
|
|
1794
|
+
var BinaryOp$3 = $EXPECT($L58, fail, 'BinaryOp "%"');
|
|
1795
|
+
var BinaryOp$4 = $EXPECT($L59, fail, 'BinaryOp "+"');
|
|
1796
|
+
var BinaryOp$5 = $EXPECT($L60, fail, 'BinaryOp "-"');
|
|
1797
|
+
var BinaryOp$6 = $EXPECT($L61, fail, 'BinaryOp "<="');
|
|
1798
|
+
var BinaryOp$7 = $EXPECT($L62, fail, 'BinaryOp ">="');
|
|
1799
|
+
var BinaryOp$8 = $EXPECT($L63, fail, 'BinaryOp "<<"');
|
|
1800
|
+
var BinaryOp$9 = $EXPECT($L14, fail, 'BinaryOp "<"');
|
|
1801
|
+
var BinaryOp$10 = $EXPECT($L64, fail, 'BinaryOp ">>>"');
|
|
1802
|
+
var BinaryOp$11 = $EXPECT($L65, fail, 'BinaryOp ">>"');
|
|
1803
|
+
var BinaryOp$12 = $EXPECT($L66, fail, 'BinaryOp ">"');
|
|
1804
|
+
var BinaryOp$13 = $EXPECT($L67, fail, 'BinaryOp "!=="');
|
|
1805
|
+
var BinaryOp$14 = $TV($EXPECT($L68, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
|
|
1860
1806
|
if (global.coffeeCompat)
|
|
1861
1807
|
return "!==";
|
|
1862
1808
|
return $1;
|
|
1863
1809
|
});
|
|
1864
|
-
var BinaryOp$15 = $T($EXPECT($
|
|
1810
|
+
var BinaryOp$15 = $T($EXPECT($L69, fail, 'BinaryOp "is"'), function(value) {
|
|
1865
1811
|
return "===";
|
|
1866
1812
|
});
|
|
1867
|
-
var BinaryOp$16 = $EXPECT($
|
|
1868
|
-
var BinaryOp$17 = $TV($EXPECT($
|
|
1813
|
+
var BinaryOp$16 = $EXPECT($L70, fail, 'BinaryOp "==="');
|
|
1814
|
+
var BinaryOp$17 = $TV($EXPECT($L71, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
|
|
1869
1815
|
if (global.coffeeCompat)
|
|
1870
1816
|
return "===";
|
|
1871
1817
|
return $1;
|
|
1872
1818
|
});
|
|
1873
|
-
var BinaryOp$18 = $T($EXPECT($
|
|
1819
|
+
var BinaryOp$18 = $T($EXPECT($L72, fail, 'BinaryOp "and"'), function(value) {
|
|
1874
1820
|
return "&&";
|
|
1875
1821
|
});
|
|
1876
|
-
var BinaryOp$19 = $EXPECT($
|
|
1877
|
-
var BinaryOp$20 = $T($EXPECT($
|
|
1822
|
+
var BinaryOp$19 = $EXPECT($L73, fail, 'BinaryOp "&&"');
|
|
1823
|
+
var BinaryOp$20 = $T($EXPECT($L74, fail, 'BinaryOp "or"'), function(value) {
|
|
1878
1824
|
return "||";
|
|
1879
1825
|
});
|
|
1880
|
-
var BinaryOp$21 = $EXPECT($
|
|
1881
|
-
var BinaryOp$22 = $EXPECT($
|
|
1882
|
-
var BinaryOp$23 = $EXPECT($
|
|
1883
|
-
var BinaryOp$24 = $EXPECT($
|
|
1884
|
-
var BinaryOp$25 = $EXPECT($
|
|
1885
|
-
var BinaryOp$26 = $EXPECT($
|
|
1886
|
-
var BinaryOp$27 = $EXPECT($
|
|
1826
|
+
var BinaryOp$21 = $EXPECT($L75, fail, 'BinaryOp "||"');
|
|
1827
|
+
var BinaryOp$22 = $EXPECT($L76, fail, 'BinaryOp "??"');
|
|
1828
|
+
var BinaryOp$23 = $EXPECT($L77, fail, 'BinaryOp "instanceof"');
|
|
1829
|
+
var BinaryOp$24 = $EXPECT($L78, fail, 'BinaryOp "in"');
|
|
1830
|
+
var BinaryOp$25 = $EXPECT($L79, fail, 'BinaryOp "&"');
|
|
1831
|
+
var BinaryOp$26 = $EXPECT($L80, fail, 'BinaryOp "^"');
|
|
1832
|
+
var BinaryOp$27 = $EXPECT($L81, fail, 'BinaryOp "|"');
|
|
1887
1833
|
function BinaryOp(state) {
|
|
1888
1834
|
if (state.tokenize) {
|
|
1889
1835
|
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));
|
|
@@ -1891,8 +1837,8 @@ var Civet = (() => {
|
|
|
1891
1837
|
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);
|
|
1892
1838
|
}
|
|
1893
1839
|
}
|
|
1894
|
-
var UnaryOp$0 = $R$0($EXPECT($
|
|
1895
|
-
var UnaryOp$1 = $S($C($EXPECT($
|
|
1840
|
+
var UnaryOp$0 = $R$0($EXPECT($R4, fail, "UnaryOp /[!~+-]/"));
|
|
1841
|
+
var UnaryOp$1 = $S($C($EXPECT($L82, fail, 'UnaryOp "delete"'), $EXPECT($L83, fail, 'UnaryOp "void"'), $EXPECT($L84, fail, 'UnaryOp "typeof"')), $P(_));
|
|
1896
1842
|
function UnaryOp(state) {
|
|
1897
1843
|
if (state.tokenize) {
|
|
1898
1844
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -1927,7 +1873,7 @@ var Civet = (() => {
|
|
|
1927
1873
|
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);
|
|
1928
1874
|
}
|
|
1929
1875
|
}
|
|
1930
|
-
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($
|
|
1876
|
+
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L85, fail, 'EmptyStatement ";"')));
|
|
1931
1877
|
function EmptyStatement(state) {
|
|
1932
1878
|
if (state.verbose)
|
|
1933
1879
|
console.log("ENTER:", "EmptyStatement");
|
|
@@ -1937,7 +1883,7 @@ var Civet = (() => {
|
|
|
1937
1883
|
return EmptyStatement$0(state);
|
|
1938
1884
|
}
|
|
1939
1885
|
}
|
|
1940
|
-
var BlockStatement$0 = $S(__, $EXPECT($
|
|
1886
|
+
var BlockStatement$0 = $S(__, $EXPECT($L11, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BlockStatement "}"'));
|
|
1941
1887
|
function BlockStatement(state) {
|
|
1942
1888
|
if (state.verbose)
|
|
1943
1889
|
console.log("ENTER:", "BlockStatement");
|
|
@@ -1947,8 +1893,8 @@ var Civet = (() => {
|
|
|
1947
1893
|
return BlockStatement$0(state);
|
|
1948
1894
|
}
|
|
1949
1895
|
}
|
|
1950
|
-
var IfStatement$0 = $S($EXPECT($
|
|
1951
|
-
var IfStatement$1 = $TS($S($EXPECT($
|
|
1896
|
+
var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L87, fail, 'IfStatement "else"'), Block)));
|
|
1897
|
+
var IfStatement$1 = $TS($S($EXPECT($L88, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
|
|
1952
1898
|
var condition = $2;
|
|
1953
1899
|
var block = $3;
|
|
1954
1900
|
return ["if", condition.map((c) => {
|
|
@@ -1978,7 +1924,7 @@ var Civet = (() => {
|
|
|
1978
1924
|
return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
|
|
1979
1925
|
}
|
|
1980
1926
|
}
|
|
1981
|
-
var LoopStatement$0 = $TS($S($EXPECT($
|
|
1927
|
+
var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), Block), function($skip, $loc, $0, $1, $2) {
|
|
1982
1928
|
var b = $2;
|
|
1983
1929
|
return ["while(true)", b];
|
|
1984
1930
|
});
|
|
@@ -1991,7 +1937,7 @@ var Civet = (() => {
|
|
|
1991
1937
|
return LoopStatement$0(state);
|
|
1992
1938
|
}
|
|
1993
1939
|
}
|
|
1994
|
-
var DoWhileStatement$0 = $S($EXPECT($
|
|
1940
|
+
var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), Block, __, $EXPECT($L91, fail, 'DoWhileStatement "while"'), Condition);
|
|
1995
1941
|
function DoWhileStatement(state) {
|
|
1996
1942
|
if (state.verbose)
|
|
1997
1943
|
console.log("ENTER:", "DoWhileStatement");
|
|
@@ -2001,7 +1947,7 @@ var Civet = (() => {
|
|
|
2001
1947
|
return DoWhileStatement$0(state);
|
|
2002
1948
|
}
|
|
2003
1949
|
}
|
|
2004
|
-
var WhileStatement$0 = $S($EXPECT($
|
|
1950
|
+
var WhileStatement$0 = $S($EXPECT($L91, fail, 'WhileStatement "while"'), Condition, Block);
|
|
2005
1951
|
function WhileStatement(state) {
|
|
2006
1952
|
if (state.verbose)
|
|
2007
1953
|
console.log("ENTER:", "WhileStatement");
|
|
@@ -2011,7 +1957,7 @@ var Civet = (() => {
|
|
|
2011
1957
|
return WhileStatement$0(state);
|
|
2012
1958
|
}
|
|
2013
1959
|
}
|
|
2014
|
-
var ForStatement$0 = $S($EXPECT($
|
|
1960
|
+
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);
|
|
2015
1961
|
function ForStatement(state) {
|
|
2016
1962
|
if (state.verbose)
|
|
2017
1963
|
console.log("ENTER:", "ForStatement");
|
|
@@ -2021,10 +1967,10 @@ var Civet = (() => {
|
|
|
2021
1967
|
return ForStatement$0(state);
|
|
2022
1968
|
}
|
|
2023
1969
|
}
|
|
2024
|
-
var ForInOfStatement$0 = $S($EXPECT($
|
|
2025
|
-
var ForInOfStatement$1 = $S($EXPECT($
|
|
2026
|
-
var ForInOfStatement$2 = $S($EXPECT($
|
|
2027
|
-
var ForInOfStatement$3 = $S($EXPECT($
|
|
1970
|
+
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);
|
|
1971
|
+
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);
|
|
1972
|
+
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);
|
|
1973
|
+
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);
|
|
2028
1974
|
function ForInOfStatement(state) {
|
|
2029
1975
|
if (state.tokenize) {
|
|
2030
1976
|
return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
|
|
@@ -2032,7 +1978,7 @@ var Civet = (() => {
|
|
|
2032
1978
|
return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
|
|
2033
1979
|
}
|
|
2034
1980
|
}
|
|
2035
|
-
var ForDeclaration$0 = $S($C($EXPECT($
|
|
1981
|
+
var ForDeclaration$0 = $S($C($EXPECT($L96, fail, 'ForDeclaration "let"'), $EXPECT($L97, fail, 'ForDeclaration "const"')), __, ForBinding);
|
|
2036
1982
|
function ForDeclaration(state) {
|
|
2037
1983
|
if (state.verbose)
|
|
2038
1984
|
console.log("ENTER:", "ForDeclaration");
|
|
@@ -2051,7 +1997,7 @@ var Civet = (() => {
|
|
|
2051
1997
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
2052
1998
|
}
|
|
2053
1999
|
}
|
|
2054
|
-
var SwitchStatement$0 = $S($EXPECT($
|
|
2000
|
+
var SwitchStatement$0 = $S($EXPECT($L98, fail, 'SwitchStatement "switch"'), Condition, CaseBlock);
|
|
2055
2001
|
function SwitchStatement(state) {
|
|
2056
2002
|
if (state.verbose)
|
|
2057
2003
|
console.log("ENTER:", "SwitchStatement");
|
|
@@ -2061,7 +2007,7 @@ var Civet = (() => {
|
|
|
2061
2007
|
return SwitchStatement$0(state);
|
|
2062
2008
|
}
|
|
2063
2009
|
}
|
|
2064
|
-
var CaseBlock$0 = $S(__, $EXPECT($
|
|
2010
|
+
var CaseBlock$0 = $S(__, $EXPECT($L11, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L16, fail, 'CaseBlock "}"'));
|
|
2065
2011
|
var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
|
|
2066
2012
|
function CaseBlock(state) {
|
|
2067
2013
|
if (state.tokenize) {
|
|
@@ -2095,9 +2041,9 @@ var Civet = (() => {
|
|
|
2095
2041
|
return NestedCaseClause$0(state);
|
|
2096
2042
|
}
|
|
2097
2043
|
}
|
|
2098
|
-
var CaseClause$0 = $S($EXPECT($
|
|
2044
|
+
var CaseClause$0 = $S($EXPECT($L99, fail, 'CaseClause "case"'), $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
|
|
2099
2045
|
var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
|
|
2100
|
-
var CaseClause$2 = $S($EXPECT($
|
|
2046
|
+
var CaseClause$2 = $S($EXPECT($L100, fail, 'CaseClause "default"'), ImpliedColon, NestedBlockExpressions);
|
|
2101
2047
|
function CaseClause(state) {
|
|
2102
2048
|
if (state.tokenize) {
|
|
2103
2049
|
return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
|
|
@@ -2105,7 +2051,7 @@ var Civet = (() => {
|
|
|
2105
2051
|
return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
|
|
2106
2052
|
}
|
|
2107
2053
|
}
|
|
2108
|
-
var When$0 = $T($EXPECT($
|
|
2054
|
+
var When$0 = $T($EXPECT($L101, fail, 'When "when"'), function(value) {
|
|
2109
2055
|
return "case";
|
|
2110
2056
|
});
|
|
2111
2057
|
function When(state) {
|
|
@@ -2117,8 +2063,8 @@ var Civet = (() => {
|
|
|
2117
2063
|
return When$0(state);
|
|
2118
2064
|
}
|
|
2119
2065
|
}
|
|
2120
|
-
var ImpliedColon$0 = $S(__, $EXPECT($
|
|
2121
|
-
var ImpliedColon$1 = $T($EXPECT($
|
|
2066
|
+
var ImpliedColon$0 = $S(__, $EXPECT($L12, fail, 'ImpliedColon ":"'));
|
|
2067
|
+
var ImpliedColon$1 = $T($EXPECT($L30, fail, 'ImpliedColon ""'), function(value) {
|
|
2122
2068
|
return ":";
|
|
2123
2069
|
});
|
|
2124
2070
|
function ImpliedColon(state) {
|
|
@@ -2128,7 +2074,7 @@ var Civet = (() => {
|
|
|
2128
2074
|
return ImpliedColon$0(state) || ImpliedColon$1(state);
|
|
2129
2075
|
}
|
|
2130
2076
|
}
|
|
2131
|
-
var TryStatement$0 = $TS($S($EXPECT($
|
|
2077
|
+
var TryStatement$0 = $TS($S($EXPECT($L102, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2132
2078
|
var c = $3;
|
|
2133
2079
|
var f = $4;
|
|
2134
2080
|
if (!c && !f) {
|
|
@@ -2145,7 +2091,7 @@ var Civet = (() => {
|
|
|
2145
2091
|
return TryStatement$0(state);
|
|
2146
2092
|
}
|
|
2147
2093
|
}
|
|
2148
|
-
var Catch$0 = $S(__, $EXPECT($
|
|
2094
|
+
var Catch$0 = $S(__, $EXPECT($L103, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
|
|
2149
2095
|
function Catch(state) {
|
|
2150
2096
|
if (state.verbose)
|
|
2151
2097
|
console.log("ENTER:", "Catch");
|
|
@@ -2164,7 +2110,7 @@ var Civet = (() => {
|
|
|
2164
2110
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2165
2111
|
}
|
|
2166
2112
|
}
|
|
2167
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2113
|
+
var Finally$0 = $S(__, $EXPECT($L104, fail, 'Finally "finally"'), BracedBlock);
|
|
2168
2114
|
function Finally(state) {
|
|
2169
2115
|
if (state.verbose)
|
|
2170
2116
|
console.log("ENTER:", "Finally");
|
|
@@ -2202,12 +2148,12 @@ var Civet = (() => {
|
|
|
2202
2148
|
return ExpressionStatement$0(state);
|
|
2203
2149
|
}
|
|
2204
2150
|
}
|
|
2205
|
-
var KeywordStatement$0 = $EXPECT($
|
|
2206
|
-
var KeywordStatement$1 = $EXPECT($
|
|
2207
|
-
var KeywordStatement$2 = $EXPECT($
|
|
2208
|
-
var KeywordStatement$3 = $S($EXPECT($
|
|
2209
|
-
var KeywordStatement$4 = $EXPECT($
|
|
2210
|
-
var KeywordStatement$5 = $S($EXPECT($
|
|
2151
|
+
var KeywordStatement$0 = $EXPECT($L105, fail, 'KeywordStatement "break"');
|
|
2152
|
+
var KeywordStatement$1 = $EXPECT($L106, fail, 'KeywordStatement "continue"');
|
|
2153
|
+
var KeywordStatement$2 = $EXPECT($L107, fail, 'KeywordStatement "debugger"');
|
|
2154
|
+
var KeywordStatement$3 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), Expression);
|
|
2155
|
+
var KeywordStatement$4 = $EXPECT($L108, fail, 'KeywordStatement "return"');
|
|
2156
|
+
var KeywordStatement$5 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), Expression);
|
|
2211
2157
|
function KeywordStatement(state) {
|
|
2212
2158
|
if (state.tokenize) {
|
|
2213
2159
|
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state));
|
|
@@ -2215,11 +2161,11 @@ var Civet = (() => {
|
|
|
2215
2161
|
return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state);
|
|
2216
2162
|
}
|
|
2217
2163
|
}
|
|
2218
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2164
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L110, fail, 'ImportDeclaration "import type"'), __, ImportClause, __, FromClause), function(value) {
|
|
2219
2165
|
return { "ts": true, "children": value };
|
|
2220
2166
|
});
|
|
2221
|
-
var ImportDeclaration$1 = $S($EXPECT($
|
|
2222
|
-
var ImportDeclaration$2 = $S($EXPECT($
|
|
2167
|
+
var ImportDeclaration$1 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), __, ImportClause, __, FromClause);
|
|
2168
|
+
var ImportDeclaration$2 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), __, ModuleSpecifier);
|
|
2223
2169
|
function ImportDeclaration(state) {
|
|
2224
2170
|
if (state.tokenize) {
|
|
2225
2171
|
return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
|
|
@@ -2237,7 +2183,7 @@ var Civet = (() => {
|
|
|
2237
2183
|
return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
|
|
2238
2184
|
}
|
|
2239
2185
|
}
|
|
2240
|
-
var NameSpaceImport$0 = $S($EXPECT($
|
|
2186
|
+
var NameSpaceImport$0 = $S($EXPECT($L9, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), __, ImportedBinding);
|
|
2241
2187
|
function NameSpaceImport(state) {
|
|
2242
2188
|
if (state.verbose)
|
|
2243
2189
|
console.log("ENTER:", "NameSpaceImport");
|
|
@@ -2247,7 +2193,7 @@ var Civet = (() => {
|
|
|
2247
2193
|
return NameSpaceImport$0(state);
|
|
2248
2194
|
}
|
|
2249
2195
|
}
|
|
2250
|
-
var NamedImports$0 = $S($EXPECT($
|
|
2196
|
+
var NamedImports$0 = $S($EXPECT($L11, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L16, fail, 'NamedImports "}"'));
|
|
2251
2197
|
function NamedImports(state) {
|
|
2252
2198
|
if (state.verbose)
|
|
2253
2199
|
console.log("ENTER:", "NamedImports");
|
|
@@ -2267,7 +2213,7 @@ var Civet = (() => {
|
|
|
2267
2213
|
return FromClause$0(state);
|
|
2268
2214
|
}
|
|
2269
2215
|
}
|
|
2270
|
-
var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($
|
|
2216
|
+
var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), __, ImportedBinding, ObjectPropertyDelimiter);
|
|
2271
2217
|
var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
|
|
2272
2218
|
function ImportSpecifier(state) {
|
|
2273
2219
|
if (state.tokenize) {
|
|
@@ -2305,7 +2251,7 @@ var Civet = (() => {
|
|
|
2305
2251
|
return ImportedBinding$0(state);
|
|
2306
2252
|
}
|
|
2307
2253
|
}
|
|
2308
|
-
var ExportDeclaration$0 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $EXPECT($
|
|
2254
|
+
var ExportDeclaration$0 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $EXPECT($L100, fail, 'ExportDeclaration "default"'), __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2309
2255
|
var ExportDeclaration$1 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, ExportFromClause, __, FromClause);
|
|
2310
2256
|
var ExportDeclaration$2 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $C(NamedExports, VariableStatement, Declaration));
|
|
2311
2257
|
function ExportDeclaration(state) {
|
|
@@ -2315,7 +2261,7 @@ var Civet = (() => {
|
|
|
2315
2261
|
return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
|
|
2316
2262
|
}
|
|
2317
2263
|
}
|
|
2318
|
-
var ExportFromClause$0 = $S($EXPECT($
|
|
2264
|
+
var ExportFromClause$0 = $S($EXPECT($L9, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), __, ModuleExportName)));
|
|
2319
2265
|
var ExportFromClause$1 = NamedExports;
|
|
2320
2266
|
function ExportFromClause(state) {
|
|
2321
2267
|
if (state.tokenize) {
|
|
@@ -2324,7 +2270,7 @@ var Civet = (() => {
|
|
|
2324
2270
|
return ExportFromClause$0(state) || ExportFromClause$1(state);
|
|
2325
2271
|
}
|
|
2326
2272
|
}
|
|
2327
|
-
var NamedExports$0 = $S($EXPECT($
|
|
2273
|
+
var NamedExports$0 = $S($EXPECT($L11, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L16, fail, 'NamedExports "}"'));
|
|
2328
2274
|
function NamedExports(state) {
|
|
2329
2275
|
if (state.verbose)
|
|
2330
2276
|
console.log("ENTER:", "NamedExports");
|
|
@@ -2334,7 +2280,7 @@ var Civet = (() => {
|
|
|
2334
2280
|
return NamedExports$0(state);
|
|
2335
2281
|
}
|
|
2336
2282
|
}
|
|
2337
|
-
var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, $EXPECT($
|
|
2283
|
+
var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, $EXPECT($L4, fail, 'ExportSpecifier "as"'), __, ModuleExportName)), ObjectPropertyDelimiter);
|
|
2338
2284
|
function ExportSpecifier(state) {
|
|
2339
2285
|
if (state.verbose)
|
|
2340
2286
|
console.log("ENTER:", "ExportSpecifier");
|
|
@@ -2355,18 +2301,17 @@ var Civet = (() => {
|
|
|
2355
2301
|
return Declaration$0(state) || Declaration$1(state) || Declaration$2(state) || Declaration$3(state);
|
|
2356
2302
|
}
|
|
2357
2303
|
}
|
|
2358
|
-
var HoistableDeclaration$0 =
|
|
2359
|
-
var HoistableDeclaration$1 = AsyncFunctionDeclaration;
|
|
2360
|
-
var HoistableDeclaration$2 = GeneratorDeclaration;
|
|
2361
|
-
var HoistableDeclaration$3 = FunctionDeclaration;
|
|
2304
|
+
var HoistableDeclaration$0 = FunctionDeclaration;
|
|
2362
2305
|
function HoistableDeclaration(state) {
|
|
2306
|
+
if (state.verbose)
|
|
2307
|
+
console.log("ENTER:", "HoistableDeclaration");
|
|
2363
2308
|
if (state.tokenize) {
|
|
2364
|
-
return $TOKEN("HoistableDeclaration", state, HoistableDeclaration$0(state)
|
|
2309
|
+
return $TOKEN("HoistableDeclaration", state, HoistableDeclaration$0(state));
|
|
2365
2310
|
} else {
|
|
2366
|
-
return HoistableDeclaration$0(state)
|
|
2311
|
+
return HoistableDeclaration$0(state);
|
|
2367
2312
|
}
|
|
2368
2313
|
}
|
|
2369
|
-
var LexicalDeclaration$0 = $S($C($EXPECT($
|
|
2314
|
+
var LexicalDeclaration$0 = $S($C($EXPECT($L96, fail, 'LexicalDeclaration "let"'), $EXPECT($L97, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
|
|
2370
2315
|
var LexicalDeclaration$1 = $T($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, $EXPECT($L113, fail, 'LexicalDeclaration ":="'), AssignmentExpression), function(value) {
|
|
2371
2316
|
var bind = value[0];
|
|
2372
2317
|
var suffix = value[1];
|
|
@@ -2390,7 +2335,7 @@ var Civet = (() => {
|
|
|
2390
2335
|
return LexicalBinding$0(state) || LexicalBinding$1(state);
|
|
2391
2336
|
}
|
|
2392
2337
|
}
|
|
2393
|
-
var Initializer$0 = $S(__, $EXPECT($
|
|
2338
|
+
var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
|
|
2394
2339
|
function Initializer(state) {
|
|
2395
2340
|
if (state.verbose)
|
|
2396
2341
|
console.log("ENTER:", "Initializer");
|
|
@@ -2400,7 +2345,7 @@ var Civet = (() => {
|
|
|
2400
2345
|
return Initializer$0(state);
|
|
2401
2346
|
}
|
|
2402
2347
|
}
|
|
2403
|
-
var VariableStatement$0 = $S($EXPECT($
|
|
2348
|
+
var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
|
|
2404
2349
|
function VariableStatement(state) {
|
|
2405
2350
|
if (state.verbose)
|
|
2406
2351
|
console.log("ENTER:", "VariableStatement");
|
|
@@ -2441,7 +2386,7 @@ var Civet = (() => {
|
|
|
2441
2386
|
return NumericLiteral$0(state) || NumericLiteral$1(state) || NumericLiteral$2(state) || NumericLiteral$3(state) || NumericLiteral$4(state);
|
|
2442
2387
|
}
|
|
2443
2388
|
}
|
|
2444
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
2389
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
2445
2390
|
function DecimalBigIntegerLiteral(state) {
|
|
2446
2391
|
if (state.verbose)
|
|
2447
2392
|
console.log("ENTER:", "DecimalBigIntegerLiteral");
|
|
@@ -2451,7 +2396,7 @@ var Civet = (() => {
|
|
|
2451
2396
|
return DecimalBigIntegerLiteral$0(state);
|
|
2452
2397
|
}
|
|
2453
2398
|
}
|
|
2454
|
-
var DecimalLiteral$0 = $R$0($EXPECT($
|
|
2399
|
+
var DecimalLiteral$0 = $R$0($EXPECT($R6, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
|
|
2455
2400
|
function DecimalLiteral(state) {
|
|
2456
2401
|
if (state.verbose)
|
|
2457
2402
|
console.log("ENTER:", "DecimalLiteral");
|
|
@@ -2461,7 +2406,7 @@ var Civet = (() => {
|
|
|
2461
2406
|
return DecimalLiteral$0(state);
|
|
2462
2407
|
}
|
|
2463
2408
|
}
|
|
2464
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
2409
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
|
|
2465
2410
|
function BinaryIntegerLiteral(state) {
|
|
2466
2411
|
if (state.verbose)
|
|
2467
2412
|
console.log("ENTER:", "BinaryIntegerLiteral");
|
|
@@ -2471,7 +2416,7 @@ var Civet = (() => {
|
|
|
2471
2416
|
return BinaryIntegerLiteral$0(state);
|
|
2472
2417
|
}
|
|
2473
2418
|
}
|
|
2474
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
2419
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R8, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*/"));
|
|
2475
2420
|
function OctalIntegerLiteral(state) {
|
|
2476
2421
|
if (state.verbose)
|
|
2477
2422
|
console.log("ENTER:", "OctalIntegerLiteral");
|
|
@@ -2481,7 +2426,7 @@ var Civet = (() => {
|
|
|
2481
2426
|
return OctalIntegerLiteral$0(state);
|
|
2482
2427
|
}
|
|
2483
2428
|
}
|
|
2484
|
-
var HexLiteral$0 = $R$0($EXPECT($
|
|
2429
|
+
var HexLiteral$0 = $R$0($EXPECT($R9, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*/"));
|
|
2485
2430
|
function HexLiteral(state) {
|
|
2486
2431
|
if (state.verbose)
|
|
2487
2432
|
console.log("ENTER:", "HexLiteral");
|
|
@@ -2503,7 +2448,7 @@ var Civet = (() => {
|
|
|
2503
2448
|
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
|
|
2504
2449
|
}
|
|
2505
2450
|
}
|
|
2506
|
-
var DoubleStringCharacter$0 = $R$0($EXPECT($
|
|
2451
|
+
var DoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'DoubleStringCharacter /[^"\\\\]+/'));
|
|
2507
2452
|
var DoubleStringCharacter$1 = EscapeSequence;
|
|
2508
2453
|
function DoubleStringCharacter(state) {
|
|
2509
2454
|
if (state.tokenize) {
|
|
@@ -2512,7 +2457,7 @@ var Civet = (() => {
|
|
|
2512
2457
|
return DoubleStringCharacter$0(state) || DoubleStringCharacter$1(state);
|
|
2513
2458
|
}
|
|
2514
2459
|
}
|
|
2515
|
-
var SingleStringCharacter$0 = $R$0($EXPECT($
|
|
2460
|
+
var SingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "SingleStringCharacter /[^'\\\\]+/"));
|
|
2516
2461
|
var SingleStringCharacter$1 = EscapeSequence;
|
|
2517
2462
|
function SingleStringCharacter(state) {
|
|
2518
2463
|
if (state.tokenize) {
|
|
@@ -2521,7 +2466,7 @@ var Civet = (() => {
|
|
|
2521
2466
|
return SingleStringCharacter$0(state) || SingleStringCharacter$1(state);
|
|
2522
2467
|
}
|
|
2523
2468
|
}
|
|
2524
|
-
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($
|
|
2469
|
+
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R12, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
|
|
2525
2470
|
function TripleDoubleStringCharacter(state) {
|
|
2526
2471
|
if (state.verbose)
|
|
2527
2472
|
console.log("ENTER:", "TripleDoubleStringCharacter");
|
|
@@ -2531,7 +2476,7 @@ var Civet = (() => {
|
|
|
2531
2476
|
return TripleDoubleStringCharacter$0(state);
|
|
2532
2477
|
}
|
|
2533
2478
|
}
|
|
2534
|
-
var EscapeSequence$0 = $TEXT($S($EXPECT($L117, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($
|
|
2479
|
+
var EscapeSequence$0 = $TEXT($S($EXPECT($L117, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R13, fail, "EscapeSequence /./")));
|
|
2535
2480
|
function EscapeSequence(state) {
|
|
2536
2481
|
if (state.verbose)
|
|
2537
2482
|
console.log("ENTER:", "EscapeSequence");
|
|
@@ -2541,7 +2486,7 @@ var Civet = (() => {
|
|
|
2541
2486
|
return EscapeSequence$0(state);
|
|
2542
2487
|
}
|
|
2543
2488
|
}
|
|
2544
|
-
var RegularExpressionLiteral$0 = $S($EXPECT($
|
|
2489
|
+
var RegularExpressionLiteral$0 = $S($EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
|
|
2545
2490
|
function RegularExpressionLiteral(state) {
|
|
2546
2491
|
if (state.verbose)
|
|
2547
2492
|
console.log("ENTER:", "RegularExpressionLiteral");
|
|
@@ -2551,7 +2496,7 @@ var Civet = (() => {
|
|
|
2551
2496
|
return RegularExpressionLiteral$0(state);
|
|
2552
2497
|
}
|
|
2553
2498
|
}
|
|
2554
|
-
var RegularExpressionBody$0 = $S($R$0($EXPECT($
|
|
2499
|
+
var RegularExpressionBody$0 = $S($R$0($EXPECT($R14, fail, "RegularExpressionBody /[^*\\/\\r\\n]/")), $Q(RegExpCharacter));
|
|
2555
2500
|
function RegularExpressionBody(state) {
|
|
2556
2501
|
if (state.verbose)
|
|
2557
2502
|
console.log("ENTER:", "RegularExpressionBody");
|
|
@@ -2561,7 +2506,7 @@ var Civet = (() => {
|
|
|
2561
2506
|
return RegularExpressionBody$0(state);
|
|
2562
2507
|
}
|
|
2563
2508
|
}
|
|
2564
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
2509
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R15, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
|
|
2565
2510
|
var RegExpCharacter$1 = EscapeSequence;
|
|
2566
2511
|
function RegExpCharacter(state) {
|
|
2567
2512
|
if (state.tokenize) {
|
|
@@ -2570,7 +2515,7 @@ var Civet = (() => {
|
|
|
2570
2515
|
return RegExpCharacter$0(state) || RegExpCharacter$1(state);
|
|
2571
2516
|
}
|
|
2572
2517
|
}
|
|
2573
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
2518
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R16, fail, "RegularExpressionFlags /(:?\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
2574
2519
|
function RegularExpressionFlags(state) {
|
|
2575
2520
|
if (state.verbose)
|
|
2576
2521
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -2590,7 +2535,7 @@ var Civet = (() => {
|
|
|
2590
2535
|
return TemplateLiteral$0(state);
|
|
2591
2536
|
}
|
|
2592
2537
|
}
|
|
2593
|
-
var TemplateSubstitution$0 = $S($EXPECT($L119, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($
|
|
2538
|
+
var TemplateSubstitution$0 = $S($EXPECT($L119, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
|
|
2594
2539
|
function TemplateSubstitution(state) {
|
|
2595
2540
|
if (state.verbose)
|
|
2596
2541
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -2600,7 +2545,7 @@ var Civet = (() => {
|
|
|
2600
2545
|
return TemplateSubstitution$0(state);
|
|
2601
2546
|
}
|
|
2602
2547
|
}
|
|
2603
|
-
var TemplateCharacters$0 = $R$0($EXPECT($
|
|
2548
|
+
var TemplateCharacters$0 = $R$0($EXPECT($R17, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
|
|
2604
2549
|
function TemplateCharacters(state) {
|
|
2605
2550
|
if (state.verbose)
|
|
2606
2551
|
console.log("ENTER:", "TemplateCharacters");
|
|
@@ -2610,7 +2555,7 @@ var Civet = (() => {
|
|
|
2610
2555
|
return TemplateCharacters$0(state);
|
|
2611
2556
|
}
|
|
2612
2557
|
}
|
|
2613
|
-
var ReservedWord$0 = $R$0($EXPECT($
|
|
2558
|
+
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})/"));
|
|
2614
2559
|
function ReservedWord(state) {
|
|
2615
2560
|
if (state.verbose)
|
|
2616
2561
|
console.log("ENTER:", "ReservedWord");
|
|
@@ -2629,7 +2574,7 @@ var Civet = (() => {
|
|
|
2629
2574
|
return Comment$0(state) || Comment$1(state);
|
|
2630
2575
|
}
|
|
2631
2576
|
}
|
|
2632
|
-
var SingleLineComment$0 = $R$0($EXPECT($
|
|
2577
|
+
var SingleLineComment$0 = $R$0($EXPECT($R19, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"));
|
|
2633
2578
|
var SingleLineComment$1 = CoffeeSingleLineComment;
|
|
2634
2579
|
function SingleLineComment(state) {
|
|
2635
2580
|
if (state.tokenize) {
|
|
@@ -2647,7 +2592,7 @@ var Civet = (() => {
|
|
|
2647
2592
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
2648
2593
|
}
|
|
2649
2594
|
}
|
|
2650
|
-
var JSMultiLineComment$0 = $S($EXPECT($L120, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'JSMultiLineComment "*/"')), $EXPECT($
|
|
2595
|
+
var JSMultiLineComment$0 = $S($EXPECT($L120, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'JSMultiLineComment "*/"')), $EXPECT($R13, fail, "JSMultiLineComment /./")))), $EXPECT($L121, fail, 'JSMultiLineComment "*/"'));
|
|
2651
2596
|
function JSMultiLineComment(state) {
|
|
2652
2597
|
if (state.verbose)
|
|
2653
2598
|
console.log("ENTER:", "JSMultiLineComment");
|
|
@@ -2657,7 +2602,7 @@ var Civet = (() => {
|
|
|
2657
2602
|
return JSMultiLineComment$0(state);
|
|
2658
2603
|
}
|
|
2659
2604
|
}
|
|
2660
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
2605
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R20, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
2661
2606
|
if (!global.coffeeCompat)
|
|
2662
2607
|
return $skip;
|
|
2663
2608
|
return ["//", $1];
|
|
@@ -2671,7 +2616,7 @@ var Civet = (() => {
|
|
|
2671
2616
|
return CoffeeSingleLineComment$0(state);
|
|
2672
2617
|
}
|
|
2673
2618
|
}
|
|
2674
|
-
var CoffeeMultiLineComment$0 = $T($S($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($
|
|
2619
|
+
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) {
|
|
2675
2620
|
return ["/*", value[1], "*/"];
|
|
2676
2621
|
});
|
|
2677
2622
|
function CoffeeMultiLineComment(state) {
|
|
@@ -2683,7 +2628,7 @@ var Civet = (() => {
|
|
|
2683
2628
|
return CoffeeMultiLineComment$0(state);
|
|
2684
2629
|
}
|
|
2685
2630
|
}
|
|
2686
|
-
var InlineComment$0 = $S($EXPECT($L120, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'InlineComment "*/"')), $EXPECT($
|
|
2631
|
+
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 "*/"'));
|
|
2687
2632
|
function InlineComment(state) {
|
|
2688
2633
|
if (state.verbose)
|
|
2689
2634
|
console.log("ENTER:", "InlineComment");
|
|
@@ -2703,7 +2648,7 @@ var Civet = (() => {
|
|
|
2703
2648
|
return RestOfLine$0(state);
|
|
2704
2649
|
}
|
|
2705
2650
|
}
|
|
2706
|
-
var TrailingComment$0 = $R$0($EXPECT($
|
|
2651
|
+
var TrailingComment$0 = $R$0($EXPECT($R22, fail, "TrailingComment /[\\t ]+/"));
|
|
2707
2652
|
var TrailingComment$1 = InlineComment;
|
|
2708
2653
|
var TrailingComment$2 = SingleLineComment;
|
|
2709
2654
|
function TrailingComment(state) {
|
|
@@ -2713,7 +2658,7 @@ var Civet = (() => {
|
|
|
2713
2658
|
return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
|
|
2714
2659
|
}
|
|
2715
2660
|
}
|
|
2716
|
-
var _$0 = $P($C($R$0($EXPECT($
|
|
2661
|
+
var _$0 = $P($C($R$0($EXPECT($R22, fail, "_ /[\\t ]+/")), Comment));
|
|
2717
2662
|
function _(state) {
|
|
2718
2663
|
if (state.verbose)
|
|
2719
2664
|
console.log("ENTER:", "_");
|
|
@@ -2723,7 +2668,7 @@ var Civet = (() => {
|
|
|
2723
2668
|
return _$0(state);
|
|
2724
2669
|
}
|
|
2725
2670
|
}
|
|
2726
|
-
var __$0 = $Q($C($R$0($EXPECT($
|
|
2671
|
+
var __$0 = $Q($C($R$0($EXPECT($R23, fail, "__ /[\\s]+/")), Comment));
|
|
2727
2672
|
function __(state) {
|
|
2728
2673
|
if (state.verbose)
|
|
2729
2674
|
console.log("ENTER:", "__");
|
|
@@ -2733,7 +2678,7 @@ var Civet = (() => {
|
|
|
2733
2678
|
return __$0(state);
|
|
2734
2679
|
}
|
|
2735
2680
|
}
|
|
2736
|
-
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($
|
|
2681
|
+
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L85, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
|
|
2737
2682
|
var StatementDelimiter$1 = $T($Y(EOS), function(value) {
|
|
2738
2683
|
return [";", value];
|
|
2739
2684
|
});
|
|
@@ -2747,7 +2692,6 @@ var Civet = (() => {
|
|
|
2747
2692
|
var JSXElement$0 = JSXSelfClosingElement;
|
|
2748
2693
|
var JSXElement$1 = $TS($S(JSXOpeningElement, $Q(JSXChildren), __, JSXClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2749
2694
|
if ($1[1] !== $4[2]) {
|
|
2750
|
-
console.log($1, $4, $loc);
|
|
2751
2695
|
throw new Error(`mismatched closing tags at ${JSON.stringify($loc)}`);
|
|
2752
2696
|
}
|
|
2753
2697
|
return $0;
|
|
@@ -2759,7 +2703,7 @@ var Civet = (() => {
|
|
|
2759
2703
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
2760
2704
|
}
|
|
2761
2705
|
}
|
|
2762
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($
|
|
2706
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L123, fail, 'JSXSelfClosingElement "/>"'));
|
|
2763
2707
|
function JSXSelfClosingElement(state) {
|
|
2764
2708
|
if (state.verbose)
|
|
2765
2709
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -2769,7 +2713,7 @@ var Civet = (() => {
|
|
|
2769
2713
|
return JSXSelfClosingElement$0(state);
|
|
2770
2714
|
}
|
|
2771
2715
|
}
|
|
2772
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
2716
|
+
var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L66, fail, 'JSXOpeningElement ">"'));
|
|
2773
2717
|
function JSXOpeningElement(state) {
|
|
2774
2718
|
if (state.verbose)
|
|
2775
2719
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -2779,7 +2723,7 @@ var Civet = (() => {
|
|
|
2779
2723
|
return JSXOpeningElement$0(state);
|
|
2780
2724
|
}
|
|
2781
2725
|
}
|
|
2782
|
-
var JSXClosingElement$0 = $S($EXPECT($L124, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($
|
|
2726
|
+
var JSXClosingElement$0 = $S($EXPECT($L124, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
|
|
2783
2727
|
function JSXClosingElement(state) {
|
|
2784
2728
|
if (state.verbose)
|
|
2785
2729
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -2799,7 +2743,7 @@ var Civet = (() => {
|
|
|
2799
2743
|
return JSXFragment$0(state);
|
|
2800
2744
|
}
|
|
2801
2745
|
}
|
|
2802
|
-
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($
|
|
2746
|
+
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L26, fail, 'JSXElementName "."'), JSXIdentifierName))));
|
|
2803
2747
|
function JSXElementName(state) {
|
|
2804
2748
|
if (state.verbose)
|
|
2805
2749
|
console.log("ENTER:", "JSXElementName");
|
|
@@ -2809,7 +2753,7 @@ var Civet = (() => {
|
|
|
2809
2753
|
return JSXElementName$0(state);
|
|
2810
2754
|
}
|
|
2811
2755
|
}
|
|
2812
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
2756
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R24, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
2813
2757
|
function JSXIdentifierName(state) {
|
|
2814
2758
|
if (state.verbose)
|
|
2815
2759
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -2829,7 +2773,7 @@ var Civet = (() => {
|
|
|
2829
2773
|
return JSXAttributes$0(state);
|
|
2830
2774
|
}
|
|
2831
2775
|
}
|
|
2832
|
-
var JSXAttribute$0 = $S($EXPECT($
|
|
2776
|
+
var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($L31, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttribute "}"'));
|
|
2833
2777
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
2834
2778
|
function JSXAttribute(state) {
|
|
2835
2779
|
if (state.tokenize) {
|
|
@@ -2838,7 +2782,7 @@ var Civet = (() => {
|
|
|
2838
2782
|
return JSXAttribute$0(state) || JSXAttribute$1(state);
|
|
2839
2783
|
}
|
|
2840
2784
|
}
|
|
2841
|
-
var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($
|
|
2785
|
+
var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L12, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
|
|
2842
2786
|
function JSXAttributeName(state) {
|
|
2843
2787
|
if (state.verbose)
|
|
2844
2788
|
console.log("ENTER:", "JSXAttributeName");
|
|
@@ -2848,7 +2792,7 @@ var Civet = (() => {
|
|
|
2848
2792
|
return JSXAttributeName$0(state);
|
|
2849
2793
|
}
|
|
2850
2794
|
}
|
|
2851
|
-
var JSXAttributeInitializer$0 = $S(__, $EXPECT($
|
|
2795
|
+
var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
|
|
2852
2796
|
function JSXAttributeInitializer(state) {
|
|
2853
2797
|
if (state.verbose)
|
|
2854
2798
|
console.log("ENTER:", "JSXAttributeInitializer");
|
|
@@ -2858,9 +2802,9 @@ var Civet = (() => {
|
|
|
2858
2802
|
return JSXAttributeInitializer$0(state);
|
|
2859
2803
|
}
|
|
2860
2804
|
}
|
|
2861
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
2862
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
2863
|
-
var JSXAttributeValue$2 = $S($EXPECT($
|
|
2805
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R25, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
2806
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R26, fail, "JSXAttributeValue /'[^']*'/"));
|
|
2807
|
+
var JSXAttributeValue$2 = $S($EXPECT($L11, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttributeValue "}"'));
|
|
2864
2808
|
var JSXAttributeValue$3 = JSXElement;
|
|
2865
2809
|
var JSXAttributeValue$4 = JSXFragment;
|
|
2866
2810
|
function JSXAttributeValue(state) {
|
|
@@ -2883,7 +2827,7 @@ var Civet = (() => {
|
|
|
2883
2827
|
var JSXChild$0 = JSXText;
|
|
2884
2828
|
var JSXChild$1 = JSXElement;
|
|
2885
2829
|
var JSXChild$2 = JSXFragment;
|
|
2886
|
-
var JSXChild$3 = $S($EXPECT($
|
|
2830
|
+
var JSXChild$3 = $S($EXPECT($L11, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L16, fail, 'JSXChild "}"'));
|
|
2887
2831
|
function JSXChild(state) {
|
|
2888
2832
|
if (state.tokenize) {
|
|
2889
2833
|
return $TOKEN("JSXChild", state, JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state));
|
|
@@ -2891,7 +2835,7 @@ var Civet = (() => {
|
|
|
2891
2835
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
2892
2836
|
}
|
|
2893
2837
|
}
|
|
2894
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
2838
|
+
var JSXText$0 = $R$0($EXPECT($R27, fail, "JSXText /[^{}<>]+/"));
|
|
2895
2839
|
function JSXText(state) {
|
|
2896
2840
|
if (state.verbose)
|
|
2897
2841
|
console.log("ENTER:", "JSXText");
|
|
@@ -2901,7 +2845,7 @@ var Civet = (() => {
|
|
|
2901
2845
|
return JSXText$0(state);
|
|
2902
2846
|
}
|
|
2903
2847
|
}
|
|
2904
|
-
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($
|
|
2848
|
+
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L31, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
|
|
2905
2849
|
function JSXChildExpression(state) {
|
|
2906
2850
|
if (state.verbose)
|
|
2907
2851
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -2911,10 +2855,10 @@ var Civet = (() => {
|
|
|
2911
2855
|
return JSXChildExpression$0(state);
|
|
2912
2856
|
}
|
|
2913
2857
|
}
|
|
2914
|
-
var TypeDeclaration$0 = $T($S($EXPECT($
|
|
2858
|
+
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) {
|
|
2915
2859
|
return { "ts": true, "children": value };
|
|
2916
2860
|
});
|
|
2917
|
-
var TypeDeclaration$1 = $T($S($EXPECT($
|
|
2861
|
+
var TypeDeclaration$1 = $T($S($EXPECT($R29, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
|
|
2918
2862
|
return { "ts": true, "children": value };
|
|
2919
2863
|
});
|
|
2920
2864
|
function TypeDeclaration(state) {
|
|
@@ -2924,13 +2868,14 @@ var Civet = (() => {
|
|
|
2924
2868
|
return TypeDeclaration$0(state) || TypeDeclaration$1(state);
|
|
2925
2869
|
}
|
|
2926
2870
|
}
|
|
2927
|
-
var InterfaceBlock$0 = $S(__, $EXPECT($
|
|
2928
|
-
var InterfaceBlock$1 = $S(
|
|
2871
|
+
var InterfaceBlock$0 = $S(__, $EXPECT($L11, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L16, fail, 'InterfaceBlock "}"'));
|
|
2872
|
+
var InterfaceBlock$1 = $S(__, $EXPECT($L11, fail, 'InterfaceBlock "{"'), $Q($S(__, InterfaceProperty)), __, $EXPECT($L16, fail, 'InterfaceBlock "}"'));
|
|
2873
|
+
var InterfaceBlock$2 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
2929
2874
|
function InterfaceBlock(state) {
|
|
2930
2875
|
if (state.tokenize) {
|
|
2931
|
-
return $TOKEN("InterfaceBlock", state, InterfaceBlock$0(state) || InterfaceBlock$1(state));
|
|
2876
|
+
return $TOKEN("InterfaceBlock", state, InterfaceBlock$0(state) || InterfaceBlock$1(state) || InterfaceBlock$2(state));
|
|
2932
2877
|
} else {
|
|
2933
|
-
return InterfaceBlock$0(state) || InterfaceBlock$1(state);
|
|
2878
|
+
return InterfaceBlock$0(state) || InterfaceBlock$1(state) || InterfaceBlock$2(state);
|
|
2934
2879
|
}
|
|
2935
2880
|
}
|
|
2936
2881
|
var NestedInterfaceProperties$0 = $TS($S(PushIndent, $Q(NestedInterfaceProperty), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
@@ -2948,7 +2893,7 @@ var Civet = (() => {
|
|
|
2948
2893
|
return NestedInterfaceProperties$0(state);
|
|
2949
2894
|
}
|
|
2950
2895
|
}
|
|
2951
|
-
var NestedInterfaceProperty$0 = $S(Nested,
|
|
2896
|
+
var NestedInterfaceProperty$0 = $S(Nested, InterfaceProperty);
|
|
2952
2897
|
function NestedInterfaceProperty(state) {
|
|
2953
2898
|
if (state.verbose)
|
|
2954
2899
|
console.log("ENTER:", "NestedInterfaceProperty");
|
|
@@ -2958,7 +2903,51 @@ var Civet = (() => {
|
|
|
2958
2903
|
return NestedInterfaceProperty$0(state);
|
|
2959
2904
|
}
|
|
2960
2905
|
}
|
|
2961
|
-
var
|
|
2906
|
+
var InterfaceProperty$0 = $S($C(TypeIndexSignature, PropertyName), TypeSuffix, InterfacePropertyDelimiter);
|
|
2907
|
+
function InterfaceProperty(state) {
|
|
2908
|
+
if (state.verbose)
|
|
2909
|
+
console.log("ENTER:", "InterfaceProperty");
|
|
2910
|
+
if (state.tokenize) {
|
|
2911
|
+
return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state));
|
|
2912
|
+
} else {
|
|
2913
|
+
return InterfaceProperty$0(state);
|
|
2914
|
+
}
|
|
2915
|
+
}
|
|
2916
|
+
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L85, fail, 'InterfacePropertyDelimiter ";"'));
|
|
2917
|
+
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
|
|
2918
|
+
var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
|
|
2919
|
+
return ";";
|
|
2920
|
+
});
|
|
2921
|
+
var InterfacePropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
2922
|
+
return ";";
|
|
2923
|
+
});
|
|
2924
|
+
function InterfacePropertyDelimiter(state) {
|
|
2925
|
+
if (state.tokenize) {
|
|
2926
|
+
return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state));
|
|
2927
|
+
} else {
|
|
2928
|
+
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
|
|
2929
|
+
}
|
|
2930
|
+
}
|
|
2931
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L127, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L24, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L25, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
|
|
2932
|
+
function TypeIndexSignature(state) {
|
|
2933
|
+
if (state.verbose)
|
|
2934
|
+
console.log("ENTER:", "TypeIndexSignature");
|
|
2935
|
+
if (state.tokenize) {
|
|
2936
|
+
return $TOKEN("TypeIndexSignature", state, TypeIndexSignature$0(state));
|
|
2937
|
+
} else {
|
|
2938
|
+
return TypeIndexSignature$0(state);
|
|
2939
|
+
}
|
|
2940
|
+
}
|
|
2941
|
+
var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
|
|
2942
|
+
var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L78, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
|
|
2943
|
+
function TypeIndex(state) {
|
|
2944
|
+
if (state.tokenize) {
|
|
2945
|
+
return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
|
|
2946
|
+
} else {
|
|
2947
|
+
return TypeIndex$0(state) || TypeIndex$1(state);
|
|
2948
|
+
}
|
|
2949
|
+
}
|
|
2950
|
+
var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L12, fail, 'TypeSuffix ":"'), Type), function(value) {
|
|
2962
2951
|
return { "ts": true, "children": value };
|
|
2963
2952
|
});
|
|
2964
2953
|
function TypeSuffix(state) {
|
|
@@ -2970,6 +2959,28 @@ var Civet = (() => {
|
|
|
2970
2959
|
return TypeSuffix$0(state);
|
|
2971
2960
|
}
|
|
2972
2961
|
}
|
|
2962
|
+
var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L128, fail, 'ReturnTypeSuffix "asserts"'), $EXPECT($R0, fail, "ReturnTypeSuffix /(?!\\p{ID_Continue})/"))), TypePredicate), function(value) {
|
|
2963
|
+
return { "ts": true, "children": value };
|
|
2964
|
+
});
|
|
2965
|
+
function ReturnTypeSuffix(state) {
|
|
2966
|
+
if (state.verbose)
|
|
2967
|
+
console.log("ENTER:", "ReturnTypeSuffix");
|
|
2968
|
+
if (state.tokenize) {
|
|
2969
|
+
return $TOKEN("ReturnTypeSuffix", state, ReturnTypeSuffix$0(state));
|
|
2970
|
+
} else {
|
|
2971
|
+
return ReturnTypeSuffix$0(state);
|
|
2972
|
+
}
|
|
2973
|
+
}
|
|
2974
|
+
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), $R$0($EXPECT($R0, fail, "TypePredicate /(?!\\p{ID_Continue})/")), Type)));
|
|
2975
|
+
function TypePredicate(state) {
|
|
2976
|
+
if (state.verbose)
|
|
2977
|
+
console.log("ENTER:", "TypePredicate");
|
|
2978
|
+
if (state.tokenize) {
|
|
2979
|
+
return $TOKEN("TypePredicate", state, TypePredicate$0(state));
|
|
2980
|
+
} else {
|
|
2981
|
+
return TypePredicate$0(state);
|
|
2982
|
+
}
|
|
2983
|
+
}
|
|
2973
2984
|
var Type$0 = TypeConditional;
|
|
2974
2985
|
function Type(state) {
|
|
2975
2986
|
if (state.verbose)
|
|
@@ -2990,7 +3001,7 @@ var Civet = (() => {
|
|
|
2990
3001
|
return TypeBinary$0(state);
|
|
2991
3002
|
}
|
|
2992
3003
|
}
|
|
2993
|
-
var TypeUnary$0 = $S($Q(TypeUnaryOp), TypePrimary);
|
|
3004
|
+
var TypeUnary$0 = $S($Q($S(__, TypeUnaryOp, $R$0($EXPECT($R0, fail, "TypeUnary /(?!\\p{ID_Continue})/")))), TypePrimary, $Q(TypeUnarySuffix));
|
|
2994
3005
|
function TypeUnary(state) {
|
|
2995
3006
|
if (state.verbose)
|
|
2996
3007
|
console.log("ENTER:", "TypeUnary");
|
|
@@ -3000,19 +3011,40 @@ var Civet = (() => {
|
|
|
3000
3011
|
return TypeUnary$0(state);
|
|
3001
3012
|
}
|
|
3002
3013
|
}
|
|
3003
|
-
var
|
|
3004
|
-
|
|
3014
|
+
var TypeUnarySuffix$0 = TypeIndexedAccess;
|
|
3015
|
+
function TypeUnarySuffix(state) {
|
|
3016
|
+
if (state.verbose)
|
|
3017
|
+
console.log("ENTER:", "TypeUnarySuffix");
|
|
3018
|
+
if (state.tokenize) {
|
|
3019
|
+
return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state));
|
|
3020
|
+
} else {
|
|
3021
|
+
return TypeUnarySuffix$0(state);
|
|
3022
|
+
}
|
|
3023
|
+
}
|
|
3024
|
+
var TypeUnaryOp$0 = $EXPECT($L129, fail, 'TypeUnaryOp "keyof"');
|
|
3025
|
+
var TypeUnaryOp$1 = $EXPECT($L84, fail, 'TypeUnaryOp "typeof"');
|
|
3026
|
+
var TypeUnaryOp$2 = $EXPECT($L130, fail, 'TypeUnaryOp "infer"');
|
|
3005
3027
|
function TypeUnaryOp(state) {
|
|
3006
3028
|
if (state.tokenize) {
|
|
3007
|
-
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state));
|
|
3029
|
+
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
3030
|
+
} else {
|
|
3031
|
+
return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
|
|
3032
|
+
}
|
|
3033
|
+
}
|
|
3034
|
+
var TypeIndexedAccess$0 = $S(__, $EXPECT($L24, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L25, fail, 'TypeIndexedAccess "]"'));
|
|
3035
|
+
function TypeIndexedAccess(state) {
|
|
3036
|
+
if (state.verbose)
|
|
3037
|
+
console.log("ENTER:", "TypeIndexedAccess");
|
|
3038
|
+
if (state.tokenize) {
|
|
3039
|
+
return $TOKEN("TypeIndexedAccess", state, TypeIndexedAccess$0(state));
|
|
3008
3040
|
} else {
|
|
3009
|
-
return
|
|
3041
|
+
return TypeIndexedAccess$0(state);
|
|
3010
3042
|
}
|
|
3011
3043
|
}
|
|
3012
3044
|
var TypePrimary$0 = InterfaceBlock;
|
|
3013
3045
|
var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
|
|
3014
3046
|
var TypePrimary$2 = $S($Q(_), FunctionType);
|
|
3015
|
-
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($
|
|
3047
|
+
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L26, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
|
|
3016
3048
|
var TypePrimary$4 = $S($Q(_), TypeLiteral);
|
|
3017
3049
|
function TypePrimary(state) {
|
|
3018
3050
|
if (state.tokenize) {
|
|
@@ -3021,7 +3053,7 @@ var Civet = (() => {
|
|
|
3021
3053
|
return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
|
|
3022
3054
|
}
|
|
3023
3055
|
}
|
|
3024
|
-
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($
|
|
3056
|
+
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L15, fail, 'TypeConditional "extends"'), Type, $E($S(__, $EXPECT($L3, fail, 'TypeConditional "?"'), Type, __, $EXPECT($L12, fail, 'TypeConditional ":"'), Type)))));
|
|
3025
3057
|
function TypeConditional(state) {
|
|
3026
3058
|
if (state.verbose)
|
|
3027
3059
|
console.log("ENTER:", "TypeConditional");
|
|
@@ -3032,8 +3064,8 @@ var Civet = (() => {
|
|
|
3032
3064
|
}
|
|
3033
3065
|
}
|
|
3034
3066
|
var TypeLiteral$0 = Literal;
|
|
3035
|
-
var TypeLiteral$1 = $EXPECT($
|
|
3036
|
-
var TypeLiteral$2 = $EXPECT($
|
|
3067
|
+
var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
|
|
3068
|
+
var TypeLiteral$2 = $EXPECT($L131, fail, 'TypeLiteral "[]"');
|
|
3037
3069
|
function TypeLiteral(state) {
|
|
3038
3070
|
if (state.tokenize) {
|
|
3039
3071
|
return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
|
|
@@ -3041,8 +3073,8 @@ var Civet = (() => {
|
|
|
3041
3073
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
3042
3074
|
}
|
|
3043
3075
|
}
|
|
3044
|
-
var TypeBinaryOp$0 = $EXPECT($
|
|
3045
|
-
var TypeBinaryOp$1 = $EXPECT($
|
|
3076
|
+
var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
|
|
3077
|
+
var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
|
|
3046
3078
|
function TypeBinaryOp(state) {
|
|
3047
3079
|
if (state.tokenize) {
|
|
3048
3080
|
return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
|
|
@@ -3050,7 +3082,7 @@ var Civet = (() => {
|
|
|
3050
3082
|
return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
|
|
3051
3083
|
}
|
|
3052
3084
|
}
|
|
3053
|
-
var FunctionType$0 = $S(Parameters, __, $EXPECT($
|
|
3085
|
+
var FunctionType$0 = $S(Parameters, __, $EXPECT($L10, fail, 'FunctionType "=>"'), Type);
|
|
3054
3086
|
function FunctionType(state) {
|
|
3055
3087
|
if (state.verbose)
|
|
3056
3088
|
console.log("ENTER:", "FunctionType");
|
|
@@ -3060,7 +3092,7 @@ var Civet = (() => {
|
|
|
3060
3092
|
return FunctionType$0(state);
|
|
3061
3093
|
}
|
|
3062
3094
|
}
|
|
3063
|
-
var TypeArguments$0 = $S(__, $EXPECT($
|
|
3095
|
+
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 ">"'));
|
|
3064
3096
|
function TypeArguments(state) {
|
|
3065
3097
|
if (state.verbose)
|
|
3066
3098
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -3070,7 +3102,7 @@ var Civet = (() => {
|
|
|
3070
3102
|
return TypeArguments$0(state);
|
|
3071
3103
|
}
|
|
3072
3104
|
}
|
|
3073
|
-
var TypeParameters$0 = $S(__, $EXPECT($
|
|
3105
|
+
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 ">"'));
|
|
3074
3106
|
function TypeParameters(state) {
|
|
3075
3107
|
if (state.verbose)
|
|
3076
3108
|
console.log("ENTER:", "TypeParameters");
|
|
@@ -3090,7 +3122,7 @@ var Civet = (() => {
|
|
|
3090
3122
|
return TypeParameter$0(state);
|
|
3091
3123
|
}
|
|
3092
3124
|
}
|
|
3093
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
3125
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L15, fail, 'TypeConstraint "extends"'), Type);
|
|
3094
3126
|
function TypeConstraint(state) {
|
|
3095
3127
|
if (state.verbose)
|
|
3096
3128
|
console.log("ENTER:", "TypeConstraint");
|
|
@@ -3101,8 +3133,8 @@ var Civet = (() => {
|
|
|
3101
3133
|
}
|
|
3102
3134
|
}
|
|
3103
3135
|
var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
|
|
3104
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
3105
|
-
var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
3136
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L66, fail, 'TypeParameterDelimiter ">"')));
|
|
3137
|
+
var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L66, fail, 'TypeParameterDelimiter ">"'))), function(value) {
|
|
3106
3138
|
return ",";
|
|
3107
3139
|
});
|
|
3108
3140
|
var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -3115,7 +3147,7 @@ var Civet = (() => {
|
|
|
3115
3147
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
3116
3148
|
}
|
|
3117
3149
|
}
|
|
3118
|
-
var Shebang$0 = $R$0($EXPECT($
|
|
3150
|
+
var Shebang$0 = $R$0($EXPECT($R32, fail, "Shebang /#![^\\r\\n]*/"));
|
|
3119
3151
|
function Shebang(state) {
|
|
3120
3152
|
if (state.verbose)
|
|
3121
3153
|
console.log("ENTER:", "Shebang");
|
|
@@ -3125,7 +3157,7 @@ var Civet = (() => {
|
|
|
3125
3157
|
return Shebang$0(state);
|
|
3126
3158
|
}
|
|
3127
3159
|
}
|
|
3128
|
-
var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($
|
|
3160
|
+
var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R33, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
|
|
3129
3161
|
return $0.map((p) => p.join(""));
|
|
3130
3162
|
});
|
|
3131
3163
|
function DirectivePrologue(state) {
|
|
@@ -3147,7 +3179,7 @@ var Civet = (() => {
|
|
|
3147
3179
|
return EOS$0(state);
|
|
3148
3180
|
}
|
|
3149
3181
|
}
|
|
3150
|
-
var EOL$0 = $R$0($EXPECT($
|
|
3182
|
+
var EOL$0 = $R$0($EXPECT($R34, fail, "EOL /\\r\\n|\\n|\\r|$/"));
|
|
3151
3183
|
function EOL(state) {
|
|
3152
3184
|
if (state.verbose)
|
|
3153
3185
|
console.log("ENTER:", "EOL");
|
|
@@ -3157,7 +3189,7 @@ var Civet = (() => {
|
|
|
3157
3189
|
return EOL$0(state);
|
|
3158
3190
|
}
|
|
3159
3191
|
}
|
|
3160
|
-
var EOF$0 = $R$0($EXPECT($
|
|
3192
|
+
var EOF$0 = $R$0($EXPECT($R35, fail, "EOF /$/"));
|
|
3161
3193
|
function EOF(state) {
|
|
3162
3194
|
if (state.verbose)
|
|
3163
3195
|
console.log("ENTER:", "EOF");
|
|
@@ -3167,7 +3199,7 @@ var Civet = (() => {
|
|
|
3167
3199
|
return EOF$0(state);
|
|
3168
3200
|
}
|
|
3169
3201
|
}
|
|
3170
|
-
var InsertOpenParen$0 = $T($EXPECT($
|
|
3202
|
+
var InsertOpenParen$0 = $T($EXPECT($L30, fail, 'InsertOpenParen ""'), function(value) {
|
|
3171
3203
|
return "(";
|
|
3172
3204
|
});
|
|
3173
3205
|
function InsertOpenParen(state) {
|
|
@@ -3179,7 +3211,7 @@ var Civet = (() => {
|
|
|
3179
3211
|
return InsertOpenParen$0(state);
|
|
3180
3212
|
}
|
|
3181
3213
|
}
|
|
3182
|
-
var InsertCloseParen$0 = $T($EXPECT($
|
|
3214
|
+
var InsertCloseParen$0 = $T($EXPECT($L30, fail, 'InsertCloseParen ""'), function(value) {
|
|
3183
3215
|
return ")";
|
|
3184
3216
|
});
|
|
3185
3217
|
function InsertCloseParen(state) {
|
|
@@ -3191,7 +3223,7 @@ var Civet = (() => {
|
|
|
3191
3223
|
return InsertCloseParen$0(state);
|
|
3192
3224
|
}
|
|
3193
3225
|
}
|
|
3194
|
-
var InsertOpenBrace$0 = $T($EXPECT($
|
|
3226
|
+
var InsertOpenBrace$0 = $T($EXPECT($L30, fail, 'InsertOpenBrace ""'), function(value) {
|
|
3195
3227
|
return " {";
|
|
3196
3228
|
});
|
|
3197
3229
|
function InsertOpenBrace(state) {
|
|
@@ -3203,7 +3235,7 @@ var Civet = (() => {
|
|
|
3203
3235
|
return InsertOpenBrace$0(state);
|
|
3204
3236
|
}
|
|
3205
3237
|
}
|
|
3206
|
-
var InsertCloseBrace$0 = $T($EXPECT($
|
|
3238
|
+
var InsertCloseBrace$0 = $T($EXPECT($L30, fail, 'InsertCloseBrace ""'), function(value) {
|
|
3207
3239
|
return "}";
|
|
3208
3240
|
});
|
|
3209
3241
|
function InsertCloseBrace(state) {
|
|
@@ -3215,7 +3247,7 @@ var Civet = (() => {
|
|
|
3215
3247
|
return InsertCloseBrace$0(state);
|
|
3216
3248
|
}
|
|
3217
3249
|
}
|
|
3218
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
3250
|
+
var InsertNewline$0 = $TV($EXPECT($L30, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
3219
3251
|
return "\n";
|
|
3220
3252
|
});
|
|
3221
3253
|
function InsertNewline(state) {
|
|
@@ -3227,7 +3259,7 @@ var Civet = (() => {
|
|
|
3227
3259
|
return InsertNewline$0(state);
|
|
3228
3260
|
}
|
|
3229
3261
|
}
|
|
3230
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
3262
|
+
var InsertIndent$0 = $TV($EXPECT($L30, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
3231
3263
|
return "".padStart(global.currentIndent * 2);
|
|
3232
3264
|
});
|
|
3233
3265
|
function InsertIndent(state) {
|
|
@@ -3239,7 +3271,7 @@ var Civet = (() => {
|
|
|
3239
3271
|
return InsertIndent$0(state);
|
|
3240
3272
|
}
|
|
3241
3273
|
}
|
|
3242
|
-
var InsertSpace$0 = $T($EXPECT($
|
|
3274
|
+
var InsertSpace$0 = $T($EXPECT($L30, fail, 'InsertSpace ""'), function(value) {
|
|
3243
3275
|
return " ";
|
|
3244
3276
|
});
|
|
3245
3277
|
function InsertSpace(state) {
|
|
@@ -3251,7 +3283,7 @@ var Civet = (() => {
|
|
|
3251
3283
|
return InsertSpace$0(state);
|
|
3252
3284
|
}
|
|
3253
3285
|
}
|
|
3254
|
-
var InsertDot$0 = $T($EXPECT($
|
|
3286
|
+
var InsertDot$0 = $T($EXPECT($L30, fail, 'InsertDot ""'), function(value) {
|
|
3255
3287
|
return ".";
|
|
3256
3288
|
});
|
|
3257
3289
|
function InsertDot(state) {
|
|
@@ -3263,7 +3295,7 @@ var Civet = (() => {
|
|
|
3263
3295
|
return InsertDot$0(state);
|
|
3264
3296
|
}
|
|
3265
3297
|
}
|
|
3266
|
-
var InsertBreak$0 = $T($EXPECT($
|
|
3298
|
+
var InsertBreak$0 = $T($EXPECT($L30, fail, 'InsertBreak ""'), function(value) {
|
|
3267
3299
|
return "break;";
|
|
3268
3300
|
});
|
|
3269
3301
|
function InsertBreak(state) {
|
|
@@ -3275,7 +3307,7 @@ var Civet = (() => {
|
|
|
3275
3307
|
return InsertBreak$0(state);
|
|
3276
3308
|
}
|
|
3277
3309
|
}
|
|
3278
|
-
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($
|
|
3310
|
+
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L30, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3279
3311
|
var directives = $2;
|
|
3280
3312
|
global.currentIndent = 0;
|
|
3281
3313
|
global.indentLevels = [0];
|
|
@@ -3295,7 +3327,7 @@ var Civet = (() => {
|
|
|
3295
3327
|
return Init$0(state);
|
|
3296
3328
|
}
|
|
3297
3329
|
}
|
|
3298
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
3330
|
+
var Indent$0 = $TV($Q($C($EXPECT($L132, fail, 'Indent " "'), $EXPECT($L133, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
3299
3331
|
return $1.length;
|
|
3300
3332
|
});
|
|
3301
3333
|
function Indent(state) {
|
|
@@ -3307,7 +3339,7 @@ var Civet = (() => {
|
|
|
3307
3339
|
return Indent$0(state);
|
|
3308
3340
|
}
|
|
3309
3341
|
}
|
|
3310
|
-
var PushIndent$0 = $TV($EXPECT($
|
|
3342
|
+
var PushIndent$0 = $TV($EXPECT($L30, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
|
|
3311
3343
|
global.currentIndent++;
|
|
3312
3344
|
if (global.verbose) {
|
|
3313
3345
|
console.log("pushing indent", global.currentIndent);
|
|
@@ -3324,7 +3356,7 @@ var Civet = (() => {
|
|
|
3324
3356
|
return PushIndent$0(state);
|
|
3325
3357
|
}
|
|
3326
3358
|
}
|
|
3327
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
3359
|
+
var PopIndent$0 = $TV($EXPECT($L30, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
3328
3360
|
if (global.verbose) {
|
|
3329
3361
|
console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
|
|
3330
3362
|
}
|