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