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