@danielx/civet 0.4.4 → 0.4.5
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/README.md +4 -1
- package/dist/browser.js +502 -359
- package/dist/main.js +502 -359
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -505,7 +505,6 @@ var Civet = (() => {
|
|
|
505
505
|
PropertyName,
|
|
506
506
|
MethodDefinition,
|
|
507
507
|
MethodModifier,
|
|
508
|
-
ConstructorShorthand,
|
|
509
508
|
MethodSignature,
|
|
510
509
|
ClassElementName,
|
|
511
510
|
PrivateIdentifier,
|
|
@@ -535,6 +534,7 @@ var Civet = (() => {
|
|
|
535
534
|
NestedCaseClauses,
|
|
536
535
|
NestedCaseClause,
|
|
537
536
|
CaseClause,
|
|
537
|
+
CaseExpressionList,
|
|
538
538
|
ImpliedColon,
|
|
539
539
|
TryStatement,
|
|
540
540
|
CatchClause,
|
|
@@ -580,12 +580,12 @@ var Civet = (() => {
|
|
|
580
580
|
OctalIntegerLiteral,
|
|
581
581
|
HexLiteral,
|
|
582
582
|
StringLiteral,
|
|
583
|
-
|
|
584
|
-
|
|
583
|
+
BasicStringLiteral,
|
|
584
|
+
DoubleStringCharacters,
|
|
585
|
+
SingleStringCharacters,
|
|
585
586
|
TripleDoubleStringCharacters,
|
|
586
587
|
TripleSingleStringCharacters,
|
|
587
588
|
CoffeeStringSubstitution,
|
|
588
|
-
CoffeeSubstitutionStart,
|
|
589
589
|
RegularExpressionLiteral,
|
|
590
590
|
RegularExpressionBody,
|
|
591
591
|
RegExpCharacter,
|
|
@@ -614,13 +614,18 @@ var Civet = (() => {
|
|
|
614
614
|
As,
|
|
615
615
|
Async,
|
|
616
616
|
Await,
|
|
617
|
+
Case,
|
|
617
618
|
Catch,
|
|
618
619
|
Class,
|
|
619
620
|
CloseBrace,
|
|
620
621
|
CloseBracket,
|
|
621
622
|
CloseParen,
|
|
623
|
+
CoffeeSubstitutionStart,
|
|
622
624
|
Colon,
|
|
625
|
+
ConstructorShorthand,
|
|
626
|
+
Default,
|
|
623
627
|
Dot,
|
|
628
|
+
DoubleQuote,
|
|
624
629
|
Else,
|
|
625
630
|
Equals,
|
|
626
631
|
Export,
|
|
@@ -641,7 +646,10 @@ var Civet = (() => {
|
|
|
641
646
|
QuestionMark,
|
|
642
647
|
Return,
|
|
643
648
|
Semicolon,
|
|
649
|
+
SingleQuote,
|
|
650
|
+
Star,
|
|
644
651
|
Static,
|
|
652
|
+
SubstitutionStart,
|
|
645
653
|
Switch,
|
|
646
654
|
Target,
|
|
647
655
|
TripleDoubleQuote,
|
|
@@ -651,6 +659,7 @@ var Civet = (() => {
|
|
|
651
659
|
Unless,
|
|
652
660
|
Var,
|
|
653
661
|
When,
|
|
662
|
+
Yield,
|
|
654
663
|
JSXElement,
|
|
655
664
|
JSXSelfClosingElement,
|
|
656
665
|
JSXOpeningElement,
|
|
@@ -732,130 +741,130 @@ var Civet = (() => {
|
|
|
732
741
|
var $L1 = $L("");
|
|
733
742
|
var $L2 = $L("++");
|
|
734
743
|
var $L3 = $L("--");
|
|
735
|
-
var $L4 = $L("
|
|
736
|
-
var $L5 = $L("
|
|
737
|
-
var $L6 = $L("
|
|
738
|
-
var $L7 = $L("
|
|
739
|
-
var $L8 = $L("
|
|
740
|
-
var $L9 = $L("
|
|
741
|
-
var $L10 = $L("
|
|
742
|
-
var $L11 = $L("
|
|
743
|
-
var $L12 = $L("
|
|
744
|
-
var $L13 = $L("
|
|
745
|
-
var $L14 = $L("
|
|
746
|
-
var $L15 = $L("
|
|
747
|
-
var $L16 = $L("
|
|
748
|
-
var $L17 = $L("
|
|
749
|
-
var $L18 = $L("
|
|
750
|
-
var $L19 = $L("
|
|
751
|
-
var $L20 = $L("
|
|
752
|
-
var $L21 = $L("
|
|
753
|
-
var $L22 = $L("
|
|
754
|
-
var $L23 = $L("
|
|
755
|
-
var $L24 = $L("
|
|
756
|
-
var $L25 = $L("
|
|
757
|
-
var $L26 = $L("
|
|
758
|
-
var $L27 = $L("
|
|
759
|
-
var $L28 = $L("
|
|
760
|
-
var $L29 = $L("
|
|
761
|
-
var $L30 = $L("
|
|
762
|
-
var $L31 = $L("
|
|
763
|
-
var $L32 = $L("
|
|
764
|
-
var $L33 = $L("
|
|
765
|
-
var $L34 = $L("
|
|
766
|
-
var $L35 = $L("
|
|
767
|
-
var $L36 = $L("
|
|
768
|
-
var $L37 = $L("
|
|
769
|
-
var $L38 = $L("
|
|
770
|
-
var $L39 = $L("
|
|
771
|
-
var $L40 = $L("
|
|
772
|
-
var $L41 = $L("
|
|
773
|
-
var $L42 = $L("
|
|
774
|
-
var $L43 = $L("
|
|
775
|
-
var $L44 = $L("
|
|
776
|
-
var $L45 = $L("
|
|
777
|
-
var $L46 = $L("
|
|
778
|
-
var $L47 = $L("
|
|
779
|
-
var $L48 = $L("
|
|
780
|
-
var $L49 = $L("
|
|
781
|
-
var $L50 = $L("
|
|
782
|
-
var $L51 = $L("
|
|
783
|
-
var $L52 = $L("
|
|
784
|
-
var $L53 = $L("
|
|
785
|
-
var $L54 = $L("
|
|
786
|
-
var $L55 = $L("
|
|
787
|
-
var $L56 = $L("
|
|
788
|
-
var $L57 = $L("
|
|
789
|
-
var $L58 = $L("
|
|
790
|
-
var $L59 = $L("
|
|
791
|
-
var $L60 = $L("
|
|
792
|
-
var $L61 = $L("
|
|
793
|
-
var $L62 = $L("
|
|
794
|
-
var $L63 = $L("
|
|
795
|
-
var $L64 = $L("
|
|
796
|
-
var $L65 = $L("
|
|
797
|
-
var $L66 = $L("
|
|
798
|
-
var $L67 = $L("
|
|
799
|
-
var $L68 = $L("
|
|
800
|
-
var $L69 = $L("
|
|
801
|
-
var $L70 = $L("
|
|
802
|
-
var $L71 = $L("
|
|
803
|
-
var $L72 = $L("
|
|
804
|
-
var $L73 = $L("
|
|
805
|
-
var $L74 = $L("
|
|
806
|
-
var $L75 = $L("
|
|
807
|
-
var $L76 = $L("
|
|
808
|
-
var $L77 = $L("
|
|
809
|
-
var $L78 = $L("
|
|
810
|
-
var $L79 = $L("
|
|
811
|
-
var $L80 = $L("
|
|
812
|
-
var $L81 = $L("
|
|
813
|
-
var $L82 = $L("
|
|
814
|
-
var $L83 = $L("
|
|
815
|
-
var $L84 = $L("
|
|
816
|
-
var $L85 = $L("
|
|
817
|
-
var $L86 = $L(
|
|
818
|
-
var $L87 = $L("
|
|
819
|
-
var $L88 = $L("
|
|
820
|
-
var $L89 = $L("
|
|
821
|
-
var $L90 = $L("
|
|
822
|
-
var $L91 = $L("
|
|
823
|
-
var $L92 = $L("
|
|
824
|
-
var $L93 = $L("
|
|
825
|
-
var $L94 = $L("
|
|
826
|
-
var $L95 = $L("
|
|
827
|
-
var $L96 = $L("
|
|
828
|
-
var $L97 = $L("
|
|
829
|
-
var $L98 = $L("
|
|
830
|
-
var $L99 = $L("
|
|
831
|
-
var $L100 = $L("
|
|
832
|
-
var $L101 = $L("
|
|
833
|
-
var $L102 = $L("
|
|
834
|
-
var $L103 = $L("
|
|
835
|
-
var $L104 = $L("
|
|
836
|
-
var $L105 = $L("
|
|
837
|
-
var $L106 = $L("
|
|
838
|
-
var $L107 = $L("
|
|
839
|
-
var $L108 = $L("
|
|
840
|
-
var $L109 = $L("
|
|
841
|
-
var $L110 = $L("
|
|
842
|
-
var $L111 = $L("
|
|
843
|
-
var $L112 = $L("
|
|
844
|
-
var $L113 = $L("
|
|
845
|
-
var $L114 = $L("
|
|
846
|
-
var $L115 = $L("
|
|
847
|
-
var $L116 = $L("
|
|
848
|
-
var $L117 = $L("
|
|
849
|
-
var $L118 = $L("
|
|
850
|
-
var $L119 = $L("
|
|
851
|
-
var $L120 = $L("
|
|
852
|
-
var $L121 = $L('"
|
|
853
|
-
var $L122 = $L("
|
|
854
|
-
var $L123 = $L("
|
|
855
|
-
var $L124 = $L("
|
|
856
|
-
var $L125 = $L("
|
|
857
|
-
var $L126 = $L("
|
|
858
|
-
var $L127 = $L("
|
|
744
|
+
var $L4 = $L("=>");
|
|
745
|
+
var $L5 = $L("<");
|
|
746
|
+
var $L6 = $L("extends");
|
|
747
|
+
var $L7 = $L("this");
|
|
748
|
+
var $L8 = $L("#");
|
|
749
|
+
var $L9 = $L("@");
|
|
750
|
+
var $L10 = $L("super");
|
|
751
|
+
var $L11 = $L("import");
|
|
752
|
+
var $L12 = $L("!");
|
|
753
|
+
var $L13 = $L("::");
|
|
754
|
+
var $L14 = $L("super[");
|
|
755
|
+
var $L15 = $L("import.meta");
|
|
756
|
+
var $L16 = $L(")");
|
|
757
|
+
var $L17 = $L("...");
|
|
758
|
+
var $L18 = $L("->");
|
|
759
|
+
var $L19 = $L("null");
|
|
760
|
+
var $L20 = $L("true");
|
|
761
|
+
var $L21 = $L("false");
|
|
762
|
+
var $L22 = $L(",");
|
|
763
|
+
var $L23 = $L("]");
|
|
764
|
+
var $L24 = $L("}");
|
|
765
|
+
var $L25 = $L("**=");
|
|
766
|
+
var $L26 = $L("*=");
|
|
767
|
+
var $L27 = $L("/=");
|
|
768
|
+
var $L28 = $L("%=");
|
|
769
|
+
var $L29 = $L("+=");
|
|
770
|
+
var $L30 = $L("-=");
|
|
771
|
+
var $L31 = $L("<<=");
|
|
772
|
+
var $L32 = $L(">>>=");
|
|
773
|
+
var $L33 = $L(">>=");
|
|
774
|
+
var $L34 = $L("&&=");
|
|
775
|
+
var $L35 = $L("&=");
|
|
776
|
+
var $L36 = $L("^=");
|
|
777
|
+
var $L37 = $L("||=");
|
|
778
|
+
var $L38 = $L("|=");
|
|
779
|
+
var $L39 = $L("??=");
|
|
780
|
+
var $L40 = $L("?=");
|
|
781
|
+
var $L41 = $L("=");
|
|
782
|
+
var $L42 = $L("**");
|
|
783
|
+
var $L43 = $L("*");
|
|
784
|
+
var $L44 = $L("/");
|
|
785
|
+
var $L45 = $L("%");
|
|
786
|
+
var $L46 = $L("+");
|
|
787
|
+
var $L47 = $L("-");
|
|
788
|
+
var $L48 = $L("<=");
|
|
789
|
+
var $L49 = $L(">=");
|
|
790
|
+
var $L50 = $L("<<");
|
|
791
|
+
var $L51 = $L(">>>");
|
|
792
|
+
var $L52 = $L(">>");
|
|
793
|
+
var $L53 = $L(">");
|
|
794
|
+
var $L54 = $L("!==");
|
|
795
|
+
var $L55 = $L("!=");
|
|
796
|
+
var $L56 = $L("is");
|
|
797
|
+
var $L57 = $L("===");
|
|
798
|
+
var $L58 = $L("==");
|
|
799
|
+
var $L59 = $L("and");
|
|
800
|
+
var $L60 = $L("&&");
|
|
801
|
+
var $L61 = $L("or");
|
|
802
|
+
var $L62 = $L("||");
|
|
803
|
+
var $L63 = $L("??");
|
|
804
|
+
var $L64 = $L("instanceof");
|
|
805
|
+
var $L65 = $L("in");
|
|
806
|
+
var $L66 = $L("&");
|
|
807
|
+
var $L67 = $L("^");
|
|
808
|
+
var $L68 = $L("|");
|
|
809
|
+
var $L69 = $L("delete");
|
|
810
|
+
var $L70 = $L("void");
|
|
811
|
+
var $L71 = $L("typeof");
|
|
812
|
+
var $L72 = $L(";");
|
|
813
|
+
var $L73 = $L("do");
|
|
814
|
+
var $L74 = $L("while");
|
|
815
|
+
var $L75 = $L("until");
|
|
816
|
+
var $L76 = $L("finally");
|
|
817
|
+
var $L77 = $L("break");
|
|
818
|
+
var $L78 = $L("continue");
|
|
819
|
+
var $L79 = $L("debugger");
|
|
820
|
+
var $L80 = $L("throw");
|
|
821
|
+
var $L81 = $L("import type");
|
|
822
|
+
var $L82 = $L("default");
|
|
823
|
+
var $L83 = $L(":=");
|
|
824
|
+
var $L84 = $L("/*");
|
|
825
|
+
var $L85 = $L("*/");
|
|
826
|
+
var $L86 = $L("###");
|
|
827
|
+
var $L87 = $L("as");
|
|
828
|
+
var $L88 = $L("async");
|
|
829
|
+
var $L89 = $L("await");
|
|
830
|
+
var $L90 = $L("case");
|
|
831
|
+
var $L91 = $L("catch");
|
|
832
|
+
var $L92 = $L("class");
|
|
833
|
+
var $L93 = $L("#{");
|
|
834
|
+
var $L94 = $L(":");
|
|
835
|
+
var $L95 = $L(".");
|
|
836
|
+
var $L96 = $L('"');
|
|
837
|
+
var $L97 = $L("else");
|
|
838
|
+
var $L98 = $L("export");
|
|
839
|
+
var $L99 = $L("for");
|
|
840
|
+
var $L100 = $L("from");
|
|
841
|
+
var $L101 = $L("function");
|
|
842
|
+
var $L102 = $L("get");
|
|
843
|
+
var $L103 = $L("set");
|
|
844
|
+
var $L104 = $L("if");
|
|
845
|
+
var $L105 = $L("let");
|
|
846
|
+
var $L106 = $L("const");
|
|
847
|
+
var $L107 = $L("loop");
|
|
848
|
+
var $L108 = $L("new");
|
|
849
|
+
var $L109 = $L("of");
|
|
850
|
+
var $L110 = $L("{");
|
|
851
|
+
var $L111 = $L("[");
|
|
852
|
+
var $L112 = $L("(");
|
|
853
|
+
var $L113 = $L("?");
|
|
854
|
+
var $L114 = $L("return");
|
|
855
|
+
var $L115 = $L("'");
|
|
856
|
+
var $L116 = $L("static");
|
|
857
|
+
var $L117 = $L("${");
|
|
858
|
+
var $L118 = $L("switch");
|
|
859
|
+
var $L119 = $L("target");
|
|
860
|
+
var $L120 = $L('"""');
|
|
861
|
+
var $L121 = $L("'''");
|
|
862
|
+
var $L122 = $L("```");
|
|
863
|
+
var $L123 = $L("try");
|
|
864
|
+
var $L124 = $L("unless");
|
|
865
|
+
var $L125 = $L("var");
|
|
866
|
+
var $L126 = $L("when");
|
|
867
|
+
var $L127 = $L("yield");
|
|
859
868
|
var $L128 = $L("/>");
|
|
860
869
|
var $L129 = $L("</");
|
|
861
870
|
var $L130 = $L("<>");
|
|
@@ -880,8 +889,8 @@ var Civet = (() => {
|
|
|
880
889
|
var $R6 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
|
|
881
890
|
var $R7 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
|
|
882
891
|
var $R8 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
|
|
883
|
-
var $R9 = $R(new RegExp('(?:\\\\.|[^"])
|
|
884
|
-
var $R10 = $R(new RegExp("(?:\\\\.|[^'])
|
|
892
|
+
var $R9 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
893
|
+
var $R10 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
885
894
|
var $R11 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
886
895
|
var $R12 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
887
896
|
var $R13 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
@@ -895,20 +904,19 @@ var Civet = (() => {
|
|
|
895
904
|
var $R21 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
896
905
|
var $R22 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
897
906
|
var $R23 = $R(new RegExp("[ \\t]+", "suy"));
|
|
898
|
-
var $R24 = $R(new RegExp("[\\
|
|
899
|
-
var $R25 = $R(new RegExp("
|
|
900
|
-
var $R26 = $R(new RegExp("
|
|
901
|
-
var $R27 = $R(new RegExp("\\
|
|
902
|
-
var $R28 = $R(new RegExp("
|
|
903
|
-
var $R29 = $R(new RegExp('
|
|
904
|
-
var $R30 = $R(new RegExp("
|
|
905
|
-
var $R31 = $R(new RegExp("[
|
|
906
|
-
var $R32 = $R(new RegExp("[+-]
|
|
907
|
-
var $R33 = $R(new RegExp("[
|
|
908
|
-
var $R34 = $R(new RegExp("
|
|
909
|
-
var $R35 = $R(new RegExp("
|
|
910
|
-
var $R36 = $R(new RegExp("
|
|
911
|
-
var $R37 = $R(new RegExp("$", "suy"));
|
|
907
|
+
var $R24 = $R(new RegExp("[\\s]+", "suy"));
|
|
908
|
+
var $R25 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
909
|
+
var $R26 = $R(new RegExp("\\s", "suy"));
|
|
910
|
+
var $R27 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
911
|
+
var $R28 = $R(new RegExp('"[^"]*"', "suy"));
|
|
912
|
+
var $R29 = $R(new RegExp("'[^']*'", "suy"));
|
|
913
|
+
var $R30 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
914
|
+
var $R31 = $R(new RegExp("[+-]?", "suy"));
|
|
915
|
+
var $R32 = $R(new RegExp("[+-]", "suy"));
|
|
916
|
+
var $R33 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
917
|
+
var $R34 = $R(new RegExp("[\\t ]*", "suy"));
|
|
918
|
+
var $R35 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
919
|
+
var $R36 = $R(new RegExp("$", "suy"));
|
|
912
920
|
var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
|
|
913
921
|
function Program(state) {
|
|
914
922
|
if (state.verbose)
|
|
@@ -1008,8 +1016,7 @@ var Civet = (() => {
|
|
|
1008
1016
|
}
|
|
1009
1017
|
var ApplicationStart$0 = $TS($S($N(EOS), _, $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1010
1018
|
var spacing = $2;
|
|
1011
|
-
|
|
1012
|
-
return spacing;
|
|
1019
|
+
return module.insertTrimmingSpace(spacing, "(");
|
|
1013
1020
|
});
|
|
1014
1021
|
var ApplicationStart$1 = $S(IndentedApplicationAllowed, $Y(NestedObjectLiteral), InsertOpenParen);
|
|
1015
1022
|
function ApplicationStart(state) {
|
|
@@ -1134,7 +1141,7 @@ var Civet = (() => {
|
|
|
1134
1141
|
return AwaitExpression$0(state);
|
|
1135
1142
|
}
|
|
1136
1143
|
}
|
|
1137
|
-
var YieldExpression$0 = $S(
|
|
1144
|
+
var YieldExpression$0 = $S(Yield, $E($S($Q(TrailingComment), Star)), AssignmentExpression);
|
|
1138
1145
|
function YieldExpression(state) {
|
|
1139
1146
|
if (state.verbose)
|
|
1140
1147
|
console.log("ENTER:", "YieldExpression");
|
|
@@ -1153,7 +1160,7 @@ var Civet = (() => {
|
|
|
1153
1160
|
return ArrowFunction$0(state) || ArrowFunction$1(state);
|
|
1154
1161
|
}
|
|
1155
1162
|
}
|
|
1156
|
-
var FatArrow$0 = $TS($S(__, $EXPECT($
|
|
1163
|
+
var FatArrow$0 = $TS($S(__, $EXPECT($L4, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
|
|
1157
1164
|
var ws = $1;
|
|
1158
1165
|
if (!ws.length)
|
|
1159
1166
|
return " =>";
|
|
@@ -1249,10 +1256,10 @@ var Civet = (() => {
|
|
|
1249
1256
|
return ClassHeritage$0(state);
|
|
1250
1257
|
}
|
|
1251
1258
|
}
|
|
1252
|
-
var ExtendsToken$0 = $TV($EXPECT($
|
|
1259
|
+
var ExtendsToken$0 = $TV($EXPECT($L5, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
|
|
1253
1260
|
return { $loc, token: "extends" };
|
|
1254
1261
|
});
|
|
1255
|
-
var ExtendsToken$1 = $TV($EXPECT($
|
|
1262
|
+
var ExtendsToken$1 = $TV($EXPECT($L6, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
|
|
1256
1263
|
return { $loc, token: $1 };
|
|
1257
1264
|
});
|
|
1258
1265
|
function ExtendsToken(state) {
|
|
@@ -1322,11 +1329,11 @@ var Civet = (() => {
|
|
|
1322
1329
|
return FieldDefinition$0(state) || FieldDefinition$1(state);
|
|
1323
1330
|
}
|
|
1324
1331
|
}
|
|
1325
|
-
var This$0 = $TV($EXPECT($
|
|
1332
|
+
var This$0 = $TV($EXPECT($L7, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
1326
1333
|
return { $loc, token: $1 };
|
|
1327
1334
|
});
|
|
1328
|
-
var This$1 = $S(AtAccessor, $S($E($EXPECT($
|
|
1329
|
-
var This$2 = $TV($EXPECT($
|
|
1335
|
+
var This$1 = $S(AtAccessor, $S($E($EXPECT($L8, fail, 'This "#"')), IdentifierName));
|
|
1336
|
+
var This$2 = $TV($EXPECT($L9, fail, 'This "@"'), function($skip, $loc, $0, $1) {
|
|
1330
1337
|
return { $loc, token: "this" };
|
|
1331
1338
|
});
|
|
1332
1339
|
function This(state) {
|
|
@@ -1336,7 +1343,7 @@ var Civet = (() => {
|
|
|
1336
1343
|
return This$0(state) || This$1(state) || This$2(state);
|
|
1337
1344
|
}
|
|
1338
1345
|
}
|
|
1339
|
-
var AtAccessor$0 = $TV($EXPECT($
|
|
1346
|
+
var AtAccessor$0 = $TV($EXPECT($L9, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
|
|
1340
1347
|
return { $loc, token: "this." };
|
|
1341
1348
|
});
|
|
1342
1349
|
function AtAccessor(state) {
|
|
@@ -1367,8 +1374,8 @@ var Civet = (() => {
|
|
|
1367
1374
|
return NewExpression$0(state);
|
|
1368
1375
|
}
|
|
1369
1376
|
}
|
|
1370
|
-
var CallExpression$0 = $S($EXPECT($
|
|
1371
|
-
var CallExpression$1 = $S($EXPECT($
|
|
1377
|
+
var CallExpression$0 = $S($EXPECT($L10, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
|
|
1378
|
+
var CallExpression$1 = $S($EXPECT($L11, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
|
|
1372
1379
|
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
|
|
1373
1380
|
function CallExpression(state) {
|
|
1374
1381
|
if (state.tokenize) {
|
|
@@ -1397,7 +1404,7 @@ var Civet = (() => {
|
|
|
1397
1404
|
return OptionalShorthand$0(state);
|
|
1398
1405
|
}
|
|
1399
1406
|
}
|
|
1400
|
-
var NonNullAssertion$0 = $T($EXPECT($
|
|
1407
|
+
var NonNullAssertion$0 = $T($EXPECT($L12, fail, 'NonNullAssertion "!"'), function(value) {
|
|
1401
1408
|
return { "ts": true, "children": value };
|
|
1402
1409
|
});
|
|
1403
1410
|
function NonNullAssertion(state) {
|
|
@@ -1431,7 +1438,7 @@ var Civet = (() => {
|
|
|
1431
1438
|
}
|
|
1432
1439
|
var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), OpenBracket, Expression, __, CloseBracket);
|
|
1433
1440
|
var MemberExpressionRest$1 = $S($E($S($Y(EOS), IndentedFurther)), PropertyAccess);
|
|
1434
|
-
var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($
|
|
1441
|
+
var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L13, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1435
1442
|
var id = $3;
|
|
1436
1443
|
if (id)
|
|
1437
1444
|
return [".prototype.", id];
|
|
@@ -1455,7 +1462,7 @@ var Civet = (() => {
|
|
|
1455
1462
|
return PropertyAccess$0(state);
|
|
1456
1463
|
}
|
|
1457
1464
|
}
|
|
1458
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
1465
|
+
var SuperProperty$0 = $S($EXPECT($L14, fail, 'SuperProperty "super["'), Expression, __, CloseBracket);
|
|
1459
1466
|
function SuperProperty(state) {
|
|
1460
1467
|
if (state.verbose)
|
|
1461
1468
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1466,7 +1473,7 @@ var Civet = (() => {
|
|
|
1466
1473
|
}
|
|
1467
1474
|
}
|
|
1468
1475
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
1469
|
-
var MetaProperty$1 = $TV($EXPECT($
|
|
1476
|
+
var MetaProperty$1 = $TV($EXPECT($L15, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
|
|
1470
1477
|
return { $loc, token: $1 };
|
|
1471
1478
|
});
|
|
1472
1479
|
function MetaProperty(state) {
|
|
@@ -1498,8 +1505,8 @@ var Civet = (() => {
|
|
|
1498
1505
|
}
|
|
1499
1506
|
}
|
|
1500
1507
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
1501
|
-
var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1502
|
-
var ParameterElementDelimiter$2 = $TV($Y($S(__, $EXPECT($
|
|
1508
|
+
var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'ParameterElementDelimiter ")"')));
|
|
1509
|
+
var ParameterElementDelimiter$2 = $TV($Y($S(__, $EXPECT($L16, fail, 'ParameterElementDelimiter ")"'))), function($skip, $loc, $0, $1) {
|
|
1503
1510
|
return { $loc, token: "," };
|
|
1504
1511
|
});
|
|
1505
1512
|
var ParameterElementDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
@@ -1586,7 +1593,7 @@ var Civet = (() => {
|
|
|
1586
1593
|
return BindingProperty$0(state) || BindingProperty$1(state);
|
|
1587
1594
|
}
|
|
1588
1595
|
}
|
|
1589
|
-
var BindingRestProperty$0 = $S($EXPECT($
|
|
1596
|
+
var BindingRestProperty$0 = $S($EXPECT($L17, fail, 'BindingRestProperty "..."'), BindingIdentifier);
|
|
1590
1597
|
function BindingRestProperty(state) {
|
|
1591
1598
|
if (state.verbose)
|
|
1592
1599
|
console.log("ENTER:", "BindingRestProperty");
|
|
@@ -1634,7 +1641,7 @@ var Civet = (() => {
|
|
|
1634
1641
|
return BindingElement$0(state);
|
|
1635
1642
|
}
|
|
1636
1643
|
}
|
|
1637
|
-
var BindingRestElement$0 = $S($EXPECT($
|
|
1644
|
+
var BindingRestElement$0 = $S($EXPECT($L17, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
|
|
1638
1645
|
function BindingRestElement(state) {
|
|
1639
1646
|
if (state.verbose)
|
|
1640
1647
|
console.log("ENTER:", "BindingRestElement");
|
|
@@ -1655,7 +1662,7 @@ var Civet = (() => {
|
|
|
1655
1662
|
}
|
|
1656
1663
|
}
|
|
1657
1664
|
var FunctionExpression$0 = ThinArrowFunction;
|
|
1658
|
-
var FunctionExpression$1 = $S($E($S(Async, __)), Function, $E($S(
|
|
1665
|
+
var FunctionExpression$1 = $S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
|
|
1659
1666
|
function FunctionExpression(state) {
|
|
1660
1667
|
if (state.tokenize) {
|
|
1661
1668
|
return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
|
|
@@ -1684,7 +1691,7 @@ var Civet = (() => {
|
|
|
1684
1691
|
return ThinArrowFunction$0(state);
|
|
1685
1692
|
}
|
|
1686
1693
|
}
|
|
1687
|
-
var Arrow$0 = $TV($EXPECT($
|
|
1694
|
+
var Arrow$0 = $TV($EXPECT($L18, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
1688
1695
|
return { $loc, token: $1 };
|
|
1689
1696
|
});
|
|
1690
1697
|
function Arrow(state) {
|
|
@@ -1777,7 +1784,7 @@ var Civet = (() => {
|
|
|
1777
1784
|
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
|
|
1778
1785
|
}
|
|
1779
1786
|
}
|
|
1780
|
-
var NullLiteral$0 = $TV($EXPECT($
|
|
1787
|
+
var NullLiteral$0 = $TV($EXPECT($L19, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
1781
1788
|
return { $loc, token: $1 };
|
|
1782
1789
|
});
|
|
1783
1790
|
function NullLiteral(state) {
|
|
@@ -1789,7 +1796,7 @@ var Civet = (() => {
|
|
|
1789
1796
|
return NullLiteral$0(state);
|
|
1790
1797
|
}
|
|
1791
1798
|
}
|
|
1792
|
-
var BooleanLiteral$0 = $TV($C($EXPECT($
|
|
1799
|
+
var BooleanLiteral$0 = $TV($C($EXPECT($L20, fail, 'BooleanLiteral "true"'), $EXPECT($L21, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
|
|
1793
1800
|
return { $loc, token: $1 };
|
|
1794
1801
|
});
|
|
1795
1802
|
function BooleanLiteral(state) {
|
|
@@ -1801,7 +1808,7 @@ var Civet = (() => {
|
|
|
1801
1808
|
return BooleanLiteral$0(state);
|
|
1802
1809
|
}
|
|
1803
1810
|
}
|
|
1804
|
-
var Comma$0 = $TV($EXPECT($
|
|
1811
|
+
var Comma$0 = $TV($EXPECT($L22, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
1805
1812
|
return { $loc, token: $1 };
|
|
1806
1813
|
});
|
|
1807
1814
|
function Comma(state) {
|
|
@@ -1883,7 +1890,7 @@ var Civet = (() => {
|
|
|
1883
1890
|
}
|
|
1884
1891
|
}
|
|
1885
1892
|
var ArrayElementDelimiter$0 = $S($Q(_), Comma);
|
|
1886
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
1893
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L23, fail, 'ArrayElementDelimiter "]"')));
|
|
1887
1894
|
var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1888
1895
|
return { $loc, token: "," };
|
|
1889
1896
|
});
|
|
@@ -1914,7 +1921,7 @@ var Civet = (() => {
|
|
|
1914
1921
|
return InlineElementList$0(state);
|
|
1915
1922
|
}
|
|
1916
1923
|
}
|
|
1917
|
-
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($
|
|
1924
|
+
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L17, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
|
|
1918
1925
|
function ArrayElementExpression(state) {
|
|
1919
1926
|
if (state.verbose)
|
|
1920
1927
|
console.log("ENTER:", "ArrayElementExpression");
|
|
@@ -1981,7 +1988,7 @@ var Civet = (() => {
|
|
|
1981
1988
|
}
|
|
1982
1989
|
}
|
|
1983
1990
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
1984
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
1991
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L24, fail, 'ObjectPropertyDelimiter "}"')));
|
|
1985
1992
|
var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1986
1993
|
return { $loc, token: "," };
|
|
1987
1994
|
});
|
|
@@ -2004,7 +2011,7 @@ var Civet = (() => {
|
|
|
2004
2011
|
}
|
|
2005
2012
|
var PropertyDefinition$0 = $S(PropertyName, __, Colon, AssignmentExpression);
|
|
2006
2013
|
var PropertyDefinition$1 = MethodDefinition;
|
|
2007
|
-
var PropertyDefinition$2 = $S($EXPECT($
|
|
2014
|
+
var PropertyDefinition$2 = $S($EXPECT($L17, fail, 'PropertyDefinition "..."'), AssignmentExpression);
|
|
2008
2015
|
var PropertyDefinition$3 = IdentifierReference;
|
|
2009
2016
|
function PropertyDefinition(state) {
|
|
2010
2017
|
if (state.tokenize) {
|
|
@@ -2016,7 +2023,7 @@ var Civet = (() => {
|
|
|
2016
2023
|
var PropertyName$0 = NumericLiteral;
|
|
2017
2024
|
var PropertyName$1 = StringLiteral;
|
|
2018
2025
|
var PropertyName$2 = IdentifierName;
|
|
2019
|
-
var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($
|
|
2026
|
+
var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L23, fail, 'PropertyName "]"'));
|
|
2020
2027
|
function PropertyName(state) {
|
|
2021
2028
|
if (state.tokenize) {
|
|
2022
2029
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -2035,8 +2042,8 @@ var Civet = (() => {
|
|
|
2035
2042
|
}
|
|
2036
2043
|
}
|
|
2037
2044
|
var MethodModifier$0 = $S(GetOrSet, $Q(TrailingComment));
|
|
2038
|
-
var MethodModifier$1 = $S($S(Async, __), $E($S(
|
|
2039
|
-
var MethodModifier$2 = $S(
|
|
2045
|
+
var MethodModifier$1 = $S($S(Async, __), $E($S(Star, __)));
|
|
2046
|
+
var MethodModifier$2 = $S(Star, __);
|
|
2040
2047
|
var MethodModifier$3 = $S(Async, __);
|
|
2041
2048
|
function MethodModifier(state) {
|
|
2042
2049
|
if (state.tokenize) {
|
|
@@ -2045,18 +2052,6 @@ var Civet = (() => {
|
|
|
2045
2052
|
return MethodModifier$0(state) || MethodModifier$1(state) || MethodModifier$2(state) || MethodModifier$3(state);
|
|
2046
2053
|
}
|
|
2047
2054
|
}
|
|
2048
|
-
var ConstructorShorthand$0 = $TV($EXPECT($L11, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
2049
|
-
return { $loc, token: "constructor" };
|
|
2050
|
-
});
|
|
2051
|
-
function ConstructorShorthand(state) {
|
|
2052
|
-
if (state.verbose)
|
|
2053
|
-
console.log("ENTER:", "ConstructorShorthand");
|
|
2054
|
-
if (state.tokenize) {
|
|
2055
|
-
return $TOKEN("ConstructorShorthand", state, ConstructorShorthand$0(state));
|
|
2056
|
-
} else {
|
|
2057
|
-
return ConstructorShorthand$0(state);
|
|
2058
|
-
}
|
|
2059
|
-
}
|
|
2060
2055
|
var MethodSignature$0 = $S(ConstructorShorthand, Parameters);
|
|
2061
2056
|
var MethodSignature$1 = $S($E(MethodModifier), ClassElementName, $Q(_), Parameters);
|
|
2062
2057
|
function MethodSignature(state) {
|
|
@@ -2075,7 +2070,7 @@ var Civet = (() => {
|
|
|
2075
2070
|
return ClassElementName$0(state) || ClassElementName$1(state);
|
|
2076
2071
|
}
|
|
2077
2072
|
}
|
|
2078
|
-
var PrivateIdentifier$0 = $S($EXPECT($
|
|
2073
|
+
var PrivateIdentifier$0 = $S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName);
|
|
2079
2074
|
function PrivateIdentifier(state) {
|
|
2080
2075
|
if (state.verbose)
|
|
2081
2076
|
console.log("ENTER:", "PrivateIdentifier");
|
|
@@ -2097,25 +2092,25 @@ var Civet = (() => {
|
|
|
2097
2092
|
return AssignmentOp$0(state);
|
|
2098
2093
|
}
|
|
2099
2094
|
}
|
|
2100
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
2101
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
2102
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
2103
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
2104
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
2105
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
2106
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
2107
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
2108
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
2109
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
2110
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
2111
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
2112
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
2113
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
2114
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
2115
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
2095
|
+
var AssignmentOpSymbol$0 = $EXPECT($L25, fail, 'AssignmentOpSymbol "**="');
|
|
2096
|
+
var AssignmentOpSymbol$1 = $EXPECT($L26, fail, 'AssignmentOpSymbol "*="');
|
|
2097
|
+
var AssignmentOpSymbol$2 = $EXPECT($L27, fail, 'AssignmentOpSymbol "/="');
|
|
2098
|
+
var AssignmentOpSymbol$3 = $EXPECT($L28, fail, 'AssignmentOpSymbol "%="');
|
|
2099
|
+
var AssignmentOpSymbol$4 = $EXPECT($L29, fail, 'AssignmentOpSymbol "+="');
|
|
2100
|
+
var AssignmentOpSymbol$5 = $EXPECT($L30, fail, 'AssignmentOpSymbol "-="');
|
|
2101
|
+
var AssignmentOpSymbol$6 = $EXPECT($L31, fail, 'AssignmentOpSymbol "<<="');
|
|
2102
|
+
var AssignmentOpSymbol$7 = $EXPECT($L32, fail, 'AssignmentOpSymbol ">>>="');
|
|
2103
|
+
var AssignmentOpSymbol$8 = $EXPECT($L33, fail, 'AssignmentOpSymbol ">>="');
|
|
2104
|
+
var AssignmentOpSymbol$9 = $EXPECT($L34, fail, 'AssignmentOpSymbol "&&="');
|
|
2105
|
+
var AssignmentOpSymbol$10 = $EXPECT($L35, fail, 'AssignmentOpSymbol "&="');
|
|
2106
|
+
var AssignmentOpSymbol$11 = $EXPECT($L36, fail, 'AssignmentOpSymbol "^="');
|
|
2107
|
+
var AssignmentOpSymbol$12 = $EXPECT($L37, fail, 'AssignmentOpSymbol "||="');
|
|
2108
|
+
var AssignmentOpSymbol$13 = $EXPECT($L38, fail, 'AssignmentOpSymbol "|="');
|
|
2109
|
+
var AssignmentOpSymbol$14 = $EXPECT($L39, fail, 'AssignmentOpSymbol "??="');
|
|
2110
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L40, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
2116
2111
|
return "??=";
|
|
2117
2112
|
});
|
|
2118
|
-
var AssignmentOpSymbol$16 = $EXPECT($
|
|
2113
|
+
var AssignmentOpSymbol$16 = $EXPECT($L41, fail, 'AssignmentOpSymbol "="');
|
|
2119
2114
|
function AssignmentOpSymbol(state) {
|
|
2120
2115
|
if (state.tokenize) {
|
|
2121
2116
|
return $TOKEN("AssignmentOpSymbol", state, AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state) || AssignmentOpSymbol$16(state));
|
|
@@ -2135,52 +2130,52 @@ var Civet = (() => {
|
|
|
2135
2130
|
return BinaryOp$0(state);
|
|
2136
2131
|
}
|
|
2137
2132
|
}
|
|
2138
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
2139
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
2140
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
2141
|
-
var BinaryOpSymbol$3 = $EXPECT($
|
|
2142
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
2143
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
2144
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
2145
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
2146
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
2147
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
2148
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
2149
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
2150
|
-
var BinaryOpSymbol$12 = $EXPECT($
|
|
2151
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
2152
|
-
var BinaryOpSymbol$14 = $TV($EXPECT($
|
|
2133
|
+
var BinaryOpSymbol$0 = $EXPECT($L42, fail, 'BinaryOpSymbol "**"');
|
|
2134
|
+
var BinaryOpSymbol$1 = $EXPECT($L43, fail, 'BinaryOpSymbol "*"');
|
|
2135
|
+
var BinaryOpSymbol$2 = $EXPECT($L44, fail, 'BinaryOpSymbol "/"');
|
|
2136
|
+
var BinaryOpSymbol$3 = $EXPECT($L45, fail, 'BinaryOpSymbol "%"');
|
|
2137
|
+
var BinaryOpSymbol$4 = $EXPECT($L46, fail, 'BinaryOpSymbol "+"');
|
|
2138
|
+
var BinaryOpSymbol$5 = $EXPECT($L47, fail, 'BinaryOpSymbol "-"');
|
|
2139
|
+
var BinaryOpSymbol$6 = $EXPECT($L48, fail, 'BinaryOpSymbol "<="');
|
|
2140
|
+
var BinaryOpSymbol$7 = $EXPECT($L49, fail, 'BinaryOpSymbol ">="');
|
|
2141
|
+
var BinaryOpSymbol$8 = $EXPECT($L50, fail, 'BinaryOpSymbol "<<"');
|
|
2142
|
+
var BinaryOpSymbol$9 = $EXPECT($L5, fail, 'BinaryOpSymbol "<"');
|
|
2143
|
+
var BinaryOpSymbol$10 = $EXPECT($L51, fail, 'BinaryOpSymbol ">>>"');
|
|
2144
|
+
var BinaryOpSymbol$11 = $EXPECT($L52, fail, 'BinaryOpSymbol ">>"');
|
|
2145
|
+
var BinaryOpSymbol$12 = $EXPECT($L53, fail, 'BinaryOpSymbol ">"');
|
|
2146
|
+
var BinaryOpSymbol$13 = $EXPECT($L54, fail, 'BinaryOpSymbol "!=="');
|
|
2147
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L55, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
2153
2148
|
if (module.coffeeCompat)
|
|
2154
2149
|
return "!==";
|
|
2155
2150
|
return $1;
|
|
2156
2151
|
});
|
|
2157
|
-
var BinaryOpSymbol$15 = $T($S($EXPECT($
|
|
2152
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L56, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
2158
2153
|
return "===";
|
|
2159
2154
|
});
|
|
2160
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
2161
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
2155
|
+
var BinaryOpSymbol$16 = $EXPECT($L57, fail, 'BinaryOpSymbol "==="');
|
|
2156
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L58, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
2162
2157
|
if (module.coffeeCompat)
|
|
2163
2158
|
return "===";
|
|
2164
2159
|
return $1;
|
|
2165
2160
|
});
|
|
2166
|
-
var BinaryOpSymbol$18 = $T($S($EXPECT($
|
|
2161
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L59, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
2167
2162
|
return "&&";
|
|
2168
2163
|
});
|
|
2169
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
2170
|
-
var BinaryOpSymbol$20 = $T($S($EXPECT($
|
|
2164
|
+
var BinaryOpSymbol$19 = $EXPECT($L60, fail, 'BinaryOpSymbol "&&"');
|
|
2165
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L61, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
2171
2166
|
return "||";
|
|
2172
2167
|
});
|
|
2173
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
2174
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
2175
|
-
var BinaryOpSymbol$23 = $TS($S($EXPECT($
|
|
2168
|
+
var BinaryOpSymbol$21 = $EXPECT($L62, fail, 'BinaryOpSymbol "||"');
|
|
2169
|
+
var BinaryOpSymbol$22 = $EXPECT($L63, fail, 'BinaryOpSymbol "??"');
|
|
2170
|
+
var BinaryOpSymbol$23 = $TS($S($EXPECT($L64, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2176
2171
|
return $1;
|
|
2177
2172
|
});
|
|
2178
|
-
var BinaryOpSymbol$24 = $TS($S($EXPECT($
|
|
2173
|
+
var BinaryOpSymbol$24 = $TS($S($EXPECT($L65, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2179
2174
|
return $1;
|
|
2180
2175
|
});
|
|
2181
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
2182
|
-
var BinaryOpSymbol$26 = $EXPECT($
|
|
2183
|
-
var BinaryOpSymbol$27 = $EXPECT($
|
|
2176
|
+
var BinaryOpSymbol$25 = $EXPECT($L66, fail, 'BinaryOpSymbol "&"');
|
|
2177
|
+
var BinaryOpSymbol$26 = $EXPECT($L67, fail, 'BinaryOpSymbol "^"');
|
|
2178
|
+
var BinaryOpSymbol$27 = $EXPECT($L68, fail, 'BinaryOpSymbol "|"');
|
|
2184
2179
|
function BinaryOpSymbol(state) {
|
|
2185
2180
|
if (state.tokenize) {
|
|
2186
2181
|
return $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state));
|
|
@@ -2189,7 +2184,7 @@ var Civet = (() => {
|
|
|
2189
2184
|
}
|
|
2190
2185
|
}
|
|
2191
2186
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
2192
|
-
var UnaryOp$1 = $S($C($EXPECT($
|
|
2187
|
+
var UnaryOp$1 = $S($C($EXPECT($L69, fail, 'UnaryOp "delete"'), $EXPECT($L70, fail, 'UnaryOp "void"'), $EXPECT($L71, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
|
|
2193
2188
|
function UnaryOp(state) {
|
|
2194
2189
|
if (state.tokenize) {
|
|
2195
2190
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -2269,7 +2264,7 @@ var Civet = (() => {
|
|
|
2269
2264
|
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);
|
|
2270
2265
|
}
|
|
2271
2266
|
}
|
|
2272
|
-
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($
|
|
2267
|
+
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L72, fail, 'EmptyStatement ";"')));
|
|
2273
2268
|
function EmptyStatement(state) {
|
|
2274
2269
|
if (state.verbose)
|
|
2275
2270
|
console.log("ENTER:", "EmptyStatement");
|
|
@@ -2334,7 +2329,7 @@ var Civet = (() => {
|
|
|
2334
2329
|
return LoopStatement$0(state);
|
|
2335
2330
|
}
|
|
2336
2331
|
}
|
|
2337
|
-
var DoWhileStatement$0 = $S($EXPECT($
|
|
2332
|
+
var DoWhileStatement$0 = $S($EXPECT($L73, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
|
|
2338
2333
|
function DoWhileStatement(state) {
|
|
2339
2334
|
if (state.verbose)
|
|
2340
2335
|
console.log("ENTER:", "DoWhileStatement");
|
|
@@ -2354,7 +2349,7 @@ var Civet = (() => {
|
|
|
2354
2349
|
return WhileStatement$0(state);
|
|
2355
2350
|
}
|
|
2356
2351
|
}
|
|
2357
|
-
var WhileClause$0 = $TS($S($C($EXPECT($
|
|
2352
|
+
var WhileClause$0 = $TS($S($C($EXPECT($L74, fail, 'WhileClause "while"'), $EXPECT($L75, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
|
|
2358
2353
|
var kind = $1;
|
|
2359
2354
|
var cond = $3;
|
|
2360
2355
|
if (kind === "until") {
|
|
@@ -2413,7 +2408,7 @@ var Civet = (() => {
|
|
|
2413
2408
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
2414
2409
|
}
|
|
2415
2410
|
}
|
|
2416
|
-
var SwitchStatement$0 = $S(Switch,
|
|
2411
|
+
var SwitchStatement$0 = $S(Switch, Condition, CaseBlock);
|
|
2417
2412
|
function SwitchStatement(state) {
|
|
2418
2413
|
if (state.verbose)
|
|
2419
2414
|
console.log("ENTER:", "SwitchStatement");
|
|
@@ -2457,9 +2452,9 @@ var Civet = (() => {
|
|
|
2457
2452
|
return NestedCaseClause$0(state);
|
|
2458
2453
|
}
|
|
2459
2454
|
}
|
|
2460
|
-
var CaseClause$0 = $S(
|
|
2461
|
-
var CaseClause$1 = $S(When,
|
|
2462
|
-
var CaseClause$2 = $S(
|
|
2455
|
+
var CaseClause$0 = $S(Case, CaseExpressionList, NestedBlockExpressions);
|
|
2456
|
+
var CaseClause$1 = $S(When, CaseExpressionList, NestedBlockExpressions, InsertBreak);
|
|
2457
|
+
var CaseClause$2 = $S(Default, ImpliedColon, NestedBlockExpressions);
|
|
2463
2458
|
function CaseClause(state) {
|
|
2464
2459
|
if (state.tokenize) {
|
|
2465
2460
|
return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
|
|
@@ -2467,6 +2462,25 @@ var Civet = (() => {
|
|
|
2467
2462
|
return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
|
|
2468
2463
|
}
|
|
2469
2464
|
}
|
|
2465
|
+
var CaseExpressionList$0 = $TS($S($S($Q(_), ExpressionWithIndentedApplicationSuppressed, ImpliedColon), $Q($S(__, Comma, ExpressionWithIndentedApplicationSuppressed, ImpliedColon))), function($skip, $loc, $0, $1, $2) {
|
|
2466
|
+
const result = $2.map(([ws, _comma, exp, col]) => {
|
|
2467
|
+
module.insertTrimmingSpace(exp, "");
|
|
2468
|
+
if (ws.length)
|
|
2469
|
+
return [module.insertTrimmingSpace("case ", ws), exp, col];
|
|
2470
|
+
return ["case ", exp, col];
|
|
2471
|
+
});
|
|
2472
|
+
result.unshift($1);
|
|
2473
|
+
return result;
|
|
2474
|
+
});
|
|
2475
|
+
function CaseExpressionList(state) {
|
|
2476
|
+
if (state.verbose)
|
|
2477
|
+
console.log("ENTER:", "CaseExpressionList");
|
|
2478
|
+
if (state.tokenize) {
|
|
2479
|
+
return $TOKEN("CaseExpressionList", state, CaseExpressionList$0(state));
|
|
2480
|
+
} else {
|
|
2481
|
+
return CaseExpressionList$0(state);
|
|
2482
|
+
}
|
|
2483
|
+
}
|
|
2470
2484
|
var ImpliedColon$0 = $S(__, Colon);
|
|
2471
2485
|
var ImpliedColon$1 = $TV($EXPECT($L1, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
2472
2486
|
return { $loc, token: ":" };
|
|
@@ -2514,7 +2528,7 @@ var Civet = (() => {
|
|
|
2514
2528
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2515
2529
|
}
|
|
2516
2530
|
}
|
|
2517
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2531
|
+
var Finally$0 = $S(__, $EXPECT($L76, fail, 'Finally "finally"'), BracedBlock);
|
|
2518
2532
|
function Finally(state) {
|
|
2519
2533
|
if (state.verbose)
|
|
2520
2534
|
console.log("ENTER:", "Finally");
|
|
@@ -2542,7 +2556,7 @@ var Civet = (() => {
|
|
|
2542
2556
|
return Condition$0(state) || Condition$1(state);
|
|
2543
2557
|
}
|
|
2544
2558
|
}
|
|
2545
|
-
var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(
|
|
2559
|
+
var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(AssignmentExpression)), function($skip, $loc, $0, $1, $2) {
|
|
2546
2560
|
var exp = $2;
|
|
2547
2561
|
module.suppressIndentedApplication = false;
|
|
2548
2562
|
if (exp)
|
|
@@ -2580,11 +2594,11 @@ var Civet = (() => {
|
|
|
2580
2594
|
return ExpressionStatement$0(state);
|
|
2581
2595
|
}
|
|
2582
2596
|
}
|
|
2583
|
-
var KeywordStatement$0 = $S($EXPECT($
|
|
2584
|
-
var KeywordStatement$1 = $S($EXPECT($
|
|
2585
|
-
var KeywordStatement$2 = $S($EXPECT($
|
|
2597
|
+
var KeywordStatement$0 = $S($EXPECT($L77, fail, 'KeywordStatement "break"'), NonIdContinue);
|
|
2598
|
+
var KeywordStatement$1 = $S($EXPECT($L78, fail, 'KeywordStatement "continue"'), NonIdContinue);
|
|
2599
|
+
var KeywordStatement$2 = $S($EXPECT($L79, fail, 'KeywordStatement "debugger"'), NonIdContinue);
|
|
2586
2600
|
var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
|
|
2587
|
-
var KeywordStatement$4 = $S($EXPECT($
|
|
2601
|
+
var KeywordStatement$4 = $S($EXPECT($L80, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
|
|
2588
2602
|
function KeywordStatement(state) {
|
|
2589
2603
|
if (state.tokenize) {
|
|
2590
2604
|
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
|
|
@@ -2601,7 +2615,7 @@ var Civet = (() => {
|
|
|
2601
2615
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2602
2616
|
}
|
|
2603
2617
|
}
|
|
2604
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2618
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L81, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2605
2619
|
return { "ts": true, "children": value };
|
|
2606
2620
|
});
|
|
2607
2621
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
@@ -2646,7 +2660,7 @@ var Civet = (() => {
|
|
|
2646
2660
|
return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
|
|
2647
2661
|
}
|
|
2648
2662
|
}
|
|
2649
|
-
var NameSpaceImport$0 = $S(
|
|
2663
|
+
var NameSpaceImport$0 = $S(Star, __, As, NonIdContinue, __, ImportedBinding);
|
|
2650
2664
|
function NameSpaceImport(state) {
|
|
2651
2665
|
if (state.verbose)
|
|
2652
2666
|
console.log("ENTER:", "NameSpaceImport");
|
|
@@ -2707,7 +2721,7 @@ var Civet = (() => {
|
|
|
2707
2721
|
return ModuleSpecifier$0(state);
|
|
2708
2722
|
}
|
|
2709
2723
|
}
|
|
2710
|
-
var UnprocessedModuleSpecifier$0 =
|
|
2724
|
+
var UnprocessedModuleSpecifier$0 = BasicStringLiteral;
|
|
2711
2725
|
var UnprocessedModuleSpecifier$1 = UnquotedSpecifier;
|
|
2712
2726
|
function UnprocessedModuleSpecifier(state) {
|
|
2713
2727
|
if (state.tokenize) {
|
|
@@ -2739,7 +2753,7 @@ var Civet = (() => {
|
|
|
2739
2753
|
return ImportedBinding$0(state);
|
|
2740
2754
|
}
|
|
2741
2755
|
}
|
|
2742
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
2756
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L82, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2743
2757
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
2744
2758
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
2745
2759
|
function ExportDeclaration(state) {
|
|
@@ -2749,7 +2763,7 @@ var Civet = (() => {
|
|
|
2749
2763
|
return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
|
|
2750
2764
|
}
|
|
2751
2765
|
}
|
|
2752
|
-
var ExportFromClause$0 = $S(
|
|
2766
|
+
var ExportFromClause$0 = $S(Star, $E($S(__, As, NonIdContinue, __, ModuleExportName)));
|
|
2753
2767
|
var ExportFromClause$1 = NamedExports;
|
|
2754
2768
|
function ExportFromClause(state) {
|
|
2755
2769
|
if (state.tokenize) {
|
|
@@ -2816,7 +2830,7 @@ var Civet = (() => {
|
|
|
2816
2830
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
2817
2831
|
}
|
|
2818
2832
|
}
|
|
2819
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
2833
|
+
var ConstAssignment$0 = $TV($EXPECT($L83, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
2820
2834
|
return { $loc, token: "=" };
|
|
2821
2835
|
});
|
|
2822
2836
|
function ConstAssignment(state) {
|
|
@@ -2959,37 +2973,57 @@ var Civet = (() => {
|
|
|
2959
2973
|
var e = $3;
|
|
2960
2974
|
return [s, module.dedentBlockString(str), e];
|
|
2961
2975
|
});
|
|
2962
|
-
var StringLiteral$2 =
|
|
2963
|
-
|
|
2976
|
+
var StringLiteral$2 = BasicStringLiteral;
|
|
2977
|
+
function StringLiteral(state) {
|
|
2978
|
+
if (state.tokenize) {
|
|
2979
|
+
return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state));
|
|
2980
|
+
} else {
|
|
2981
|
+
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
|
|
2982
|
+
}
|
|
2983
|
+
}
|
|
2984
|
+
var BasicStringLiteral$0 = $TS($S(DoubleQuote, DoubleStringCharacters, DoubleQuote), function($skip, $loc, $0, $1, $2, $3) {
|
|
2985
|
+
var str = $2;
|
|
2986
|
+
return {
|
|
2987
|
+
token: `"${module.modifyString(str.token)}"`,
|
|
2988
|
+
$loc
|
|
2989
|
+
};
|
|
2964
2990
|
});
|
|
2965
|
-
var
|
|
2966
|
-
|
|
2991
|
+
var BasicStringLiteral$1 = $TS($S(SingleQuote, SingleStringCharacters, SingleQuote), function($skip, $loc, $0, $1, $2, $3) {
|
|
2992
|
+
var str = $2;
|
|
2993
|
+
return {
|
|
2994
|
+
token: `'${module.modifyString(str.token)}'`,
|
|
2995
|
+
$loc
|
|
2996
|
+
};
|
|
2967
2997
|
});
|
|
2968
|
-
function
|
|
2998
|
+
function BasicStringLiteral(state) {
|
|
2969
2999
|
if (state.tokenize) {
|
|
2970
|
-
return $TOKEN("
|
|
3000
|
+
return $TOKEN("BasicStringLiteral", state, BasicStringLiteral$0(state) || BasicStringLiteral$1(state));
|
|
2971
3001
|
} else {
|
|
2972
|
-
return
|
|
3002
|
+
return BasicStringLiteral$0(state) || BasicStringLiteral$1(state);
|
|
2973
3003
|
}
|
|
2974
3004
|
}
|
|
2975
|
-
var
|
|
2976
|
-
|
|
3005
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R9, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3006
|
+
return { $loc, token: $0 };
|
|
3007
|
+
});
|
|
3008
|
+
function DoubleStringCharacters(state) {
|
|
2977
3009
|
if (state.verbose)
|
|
2978
|
-
console.log("ENTER:", "
|
|
3010
|
+
console.log("ENTER:", "DoubleStringCharacters");
|
|
2979
3011
|
if (state.tokenize) {
|
|
2980
|
-
return $TOKEN("
|
|
3012
|
+
return $TOKEN("DoubleStringCharacters", state, DoubleStringCharacters$0(state));
|
|
2981
3013
|
} else {
|
|
2982
|
-
return
|
|
3014
|
+
return DoubleStringCharacters$0(state);
|
|
2983
3015
|
}
|
|
2984
3016
|
}
|
|
2985
|
-
var
|
|
2986
|
-
|
|
3017
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R10, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3018
|
+
return { $loc, token: $0 };
|
|
3019
|
+
});
|
|
3020
|
+
function SingleStringCharacters(state) {
|
|
2987
3021
|
if (state.verbose)
|
|
2988
|
-
console.log("ENTER:", "
|
|
3022
|
+
console.log("ENTER:", "SingleStringCharacters");
|
|
2989
3023
|
if (state.tokenize) {
|
|
2990
|
-
return $TOKEN("
|
|
3024
|
+
return $TOKEN("SingleStringCharacters", state, SingleStringCharacters$0(state));
|
|
2991
3025
|
} else {
|
|
2992
|
-
return
|
|
3026
|
+
return SingleStringCharacters$0(state);
|
|
2993
3027
|
}
|
|
2994
3028
|
}
|
|
2995
3029
|
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R11, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
@@ -3026,19 +3060,7 @@ var Civet = (() => {
|
|
|
3026
3060
|
return CoffeeStringSubstitution$0(state);
|
|
3027
3061
|
}
|
|
3028
3062
|
}
|
|
3029
|
-
var
|
|
3030
|
-
return { $loc, token: "${" };
|
|
3031
|
-
});
|
|
3032
|
-
function CoffeeSubstitutionStart(state) {
|
|
3033
|
-
if (state.verbose)
|
|
3034
|
-
console.log("ENTER:", "CoffeeSubstitutionStart");
|
|
3035
|
-
if (state.tokenize) {
|
|
3036
|
-
return $TOKEN("CoffeeSubstitutionStart", state, CoffeeSubstitutionStart$0(state));
|
|
3037
|
-
} else {
|
|
3038
|
-
return CoffeeSubstitutionStart$0(state);
|
|
3039
|
-
}
|
|
3040
|
-
}
|
|
3041
|
-
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L45, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L45, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
3063
|
+
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L44, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L44, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
3042
3064
|
return { $loc, token: $1 };
|
|
3043
3065
|
});
|
|
3044
3066
|
function RegularExpressionLiteral(state) {
|
|
@@ -3091,7 +3113,7 @@ var Civet = (() => {
|
|
|
3091
3113
|
return TemplateLiteral$0(state) || TemplateLiteral$1(state);
|
|
3092
3114
|
}
|
|
3093
3115
|
}
|
|
3094
|
-
var TemplateSubstitution$0 = $S(
|
|
3116
|
+
var TemplateSubstitution$0 = $S(SubstitutionStart, Expression, __, CloseBrace);
|
|
3095
3117
|
function TemplateSubstitution(state) {
|
|
3096
3118
|
if (state.verbose)
|
|
3097
3119
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -3164,7 +3186,7 @@ var Civet = (() => {
|
|
|
3164
3186
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
3165
3187
|
}
|
|
3166
3188
|
}
|
|
3167
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
3189
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L85, fail, 'JSMultiLineComment "*/"')), $EXPECT($R20, fail, "JSMultiLineComment /./"))), $EXPECT($L85, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
3168
3190
|
return { $loc, token: $1 };
|
|
3169
3191
|
});
|
|
3170
3192
|
function JSMultiLineComment(state) {
|
|
@@ -3190,7 +3212,7 @@ var Civet = (() => {
|
|
|
3190
3212
|
return CoffeeSingleLineComment$0(state);
|
|
3191
3213
|
}
|
|
3192
3214
|
}
|
|
3193
|
-
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($
|
|
3215
|
+
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L85, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R20, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L86, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3194
3216
|
return { $loc, token: `/*${$2}*/` };
|
|
3195
3217
|
});
|
|
3196
3218
|
function CoffeeMultiLineComment(state) {
|
|
@@ -3202,7 +3224,7 @@ var Civet = (() => {
|
|
|
3202
3224
|
return CoffeeMultiLineComment$0(state);
|
|
3203
3225
|
}
|
|
3204
3226
|
}
|
|
3205
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
3227
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L85, fail, 'InlineComment "*/"')), $EXPECT($R22, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L85, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
3206
3228
|
return { $loc, token: $1 };
|
|
3207
3229
|
});
|
|
3208
3230
|
function InlineComment(state) {
|
|
@@ -3214,7 +3236,7 @@ var Civet = (() => {
|
|
|
3214
3236
|
return InlineComment$0(state);
|
|
3215
3237
|
}
|
|
3216
3238
|
}
|
|
3217
|
-
var RestOfLine$0 = $S($Q($C(
|
|
3239
|
+
var RestOfLine$0 = $S($Q($C(NonNewlineWhitespace, SingleLineComment, MultiLineComment)), EOL);
|
|
3218
3240
|
function RestOfLine(state) {
|
|
3219
3241
|
if (state.verbose)
|
|
3220
3242
|
console.log("ENTER:", "RestOfLine");
|
|
@@ -3224,7 +3246,7 @@ var Civet = (() => {
|
|
|
3224
3246
|
return RestOfLine$0(state);
|
|
3225
3247
|
}
|
|
3226
3248
|
}
|
|
3227
|
-
var TrailingComment$0 =
|
|
3249
|
+
var TrailingComment$0 = NonNewlineWhitespace;
|
|
3228
3250
|
var TrailingComment$1 = InlineComment;
|
|
3229
3251
|
var TrailingComment$2 = SingleLineComment;
|
|
3230
3252
|
function TrailingComment(state) {
|
|
@@ -3266,7 +3288,7 @@ var Civet = (() => {
|
|
|
3266
3288
|
return __$0(state);
|
|
3267
3289
|
}
|
|
3268
3290
|
}
|
|
3269
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
3291
|
+
var Whitespace$0 = $TR($EXPECT($R24, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3270
3292
|
return { $loc, token: $0 };
|
|
3271
3293
|
});
|
|
3272
3294
|
function Whitespace(state) {
|
|
@@ -3289,7 +3311,7 @@ var Civet = (() => {
|
|
|
3289
3311
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
3290
3312
|
}
|
|
3291
3313
|
}
|
|
3292
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3314
|
+
var NonIdContinue$0 = $R$0($EXPECT($R25, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
3293
3315
|
function NonIdContinue(state) {
|
|
3294
3316
|
if (state.verbose)
|
|
3295
3317
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -3311,7 +3333,7 @@ var Civet = (() => {
|
|
|
3311
3333
|
return Loc$0(state);
|
|
3312
3334
|
}
|
|
3313
3335
|
}
|
|
3314
|
-
var As$0 = $TS($S($EXPECT($
|
|
3336
|
+
var As$0 = $TS($S($EXPECT($L87, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3315
3337
|
return { $loc, token: $1 };
|
|
3316
3338
|
});
|
|
3317
3339
|
function As(state) {
|
|
@@ -3323,7 +3345,7 @@ var Civet = (() => {
|
|
|
3323
3345
|
return As$0(state);
|
|
3324
3346
|
}
|
|
3325
3347
|
}
|
|
3326
|
-
var Async$0 = $TV($EXPECT($
|
|
3348
|
+
var Async$0 = $TV($EXPECT($L88, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
|
|
3327
3349
|
return { $loc, token: $1 };
|
|
3328
3350
|
});
|
|
3329
3351
|
function Async(state) {
|
|
@@ -3335,7 +3357,7 @@ var Civet = (() => {
|
|
|
3335
3357
|
return Async$0(state);
|
|
3336
3358
|
}
|
|
3337
3359
|
}
|
|
3338
|
-
var Await$0 = $TS($S($EXPECT($
|
|
3360
|
+
var Await$0 = $TS($S($EXPECT($L89, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3339
3361
|
return { $loc, token: $1 };
|
|
3340
3362
|
});
|
|
3341
3363
|
function Await(state) {
|
|
@@ -3347,7 +3369,19 @@ var Civet = (() => {
|
|
|
3347
3369
|
return Await$0(state);
|
|
3348
3370
|
}
|
|
3349
3371
|
}
|
|
3350
|
-
var
|
|
3372
|
+
var Case$0 = $TS($S($EXPECT($L90, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3373
|
+
return { $loc, token: $1 };
|
|
3374
|
+
});
|
|
3375
|
+
function Case(state) {
|
|
3376
|
+
if (state.verbose)
|
|
3377
|
+
console.log("ENTER:", "Case");
|
|
3378
|
+
if (state.tokenize) {
|
|
3379
|
+
return $TOKEN("Case", state, Case$0(state));
|
|
3380
|
+
} else {
|
|
3381
|
+
return Case$0(state);
|
|
3382
|
+
}
|
|
3383
|
+
}
|
|
3384
|
+
var Catch$0 = $TV($EXPECT($L91, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
3351
3385
|
return { $loc, token: $1 };
|
|
3352
3386
|
});
|
|
3353
3387
|
function Catch(state) {
|
|
@@ -3359,7 +3393,7 @@ var Civet = (() => {
|
|
|
3359
3393
|
return Catch$0(state);
|
|
3360
3394
|
}
|
|
3361
3395
|
}
|
|
3362
|
-
var Class$0 = $TV($EXPECT($
|
|
3396
|
+
var Class$0 = $TV($EXPECT($L92, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
3363
3397
|
return { $loc, token: $1 };
|
|
3364
3398
|
});
|
|
3365
3399
|
function Class(state) {
|
|
@@ -3371,7 +3405,7 @@ var Civet = (() => {
|
|
|
3371
3405
|
return Class$0(state);
|
|
3372
3406
|
}
|
|
3373
3407
|
}
|
|
3374
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
3408
|
+
var CloseBrace$0 = $TV($EXPECT($L24, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
3375
3409
|
return { $loc, token: $1 };
|
|
3376
3410
|
});
|
|
3377
3411
|
function CloseBrace(state) {
|
|
@@ -3383,7 +3417,7 @@ var Civet = (() => {
|
|
|
3383
3417
|
return CloseBrace$0(state);
|
|
3384
3418
|
}
|
|
3385
3419
|
}
|
|
3386
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
3420
|
+
var CloseBracket$0 = $TV($EXPECT($L23, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
3387
3421
|
return { $loc, token: $1 };
|
|
3388
3422
|
});
|
|
3389
3423
|
function CloseBracket(state) {
|
|
@@ -3395,7 +3429,7 @@ var Civet = (() => {
|
|
|
3395
3429
|
return CloseBracket$0(state);
|
|
3396
3430
|
}
|
|
3397
3431
|
}
|
|
3398
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
3432
|
+
var CloseParen$0 = $TV($EXPECT($L16, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
3399
3433
|
return { $loc, token: $1 };
|
|
3400
3434
|
});
|
|
3401
3435
|
function CloseParen(state) {
|
|
@@ -3407,7 +3441,19 @@ var Civet = (() => {
|
|
|
3407
3441
|
return CloseParen$0(state);
|
|
3408
3442
|
}
|
|
3409
3443
|
}
|
|
3410
|
-
var
|
|
3444
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L93, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
3445
|
+
return { $loc, token: "${" };
|
|
3446
|
+
});
|
|
3447
|
+
function CoffeeSubstitutionStart(state) {
|
|
3448
|
+
if (state.verbose)
|
|
3449
|
+
console.log("ENTER:", "CoffeeSubstitutionStart");
|
|
3450
|
+
if (state.tokenize) {
|
|
3451
|
+
return $TOKEN("CoffeeSubstitutionStart", state, CoffeeSubstitutionStart$0(state));
|
|
3452
|
+
} else {
|
|
3453
|
+
return CoffeeSubstitutionStart$0(state);
|
|
3454
|
+
}
|
|
3455
|
+
}
|
|
3456
|
+
var Colon$0 = $TV($EXPECT($L94, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
3411
3457
|
return { $loc, token: $1 };
|
|
3412
3458
|
});
|
|
3413
3459
|
function Colon(state) {
|
|
@@ -3419,7 +3465,31 @@ var Civet = (() => {
|
|
|
3419
3465
|
return Colon$0(state);
|
|
3420
3466
|
}
|
|
3421
3467
|
}
|
|
3422
|
-
var
|
|
3468
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L9, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
3469
|
+
return { $loc, token: "constructor" };
|
|
3470
|
+
});
|
|
3471
|
+
function ConstructorShorthand(state) {
|
|
3472
|
+
if (state.verbose)
|
|
3473
|
+
console.log("ENTER:", "ConstructorShorthand");
|
|
3474
|
+
if (state.tokenize) {
|
|
3475
|
+
return $TOKEN("ConstructorShorthand", state, ConstructorShorthand$0(state));
|
|
3476
|
+
} else {
|
|
3477
|
+
return ConstructorShorthand$0(state);
|
|
3478
|
+
}
|
|
3479
|
+
}
|
|
3480
|
+
var Default$0 = $TS($S($EXPECT($L82, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3481
|
+
return { $loc, token: $1 };
|
|
3482
|
+
});
|
|
3483
|
+
function Default(state) {
|
|
3484
|
+
if (state.verbose)
|
|
3485
|
+
console.log("ENTER:", "Default");
|
|
3486
|
+
if (state.tokenize) {
|
|
3487
|
+
return $TOKEN("Default", state, Default$0(state));
|
|
3488
|
+
} else {
|
|
3489
|
+
return Default$0(state);
|
|
3490
|
+
}
|
|
3491
|
+
}
|
|
3492
|
+
var Dot$0 = $TV($EXPECT($L95, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
3423
3493
|
return { $loc, token: $1 };
|
|
3424
3494
|
});
|
|
3425
3495
|
function Dot(state) {
|
|
@@ -3431,7 +3501,19 @@ var Civet = (() => {
|
|
|
3431
3501
|
return Dot$0(state);
|
|
3432
3502
|
}
|
|
3433
3503
|
}
|
|
3434
|
-
var
|
|
3504
|
+
var DoubleQuote$0 = $TV($EXPECT($L96, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
3505
|
+
return { $loc, token: $1 };
|
|
3506
|
+
});
|
|
3507
|
+
function DoubleQuote(state) {
|
|
3508
|
+
if (state.verbose)
|
|
3509
|
+
console.log("ENTER:", "DoubleQuote");
|
|
3510
|
+
if (state.tokenize) {
|
|
3511
|
+
return $TOKEN("DoubleQuote", state, DoubleQuote$0(state));
|
|
3512
|
+
} else {
|
|
3513
|
+
return DoubleQuote$0(state);
|
|
3514
|
+
}
|
|
3515
|
+
}
|
|
3516
|
+
var Else$0 = $TV($EXPECT($L97, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
3435
3517
|
return { $loc, token: $1 };
|
|
3436
3518
|
});
|
|
3437
3519
|
function Else(state) {
|
|
@@ -3443,7 +3525,7 @@ var Civet = (() => {
|
|
|
3443
3525
|
return Else$0(state);
|
|
3444
3526
|
}
|
|
3445
3527
|
}
|
|
3446
|
-
var Equals$0 = $TV($EXPECT($
|
|
3528
|
+
var Equals$0 = $TV($EXPECT($L41, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
3447
3529
|
return { $loc, token: $1 };
|
|
3448
3530
|
});
|
|
3449
3531
|
function Equals(state) {
|
|
@@ -3455,7 +3537,7 @@ var Civet = (() => {
|
|
|
3455
3537
|
return Equals$0(state);
|
|
3456
3538
|
}
|
|
3457
3539
|
}
|
|
3458
|
-
var Export$0 = $TS($S($EXPECT($
|
|
3540
|
+
var Export$0 = $TS($S($EXPECT($L98, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3459
3541
|
return { $loc, token: $1 };
|
|
3460
3542
|
});
|
|
3461
3543
|
function Export(state) {
|
|
@@ -3467,7 +3549,7 @@ var Civet = (() => {
|
|
|
3467
3549
|
return Export$0(state);
|
|
3468
3550
|
}
|
|
3469
3551
|
}
|
|
3470
|
-
var For$0 = $TS($S($EXPECT($
|
|
3552
|
+
var For$0 = $TS($S($EXPECT($L99, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3471
3553
|
return { $loc, token: $1 };
|
|
3472
3554
|
});
|
|
3473
3555
|
function For(state) {
|
|
@@ -3479,7 +3561,7 @@ var Civet = (() => {
|
|
|
3479
3561
|
return For$0(state);
|
|
3480
3562
|
}
|
|
3481
3563
|
}
|
|
3482
|
-
var From$0 = $TS($S($EXPECT($
|
|
3564
|
+
var From$0 = $TS($S($EXPECT($L100, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3483
3565
|
return { $loc, token: $1 };
|
|
3484
3566
|
});
|
|
3485
3567
|
function From(state) {
|
|
@@ -3491,7 +3573,7 @@ var Civet = (() => {
|
|
|
3491
3573
|
return From$0(state);
|
|
3492
3574
|
}
|
|
3493
3575
|
}
|
|
3494
|
-
var Function$0 = $TV($EXPECT($
|
|
3576
|
+
var Function$0 = $TV($EXPECT($L101, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
3495
3577
|
return { $loc, token: $1 };
|
|
3496
3578
|
});
|
|
3497
3579
|
function Function(state) {
|
|
@@ -3503,7 +3585,7 @@ var Civet = (() => {
|
|
|
3503
3585
|
return Function$0(state);
|
|
3504
3586
|
}
|
|
3505
3587
|
}
|
|
3506
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
3588
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L102, fail, 'GetOrSet "get"'), $EXPECT($L103, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3507
3589
|
return { $loc, token: $1 };
|
|
3508
3590
|
});
|
|
3509
3591
|
function GetOrSet(state) {
|
|
@@ -3515,7 +3597,7 @@ var Civet = (() => {
|
|
|
3515
3597
|
return GetOrSet$0(state);
|
|
3516
3598
|
}
|
|
3517
3599
|
}
|
|
3518
|
-
var If$0 = $TV($EXPECT($
|
|
3600
|
+
var If$0 = $TV($EXPECT($L104, fail, 'If "if"'), function($skip, $loc, $0, $1) {
|
|
3519
3601
|
return { $loc, token: $1 };
|
|
3520
3602
|
});
|
|
3521
3603
|
function If(state) {
|
|
@@ -3527,7 +3609,7 @@ var Civet = (() => {
|
|
|
3527
3609
|
return If$0(state);
|
|
3528
3610
|
}
|
|
3529
3611
|
}
|
|
3530
|
-
var Import$0 = $TS($S($EXPECT($
|
|
3612
|
+
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R26, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
3531
3613
|
return { $loc, token: $1 };
|
|
3532
3614
|
});
|
|
3533
3615
|
function Import(state) {
|
|
@@ -3539,7 +3621,7 @@ var Civet = (() => {
|
|
|
3539
3621
|
return Import$0(state);
|
|
3540
3622
|
}
|
|
3541
3623
|
}
|
|
3542
|
-
var In$0 = $TV($EXPECT($
|
|
3624
|
+
var In$0 = $TV($EXPECT($L65, fail, 'In "in"'), function($skip, $loc, $0, $1) {
|
|
3543
3625
|
return { $loc, token: $1 };
|
|
3544
3626
|
});
|
|
3545
3627
|
function In(state) {
|
|
@@ -3551,7 +3633,7 @@ var Civet = (() => {
|
|
|
3551
3633
|
return In$0(state);
|
|
3552
3634
|
}
|
|
3553
3635
|
}
|
|
3554
|
-
var LetOrConst$0 = $TV($C($EXPECT($
|
|
3636
|
+
var LetOrConst$0 = $TV($C($EXPECT($L105, fail, 'LetOrConst "let"'), $EXPECT($L106, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
3555
3637
|
return { $loc, token: $1 };
|
|
3556
3638
|
});
|
|
3557
3639
|
function LetOrConst(state) {
|
|
@@ -3563,7 +3645,7 @@ var Civet = (() => {
|
|
|
3563
3645
|
return LetOrConst$0(state);
|
|
3564
3646
|
}
|
|
3565
3647
|
}
|
|
3566
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
3648
|
+
var Loop$0 = $TS($S($EXPECT($L107, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3567
3649
|
return { $loc, token: "while(true)" };
|
|
3568
3650
|
});
|
|
3569
3651
|
function Loop(state) {
|
|
@@ -3575,7 +3657,7 @@ var Civet = (() => {
|
|
|
3575
3657
|
return Loop$0(state);
|
|
3576
3658
|
}
|
|
3577
3659
|
}
|
|
3578
|
-
var New$0 = $TV($EXPECT($
|
|
3660
|
+
var New$0 = $TV($EXPECT($L108, fail, 'New "new"'), function($skip, $loc, $0, $1) {
|
|
3579
3661
|
return { $loc, token: $1 };
|
|
3580
3662
|
});
|
|
3581
3663
|
function New(state) {
|
|
@@ -3587,7 +3669,7 @@ var Civet = (() => {
|
|
|
3587
3669
|
return New$0(state);
|
|
3588
3670
|
}
|
|
3589
3671
|
}
|
|
3590
|
-
var Of$0 = $TV($EXPECT($
|
|
3672
|
+
var Of$0 = $TV($EXPECT($L109, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
3591
3673
|
return { $loc, token: $1 };
|
|
3592
3674
|
});
|
|
3593
3675
|
function Of(state) {
|
|
@@ -3599,7 +3681,7 @@ var Civet = (() => {
|
|
|
3599
3681
|
return Of$0(state);
|
|
3600
3682
|
}
|
|
3601
3683
|
}
|
|
3602
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
3684
|
+
var OpenBrace$0 = $TV($EXPECT($L110, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
3603
3685
|
return { $loc, token: $1 };
|
|
3604
3686
|
});
|
|
3605
3687
|
function OpenBrace(state) {
|
|
@@ -3611,7 +3693,7 @@ var Civet = (() => {
|
|
|
3611
3693
|
return OpenBrace$0(state);
|
|
3612
3694
|
}
|
|
3613
3695
|
}
|
|
3614
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
3696
|
+
var OpenBracket$0 = $TV($EXPECT($L111, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
3615
3697
|
return { $loc, token: $1 };
|
|
3616
3698
|
});
|
|
3617
3699
|
function OpenBracket(state) {
|
|
@@ -3623,7 +3705,7 @@ var Civet = (() => {
|
|
|
3623
3705
|
return OpenBracket$0(state);
|
|
3624
3706
|
}
|
|
3625
3707
|
}
|
|
3626
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
3708
|
+
var OpenParen$0 = $TV($EXPECT($L112, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
3627
3709
|
return { $loc, token: $1 };
|
|
3628
3710
|
});
|
|
3629
3711
|
function OpenParen(state) {
|
|
@@ -3635,7 +3717,7 @@ var Civet = (() => {
|
|
|
3635
3717
|
return OpenParen$0(state);
|
|
3636
3718
|
}
|
|
3637
3719
|
}
|
|
3638
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
3720
|
+
var QuestionMark$0 = $TV($EXPECT($L113, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
3639
3721
|
return { $loc, token: $1 };
|
|
3640
3722
|
});
|
|
3641
3723
|
function QuestionMark(state) {
|
|
@@ -3647,7 +3729,7 @@ var Civet = (() => {
|
|
|
3647
3729
|
return QuestionMark$0(state);
|
|
3648
3730
|
}
|
|
3649
3731
|
}
|
|
3650
|
-
var Return$0 = $TS($S($EXPECT($
|
|
3732
|
+
var Return$0 = $TS($S($EXPECT($L114, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3651
3733
|
return { $loc, token: $1 };
|
|
3652
3734
|
});
|
|
3653
3735
|
function Return(state) {
|
|
@@ -3659,7 +3741,7 @@ var Civet = (() => {
|
|
|
3659
3741
|
return Return$0(state);
|
|
3660
3742
|
}
|
|
3661
3743
|
}
|
|
3662
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
3744
|
+
var Semicolon$0 = $TV($EXPECT($L72, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
3663
3745
|
return { $loc, token: $1 };
|
|
3664
3746
|
});
|
|
3665
3747
|
function Semicolon(state) {
|
|
@@ -3671,10 +3753,34 @@ var Civet = (() => {
|
|
|
3671
3753
|
return Semicolon$0(state);
|
|
3672
3754
|
}
|
|
3673
3755
|
}
|
|
3674
|
-
var
|
|
3756
|
+
var SingleQuote$0 = $TV($EXPECT($L115, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
3675
3757
|
return { $loc, token: $1 };
|
|
3676
3758
|
});
|
|
3677
|
-
|
|
3759
|
+
function SingleQuote(state) {
|
|
3760
|
+
if (state.verbose)
|
|
3761
|
+
console.log("ENTER:", "SingleQuote");
|
|
3762
|
+
if (state.tokenize) {
|
|
3763
|
+
return $TOKEN("SingleQuote", state, SingleQuote$0(state));
|
|
3764
|
+
} else {
|
|
3765
|
+
return SingleQuote$0(state);
|
|
3766
|
+
}
|
|
3767
|
+
}
|
|
3768
|
+
var Star$0 = $TV($EXPECT($L43, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
3769
|
+
return { $loc, token: $1 };
|
|
3770
|
+
});
|
|
3771
|
+
function Star(state) {
|
|
3772
|
+
if (state.verbose)
|
|
3773
|
+
console.log("ENTER:", "Star");
|
|
3774
|
+
if (state.tokenize) {
|
|
3775
|
+
return $TOKEN("Star", state, Star$0(state));
|
|
3776
|
+
} else {
|
|
3777
|
+
return Star$0(state);
|
|
3778
|
+
}
|
|
3779
|
+
}
|
|
3780
|
+
var Static$0 = $TV($EXPECT($L116, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
3781
|
+
return { $loc, token: $1 };
|
|
3782
|
+
});
|
|
3783
|
+
var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L112, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
|
|
3678
3784
|
return { $loc, token: "static " };
|
|
3679
3785
|
});
|
|
3680
3786
|
function Static(state) {
|
|
@@ -3684,7 +3790,19 @@ var Civet = (() => {
|
|
|
3684
3790
|
return Static$0(state) || Static$1(state);
|
|
3685
3791
|
}
|
|
3686
3792
|
}
|
|
3687
|
-
var
|
|
3793
|
+
var SubstitutionStart$0 = $TV($EXPECT($L117, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
3794
|
+
return { $loc, token: $1 };
|
|
3795
|
+
});
|
|
3796
|
+
function SubstitutionStart(state) {
|
|
3797
|
+
if (state.verbose)
|
|
3798
|
+
console.log("ENTER:", "SubstitutionStart");
|
|
3799
|
+
if (state.tokenize) {
|
|
3800
|
+
return $TOKEN("SubstitutionStart", state, SubstitutionStart$0(state));
|
|
3801
|
+
} else {
|
|
3802
|
+
return SubstitutionStart$0(state);
|
|
3803
|
+
}
|
|
3804
|
+
}
|
|
3805
|
+
var Switch$0 = $TS($S($EXPECT($L118, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3688
3806
|
return { $loc, token: $1 };
|
|
3689
3807
|
});
|
|
3690
3808
|
function Switch(state) {
|
|
@@ -3696,7 +3814,7 @@ var Civet = (() => {
|
|
|
3696
3814
|
return Switch$0(state);
|
|
3697
3815
|
}
|
|
3698
3816
|
}
|
|
3699
|
-
var Target$0 = $TV($EXPECT($
|
|
3817
|
+
var Target$0 = $TV($EXPECT($L119, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
|
|
3700
3818
|
return { $loc, token: $1 };
|
|
3701
3819
|
});
|
|
3702
3820
|
function Target(state) {
|
|
@@ -3708,7 +3826,7 @@ var Civet = (() => {
|
|
|
3708
3826
|
return Target$0(state);
|
|
3709
3827
|
}
|
|
3710
3828
|
}
|
|
3711
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
3829
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L120, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
3712
3830
|
return { $loc, token: "`" };
|
|
3713
3831
|
});
|
|
3714
3832
|
function TripleDoubleQuote(state) {
|
|
@@ -3720,7 +3838,7 @@ var Civet = (() => {
|
|
|
3720
3838
|
return TripleDoubleQuote$0(state);
|
|
3721
3839
|
}
|
|
3722
3840
|
}
|
|
3723
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
3841
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L121, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
3724
3842
|
return { $loc, token: "`" };
|
|
3725
3843
|
});
|
|
3726
3844
|
function TripleSingleQuote(state) {
|
|
@@ -3732,7 +3850,7 @@ var Civet = (() => {
|
|
|
3732
3850
|
return TripleSingleQuote$0(state);
|
|
3733
3851
|
}
|
|
3734
3852
|
}
|
|
3735
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
3853
|
+
var TripleTick$0 = $TV($EXPECT($L122, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
3736
3854
|
return { $loc, token: "`" };
|
|
3737
3855
|
});
|
|
3738
3856
|
function TripleTick(state) {
|
|
@@ -3744,7 +3862,7 @@ var Civet = (() => {
|
|
|
3744
3862
|
return TripleTick$0(state);
|
|
3745
3863
|
}
|
|
3746
3864
|
}
|
|
3747
|
-
var Try$0 = $TV($EXPECT($
|
|
3865
|
+
var Try$0 = $TV($EXPECT($L123, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
3748
3866
|
return { $loc, token: $1 };
|
|
3749
3867
|
});
|
|
3750
3868
|
function Try(state) {
|
|
@@ -3756,7 +3874,7 @@ var Civet = (() => {
|
|
|
3756
3874
|
return Try$0(state);
|
|
3757
3875
|
}
|
|
3758
3876
|
}
|
|
3759
|
-
var Unless$0 = $TV($EXPECT($
|
|
3877
|
+
var Unless$0 = $TV($EXPECT($L124, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
3760
3878
|
return { $loc, token: $1 };
|
|
3761
3879
|
});
|
|
3762
3880
|
function Unless(state) {
|
|
@@ -3768,7 +3886,7 @@ var Civet = (() => {
|
|
|
3768
3886
|
return Unless$0(state);
|
|
3769
3887
|
}
|
|
3770
3888
|
}
|
|
3771
|
-
var Var$0 = $TV($EXPECT($
|
|
3889
|
+
var Var$0 = $TV($EXPECT($L125, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
3772
3890
|
return { $loc, token: $1 };
|
|
3773
3891
|
});
|
|
3774
3892
|
function Var(state) {
|
|
@@ -3780,7 +3898,7 @@ var Civet = (() => {
|
|
|
3780
3898
|
return Var$0(state);
|
|
3781
3899
|
}
|
|
3782
3900
|
}
|
|
3783
|
-
var When$0 = $TS($S($EXPECT($
|
|
3901
|
+
var When$0 = $TS($S($EXPECT($L126, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3784
3902
|
return { $loc, token: "case" };
|
|
3785
3903
|
});
|
|
3786
3904
|
function When(state) {
|
|
@@ -3792,6 +3910,18 @@ var Civet = (() => {
|
|
|
3792
3910
|
return When$0(state);
|
|
3793
3911
|
}
|
|
3794
3912
|
}
|
|
3913
|
+
var Yield$0 = $TS($S($EXPECT($L127, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3914
|
+
return { $loc, token: $1 };
|
|
3915
|
+
});
|
|
3916
|
+
function Yield(state) {
|
|
3917
|
+
if (state.verbose)
|
|
3918
|
+
console.log("ENTER:", "Yield");
|
|
3919
|
+
if (state.tokenize) {
|
|
3920
|
+
return $TOKEN("Yield", state, Yield$0(state));
|
|
3921
|
+
} else {
|
|
3922
|
+
return Yield$0(state);
|
|
3923
|
+
}
|
|
3924
|
+
}
|
|
3795
3925
|
var JSXElement$0 = JSXSelfClosingElement;
|
|
3796
3926
|
var JSXElement$1 = $TS($S(JSXOpeningElement, $Q(JSXChildren), __, JSXClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
3797
3927
|
if ($1[1] !== $4[2]) {
|
|
@@ -3806,7 +3936,7 @@ var Civet = (() => {
|
|
|
3806
3936
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
3807
3937
|
}
|
|
3808
3938
|
}
|
|
3809
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($
|
|
3939
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L128, fail, 'JSXSelfClosingElement "/>"'));
|
|
3810
3940
|
function JSXSelfClosingElement(state) {
|
|
3811
3941
|
if (state.verbose)
|
|
3812
3942
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -3816,7 +3946,7 @@ var Civet = (() => {
|
|
|
3816
3946
|
return JSXSelfClosingElement$0(state);
|
|
3817
3947
|
}
|
|
3818
3948
|
}
|
|
3819
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
3949
|
+
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L53, fail, 'JSXOpeningElement ">"'));
|
|
3820
3950
|
function JSXOpeningElement(state) {
|
|
3821
3951
|
if (state.verbose)
|
|
3822
3952
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -3826,7 +3956,7 @@ var Civet = (() => {
|
|
|
3826
3956
|
return JSXOpeningElement$0(state);
|
|
3827
3957
|
}
|
|
3828
3958
|
}
|
|
3829
|
-
var JSXClosingElement$0 = $S($EXPECT($L129, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($
|
|
3959
|
+
var JSXClosingElement$0 = $S($EXPECT($L129, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L53, fail, 'JSXClosingElement ">"'));
|
|
3830
3960
|
function JSXClosingElement(state) {
|
|
3831
3961
|
if (state.verbose)
|
|
3832
3962
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -3856,7 +3986,7 @@ var Civet = (() => {
|
|
|
3856
3986
|
return JSXElementName$0(state);
|
|
3857
3987
|
}
|
|
3858
3988
|
}
|
|
3859
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
3989
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R27, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
3860
3990
|
function JSXIdentifierName(state) {
|
|
3861
3991
|
if (state.verbose)
|
|
3862
3992
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -3876,7 +4006,7 @@ var Civet = (() => {
|
|
|
3876
4006
|
return JSXAttributes$0(state);
|
|
3877
4007
|
}
|
|
3878
4008
|
}
|
|
3879
|
-
var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($
|
|
4009
|
+
var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($L17, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, CloseBrace);
|
|
3880
4010
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
3881
4011
|
function JSXAttribute(state) {
|
|
3882
4012
|
if (state.tokenize) {
|
|
@@ -3905,8 +4035,8 @@ var Civet = (() => {
|
|
|
3905
4035
|
return JSXAttributeInitializer$0(state);
|
|
3906
4036
|
}
|
|
3907
4037
|
}
|
|
3908
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
3909
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
4038
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R28, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
4039
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R29, fail, "JSXAttributeValue /'[^']*'/"));
|
|
3910
4040
|
var JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
|
|
3911
4041
|
var JSXAttributeValue$3 = JSXElement;
|
|
3912
4042
|
var JSXAttributeValue$4 = JSXFragment;
|
|
@@ -3938,7 +4068,7 @@ var Civet = (() => {
|
|
|
3938
4068
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
3939
4069
|
}
|
|
3940
4070
|
}
|
|
3941
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
4071
|
+
var JSXText$0 = $R$0($EXPECT($R30, fail, "JSXText /[^{}<>]+/"));
|
|
3942
4072
|
function JSXText(state) {
|
|
3943
4073
|
if (state.verbose)
|
|
3944
4074
|
console.log("ENTER:", "JSXText");
|
|
@@ -3948,7 +4078,7 @@ var Civet = (() => {
|
|
|
3948
4078
|
return JSXText$0(state);
|
|
3949
4079
|
}
|
|
3950
4080
|
}
|
|
3951
|
-
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($
|
|
4081
|
+
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L17, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
|
|
3952
4082
|
function JSXChildExpression(state) {
|
|
3953
4083
|
if (state.verbose)
|
|
3954
4084
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -4113,7 +4243,7 @@ var Civet = (() => {
|
|
|
4113
4243
|
return NestedTypeDeclaration$0(state);
|
|
4114
4244
|
}
|
|
4115
4245
|
}
|
|
4116
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
4246
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L136, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R32, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
4117
4247
|
function TypeIndexSignature(state) {
|
|
4118
4248
|
if (state.verbose)
|
|
4119
4249
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -4156,7 +4286,7 @@ var Civet = (() => {
|
|
|
4156
4286
|
return ReturnTypeSuffix$0(state);
|
|
4157
4287
|
}
|
|
4158
4288
|
}
|
|
4159
|
-
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($
|
|
4289
|
+
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L56, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
|
|
4160
4290
|
function TypePredicate(state) {
|
|
4161
4291
|
if (state.verbose)
|
|
4162
4292
|
console.log("ENTER:", "TypePredicate");
|
|
@@ -4207,7 +4337,7 @@ var Civet = (() => {
|
|
|
4207
4337
|
}
|
|
4208
4338
|
}
|
|
4209
4339
|
var TypeUnaryOp$0 = $EXPECT($L138, fail, 'TypeUnaryOp "keyof"');
|
|
4210
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
4340
|
+
var TypeUnaryOp$1 = $EXPECT($L71, fail, 'TypeUnaryOp "typeof"');
|
|
4211
4341
|
var TypeUnaryOp$2 = $EXPECT($L139, fail, 'TypeUnaryOp "infer"');
|
|
4212
4342
|
function TypeUnaryOp(state) {
|
|
4213
4343
|
if (state.tokenize) {
|
|
@@ -4238,7 +4368,7 @@ var Civet = (() => {
|
|
|
4238
4368
|
return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
|
|
4239
4369
|
}
|
|
4240
4370
|
}
|
|
4241
|
-
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($
|
|
4371
|
+
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type)))));
|
|
4242
4372
|
function TypeConditional(state) {
|
|
4243
4373
|
if (state.verbose)
|
|
4244
4374
|
console.log("ENTER:", "TypeConditional");
|
|
@@ -4249,7 +4379,7 @@ var Civet = (() => {
|
|
|
4249
4379
|
}
|
|
4250
4380
|
}
|
|
4251
4381
|
var TypeLiteral$0 = Literal;
|
|
4252
|
-
var TypeLiteral$1 = $EXPECT($
|
|
4382
|
+
var TypeLiteral$1 = $EXPECT($L70, fail, 'TypeLiteral "void"');
|
|
4253
4383
|
var TypeLiteral$2 = $EXPECT($L140, fail, 'TypeLiteral "[]"');
|
|
4254
4384
|
function TypeLiteral(state) {
|
|
4255
4385
|
if (state.tokenize) {
|
|
@@ -4258,8 +4388,8 @@ var Civet = (() => {
|
|
|
4258
4388
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
4259
4389
|
}
|
|
4260
4390
|
}
|
|
4261
|
-
var TypeBinaryOp$0 = $EXPECT($
|
|
4262
|
-
var TypeBinaryOp$1 = $EXPECT($
|
|
4391
|
+
var TypeBinaryOp$0 = $EXPECT($L68, fail, 'TypeBinaryOp "|"');
|
|
4392
|
+
var TypeBinaryOp$1 = $EXPECT($L66, fail, 'TypeBinaryOp "&"');
|
|
4263
4393
|
function TypeBinaryOp(state) {
|
|
4264
4394
|
if (state.tokenize) {
|
|
4265
4395
|
return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
|
|
@@ -4267,7 +4397,7 @@ var Civet = (() => {
|
|
|
4267
4397
|
return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
|
|
4268
4398
|
}
|
|
4269
4399
|
}
|
|
4270
|
-
var FunctionType$0 = $S(Parameters, __, $EXPECT($
|
|
4400
|
+
var FunctionType$0 = $S(Parameters, __, $EXPECT($L4, fail, 'FunctionType "=>"'), Type);
|
|
4271
4401
|
function FunctionType(state) {
|
|
4272
4402
|
if (state.verbose)
|
|
4273
4403
|
console.log("ENTER:", "FunctionType");
|
|
@@ -4277,7 +4407,7 @@ var Civet = (() => {
|
|
|
4277
4407
|
return FunctionType$0(state);
|
|
4278
4408
|
}
|
|
4279
4409
|
}
|
|
4280
|
-
var TypeArguments$0 = $S(__, $EXPECT($
|
|
4410
|
+
var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L53, fail, 'TypeArguments ">"'));
|
|
4281
4411
|
function TypeArguments(state) {
|
|
4282
4412
|
if (state.verbose)
|
|
4283
4413
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -4287,7 +4417,7 @@ var Civet = (() => {
|
|
|
4287
4417
|
return TypeArguments$0(state);
|
|
4288
4418
|
}
|
|
4289
4419
|
}
|
|
4290
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
4420
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L53, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
4291
4421
|
return { ts: true, children: $0 };
|
|
4292
4422
|
});
|
|
4293
4423
|
function TypeParameters(state) {
|
|
@@ -4309,7 +4439,7 @@ var Civet = (() => {
|
|
|
4309
4439
|
return TypeParameter$0(state);
|
|
4310
4440
|
}
|
|
4311
4441
|
}
|
|
4312
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
4442
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L6, fail, 'TypeConstraint "extends"'), Type);
|
|
4313
4443
|
function TypeConstraint(state) {
|
|
4314
4444
|
if (state.verbose)
|
|
4315
4445
|
console.log("ENTER:", "TypeConstraint");
|
|
@@ -4320,8 +4450,8 @@ var Civet = (() => {
|
|
|
4320
4450
|
}
|
|
4321
4451
|
}
|
|
4322
4452
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
4323
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
4324
|
-
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($
|
|
4453
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L53, fail, 'TypeParameterDelimiter ">"')));
|
|
4454
|
+
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L53, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
|
|
4325
4455
|
return { $loc, token: "," };
|
|
4326
4456
|
});
|
|
4327
4457
|
var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
@@ -4334,7 +4464,7 @@ var Civet = (() => {
|
|
|
4334
4464
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
4335
4465
|
}
|
|
4336
4466
|
}
|
|
4337
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
4467
|
+
var Shebang$0 = $S($R$0($EXPECT($R33, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
4338
4468
|
function Shebang(state) {
|
|
4339
4469
|
if (state.verbose)
|
|
4340
4470
|
console.log("ENTER:", "Shebang");
|
|
@@ -4344,7 +4474,7 @@ var Civet = (() => {
|
|
|
4344
4474
|
return Shebang$0(state);
|
|
4345
4475
|
}
|
|
4346
4476
|
}
|
|
4347
|
-
var DirectivePrologue$0 = $Q($S($R$0($EXPECT($
|
|
4477
|
+
var DirectivePrologue$0 = $Q($S($R$0($EXPECT($R34, fail, "DirectivePrologue /[\\t ]*/")), StringLiteral, $TEXT(StatementDelimiter), EOS));
|
|
4348
4478
|
function DirectivePrologue(state) {
|
|
4349
4479
|
if (state.verbose)
|
|
4350
4480
|
console.log("ENTER:", "DirectivePrologue");
|
|
@@ -4364,7 +4494,7 @@ var Civet = (() => {
|
|
|
4364
4494
|
return EOS$0(state);
|
|
4365
4495
|
}
|
|
4366
4496
|
}
|
|
4367
|
-
var EOL$0 = $R$0($EXPECT($
|
|
4497
|
+
var EOL$0 = $R$0($EXPECT($R35, fail, "EOL /\\r\\n|\\n|\\r|$/"));
|
|
4368
4498
|
function EOL(state) {
|
|
4369
4499
|
if (state.verbose)
|
|
4370
4500
|
console.log("ENTER:", "EOL");
|
|
@@ -4374,7 +4504,7 @@ var Civet = (() => {
|
|
|
4374
4504
|
return EOL$0(state);
|
|
4375
4505
|
}
|
|
4376
4506
|
}
|
|
4377
|
-
var EOF$0 = $R$0($EXPECT($
|
|
4507
|
+
var EOF$0 = $R$0($EXPECT($R36, fail, "EOF /$/"));
|
|
4378
4508
|
function EOF(state) {
|
|
4379
4509
|
if (state.verbose)
|
|
4380
4510
|
console.log("ENTER:", "EOF");
|
|
@@ -4544,6 +4674,19 @@ var Civet = (() => {
|
|
|
4544
4674
|
s = s.slice(1, s.indexOf("Program") + 1);
|
|
4545
4675
|
return s;
|
|
4546
4676
|
};
|
|
4677
|
+
module.insertTrimmingSpace = function(spacing, c) {
|
|
4678
|
+
let target = spacing;
|
|
4679
|
+
while (Array.isArray(target)) {
|
|
4680
|
+
target = target[0];
|
|
4681
|
+
}
|
|
4682
|
+
if (target.token) {
|
|
4683
|
+
target.token = target.token.replace(/^ ?/, c);
|
|
4684
|
+
}
|
|
4685
|
+
return spacing;
|
|
4686
|
+
};
|
|
4687
|
+
module.modifyString = function(str) {
|
|
4688
|
+
return str.replace(/(?<!\\)(\\\\)*\n/g, "$1\\n");
|
|
4689
|
+
};
|
|
4547
4690
|
module.dedentBlockSubstitutions = function($02) {
|
|
4548
4691
|
const [s, strWithSubstitutions, e] = $02;
|
|
4549
4692
|
if (strWithSubstitutions.length === 0) {
|