@danielx/civet 0.4.12 → 0.4.14
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 +18 -10
- package/dist/browser.js +648 -493
- package/dist/esbuild-plugin.js +7 -1
- package/dist/esm.mjs +2 -2
- package/dist/main.js +648 -493
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -520,18 +520,23 @@ var Civet = (() => {
|
|
|
520
520
|
UnaryOp,
|
|
521
521
|
ModuleItem,
|
|
522
522
|
StatementListItem,
|
|
523
|
-
|
|
523
|
+
PostfixStatement,
|
|
524
524
|
Statement,
|
|
525
525
|
EmptyStatement,
|
|
526
526
|
BlockStatement,
|
|
527
527
|
IfStatement,
|
|
528
|
+
IfClause,
|
|
529
|
+
UnlessClause,
|
|
528
530
|
IterationStatement,
|
|
529
531
|
LoopStatement,
|
|
532
|
+
LoopClause,
|
|
530
533
|
DoWhileStatement,
|
|
531
534
|
WhileStatement,
|
|
532
535
|
WhileClause,
|
|
533
536
|
ForStatement,
|
|
534
|
-
|
|
537
|
+
ForClause,
|
|
538
|
+
ForStatementControl,
|
|
539
|
+
ForInOfDeclaration,
|
|
535
540
|
ForDeclaration,
|
|
536
541
|
ForBinding,
|
|
537
542
|
SwitchStatement,
|
|
@@ -623,6 +628,7 @@ var Civet = (() => {
|
|
|
623
628
|
As,
|
|
624
629
|
Async,
|
|
625
630
|
Await,
|
|
631
|
+
Backtick,
|
|
626
632
|
Case,
|
|
627
633
|
Catch,
|
|
628
634
|
Class,
|
|
@@ -633,6 +639,8 @@ var Civet = (() => {
|
|
|
633
639
|
Colon,
|
|
634
640
|
ConstructorShorthand,
|
|
635
641
|
Default,
|
|
642
|
+
Delete,
|
|
643
|
+
Do,
|
|
636
644
|
Dot,
|
|
637
645
|
DotDotDot,
|
|
638
646
|
DoubleQuote,
|
|
@@ -667,9 +675,13 @@ var Civet = (() => {
|
|
|
667
675
|
TripleSingleQuote,
|
|
668
676
|
TripleTick,
|
|
669
677
|
Try,
|
|
678
|
+
Typeof,
|
|
670
679
|
Unless,
|
|
680
|
+
Until,
|
|
671
681
|
Var,
|
|
682
|
+
Void,
|
|
672
683
|
When,
|
|
684
|
+
While,
|
|
673
685
|
Yield,
|
|
674
686
|
JSXElement,
|
|
675
687
|
JSXSelfClosingElement,
|
|
@@ -734,7 +746,6 @@ var Civet = (() => {
|
|
|
734
746
|
DirectivePrologue,
|
|
735
747
|
EOS,
|
|
736
748
|
EOL,
|
|
737
|
-
EOF,
|
|
738
749
|
Debugger,
|
|
739
750
|
InsertOpenParen,
|
|
740
751
|
InsertCloseParen,
|
|
@@ -760,137 +771,137 @@ var Civet = (() => {
|
|
|
760
771
|
PopIndent,
|
|
761
772
|
Nested
|
|
762
773
|
});
|
|
763
|
-
var $L0 = $L("
|
|
764
|
-
var $L1 = $L("");
|
|
765
|
-
var $L2 = $L("
|
|
766
|
-
var $L3 = $L("
|
|
767
|
-
var $L4 = $L("
|
|
768
|
-
var $L5 = $L("
|
|
769
|
-
var $L6 = $L("
|
|
770
|
-
var $L7 = $L("
|
|
771
|
-
var $L8 = $L("
|
|
772
|
-
var $L9 = $L("
|
|
773
|
-
var $L10 = $L("
|
|
774
|
-
var $L11 = $L("
|
|
775
|
-
var $L12 = $L("
|
|
776
|
-
var $L13 = $L("
|
|
777
|
-
var $L14 = $L("
|
|
778
|
-
var $L15 = $L("
|
|
779
|
-
var $L16 = $L("
|
|
780
|
-
var $L17 = $L("
|
|
781
|
-
var $L18 = $L("
|
|
782
|
-
var $L19 = $L("
|
|
783
|
-
var $L20 = $L("
|
|
784
|
-
var $L21 = $L("
|
|
785
|
-
var $L22 = $L("
|
|
786
|
-
var $L23 = $L("
|
|
787
|
-
var $L24 = $L("
|
|
788
|
-
var $L25 = $L("
|
|
789
|
-
var $L26 = $L("
|
|
790
|
-
var $L27 = $L("
|
|
791
|
-
var $L28 = $L("
|
|
792
|
-
var $L29 = $L("
|
|
793
|
-
var $L30 = $L("
|
|
794
|
-
var $L31 = $L("
|
|
795
|
-
var $L32 = $L("
|
|
796
|
-
var $L33 = $L("
|
|
797
|
-
var $L34 = $L("
|
|
798
|
-
var $L35 = $L("
|
|
799
|
-
var $L36 = $L("
|
|
800
|
-
var $L37 = $L("
|
|
801
|
-
var $L38 = $L("
|
|
802
|
-
var $L39 = $L("
|
|
803
|
-
var $L40 = $L("
|
|
804
|
-
var $L41 = $L("
|
|
805
|
-
var $L42 = $L("
|
|
806
|
-
var $L43 = $L("
|
|
807
|
-
var $L44 = $L("
|
|
808
|
-
var $L45 = $L("
|
|
809
|
-
var $L46 = $L("
|
|
810
|
-
var $L47 = $L("
|
|
811
|
-
var $L48 = $L("
|
|
812
|
-
var $L49 = $L("
|
|
813
|
-
var $L50 = $L("
|
|
814
|
-
var $L51 = $L("
|
|
815
|
-
var $L52 = $L("
|
|
816
|
-
var $L53 = $L("
|
|
817
|
-
var $L54 = $L("
|
|
818
|
-
var $L55 = $L("
|
|
819
|
-
var $L56 = $L("
|
|
820
|
-
var $L57 = $L("
|
|
821
|
-
var $L58 = $L("
|
|
822
|
-
var $L59 = $L("
|
|
823
|
-
var $L60 = $L("
|
|
824
|
-
var $L61 = $L("
|
|
825
|
-
var $L62 = $L("
|
|
826
|
-
var $L63 = $L("
|
|
827
|
-
var $L64 = $L("
|
|
828
|
-
var $L65 = $L("
|
|
829
|
-
var $L66 = $L("
|
|
830
|
-
var $L67 = $L("
|
|
831
|
-
var $L68 = $L("
|
|
832
|
-
var $L69 = $L("
|
|
833
|
-
var $L70 = $L("
|
|
834
|
-
var $L71 = $L("
|
|
835
|
-
var $L72 = $L("
|
|
836
|
-
var $L73 = $L("
|
|
837
|
-
var $L74 = $L("
|
|
838
|
-
var $L75 = $L("
|
|
839
|
-
var $L76 = $L("
|
|
840
|
-
var $L77 = $L("
|
|
841
|
-
var $L78 = $L("
|
|
842
|
-
var $L79 = $L("
|
|
843
|
-
var $L80 = $L("
|
|
844
|
-
var $L81 = $L("
|
|
845
|
-
var $L82 = $L("
|
|
846
|
-
var $L83 = $L("
|
|
847
|
-
var $L84 = $L("
|
|
848
|
-
var $L85 = $L("
|
|
849
|
-
var $L86 = $L("
|
|
850
|
-
var $L87 = $L("
|
|
851
|
-
var $L88 = $L("
|
|
852
|
-
var $L89 = $L("
|
|
853
|
-
var $L90 = $L("
|
|
854
|
-
var $L91 = $L("
|
|
855
|
-
var $L92 = $L("
|
|
856
|
-
var $L93 = $L("
|
|
857
|
-
var $L94 = $L("
|
|
858
|
-
var $L95 = $L("
|
|
859
|
-
var $L96 = $L("
|
|
860
|
-
var $L97 = $L("
|
|
861
|
-
var $L98 = $L("
|
|
862
|
-
var $L99 = $L(
|
|
863
|
-
var $L100 = $L("
|
|
864
|
-
var $L101 = $L("
|
|
865
|
-
var $L102 = $L("
|
|
866
|
-
var $L103 = $L("
|
|
867
|
-
var $L104 = $L("
|
|
868
|
-
var $L105 = $L("
|
|
869
|
-
var $L106 = $L("
|
|
870
|
-
var $L107 = $L("
|
|
871
|
-
var $L108 = $L("
|
|
872
|
-
var $L109 = $L("
|
|
873
|
-
var $L110 = $L("
|
|
874
|
-
var $L111 = $L("
|
|
875
|
-
var $L112 = $L("
|
|
876
|
-
var $L113 = $L("
|
|
877
|
-
var $L114 = $L("
|
|
878
|
-
var $L115 = $L("
|
|
879
|
-
var $L116 = $L("
|
|
880
|
-
var $L117 = $L("
|
|
881
|
-
var $L118 = $L("
|
|
882
|
-
var $L119 = $L("
|
|
883
|
-
var $L120 = $L("
|
|
884
|
-
var $L121 = $L("
|
|
885
|
-
var $L122 = $L("
|
|
886
|
-
var $L123 = $L("
|
|
887
|
-
var $L124 = $L(
|
|
888
|
-
var $L125 = $L("
|
|
889
|
-
var $L126 = $L("
|
|
890
|
-
var $L127 = $L("
|
|
891
|
-
var $L128 = $L("
|
|
892
|
-
var $L129 = $L("
|
|
893
|
-
var $L130 = $L("
|
|
774
|
+
var $L0 = $L("");
|
|
775
|
+
var $L1 = $L("++");
|
|
776
|
+
var $L2 = $L("--");
|
|
777
|
+
var $L3 = $L("=>");
|
|
778
|
+
var $L4 = $L("<");
|
|
779
|
+
var $L5 = $L("extends");
|
|
780
|
+
var $L6 = $L("this");
|
|
781
|
+
var $L7 = $L("#");
|
|
782
|
+
var $L8 = $L("@");
|
|
783
|
+
var $L9 = $L("super");
|
|
784
|
+
var $L10 = $L("import");
|
|
785
|
+
var $L11 = $L("!");
|
|
786
|
+
var $L12 = $L("::");
|
|
787
|
+
var $L13 = $L("super[");
|
|
788
|
+
var $L14 = $L("import.meta");
|
|
789
|
+
var $L15 = $L(")");
|
|
790
|
+
var $L16 = $L("->");
|
|
791
|
+
var $L17 = $L("null");
|
|
792
|
+
var $L18 = $L("true");
|
|
793
|
+
var $L19 = $L("false");
|
|
794
|
+
var $L20 = $L("yes");
|
|
795
|
+
var $L21 = $L("on");
|
|
796
|
+
var $L22 = $L("no");
|
|
797
|
+
var $L23 = $L("off");
|
|
798
|
+
var $L24 = $L(",");
|
|
799
|
+
var $L25 = $L("]");
|
|
800
|
+
var $L26 = $L("}");
|
|
801
|
+
var $L27 = $L("**=");
|
|
802
|
+
var $L28 = $L("*=");
|
|
803
|
+
var $L29 = $L("/=");
|
|
804
|
+
var $L30 = $L("%=");
|
|
805
|
+
var $L31 = $L("+=");
|
|
806
|
+
var $L32 = $L("-=");
|
|
807
|
+
var $L33 = $L("<<=");
|
|
808
|
+
var $L34 = $L(">>>=");
|
|
809
|
+
var $L35 = $L(">>=");
|
|
810
|
+
var $L36 = $L("&&=");
|
|
811
|
+
var $L37 = $L("&=");
|
|
812
|
+
var $L38 = $L("^=");
|
|
813
|
+
var $L39 = $L("||=");
|
|
814
|
+
var $L40 = $L("|=");
|
|
815
|
+
var $L41 = $L("??=");
|
|
816
|
+
var $L42 = $L("?=");
|
|
817
|
+
var $L43 = $L("=");
|
|
818
|
+
var $L44 = $L("**");
|
|
819
|
+
var $L45 = $L("*");
|
|
820
|
+
var $L46 = $L("/");
|
|
821
|
+
var $L47 = $L("%");
|
|
822
|
+
var $L48 = $L("+");
|
|
823
|
+
var $L49 = $L("-");
|
|
824
|
+
var $L50 = $L("<=");
|
|
825
|
+
var $L51 = $L(">=");
|
|
826
|
+
var $L52 = $L("<<");
|
|
827
|
+
var $L53 = $L(">>>");
|
|
828
|
+
var $L54 = $L(">>");
|
|
829
|
+
var $L55 = $L(">");
|
|
830
|
+
var $L56 = $L("!==");
|
|
831
|
+
var $L57 = $L("!=");
|
|
832
|
+
var $L58 = $L("is");
|
|
833
|
+
var $L59 = $L("===");
|
|
834
|
+
var $L60 = $L("==");
|
|
835
|
+
var $L61 = $L("and");
|
|
836
|
+
var $L62 = $L("&&");
|
|
837
|
+
var $L63 = $L("or");
|
|
838
|
+
var $L64 = $L("||");
|
|
839
|
+
var $L65 = $L("??");
|
|
840
|
+
var $L66 = $L("instanceof");
|
|
841
|
+
var $L67 = $L("in");
|
|
842
|
+
var $L68 = $L("&");
|
|
843
|
+
var $L69 = $L("^");
|
|
844
|
+
var $L70 = $L("|");
|
|
845
|
+
var $L71 = $L(";");
|
|
846
|
+
var $L72 = $L("finally");
|
|
847
|
+
var $L73 = $L("break");
|
|
848
|
+
var $L74 = $L("continue");
|
|
849
|
+
var $L75 = $L("debugger");
|
|
850
|
+
var $L76 = $L("import type");
|
|
851
|
+
var $L77 = $L("default");
|
|
852
|
+
var $L78 = $L(":=");
|
|
853
|
+
var $L79 = $L("/*");
|
|
854
|
+
var $L80 = $L("*/");
|
|
855
|
+
var $L81 = $L("###");
|
|
856
|
+
var $L82 = $L("as");
|
|
857
|
+
var $L83 = $L("async");
|
|
858
|
+
var $L84 = $L("await");
|
|
859
|
+
var $L85 = $L("`");
|
|
860
|
+
var $L86 = $L("case");
|
|
861
|
+
var $L87 = $L("catch");
|
|
862
|
+
var $L88 = $L("class");
|
|
863
|
+
var $L89 = $L("#{");
|
|
864
|
+
var $L90 = $L(":");
|
|
865
|
+
var $L91 = $L("delete");
|
|
866
|
+
var $L92 = $L("do");
|
|
867
|
+
var $L93 = $L(".");
|
|
868
|
+
var $L94 = $L("...");
|
|
869
|
+
var $L95 = $L('"');
|
|
870
|
+
var $L96 = $L("else");
|
|
871
|
+
var $L97 = $L("export");
|
|
872
|
+
var $L98 = $L("for");
|
|
873
|
+
var $L99 = $L("from");
|
|
874
|
+
var $L100 = $L("function");
|
|
875
|
+
var $L101 = $L("get");
|
|
876
|
+
var $L102 = $L("set");
|
|
877
|
+
var $L103 = $L("if");
|
|
878
|
+
var $L104 = $L("let");
|
|
879
|
+
var $L105 = $L("const");
|
|
880
|
+
var $L106 = $L("loop");
|
|
881
|
+
var $L107 = $L("new");
|
|
882
|
+
var $L108 = $L("of");
|
|
883
|
+
var $L109 = $L("{");
|
|
884
|
+
var $L110 = $L("[");
|
|
885
|
+
var $L111 = $L("(");
|
|
886
|
+
var $L112 = $L("?");
|
|
887
|
+
var $L113 = $L("return");
|
|
888
|
+
var $L114 = $L("'");
|
|
889
|
+
var $L115 = $L("static");
|
|
890
|
+
var $L116 = $L("${");
|
|
891
|
+
var $L117 = $L("switch");
|
|
892
|
+
var $L118 = $L("target");
|
|
893
|
+
var $L119 = $L("throw");
|
|
894
|
+
var $L120 = $L('"""');
|
|
895
|
+
var $L121 = $L("'''");
|
|
896
|
+
var $L122 = $L("```");
|
|
897
|
+
var $L123 = $L("try");
|
|
898
|
+
var $L124 = $L("typeof");
|
|
899
|
+
var $L125 = $L("unless");
|
|
900
|
+
var $L126 = $L("until");
|
|
901
|
+
var $L127 = $L("var");
|
|
902
|
+
var $L128 = $L("void");
|
|
903
|
+
var $L129 = $L("when");
|
|
904
|
+
var $L130 = $L("while");
|
|
894
905
|
var $L131 = $L("yield");
|
|
895
906
|
var $L132 = $L("/>");
|
|
896
907
|
var $L133 = $L("</");
|
|
@@ -908,50 +919,50 @@ var Civet = (() => {
|
|
|
908
919
|
var $L145 = $L("civet");
|
|
909
920
|
var $L146 = $L(" ");
|
|
910
921
|
var $L147 = $L(" ");
|
|
911
|
-
var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
922
|
+
var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
912
923
|
var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
913
924
|
var $R2 = $R(new RegExp("[!~+-]", "suy"));
|
|
914
|
-
var $R3 = $R(new RegExp(
|
|
915
|
-
var $R4 = $R(new RegExp("
|
|
916
|
-
var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)
|
|
917
|
-
var $R6 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(
|
|
918
|
-
var $R7 = $R(new RegExp("(?:\\.(
|
|
919
|
-
var $R8 = $R(new RegExp("(
|
|
920
|
-
var $R9 = $R(new RegExp("
|
|
921
|
-
var $R10 = $R(new RegExp("0[
|
|
922
|
-
var $R11 = $R(new RegExp("0[
|
|
923
|
-
var $R12 = $R(new RegExp(
|
|
924
|
-
var $R13 = $R(new RegExp(
|
|
925
|
-
var $R14 = $R(new RegExp(
|
|
926
|
-
var $R15 = $R(new RegExp(
|
|
927
|
-
var $R16 = $R(new RegExp('(
|
|
928
|
-
var $R17 = $R(new RegExp("
|
|
929
|
-
var $R18 = $R(new RegExp("
|
|
930
|
-
var $R19 = $R(new RegExp("(
|
|
931
|
-
var $R20 = $R(new RegExp("(
|
|
932
|
-
var $R21 = $R(new RegExp("(?:\\$(?!\\{)
|
|
933
|
-
var $R22 = $R(new RegExp("(
|
|
934
|
-
var $R23 = $R(new RegExp("(?:
|
|
935
|
-
var $R24 = $R(new RegExp("
|
|
936
|
-
var $R25 = $R(new RegExp("
|
|
937
|
-
var $R26 = $R(new RegExp("
|
|
938
|
-
var $R27 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
939
|
-
var $R28 = $R(new RegExp("[
|
|
940
|
-
var $R29 = $R(new RegExp("[\\
|
|
941
|
-
var $R30 = $R(new RegExp("
|
|
942
|
-
var $R31 = $R(new RegExp("
|
|
943
|
-
var $R32 = $R(new RegExp("
|
|
944
|
-
var $R33 = $R(new RegExp(
|
|
945
|
-
var $R34 = $R(new RegExp("
|
|
946
|
-
var $R35 = $R(new RegExp("[^
|
|
947
|
-
var $R36 = $R(new RegExp("[
|
|
948
|
-
var $R37 = $R(new RegExp("[+-]", "suy"));
|
|
949
|
-
var $R38 = $R(new RegExp("
|
|
950
|
-
var $R39 = $R(new RegExp("[\\
|
|
951
|
-
var $R40 = $R(new RegExp("[\\
|
|
952
|
-
var $R41 = $R(new RegExp("\\s
|
|
953
|
-
var $R42 = $R(new RegExp("\\
|
|
954
|
-
var $R43 = $R(new RegExp("
|
|
925
|
+
var $R3 = $R(new RegExp("(?=[\\s\\)])", "suy"));
|
|
926
|
+
var $R4 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
927
|
+
var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
928
|
+
var $R6 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
929
|
+
var $R7 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*)?)?", "suy"));
|
|
930
|
+
var $R8 = $R(new RegExp("(?:\\.(?!\\p{ID_Start})[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
931
|
+
var $R9 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
932
|
+
var $R10 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
933
|
+
var $R11 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
934
|
+
var $R12 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
935
|
+
var $R13 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
936
|
+
var $R14 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
937
|
+
var $R15 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
938
|
+
var $R16 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
939
|
+
var $R17 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
940
|
+
var $R18 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
941
|
+
var $R19 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
|
|
942
|
+
var $R20 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
943
|
+
var $R21 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
944
|
+
var $R22 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
945
|
+
var $R23 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
946
|
+
var $R24 = $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|loop|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
947
|
+
var $R25 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
948
|
+
var $R26 = $R(new RegExp(".", "suy"));
|
|
949
|
+
var $R27 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
950
|
+
var $R28 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
951
|
+
var $R29 = $R(new RegExp("[ \\t]+", "suy"));
|
|
952
|
+
var $R30 = $R(new RegExp("[\\s]+", "suy"));
|
|
953
|
+
var $R31 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
954
|
+
var $R32 = $R(new RegExp("\\s", "suy"));
|
|
955
|
+
var $R33 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
956
|
+
var $R34 = $R(new RegExp('"[^"]*"', "suy"));
|
|
957
|
+
var $R35 = $R(new RegExp("'[^']*'", "suy"));
|
|
958
|
+
var $R36 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
959
|
+
var $R37 = $R(new RegExp("[+-]?", "suy"));
|
|
960
|
+
var $R38 = $R(new RegExp("[+-]", "suy"));
|
|
961
|
+
var $R39 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
962
|
+
var $R40 = $R(new RegExp("[\\t ]*", "suy"));
|
|
963
|
+
var $R41 = $R(new RegExp("[\\s]*", "suy"));
|
|
964
|
+
var $R42 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
|
|
965
|
+
var $R43 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
955
966
|
var Program$0 = $S(Reset, Init, __, $Q(TopLevelStatement), __);
|
|
956
967
|
function Program(state) {
|
|
957
968
|
if (state.verbose)
|
|
@@ -995,7 +1006,7 @@ var Civet = (() => {
|
|
|
995
1006
|
return Arguments$0(state) || Arguments$1(state);
|
|
996
1007
|
}
|
|
997
1008
|
}
|
|
998
|
-
var ArgumentsWithTrailingCallExpressions$0 = $TS($S(TrackIndent, $C($S(Arguments, $Q($S($Y(EOS), Samedent, $N(
|
|
1009
|
+
var ArgumentsWithTrailingCallExpressions$0 = $TS($S(TrackIndent, $C($S(Arguments, $Q($S($Y(EOS), Samedent, $N(Backtick), CallExpressionRest)), PopIndent), PopIndent)), function($skip, $loc, $0, $1, $2) {
|
|
999
1010
|
if (!$2)
|
|
1000
1011
|
return $skip;
|
|
1001
1012
|
return $2;
|
|
@@ -1081,7 +1092,7 @@ var Civet = (() => {
|
|
|
1081
1092
|
return ApplicationStart$0(state) || ApplicationStart$1(state);
|
|
1082
1093
|
}
|
|
1083
1094
|
}
|
|
1084
|
-
var IndentedApplicationAllowed$0 = $TV($EXPECT($
|
|
1095
|
+
var IndentedApplicationAllowed$0 = $TV($EXPECT($L0, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
|
|
1085
1096
|
if (module.suppressIndentedApplication)
|
|
1086
1097
|
return $skip;
|
|
1087
1098
|
return;
|
|
@@ -1159,7 +1170,7 @@ var Civet = (() => {
|
|
|
1159
1170
|
return UpdateExpression$0(state) || UpdateExpression$1(state);
|
|
1160
1171
|
}
|
|
1161
1172
|
}
|
|
1162
|
-
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($
|
|
1173
|
+
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L1, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L2, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
|
|
1163
1174
|
return { $loc, token: $1 };
|
|
1164
1175
|
});
|
|
1165
1176
|
function UpdateExpressionSymbol(state) {
|
|
@@ -1239,7 +1250,7 @@ var Civet = (() => {
|
|
|
1239
1250
|
return ArrowFunction$0(state) || ArrowFunction$1(state);
|
|
1240
1251
|
}
|
|
1241
1252
|
}
|
|
1242
|
-
var FatArrow$0 = $TS($S(__, $EXPECT($
|
|
1253
|
+
var FatArrow$0 = $TS($S(__, $EXPECT($L3, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
|
|
1243
1254
|
var ws = $1;
|
|
1244
1255
|
if (!ws.length)
|
|
1245
1256
|
return " =>";
|
|
@@ -1345,10 +1356,10 @@ var Civet = (() => {
|
|
|
1345
1356
|
return ClassHeritage$0(state);
|
|
1346
1357
|
}
|
|
1347
1358
|
}
|
|
1348
|
-
var ExtendsToken$0 = $TV($EXPECT($
|
|
1359
|
+
var ExtendsToken$0 = $TV($EXPECT($L4, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
|
|
1349
1360
|
return { $loc, token: "extends" };
|
|
1350
1361
|
});
|
|
1351
|
-
var ExtendsToken$1 = $TV($EXPECT($
|
|
1362
|
+
var ExtendsToken$1 = $TV($EXPECT($L5, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
|
|
1352
1363
|
return { $loc, token: $1 };
|
|
1353
1364
|
});
|
|
1354
1365
|
function ExtendsToken(state) {
|
|
@@ -1418,11 +1429,11 @@ var Civet = (() => {
|
|
|
1418
1429
|
return FieldDefinition$0(state) || FieldDefinition$1(state);
|
|
1419
1430
|
}
|
|
1420
1431
|
}
|
|
1421
|
-
var This$0 = $TV($EXPECT($
|
|
1432
|
+
var This$0 = $TV($EXPECT($L6, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
1422
1433
|
return { $loc, token: $1 };
|
|
1423
1434
|
});
|
|
1424
|
-
var This$1 = $S(AtAccessor, $S($E($EXPECT($
|
|
1425
|
-
var This$2 = $TV($EXPECT($
|
|
1435
|
+
var This$1 = $S(AtAccessor, $S($E($EXPECT($L7, fail, 'This "#"')), IdentifierName));
|
|
1436
|
+
var This$2 = $TV($EXPECT($L8, fail, 'This "@"'), function($skip, $loc, $0, $1) {
|
|
1426
1437
|
return { $loc, token: "this" };
|
|
1427
1438
|
});
|
|
1428
1439
|
function This(state) {
|
|
@@ -1432,7 +1443,7 @@ var Civet = (() => {
|
|
|
1432
1443
|
return This$0(state) || This$1(state) || This$2(state);
|
|
1433
1444
|
}
|
|
1434
1445
|
}
|
|
1435
|
-
var AtAccessor$0 = $TV($EXPECT($
|
|
1446
|
+
var AtAccessor$0 = $TV($EXPECT($L8, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
|
|
1436
1447
|
return { $loc, token: "this." };
|
|
1437
1448
|
});
|
|
1438
1449
|
function AtAccessor(state) {
|
|
@@ -1463,8 +1474,8 @@ var Civet = (() => {
|
|
|
1463
1474
|
return NewExpression$0(state);
|
|
1464
1475
|
}
|
|
1465
1476
|
}
|
|
1466
|
-
var CallExpression$0 = $S($EXPECT($
|
|
1467
|
-
var CallExpression$1 = $S($EXPECT($
|
|
1477
|
+
var CallExpression$0 = $S($EXPECT($L9, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
|
|
1478
|
+
var CallExpression$1 = $S($EXPECT($L10, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
|
|
1468
1479
|
var CallExpression$2 = $TS($S(MemberExpression, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
1469
1480
|
if ($2.length)
|
|
1470
1481
|
return $0;
|
|
@@ -1497,7 +1508,7 @@ var Civet = (() => {
|
|
|
1497
1508
|
return OptionalShorthand$0(state);
|
|
1498
1509
|
}
|
|
1499
1510
|
}
|
|
1500
|
-
var NonNullAssertion$0 = $T($EXPECT($
|
|
1511
|
+
var NonNullAssertion$0 = $T($EXPECT($L11, fail, 'NonNullAssertion "!"'), function(value) {
|
|
1501
1512
|
return { "ts": true, "children": value };
|
|
1502
1513
|
});
|
|
1503
1514
|
function NonNullAssertion(state) {
|
|
@@ -1509,7 +1520,7 @@ var Civet = (() => {
|
|
|
1509
1520
|
return NonNullAssertion$0(state);
|
|
1510
1521
|
}
|
|
1511
1522
|
}
|
|
1512
|
-
var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue})/"));
|
|
1523
|
+
var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
1513
1524
|
function AdditionalReservedWords(state) {
|
|
1514
1525
|
if (state.verbose)
|
|
1515
1526
|
console.log("ENTER:", "AdditionalReservedWords");
|
|
@@ -1535,7 +1546,7 @@ var Civet = (() => {
|
|
|
1535
1546
|
}
|
|
1536
1547
|
var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), OpenBracket, Expression, __, CloseBracket);
|
|
1537
1548
|
var MemberExpressionRest$1 = $S($E($S($Y(EOS), IndentedFurther)), PropertyAccess);
|
|
1538
|
-
var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($
|
|
1549
|
+
var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L12, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1539
1550
|
var id = $3;
|
|
1540
1551
|
if (id)
|
|
1541
1552
|
return [".prototype.", id];
|
|
@@ -1559,7 +1570,7 @@ var Civet = (() => {
|
|
|
1559
1570
|
return PropertyAccess$0(state);
|
|
1560
1571
|
}
|
|
1561
1572
|
}
|
|
1562
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
1573
|
+
var SuperProperty$0 = $S($EXPECT($L13, fail, 'SuperProperty "super["'), Expression, __, CloseBracket);
|
|
1563
1574
|
function SuperProperty(state) {
|
|
1564
1575
|
if (state.verbose)
|
|
1565
1576
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1570,7 +1581,7 @@ var Civet = (() => {
|
|
|
1570
1581
|
}
|
|
1571
1582
|
}
|
|
1572
1583
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
1573
|
-
var MetaProperty$1 = $TV($EXPECT($
|
|
1584
|
+
var MetaProperty$1 = $TV($EXPECT($L14, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
|
|
1574
1585
|
return { $loc, token: $1 };
|
|
1575
1586
|
});
|
|
1576
1587
|
function MetaProperty(state) {
|
|
@@ -1581,7 +1592,7 @@ var Civet = (() => {
|
|
|
1581
1592
|
}
|
|
1582
1593
|
}
|
|
1583
1594
|
var Parameters$0 = NonEmptyParameters;
|
|
1584
|
-
var Parameters$1 = $TV($EXPECT($
|
|
1595
|
+
var Parameters$1 = $TV($EXPECT($L0, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
1585
1596
|
return { $loc, token: "()" };
|
|
1586
1597
|
});
|
|
1587
1598
|
function Parameters(state) {
|
|
@@ -1622,7 +1633,7 @@ var Civet = (() => {
|
|
|
1622
1633
|
}
|
|
1623
1634
|
}
|
|
1624
1635
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
1625
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
1636
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L15, fail, 'ParameterElementDelimiter ")"')));
|
|
1626
1637
|
var ParameterElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1627
1638
|
return { $loc, token: "," };
|
|
1628
1639
|
});
|
|
@@ -1841,7 +1852,7 @@ var Civet = (() => {
|
|
|
1841
1852
|
return ThinArrowFunction$0(state);
|
|
1842
1853
|
}
|
|
1843
1854
|
}
|
|
1844
|
-
var Arrow$0 = $TV($EXPECT($
|
|
1855
|
+
var Arrow$0 = $TV($EXPECT($L16, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
1845
1856
|
return { $loc, token: $1 };
|
|
1846
1857
|
});
|
|
1847
1858
|
function Arrow(state) {
|
|
@@ -1965,7 +1976,7 @@ var Civet = (() => {
|
|
|
1965
1976
|
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
|
|
1966
1977
|
}
|
|
1967
1978
|
}
|
|
1968
|
-
var NullLiteral$0 = $TV($EXPECT($
|
|
1979
|
+
var NullLiteral$0 = $TV($EXPECT($L17, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
1969
1980
|
return { $loc, token: $1 };
|
|
1970
1981
|
});
|
|
1971
1982
|
function NullLiteral(state) {
|
|
@@ -1978,7 +1989,7 @@ var Civet = (() => {
|
|
|
1978
1989
|
}
|
|
1979
1990
|
}
|
|
1980
1991
|
var BooleanLiteral$0 = CoffeeScriptBooleanLiteral;
|
|
1981
|
-
var BooleanLiteral$1 = $TV($C($EXPECT($
|
|
1992
|
+
var BooleanLiteral$1 = $TV($C($EXPECT($L18, fail, 'BooleanLiteral "true"'), $EXPECT($L19, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
|
|
1982
1993
|
return { $loc, token: $1 };
|
|
1983
1994
|
});
|
|
1984
1995
|
function BooleanLiteral(state) {
|
|
@@ -1988,10 +1999,10 @@ var Civet = (() => {
|
|
|
1988
1999
|
return BooleanLiteral$0(state) || BooleanLiteral$1(state);
|
|
1989
2000
|
}
|
|
1990
2001
|
}
|
|
1991
|
-
var CoffeeScriptBooleanLiteral$0 = $TV($C($EXPECT($
|
|
2002
|
+
var CoffeeScriptBooleanLiteral$0 = $TV($C($EXPECT($L20, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "on"')), function($skip, $loc, $0, $1) {
|
|
1992
2003
|
return { $loc, token: "true" };
|
|
1993
2004
|
});
|
|
1994
|
-
var CoffeeScriptBooleanLiteral$1 = $TV($C($EXPECT($
|
|
2005
|
+
var CoffeeScriptBooleanLiteral$1 = $TV($C($EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "off"')), function($skip, $loc, $0, $1) {
|
|
1995
2006
|
return { $loc, token: "false" };
|
|
1996
2007
|
});
|
|
1997
2008
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -2001,7 +2012,7 @@ var Civet = (() => {
|
|
|
2001
2012
|
return CoffeeScriptBooleanLiteral$0(state) || CoffeeScriptBooleanLiteral$1(state);
|
|
2002
2013
|
}
|
|
2003
2014
|
}
|
|
2004
|
-
var Comma$0 = $TV($EXPECT($
|
|
2015
|
+
var Comma$0 = $TV($EXPECT($L24, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
2005
2016
|
return { $loc, token: $1 };
|
|
2006
2017
|
});
|
|
2007
2018
|
function Comma(state) {
|
|
@@ -2086,7 +2097,7 @@ var Civet = (() => {
|
|
|
2086
2097
|
}
|
|
2087
2098
|
}
|
|
2088
2099
|
var ArrayElementDelimiter$0 = $S($Q(_), Comma);
|
|
2089
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2100
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
|
|
2090
2101
|
var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2091
2102
|
return { $loc, token: "," };
|
|
2092
2103
|
});
|
|
@@ -2184,7 +2195,7 @@ var Civet = (() => {
|
|
|
2184
2195
|
}
|
|
2185
2196
|
}
|
|
2186
2197
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
2187
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2198
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ObjectPropertyDelimiter "}"')));
|
|
2188
2199
|
var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2189
2200
|
return { $loc, token: "," };
|
|
2190
2201
|
});
|
|
@@ -2219,7 +2230,7 @@ var Civet = (() => {
|
|
|
2219
2230
|
var PropertyName$0 = NumericLiteral;
|
|
2220
2231
|
var PropertyName$1 = StringLiteral;
|
|
2221
2232
|
var PropertyName$2 = IdentifierName;
|
|
2222
|
-
var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($
|
|
2233
|
+
var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L25, fail, 'PropertyName "]"'));
|
|
2223
2234
|
function PropertyName(state) {
|
|
2224
2235
|
if (state.tokenize) {
|
|
2225
2236
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -2294,7 +2305,7 @@ var Civet = (() => {
|
|
|
2294
2305
|
return ClassElementName$0(state) || ClassElementName$1(state);
|
|
2295
2306
|
}
|
|
2296
2307
|
}
|
|
2297
|
-
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($
|
|
2308
|
+
var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L7, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
|
|
2298
2309
|
return {
|
|
2299
2310
|
$loc,
|
|
2300
2311
|
token: $1
|
|
@@ -2321,25 +2332,25 @@ var Civet = (() => {
|
|
|
2321
2332
|
return AssignmentOp$0(state);
|
|
2322
2333
|
}
|
|
2323
2334
|
}
|
|
2324
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
2325
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
2326
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
2327
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
2328
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
2329
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
2330
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
2331
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
2332
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
2333
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
2334
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
2335
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
2336
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
2337
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
2338
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
2339
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
2335
|
+
var AssignmentOpSymbol$0 = $EXPECT($L27, fail, 'AssignmentOpSymbol "**="');
|
|
2336
|
+
var AssignmentOpSymbol$1 = $EXPECT($L28, fail, 'AssignmentOpSymbol "*="');
|
|
2337
|
+
var AssignmentOpSymbol$2 = $EXPECT($L29, fail, 'AssignmentOpSymbol "/="');
|
|
2338
|
+
var AssignmentOpSymbol$3 = $EXPECT($L30, fail, 'AssignmentOpSymbol "%="');
|
|
2339
|
+
var AssignmentOpSymbol$4 = $EXPECT($L31, fail, 'AssignmentOpSymbol "+="');
|
|
2340
|
+
var AssignmentOpSymbol$5 = $EXPECT($L32, fail, 'AssignmentOpSymbol "-="');
|
|
2341
|
+
var AssignmentOpSymbol$6 = $EXPECT($L33, fail, 'AssignmentOpSymbol "<<="');
|
|
2342
|
+
var AssignmentOpSymbol$7 = $EXPECT($L34, fail, 'AssignmentOpSymbol ">>>="');
|
|
2343
|
+
var AssignmentOpSymbol$8 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>="');
|
|
2344
|
+
var AssignmentOpSymbol$9 = $EXPECT($L36, fail, 'AssignmentOpSymbol "&&="');
|
|
2345
|
+
var AssignmentOpSymbol$10 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&="');
|
|
2346
|
+
var AssignmentOpSymbol$11 = $EXPECT($L38, fail, 'AssignmentOpSymbol "^="');
|
|
2347
|
+
var AssignmentOpSymbol$12 = $EXPECT($L39, fail, 'AssignmentOpSymbol "||="');
|
|
2348
|
+
var AssignmentOpSymbol$13 = $EXPECT($L40, fail, 'AssignmentOpSymbol "|="');
|
|
2349
|
+
var AssignmentOpSymbol$14 = $EXPECT($L41, fail, 'AssignmentOpSymbol "??="');
|
|
2350
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L42, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
2340
2351
|
return "??=";
|
|
2341
2352
|
});
|
|
2342
|
-
var AssignmentOpSymbol$16 = $EXPECT($
|
|
2353
|
+
var AssignmentOpSymbol$16 = $EXPECT($L43, fail, 'AssignmentOpSymbol "="');
|
|
2343
2354
|
function AssignmentOpSymbol(state) {
|
|
2344
2355
|
if (state.tokenize) {
|
|
2345
2356
|
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));
|
|
@@ -2359,52 +2370,52 @@ var Civet = (() => {
|
|
|
2359
2370
|
return BinaryOp$0(state);
|
|
2360
2371
|
}
|
|
2361
2372
|
}
|
|
2362
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
2363
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
2364
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
2365
|
-
var BinaryOpSymbol$3 = $EXPECT($
|
|
2366
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
2367
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
2368
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
2369
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
2370
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
2371
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
2372
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
2373
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
2374
|
-
var BinaryOpSymbol$12 = $EXPECT($
|
|
2375
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
2376
|
-
var BinaryOpSymbol$14 = $TV($EXPECT($
|
|
2373
|
+
var BinaryOpSymbol$0 = $EXPECT($L44, fail, 'BinaryOpSymbol "**"');
|
|
2374
|
+
var BinaryOpSymbol$1 = $EXPECT($L45, fail, 'BinaryOpSymbol "*"');
|
|
2375
|
+
var BinaryOpSymbol$2 = $EXPECT($L46, fail, 'BinaryOpSymbol "/"');
|
|
2376
|
+
var BinaryOpSymbol$3 = $EXPECT($L47, fail, 'BinaryOpSymbol "%"');
|
|
2377
|
+
var BinaryOpSymbol$4 = $EXPECT($L48, fail, 'BinaryOpSymbol "+"');
|
|
2378
|
+
var BinaryOpSymbol$5 = $EXPECT($L49, fail, 'BinaryOpSymbol "-"');
|
|
2379
|
+
var BinaryOpSymbol$6 = $EXPECT($L50, fail, 'BinaryOpSymbol "<="');
|
|
2380
|
+
var BinaryOpSymbol$7 = $EXPECT($L51, fail, 'BinaryOpSymbol ">="');
|
|
2381
|
+
var BinaryOpSymbol$8 = $EXPECT($L52, fail, 'BinaryOpSymbol "<<"');
|
|
2382
|
+
var BinaryOpSymbol$9 = $EXPECT($L4, fail, 'BinaryOpSymbol "<"');
|
|
2383
|
+
var BinaryOpSymbol$10 = $EXPECT($L53, fail, 'BinaryOpSymbol ">>>"');
|
|
2384
|
+
var BinaryOpSymbol$11 = $EXPECT($L54, fail, 'BinaryOpSymbol ">>"');
|
|
2385
|
+
var BinaryOpSymbol$12 = $EXPECT($L55, fail, 'BinaryOpSymbol ">"');
|
|
2386
|
+
var BinaryOpSymbol$13 = $EXPECT($L56, fail, 'BinaryOpSymbol "!=="');
|
|
2387
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L57, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
2377
2388
|
if (module.config.coffeeEq)
|
|
2378
2389
|
return "!==";
|
|
2379
2390
|
return $1;
|
|
2380
2391
|
});
|
|
2381
|
-
var BinaryOpSymbol$15 = $T($S($EXPECT($
|
|
2392
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L58, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
2382
2393
|
return "===";
|
|
2383
2394
|
});
|
|
2384
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
2385
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
2395
|
+
var BinaryOpSymbol$16 = $EXPECT($L59, fail, 'BinaryOpSymbol "==="');
|
|
2396
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L60, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
2386
2397
|
if (module.config.coffeeEq)
|
|
2387
2398
|
return "===";
|
|
2388
2399
|
return $1;
|
|
2389
2400
|
});
|
|
2390
|
-
var BinaryOpSymbol$18 = $T($S($EXPECT($
|
|
2401
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L61, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
2391
2402
|
return "&&";
|
|
2392
2403
|
});
|
|
2393
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
2394
|
-
var BinaryOpSymbol$20 = $T($S($EXPECT($
|
|
2404
|
+
var BinaryOpSymbol$19 = $EXPECT($L62, fail, 'BinaryOpSymbol "&&"');
|
|
2405
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L63, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
2395
2406
|
return "||";
|
|
2396
2407
|
});
|
|
2397
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
2398
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
2399
|
-
var BinaryOpSymbol$23 = $TS($S($EXPECT($
|
|
2408
|
+
var BinaryOpSymbol$21 = $EXPECT($L64, fail, 'BinaryOpSymbol "||"');
|
|
2409
|
+
var BinaryOpSymbol$22 = $EXPECT($L65, fail, 'BinaryOpSymbol "??"');
|
|
2410
|
+
var BinaryOpSymbol$23 = $TS($S($EXPECT($L66, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2400
2411
|
return $1;
|
|
2401
2412
|
});
|
|
2402
|
-
var BinaryOpSymbol$24 = $TS($S($EXPECT($
|
|
2413
|
+
var BinaryOpSymbol$24 = $TS($S($EXPECT($L67, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2403
2414
|
return $1;
|
|
2404
2415
|
});
|
|
2405
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
2406
|
-
var BinaryOpSymbol$26 = $EXPECT($
|
|
2407
|
-
var BinaryOpSymbol$27 = $EXPECT($
|
|
2416
|
+
var BinaryOpSymbol$25 = $EXPECT($L68, fail, 'BinaryOpSymbol "&"');
|
|
2417
|
+
var BinaryOpSymbol$26 = $EXPECT($L69, fail, 'BinaryOpSymbol "^"');
|
|
2418
|
+
var BinaryOpSymbol$27 = $EXPECT($L70, fail, 'BinaryOpSymbol "|"');
|
|
2408
2419
|
function BinaryOpSymbol(state) {
|
|
2409
2420
|
if (state.tokenize) {
|
|
2410
2421
|
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));
|
|
@@ -2412,8 +2423,10 @@ var Civet = (() => {
|
|
|
2412
2423
|
return 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);
|
|
2413
2424
|
}
|
|
2414
2425
|
}
|
|
2415
|
-
var UnaryOp$0 = $
|
|
2416
|
-
|
|
2426
|
+
var UnaryOp$0 = $TR($EXPECT($R2, fail, "UnaryOp /[!~+-]/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
2427
|
+
return { $loc, token: $0 };
|
|
2428
|
+
});
|
|
2429
|
+
var UnaryOp$1 = $S($C(Delete, Void, Typeof), __);
|
|
2417
2430
|
function UnaryOp(state) {
|
|
2418
2431
|
if (state.tokenize) {
|
|
2419
2432
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -2431,49 +2444,36 @@ var Civet = (() => {
|
|
|
2431
2444
|
return ModuleItem$0(state) || ModuleItem$1(state) || ModuleItem$2(state);
|
|
2432
2445
|
}
|
|
2433
2446
|
}
|
|
2434
|
-
var StatementListItem$0 =
|
|
2447
|
+
var StatementListItem$0 = Declaration;
|
|
2448
|
+
var StatementListItem$1 = $TS($S(Statement, $Q(TrailingComment), $E(PostfixStatement)), function($skip, $loc, $0, $1, $2, $3) {
|
|
2435
2449
|
var statement = $1;
|
|
2436
|
-
var
|
|
2437
|
-
var
|
|
2438
|
-
if (
|
|
2439
|
-
|
|
2450
|
+
var ws = $2;
|
|
2451
|
+
var post = $3;
|
|
2452
|
+
if (post) {
|
|
2453
|
+
post.children.push(statement);
|
|
2454
|
+
if (!module.isWhitespaceOrEmpty(ws))
|
|
2455
|
+
post.children.push(ws);
|
|
2456
|
+
return post;
|
|
2457
|
+
}
|
|
2440
2458
|
return statement;
|
|
2441
2459
|
});
|
|
2442
2460
|
function StatementListItem(state) {
|
|
2443
|
-
if (state.verbose)
|
|
2444
|
-
console.log("ENTER:", "StatementListItem");
|
|
2445
2461
|
if (state.tokenize) {
|
|
2446
|
-
return $TOKEN("StatementListItem", state, StatementListItem$0(state));
|
|
2462
|
+
return $TOKEN("StatementListItem", state, StatementListItem$0(state) || StatementListItem$1(state));
|
|
2447
2463
|
} else {
|
|
2448
|
-
return StatementListItem$0(state);
|
|
2464
|
+
return StatementListItem$0(state) || StatementListItem$1(state);
|
|
2449
2465
|
}
|
|
2450
2466
|
}
|
|
2451
|
-
var
|
|
2452
|
-
|
|
2453
|
-
|
|
2454
|
-
|
|
2455
|
-
|
|
2456
|
-
|
|
2457
|
-
let openParens = { $loc: l1.$loc, token: "(!(" };
|
|
2458
|
-
let closingParens = { $loc: l2.$loc, token: "))" };
|
|
2459
|
-
let space = { $loc: l2.$loc, token: " " };
|
|
2460
|
-
let openingBrace = { $loc: l2.$loc, token: "{" };
|
|
2461
|
-
if (cond.token === "if") {
|
|
2462
|
-
cond.token = "if";
|
|
2463
|
-
closingParens.token = ")";
|
|
2464
|
-
openParens.token = "(";
|
|
2465
|
-
} else {
|
|
2466
|
-
cond.token = "if";
|
|
2467
|
-
}
|
|
2468
|
-
return [ws, cond, openParens, exp, closingParens, space, openingBrace];
|
|
2469
|
-
});
|
|
2470
|
-
function PostfixConditional(state) {
|
|
2471
|
-
if (state.verbose)
|
|
2472
|
-
console.log("ENTER:", "PostfixConditional");
|
|
2467
|
+
var PostfixStatement$0 = ForClause;
|
|
2468
|
+
var PostfixStatement$1 = IfClause;
|
|
2469
|
+
var PostfixStatement$2 = LoopClause;
|
|
2470
|
+
var PostfixStatement$3 = UnlessClause;
|
|
2471
|
+
var PostfixStatement$4 = WhileClause;
|
|
2472
|
+
function PostfixStatement(state) {
|
|
2473
2473
|
if (state.tokenize) {
|
|
2474
|
-
return $TOKEN("
|
|
2474
|
+
return $TOKEN("PostfixStatement", state, PostfixStatement$0(state) || PostfixStatement$1(state) || PostfixStatement$2(state) || PostfixStatement$3(state) || PostfixStatement$4(state));
|
|
2475
2475
|
} else {
|
|
2476
|
-
return
|
|
2476
|
+
return PostfixStatement$0(state) || PostfixStatement$1(state) || PostfixStatement$2(state) || PostfixStatement$3(state) || PostfixStatement$4(state);
|
|
2477
2477
|
}
|
|
2478
2478
|
}
|
|
2479
2479
|
var Statement$0 = KeywordStatement;
|
|
@@ -2492,7 +2492,7 @@ var Civet = (() => {
|
|
|
2492
2492
|
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);
|
|
2493
2493
|
}
|
|
2494
2494
|
}
|
|
2495
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
2495
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L71, fail, 'EmptyStatement ";"'))), function(value) {
|
|
2496
2496
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
2497
2497
|
});
|
|
2498
2498
|
function EmptyStatement(state) {
|
|
@@ -2517,13 +2517,43 @@ var Civet = (() => {
|
|
|
2517
2517
|
return BlockStatement$0(state);
|
|
2518
2518
|
}
|
|
2519
2519
|
}
|
|
2520
|
-
var IfStatement$0 = $
|
|
2520
|
+
var IfStatement$0 = $TS($S(IfClause, Block, $E($S(__, Else, Block))), function($skip, $loc, $0, $1, $2, $3) {
|
|
2521
|
+
var clause = $1;
|
|
2522
|
+
var block = $2;
|
|
2523
|
+
var e = $3;
|
|
2524
|
+
clause.children.push(block);
|
|
2525
|
+
if (e)
|
|
2526
|
+
clause.children.push(e);
|
|
2527
|
+
return clause;
|
|
2528
|
+
});
|
|
2529
|
+
var IfStatement$1 = $TS($S(UnlessClause, Block), function($skip, $loc, $0, $1, $2) {
|
|
2530
|
+
var clause = $1;
|
|
2531
|
+
var block = $2;
|
|
2532
|
+
clause.children.push(block);
|
|
2533
|
+
return clause;
|
|
2534
|
+
});
|
|
2535
|
+
function IfStatement(state) {
|
|
2536
|
+
if (state.tokenize) {
|
|
2537
|
+
return $TOKEN("IfStatement", state, IfStatement$0(state) || IfStatement$1(state));
|
|
2538
|
+
} else {
|
|
2539
|
+
return IfStatement$0(state) || IfStatement$1(state);
|
|
2540
|
+
}
|
|
2541
|
+
}
|
|
2542
|
+
var IfClause$0 = $T($S(If, Condition), function(value) {
|
|
2521
2543
|
return { "type": "IfStatement", "children": value };
|
|
2522
2544
|
});
|
|
2523
|
-
|
|
2545
|
+
function IfClause(state) {
|
|
2546
|
+
if (state.verbose)
|
|
2547
|
+
console.log("ENTER:", "IfClause");
|
|
2548
|
+
if (state.tokenize) {
|
|
2549
|
+
return $TOKEN("IfClause", state, IfClause$0(state));
|
|
2550
|
+
} else {
|
|
2551
|
+
return IfClause$0(state);
|
|
2552
|
+
}
|
|
2553
|
+
}
|
|
2554
|
+
var UnlessClause$0 = $TS($S(Unless, Condition), function($skip, $loc, $0, $1, $2) {
|
|
2524
2555
|
var kind = $1;
|
|
2525
2556
|
var condition = $2;
|
|
2526
|
-
var block = $3;
|
|
2527
2557
|
condition.forEach((c) => {
|
|
2528
2558
|
if (!c)
|
|
2529
2559
|
return;
|
|
@@ -2535,34 +2565,34 @@ var Civet = (() => {
|
|
|
2535
2565
|
kind.token = "if";
|
|
2536
2566
|
return {
|
|
2537
2567
|
type: "IfStatement",
|
|
2538
|
-
children: [kind, condition
|
|
2568
|
+
children: [kind, condition]
|
|
2539
2569
|
};
|
|
2540
2570
|
});
|
|
2541
|
-
function
|
|
2571
|
+
function UnlessClause(state) {
|
|
2572
|
+
if (state.verbose)
|
|
2573
|
+
console.log("ENTER:", "UnlessClause");
|
|
2542
2574
|
if (state.tokenize) {
|
|
2543
|
-
return $TOKEN("
|
|
2575
|
+
return $TOKEN("UnlessClause", state, UnlessClause$0(state));
|
|
2544
2576
|
} else {
|
|
2545
|
-
return
|
|
2577
|
+
return UnlessClause$0(state);
|
|
2546
2578
|
}
|
|
2547
2579
|
}
|
|
2548
2580
|
var IterationStatement$0 = LoopStatement;
|
|
2549
2581
|
var IterationStatement$1 = DoWhileStatement;
|
|
2550
2582
|
var IterationStatement$2 = WhileStatement;
|
|
2551
|
-
var IterationStatement$3 =
|
|
2552
|
-
return { "type": "IterationStatement", "children": value };
|
|
2553
|
-
});
|
|
2554
|
-
var IterationStatement$4 = $T($S(ForInOfStatement), function(value) {
|
|
2555
|
-
return { "type": "IterationStatement", "children": value };
|
|
2556
|
-
});
|
|
2583
|
+
var IterationStatement$3 = ForStatement;
|
|
2557
2584
|
function IterationStatement(state) {
|
|
2558
2585
|
if (state.tokenize) {
|
|
2559
|
-
return $TOKEN("IterationStatement", state, IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state)
|
|
2586
|
+
return $TOKEN("IterationStatement", state, IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state));
|
|
2560
2587
|
} else {
|
|
2561
|
-
return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state)
|
|
2588
|
+
return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state);
|
|
2562
2589
|
}
|
|
2563
2590
|
}
|
|
2564
|
-
var LoopStatement$0 = $
|
|
2565
|
-
|
|
2591
|
+
var LoopStatement$0 = $TS($S(LoopClause, Block), function($skip, $loc, $0, $1, $2) {
|
|
2592
|
+
var clause = $1;
|
|
2593
|
+
var block = $2;
|
|
2594
|
+
clause.children.push(block);
|
|
2595
|
+
return clause;
|
|
2566
2596
|
});
|
|
2567
2597
|
function LoopStatement(state) {
|
|
2568
2598
|
if (state.verbose)
|
|
@@ -2573,7 +2603,19 @@ var Civet = (() => {
|
|
|
2573
2603
|
return LoopStatement$0(state);
|
|
2574
2604
|
}
|
|
2575
2605
|
}
|
|
2576
|
-
var
|
|
2606
|
+
var LoopClause$0 = $T($S(Loop), function(value) {
|
|
2607
|
+
return { "type": "IterationStatement", "children": value };
|
|
2608
|
+
});
|
|
2609
|
+
function LoopClause(state) {
|
|
2610
|
+
if (state.verbose)
|
|
2611
|
+
console.log("ENTER:", "LoopClause");
|
|
2612
|
+
if (state.tokenize) {
|
|
2613
|
+
return $TOKEN("LoopClause", state, LoopClause$0(state));
|
|
2614
|
+
} else {
|
|
2615
|
+
return LoopClause$0(state);
|
|
2616
|
+
}
|
|
2617
|
+
}
|
|
2618
|
+
var DoWhileStatement$0 = $T($S(Do, BracedBlock, __, WhileClause), function(value) {
|
|
2577
2619
|
return { "type": "IterationStatement", "children": value };
|
|
2578
2620
|
});
|
|
2579
2621
|
function DoWhileStatement(state) {
|
|
@@ -2585,8 +2627,11 @@ var Civet = (() => {
|
|
|
2585
2627
|
return DoWhileStatement$0(state);
|
|
2586
2628
|
}
|
|
2587
2629
|
}
|
|
2588
|
-
var WhileStatement$0 = $
|
|
2589
|
-
|
|
2630
|
+
var WhileStatement$0 = $TS($S(WhileClause, Block), function($skip, $loc, $0, $1, $2) {
|
|
2631
|
+
var clause = $1;
|
|
2632
|
+
var block = $2;
|
|
2633
|
+
clause.children.push(block);
|
|
2634
|
+
return clause;
|
|
2590
2635
|
});
|
|
2591
2636
|
function WhileStatement(state) {
|
|
2592
2637
|
if (state.verbose)
|
|
@@ -2597,15 +2642,19 @@ var Civet = (() => {
|
|
|
2597
2642
|
return WhileStatement$0(state);
|
|
2598
2643
|
}
|
|
2599
2644
|
}
|
|
2600
|
-
var WhileClause$0 = $TS($S($C(
|
|
2645
|
+
var WhileClause$0 = $TS($S($C(While, Until), Condition), function($skip, $loc, $0, $1, $2) {
|
|
2601
2646
|
var kind = $1;
|
|
2602
|
-
var cond = $
|
|
2603
|
-
if (kind === "until") {
|
|
2647
|
+
var cond = $2;
|
|
2648
|
+
if (kind.token === "until") {
|
|
2604
2649
|
cond[1] = "(!(";
|
|
2605
|
-
cond[
|
|
2606
|
-
|
|
2650
|
+
cond[cond.length - 1] = "))";
|
|
2651
|
+
kind.token = "while";
|
|
2652
|
+
$0 = [kind, cond];
|
|
2607
2653
|
}
|
|
2608
|
-
return
|
|
2654
|
+
return {
|
|
2655
|
+
type: "IterationStatement",
|
|
2656
|
+
children: $0
|
|
2657
|
+
};
|
|
2609
2658
|
});
|
|
2610
2659
|
function WhileClause(state) {
|
|
2611
2660
|
if (state.verbose)
|
|
@@ -2616,7 +2665,12 @@ var Civet = (() => {
|
|
|
2616
2665
|
return WhileClause$0(state);
|
|
2617
2666
|
}
|
|
2618
2667
|
}
|
|
2619
|
-
var ForStatement$0 = $S(
|
|
2668
|
+
var ForStatement$0 = $TS($S(ForClause, Block), function($skip, $loc, $0, $1, $2) {
|
|
2669
|
+
var clause = $1;
|
|
2670
|
+
var block = $2;
|
|
2671
|
+
clause.children.push(block);
|
|
2672
|
+
return clause;
|
|
2673
|
+
});
|
|
2620
2674
|
function ForStatement(state) {
|
|
2621
2675
|
if (state.verbose)
|
|
2622
2676
|
console.log("ENTER:", "ForStatement");
|
|
@@ -2626,25 +2680,48 @@ var Civet = (() => {
|
|
|
2626
2680
|
return ForStatement$0(state);
|
|
2627
2681
|
}
|
|
2628
2682
|
}
|
|
2629
|
-
var
|
|
2630
|
-
|
|
2631
|
-
|
|
2632
|
-
|
|
2633
|
-
|
|
2683
|
+
var ForClause$0 = $T($S(For, __, ForStatementControl), function(value) {
|
|
2684
|
+
return { "type": "IterationStatement", "children": value };
|
|
2685
|
+
});
|
|
2686
|
+
function ForClause(state) {
|
|
2687
|
+
if (state.verbose)
|
|
2688
|
+
console.log("ENTER:", "ForClause");
|
|
2634
2689
|
if (state.tokenize) {
|
|
2635
|
-
return $TOKEN("
|
|
2690
|
+
return $TOKEN("ForClause", state, ForClause$0(state));
|
|
2636
2691
|
} else {
|
|
2637
|
-
return
|
|
2692
|
+
return ForClause$0(state);
|
|
2638
2693
|
}
|
|
2639
2694
|
}
|
|
2640
|
-
var
|
|
2695
|
+
var ForStatementControl$0 = $S(OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E(Expression), __, CloseParen);
|
|
2696
|
+
var ForStatementControl$1 = $S(InsertOpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E($S($N(EOS), Expression)), InsertCloseParen);
|
|
2697
|
+
var ForStatementControl$2 = $S(OpenParen, __, ForInOfDeclaration, __, In, Expression, __, CloseParen);
|
|
2698
|
+
var ForStatementControl$3 = $S(InsertOpenParen, ForInOfDeclaration, __, In, Expression, InsertCloseParen);
|
|
2699
|
+
var ForStatementControl$4 = $S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, Of, AssignmentExpression, __, CloseParen);
|
|
2700
|
+
var ForStatementControl$5 = $S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, Of, AssignmentExpression, InsertCloseParen);
|
|
2701
|
+
function ForStatementControl(state) {
|
|
2702
|
+
if (state.tokenize) {
|
|
2703
|
+
return $TOKEN("ForStatementControl", state, ForStatementControl$0(state) || ForStatementControl$1(state) || ForStatementControl$2(state) || ForStatementControl$3(state) || ForStatementControl$4(state) || ForStatementControl$5(state));
|
|
2704
|
+
} else {
|
|
2705
|
+
return ForStatementControl$0(state) || ForStatementControl$1(state) || ForStatementControl$2(state) || ForStatementControl$3(state) || ForStatementControl$4(state) || ForStatementControl$5(state);
|
|
2706
|
+
}
|
|
2707
|
+
}
|
|
2708
|
+
var ForInOfDeclaration$0 = $S(Var, ForBinding);
|
|
2709
|
+
var ForInOfDeclaration$1 = ForDeclaration;
|
|
2710
|
+
var ForInOfDeclaration$2 = LeftHandSideExpression;
|
|
2711
|
+
function ForInOfDeclaration(state) {
|
|
2712
|
+
if (state.tokenize) {
|
|
2713
|
+
return $TOKEN("ForInOfDeclaration", state, ForInOfDeclaration$0(state) || ForInOfDeclaration$1(state) || ForInOfDeclaration$2(state));
|
|
2714
|
+
} else {
|
|
2715
|
+
return ForInOfDeclaration$0(state) || ForInOfDeclaration$1(state) || ForInOfDeclaration$2(state);
|
|
2716
|
+
}
|
|
2717
|
+
}
|
|
2718
|
+
var ForDeclaration$0 = $S(LetOrConst, NonIdContinue, ForBinding);
|
|
2719
|
+
var ForDeclaration$1 = $S(InsertConst, ForBinding, $R$0($EXPECT($R3, fail, "ForDeclaration /(?=[\\s\\)])/")));
|
|
2641
2720
|
function ForDeclaration(state) {
|
|
2642
|
-
if (state.verbose)
|
|
2643
|
-
console.log("ENTER:", "ForDeclaration");
|
|
2644
2721
|
if (state.tokenize) {
|
|
2645
|
-
return $TOKEN("ForDeclaration", state, ForDeclaration$0(state));
|
|
2722
|
+
return $TOKEN("ForDeclaration", state, ForDeclaration$0(state) || ForDeclaration$1(state));
|
|
2646
2723
|
} else {
|
|
2647
|
-
return ForDeclaration$0(state);
|
|
2724
|
+
return ForDeclaration$0(state) || ForDeclaration$1(state);
|
|
2648
2725
|
}
|
|
2649
2726
|
}
|
|
2650
2727
|
var ForBinding$0 = BindingIdentifier;
|
|
@@ -2768,7 +2845,7 @@ var Civet = (() => {
|
|
|
2768
2845
|
return CaseExpressionList$0(state);
|
|
2769
2846
|
}
|
|
2770
2847
|
}
|
|
2771
|
-
var NoExpressions$0 = $T($EXPECT($
|
|
2848
|
+
var NoExpressions$0 = $T($EXPECT($L0, fail, 'NoExpressions ""'), function(value) {
|
|
2772
2849
|
return [];
|
|
2773
2850
|
});
|
|
2774
2851
|
function NoExpressions(state) {
|
|
@@ -2781,7 +2858,7 @@ var Civet = (() => {
|
|
|
2781
2858
|
}
|
|
2782
2859
|
}
|
|
2783
2860
|
var ImpliedColon$0 = $S(__, Colon);
|
|
2784
|
-
var ImpliedColon$1 = $TV($EXPECT($
|
|
2861
|
+
var ImpliedColon$1 = $TV($EXPECT($L0, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
2785
2862
|
return { $loc, token: ":" };
|
|
2786
2863
|
});
|
|
2787
2864
|
function ImpliedColon(state) {
|
|
@@ -2835,7 +2912,7 @@ var Civet = (() => {
|
|
|
2835
2912
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2836
2913
|
}
|
|
2837
2914
|
}
|
|
2838
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2915
|
+
var Finally$0 = $S(__, $EXPECT($L72, fail, 'Finally "finally"'), BracedBlock);
|
|
2839
2916
|
function Finally(state) {
|
|
2840
2917
|
if (state.verbose)
|
|
2841
2918
|
console.log("ENTER:", "Finally");
|
|
@@ -2855,7 +2932,10 @@ var Civet = (() => {
|
|
|
2855
2932
|
}
|
|
2856
2933
|
}
|
|
2857
2934
|
var Condition$0 = $S(__, OpenParen, Expression, __, CloseParen);
|
|
2858
|
-
var Condition$1 = $S($N(EOS), __, InsertOpenParen, ExpressionWithIndentedApplicationSuppressed, InsertCloseParen)
|
|
2935
|
+
var Condition$1 = $TS($S($N(EOS), __, InsertOpenParen, ExpressionWithIndentedApplicationSuppressed, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
2936
|
+
$0.shift();
|
|
2937
|
+
return $0;
|
|
2938
|
+
});
|
|
2859
2939
|
function Condition(state) {
|
|
2860
2940
|
if (state.tokenize) {
|
|
2861
2941
|
return $TOKEN("Condition", state, Condition$0(state) || Condition$1(state));
|
|
@@ -2879,7 +2959,7 @@ var Civet = (() => {
|
|
|
2879
2959
|
return ExpressionWithIndentedApplicationSuppressed$0(state);
|
|
2880
2960
|
}
|
|
2881
2961
|
}
|
|
2882
|
-
var SuppressIndentedApplication$0 = $TV($EXPECT($
|
|
2962
|
+
var SuppressIndentedApplication$0 = $TV($EXPECT($L0, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
|
|
2883
2963
|
module.suppressIndentedApplication = true;
|
|
2884
2964
|
});
|
|
2885
2965
|
function SuppressIndentedApplication(state) {
|
|
@@ -2901,13 +2981,13 @@ var Civet = (() => {
|
|
|
2901
2981
|
return ExpressionStatement$0(state);
|
|
2902
2982
|
}
|
|
2903
2983
|
}
|
|
2904
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
2984
|
+
var KeywordStatement$0 = $T($S($EXPECT($L73, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
2905
2985
|
return { "type": "BreakStatement", "children": value };
|
|
2906
2986
|
});
|
|
2907
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
2987
|
+
var KeywordStatement$1 = $T($S($EXPECT($L74, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
2908
2988
|
return { "type": "ContinueStatement", "children": value };
|
|
2909
2989
|
});
|
|
2910
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
2990
|
+
var KeywordStatement$2 = $T($S($EXPECT($L75, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
2911
2991
|
return { "type": "DebuggerStatement", "children": value };
|
|
2912
2992
|
});
|
|
2913
2993
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -2932,7 +3012,7 @@ var Civet = (() => {
|
|
|
2932
3012
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2933
3013
|
}
|
|
2934
3014
|
}
|
|
2935
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
3015
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L76, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2936
3016
|
return { "ts": true, "children": value };
|
|
2937
3017
|
});
|
|
2938
3018
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
@@ -2955,7 +3035,7 @@ var Civet = (() => {
|
|
|
2955
3035
|
return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state);
|
|
2956
3036
|
}
|
|
2957
3037
|
}
|
|
2958
|
-
var ImpliedImport$0 = $TV($EXPECT($
|
|
3038
|
+
var ImpliedImport$0 = $TV($EXPECT($L0, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
2959
3039
|
return { $loc, token: "import " };
|
|
2960
3040
|
});
|
|
2961
3041
|
function ImpliedImport(state) {
|
|
@@ -3047,7 +3127,7 @@ var Civet = (() => {
|
|
|
3047
3127
|
return UnprocessedModuleSpecifier$0(state) || UnprocessedModuleSpecifier$1(state);
|
|
3048
3128
|
}
|
|
3049
3129
|
}
|
|
3050
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
3130
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R4, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
3051
3131
|
var spec = $0;
|
|
3052
3132
|
return { $loc, token: `"${spec}"` };
|
|
3053
3133
|
});
|
|
@@ -3070,7 +3150,7 @@ var Civet = (() => {
|
|
|
3070
3150
|
return ImportedBinding$0(state);
|
|
3071
3151
|
}
|
|
3072
3152
|
}
|
|
3073
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
3153
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L77, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
3074
3154
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
3075
3155
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
3076
3156
|
function ExportDeclaration(state) {
|
|
@@ -3152,7 +3232,7 @@ var Civet = (() => {
|
|
|
3152
3232
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
3153
3233
|
}
|
|
3154
3234
|
}
|
|
3155
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
3235
|
+
var ConstAssignment$0 = $TV($EXPECT($L78, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
3156
3236
|
return { $loc, token: "=" };
|
|
3157
3237
|
});
|
|
3158
3238
|
function ConstAssignment(state) {
|
|
@@ -3238,7 +3318,7 @@ var Civet = (() => {
|
|
|
3238
3318
|
return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
|
|
3239
3319
|
}
|
|
3240
3320
|
}
|
|
3241
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
3321
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
3242
3322
|
function DecimalBigIntegerLiteral(state) {
|
|
3243
3323
|
if (state.verbose)
|
|
3244
3324
|
console.log("ENTER:", "DecimalBigIntegerLiteral");
|
|
@@ -3248,11 +3328,11 @@ var Civet = (() => {
|
|
|
3248
3328
|
return DecimalBigIntegerLiteral$0(state);
|
|
3249
3329
|
}
|
|
3250
3330
|
}
|
|
3251
|
-
var DecimalLiteral$0 = $TV($TEXT($EXPECT($
|
|
3331
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R6, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
3252
3332
|
return $1 + ".";
|
|
3253
3333
|
});
|
|
3254
|
-
var DecimalLiteral$1 = $TEXT($S($EXPECT($
|
|
3255
|
-
var DecimalLiteral$2 = $TEXT($S($EXPECT($
|
|
3334
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R7, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*)?)?/"), $E(ExponentPart)));
|
|
3335
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R8, fail, "DecimalLiteral /(?:\\.(?!\\p{ID_Start})[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
3256
3336
|
function DecimalLiteral(state) {
|
|
3257
3337
|
if (state.tokenize) {
|
|
3258
3338
|
return $TOKEN("DecimalLiteral", state, DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state));
|
|
@@ -3260,7 +3340,7 @@ var Civet = (() => {
|
|
|
3260
3340
|
return DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state);
|
|
3261
3341
|
}
|
|
3262
3342
|
}
|
|
3263
|
-
var ExponentPart$0 = $R$0($EXPECT($
|
|
3343
|
+
var ExponentPart$0 = $R$0($EXPECT($R9, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
3264
3344
|
function ExponentPart(state) {
|
|
3265
3345
|
if (state.verbose)
|
|
3266
3346
|
console.log("ENTER:", "ExponentPart");
|
|
@@ -3270,7 +3350,7 @@ var Civet = (() => {
|
|
|
3270
3350
|
return ExponentPart$0(state);
|
|
3271
3351
|
}
|
|
3272
3352
|
}
|
|
3273
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
3353
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R10, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
3274
3354
|
function BinaryIntegerLiteral(state) {
|
|
3275
3355
|
if (state.verbose)
|
|
3276
3356
|
console.log("ENTER:", "BinaryIntegerLiteral");
|
|
@@ -3280,7 +3360,7 @@ var Civet = (() => {
|
|
|
3280
3360
|
return BinaryIntegerLiteral$0(state);
|
|
3281
3361
|
}
|
|
3282
3362
|
}
|
|
3283
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
3363
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R11, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
3284
3364
|
function OctalIntegerLiteral(state) {
|
|
3285
3365
|
if (state.verbose)
|
|
3286
3366
|
console.log("ENTER:", "OctalIntegerLiteral");
|
|
@@ -3290,7 +3370,7 @@ var Civet = (() => {
|
|
|
3290
3370
|
return OctalIntegerLiteral$0(state);
|
|
3291
3371
|
}
|
|
3292
3372
|
}
|
|
3293
|
-
var HexLiteral$0 = $R$0($EXPECT($
|
|
3373
|
+
var HexLiteral$0 = $R$0($EXPECT($R12, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
3294
3374
|
function HexLiteral(state) {
|
|
3295
3375
|
if (state.verbose)
|
|
3296
3376
|
console.log("ENTER:", "HexLiteral");
|
|
@@ -3339,7 +3419,7 @@ var Civet = (() => {
|
|
|
3339
3419
|
return BasicStringLiteral$0(state) || BasicStringLiteral$1(state);
|
|
3340
3420
|
}
|
|
3341
3421
|
}
|
|
3342
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
3422
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R13, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3343
3423
|
return { $loc, token: $0 };
|
|
3344
3424
|
});
|
|
3345
3425
|
function DoubleStringCharacters(state) {
|
|
@@ -3351,7 +3431,7 @@ var Civet = (() => {
|
|
|
3351
3431
|
return DoubleStringCharacters$0(state);
|
|
3352
3432
|
}
|
|
3353
3433
|
}
|
|
3354
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
3434
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R14, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3355
3435
|
return { $loc, token: $0 };
|
|
3356
3436
|
});
|
|
3357
3437
|
function SingleStringCharacters(state) {
|
|
@@ -3363,7 +3443,7 @@ var Civet = (() => {
|
|
|
3363
3443
|
return SingleStringCharacters$0(state);
|
|
3364
3444
|
}
|
|
3365
3445
|
}
|
|
3366
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
3446
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R15, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3367
3447
|
return { $loc, token: $0 };
|
|
3368
3448
|
});
|
|
3369
3449
|
function TripleDoubleStringCharacters(state) {
|
|
@@ -3375,7 +3455,7 @@ var Civet = (() => {
|
|
|
3375
3455
|
return TripleDoubleStringCharacters$0(state);
|
|
3376
3456
|
}
|
|
3377
3457
|
}
|
|
3378
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
3458
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R16, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3379
3459
|
return { $loc, token: $0 };
|
|
3380
3460
|
});
|
|
3381
3461
|
function TripleSingleStringCharacters(state) {
|
|
@@ -3426,7 +3506,7 @@ var Civet = (() => {
|
|
|
3426
3506
|
return CoffeeInterpolatedDoubleQuotedString$0(state);
|
|
3427
3507
|
}
|
|
3428
3508
|
}
|
|
3429
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
3509
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R17, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3430
3510
|
return { $loc, token: $0 };
|
|
3431
3511
|
});
|
|
3432
3512
|
function CoffeeDoubleQuotedStringCharacters(state) {
|
|
@@ -3438,7 +3518,7 @@ var Civet = (() => {
|
|
|
3438
3518
|
return CoffeeDoubleQuotedStringCharacters$0(state);
|
|
3439
3519
|
}
|
|
3440
3520
|
}
|
|
3441
|
-
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($
|
|
3521
|
+
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L46, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L46, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
3442
3522
|
return { $loc, token: $1 };
|
|
3443
3523
|
});
|
|
3444
3524
|
function RegularExpressionLiteral(state) {
|
|
@@ -3450,7 +3530,7 @@ var Civet = (() => {
|
|
|
3450
3530
|
return RegularExpressionLiteral$0(state);
|
|
3451
3531
|
}
|
|
3452
3532
|
}
|
|
3453
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
3533
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R18, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
|
|
3454
3534
|
function RegularExpressionBody(state) {
|
|
3455
3535
|
if (state.verbose)
|
|
3456
3536
|
console.log("ENTER:", "RegularExpressionBody");
|
|
@@ -3460,7 +3540,7 @@ var Civet = (() => {
|
|
|
3460
3540
|
return RegularExpressionBody$0(state);
|
|
3461
3541
|
}
|
|
3462
3542
|
}
|
|
3463
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
3543
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R19, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
3464
3544
|
function RegExpCharacter(state) {
|
|
3465
3545
|
if (state.verbose)
|
|
3466
3546
|
console.log("ENTER:", "RegExpCharacter");
|
|
@@ -3470,7 +3550,7 @@ var Civet = (() => {
|
|
|
3470
3550
|
return RegExpCharacter$0(state);
|
|
3471
3551
|
}
|
|
3472
3552
|
}
|
|
3473
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
3553
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R20, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
3474
3554
|
function RegularExpressionFlags(state) {
|
|
3475
3555
|
if (state.verbose)
|
|
3476
3556
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -3483,7 +3563,7 @@ var Civet = (() => {
|
|
|
3483
3563
|
var TemplateLiteral$0 = $TS($S(TripleTick, $Q($C(TemplateBlockCharacters, TemplateSubstitution)), TripleTick), function($skip, $loc, $0, $1, $2, $3) {
|
|
3484
3564
|
return module.dedentBlockSubstitutions($0);
|
|
3485
3565
|
});
|
|
3486
|
-
var TemplateLiteral$1 = $S(
|
|
3566
|
+
var TemplateLiteral$1 = $S(Backtick, $Q($C(TemplateCharacters, TemplateSubstitution)), Backtick);
|
|
3487
3567
|
function TemplateLiteral(state) {
|
|
3488
3568
|
if (state.tokenize) {
|
|
3489
3569
|
return $TOKEN("TemplateLiteral", state, TemplateLiteral$0(state) || TemplateLiteral$1(state));
|
|
@@ -3501,7 +3581,7 @@ var Civet = (() => {
|
|
|
3501
3581
|
return TemplateSubstitution$0(state);
|
|
3502
3582
|
}
|
|
3503
3583
|
}
|
|
3504
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
3584
|
+
var TemplateCharacters$0 = $TR($EXPECT($R21, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3505
3585
|
return { $loc, token: $0 };
|
|
3506
3586
|
});
|
|
3507
3587
|
function TemplateCharacters(state) {
|
|
@@ -3513,7 +3593,7 @@ var Civet = (() => {
|
|
|
3513
3593
|
return TemplateCharacters$0(state);
|
|
3514
3594
|
}
|
|
3515
3595
|
}
|
|
3516
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
3596
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R22, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3517
3597
|
return { $loc, token: $0 };
|
|
3518
3598
|
});
|
|
3519
3599
|
function TemplateBlockCharacters(state) {
|
|
@@ -3525,8 +3605,8 @@ var Civet = (() => {
|
|
|
3525
3605
|
return TemplateBlockCharacters$0(state);
|
|
3526
3606
|
}
|
|
3527
3607
|
}
|
|
3528
|
-
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($
|
|
3529
|
-
var ReservedWord$1 = $R$0($EXPECT($
|
|
3608
|
+
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R23, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
|
|
3609
|
+
var ReservedWord$1 = $R$0($EXPECT($R24, 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|loop|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
3530
3610
|
function ReservedWord(state) {
|
|
3531
3611
|
if (state.tokenize) {
|
|
3532
3612
|
return $TOKEN("ReservedWord", state, ReservedWord$0(state) || ReservedWord$1(state));
|
|
@@ -3543,7 +3623,7 @@ var Civet = (() => {
|
|
|
3543
3623
|
return Comment$0(state) || Comment$1(state);
|
|
3544
3624
|
}
|
|
3545
3625
|
}
|
|
3546
|
-
var SingleLineComment$0 = $TR($EXPECT($
|
|
3626
|
+
var SingleLineComment$0 = $TR($EXPECT($R25, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3547
3627
|
return { $loc, token: $0 };
|
|
3548
3628
|
});
|
|
3549
3629
|
var SingleLineComment$1 = $S(CoffeeCommentEnabled, CoffeeSingleLineComment);
|
|
@@ -3563,7 +3643,7 @@ var Civet = (() => {
|
|
|
3563
3643
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
3564
3644
|
}
|
|
3565
3645
|
}
|
|
3566
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
3646
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L79, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L80, fail, 'JSMultiLineComment "*/"')), $EXPECT($R26, fail, "JSMultiLineComment /./"))), $EXPECT($L80, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
3567
3647
|
return { $loc, token: $1 };
|
|
3568
3648
|
});
|
|
3569
3649
|
function JSMultiLineComment(state) {
|
|
@@ -3575,7 +3655,7 @@ var Civet = (() => {
|
|
|
3575
3655
|
return JSMultiLineComment$0(state);
|
|
3576
3656
|
}
|
|
3577
3657
|
}
|
|
3578
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
3658
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R27, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3579
3659
|
return { $loc, token: `//${$1}` };
|
|
3580
3660
|
});
|
|
3581
3661
|
function CoffeeSingleLineComment(state) {
|
|
@@ -3587,7 +3667,7 @@ var Civet = (() => {
|
|
|
3587
3667
|
return CoffeeSingleLineComment$0(state);
|
|
3588
3668
|
}
|
|
3589
3669
|
}
|
|
3590
|
-
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($
|
|
3670
|
+
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L81, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L81, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L80, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R26, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L81, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3591
3671
|
return { $loc, token: `/*${$2}*/` };
|
|
3592
3672
|
});
|
|
3593
3673
|
function CoffeeMultiLineComment(state) {
|
|
@@ -3599,7 +3679,7 @@ var Civet = (() => {
|
|
|
3599
3679
|
return CoffeeMultiLineComment$0(state);
|
|
3600
3680
|
}
|
|
3601
3681
|
}
|
|
3602
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
3682
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L79, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L80, fail, 'InlineComment "*/"')), $EXPECT($R28, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L80, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
3603
3683
|
return { $loc, token: $1 };
|
|
3604
3684
|
});
|
|
3605
3685
|
function InlineComment(state) {
|
|
@@ -3641,7 +3721,7 @@ var Civet = (() => {
|
|
|
3641
3721
|
return _$0(state);
|
|
3642
3722
|
}
|
|
3643
3723
|
}
|
|
3644
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
3724
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R29, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3645
3725
|
return { $loc, token: $0 };
|
|
3646
3726
|
});
|
|
3647
3727
|
function NonNewlineWhitespace(state) {
|
|
@@ -3663,7 +3743,7 @@ var Civet = (() => {
|
|
|
3663
3743
|
return __$0(state);
|
|
3664
3744
|
}
|
|
3665
3745
|
}
|
|
3666
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
3746
|
+
var Whitespace$0 = $TR($EXPECT($R30, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3667
3747
|
return { $loc, token: $0 };
|
|
3668
3748
|
});
|
|
3669
3749
|
function Whitespace(state) {
|
|
@@ -3684,7 +3764,7 @@ var Civet = (() => {
|
|
|
3684
3764
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
3685
3765
|
}
|
|
3686
3766
|
}
|
|
3687
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3767
|
+
var NonIdContinue$0 = $R$0($EXPECT($R31, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
3688
3768
|
function NonIdContinue(state) {
|
|
3689
3769
|
if (state.verbose)
|
|
3690
3770
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -3694,7 +3774,7 @@ var Civet = (() => {
|
|
|
3694
3774
|
return NonIdContinue$0(state);
|
|
3695
3775
|
}
|
|
3696
3776
|
}
|
|
3697
|
-
var Loc$0 = $TV($EXPECT($
|
|
3777
|
+
var Loc$0 = $TV($EXPECT($L0, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
3698
3778
|
return { $loc, token: "" };
|
|
3699
3779
|
});
|
|
3700
3780
|
function Loc(state) {
|
|
@@ -3706,7 +3786,7 @@ var Civet = (() => {
|
|
|
3706
3786
|
return Loc$0(state);
|
|
3707
3787
|
}
|
|
3708
3788
|
}
|
|
3709
|
-
var As$0 = $TS($S($EXPECT($
|
|
3789
|
+
var As$0 = $TS($S($EXPECT($L82, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3710
3790
|
return { $loc, token: $1 };
|
|
3711
3791
|
});
|
|
3712
3792
|
function As(state) {
|
|
@@ -3718,7 +3798,7 @@ var Civet = (() => {
|
|
|
3718
3798
|
return As$0(state);
|
|
3719
3799
|
}
|
|
3720
3800
|
}
|
|
3721
|
-
var Async$0 = $TV($EXPECT($
|
|
3801
|
+
var Async$0 = $TV($EXPECT($L83, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
|
|
3722
3802
|
return { $loc, token: $1 };
|
|
3723
3803
|
});
|
|
3724
3804
|
function Async(state) {
|
|
@@ -3730,7 +3810,7 @@ var Civet = (() => {
|
|
|
3730
3810
|
return Async$0(state);
|
|
3731
3811
|
}
|
|
3732
3812
|
}
|
|
3733
|
-
var Await$0 = $TS($S($EXPECT($
|
|
3813
|
+
var Await$0 = $TS($S($EXPECT($L84, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3734
3814
|
return { $loc, token: $1 };
|
|
3735
3815
|
});
|
|
3736
3816
|
function Await(state) {
|
|
@@ -3742,7 +3822,19 @@ var Civet = (() => {
|
|
|
3742
3822
|
return Await$0(state);
|
|
3743
3823
|
}
|
|
3744
3824
|
}
|
|
3745
|
-
var
|
|
3825
|
+
var Backtick$0 = $TV($EXPECT($L85, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
3826
|
+
return { $loc, token: $1 };
|
|
3827
|
+
});
|
|
3828
|
+
function Backtick(state) {
|
|
3829
|
+
if (state.verbose)
|
|
3830
|
+
console.log("ENTER:", "Backtick");
|
|
3831
|
+
if (state.tokenize) {
|
|
3832
|
+
return $TOKEN("Backtick", state, Backtick$0(state));
|
|
3833
|
+
} else {
|
|
3834
|
+
return Backtick$0(state);
|
|
3835
|
+
}
|
|
3836
|
+
}
|
|
3837
|
+
var Case$0 = $TS($S($EXPECT($L86, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3746
3838
|
return { $loc, token: $1 };
|
|
3747
3839
|
});
|
|
3748
3840
|
function Case(state) {
|
|
@@ -3754,7 +3846,7 @@ var Civet = (() => {
|
|
|
3754
3846
|
return Case$0(state);
|
|
3755
3847
|
}
|
|
3756
3848
|
}
|
|
3757
|
-
var Catch$0 = $TV($EXPECT($
|
|
3849
|
+
var Catch$0 = $TV($EXPECT($L87, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
3758
3850
|
return { $loc, token: $1 };
|
|
3759
3851
|
});
|
|
3760
3852
|
function Catch(state) {
|
|
@@ -3766,7 +3858,7 @@ var Civet = (() => {
|
|
|
3766
3858
|
return Catch$0(state);
|
|
3767
3859
|
}
|
|
3768
3860
|
}
|
|
3769
|
-
var Class$0 = $TV($EXPECT($
|
|
3861
|
+
var Class$0 = $TV($EXPECT($L88, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
3770
3862
|
return { $loc, token: $1 };
|
|
3771
3863
|
});
|
|
3772
3864
|
function Class(state) {
|
|
@@ -3778,7 +3870,7 @@ var Civet = (() => {
|
|
|
3778
3870
|
return Class$0(state);
|
|
3779
3871
|
}
|
|
3780
3872
|
}
|
|
3781
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
3873
|
+
var CloseBrace$0 = $TV($EXPECT($L26, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
3782
3874
|
return { $loc, token: $1 };
|
|
3783
3875
|
});
|
|
3784
3876
|
function CloseBrace(state) {
|
|
@@ -3790,7 +3882,7 @@ var Civet = (() => {
|
|
|
3790
3882
|
return CloseBrace$0(state);
|
|
3791
3883
|
}
|
|
3792
3884
|
}
|
|
3793
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
3885
|
+
var CloseBracket$0 = $TV($EXPECT($L25, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
3794
3886
|
return { $loc, token: $1 };
|
|
3795
3887
|
});
|
|
3796
3888
|
function CloseBracket(state) {
|
|
@@ -3802,7 +3894,7 @@ var Civet = (() => {
|
|
|
3802
3894
|
return CloseBracket$0(state);
|
|
3803
3895
|
}
|
|
3804
3896
|
}
|
|
3805
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
3897
|
+
var CloseParen$0 = $TV($EXPECT($L15, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
3806
3898
|
return { $loc, token: $1 };
|
|
3807
3899
|
});
|
|
3808
3900
|
function CloseParen(state) {
|
|
@@ -3814,7 +3906,7 @@ var Civet = (() => {
|
|
|
3814
3906
|
return CloseParen$0(state);
|
|
3815
3907
|
}
|
|
3816
3908
|
}
|
|
3817
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
3909
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L89, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
3818
3910
|
return { $loc, token: "${" };
|
|
3819
3911
|
});
|
|
3820
3912
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -3826,7 +3918,7 @@ var Civet = (() => {
|
|
|
3826
3918
|
return CoffeeSubstitutionStart$0(state);
|
|
3827
3919
|
}
|
|
3828
3920
|
}
|
|
3829
|
-
var Colon$0 = $TV($EXPECT($
|
|
3921
|
+
var Colon$0 = $TV($EXPECT($L90, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
3830
3922
|
return { $loc, token: $1 };
|
|
3831
3923
|
});
|
|
3832
3924
|
function Colon(state) {
|
|
@@ -3838,7 +3930,7 @@ var Civet = (() => {
|
|
|
3838
3930
|
return Colon$0(state);
|
|
3839
3931
|
}
|
|
3840
3932
|
}
|
|
3841
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
3933
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L8, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
3842
3934
|
return { $loc, token: "constructor" };
|
|
3843
3935
|
});
|
|
3844
3936
|
function ConstructorShorthand(state) {
|
|
@@ -3850,7 +3942,7 @@ var Civet = (() => {
|
|
|
3850
3942
|
return ConstructorShorthand$0(state);
|
|
3851
3943
|
}
|
|
3852
3944
|
}
|
|
3853
|
-
var Default$0 = $TS($S($EXPECT($
|
|
3945
|
+
var Default$0 = $TS($S($EXPECT($L77, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3854
3946
|
return { $loc, token: $1 };
|
|
3855
3947
|
});
|
|
3856
3948
|
function Default(state) {
|
|
@@ -3862,7 +3954,31 @@ var Civet = (() => {
|
|
|
3862
3954
|
return Default$0(state);
|
|
3863
3955
|
}
|
|
3864
3956
|
}
|
|
3865
|
-
var
|
|
3957
|
+
var Delete$0 = $TS($S($EXPECT($L91, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3958
|
+
return { $loc, token: $1 };
|
|
3959
|
+
});
|
|
3960
|
+
function Delete(state) {
|
|
3961
|
+
if (state.verbose)
|
|
3962
|
+
console.log("ENTER:", "Delete");
|
|
3963
|
+
if (state.tokenize) {
|
|
3964
|
+
return $TOKEN("Delete", state, Delete$0(state));
|
|
3965
|
+
} else {
|
|
3966
|
+
return Delete$0(state);
|
|
3967
|
+
}
|
|
3968
|
+
}
|
|
3969
|
+
var Do$0 = $TS($S($EXPECT($L92, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3970
|
+
return { $loc, token: $1 };
|
|
3971
|
+
});
|
|
3972
|
+
function Do(state) {
|
|
3973
|
+
if (state.verbose)
|
|
3974
|
+
console.log("ENTER:", "Do");
|
|
3975
|
+
if (state.tokenize) {
|
|
3976
|
+
return $TOKEN("Do", state, Do$0(state));
|
|
3977
|
+
} else {
|
|
3978
|
+
return Do$0(state);
|
|
3979
|
+
}
|
|
3980
|
+
}
|
|
3981
|
+
var Dot$0 = $TV($EXPECT($L93, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
3866
3982
|
return { $loc, token: $1 };
|
|
3867
3983
|
});
|
|
3868
3984
|
function Dot(state) {
|
|
@@ -3874,7 +3990,7 @@ var Civet = (() => {
|
|
|
3874
3990
|
return Dot$0(state);
|
|
3875
3991
|
}
|
|
3876
3992
|
}
|
|
3877
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
3993
|
+
var DotDotDot$0 = $TV($EXPECT($L94, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
3878
3994
|
return { $loc, token: $1 };
|
|
3879
3995
|
});
|
|
3880
3996
|
function DotDotDot(state) {
|
|
@@ -3886,7 +4002,7 @@ var Civet = (() => {
|
|
|
3886
4002
|
return DotDotDot$0(state);
|
|
3887
4003
|
}
|
|
3888
4004
|
}
|
|
3889
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
4005
|
+
var DoubleQuote$0 = $TV($EXPECT($L95, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
3890
4006
|
return { $loc, token: $1 };
|
|
3891
4007
|
});
|
|
3892
4008
|
function DoubleQuote(state) {
|
|
@@ -3898,7 +4014,7 @@ var Civet = (() => {
|
|
|
3898
4014
|
return DoubleQuote$0(state);
|
|
3899
4015
|
}
|
|
3900
4016
|
}
|
|
3901
|
-
var Else$0 = $TV($EXPECT($
|
|
4017
|
+
var Else$0 = $TV($EXPECT($L96, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
3902
4018
|
return { $loc, token: $1 };
|
|
3903
4019
|
});
|
|
3904
4020
|
function Else(state) {
|
|
@@ -3910,7 +4026,7 @@ var Civet = (() => {
|
|
|
3910
4026
|
return Else$0(state);
|
|
3911
4027
|
}
|
|
3912
4028
|
}
|
|
3913
|
-
var Equals$0 = $TV($EXPECT($
|
|
4029
|
+
var Equals$0 = $TV($EXPECT($L43, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
3914
4030
|
return { $loc, token: $1 };
|
|
3915
4031
|
});
|
|
3916
4032
|
function Equals(state) {
|
|
@@ -3922,7 +4038,7 @@ var Civet = (() => {
|
|
|
3922
4038
|
return Equals$0(state);
|
|
3923
4039
|
}
|
|
3924
4040
|
}
|
|
3925
|
-
var Export$0 = $TS($S($EXPECT($
|
|
4041
|
+
var Export$0 = $TS($S($EXPECT($L97, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3926
4042
|
return { $loc, token: $1 };
|
|
3927
4043
|
});
|
|
3928
4044
|
function Export(state) {
|
|
@@ -3934,7 +4050,7 @@ var Civet = (() => {
|
|
|
3934
4050
|
return Export$0(state);
|
|
3935
4051
|
}
|
|
3936
4052
|
}
|
|
3937
|
-
var For$0 = $TS($S($EXPECT($
|
|
4053
|
+
var For$0 = $TS($S($EXPECT($L98, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3938
4054
|
return { $loc, token: $1 };
|
|
3939
4055
|
});
|
|
3940
4056
|
function For(state) {
|
|
@@ -3946,7 +4062,7 @@ var Civet = (() => {
|
|
|
3946
4062
|
return For$0(state);
|
|
3947
4063
|
}
|
|
3948
4064
|
}
|
|
3949
|
-
var From$0 = $TS($S($EXPECT($
|
|
4065
|
+
var From$0 = $TS($S($EXPECT($L99, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3950
4066
|
return { $loc, token: $1 };
|
|
3951
4067
|
});
|
|
3952
4068
|
function From(state) {
|
|
@@ -3958,7 +4074,7 @@ var Civet = (() => {
|
|
|
3958
4074
|
return From$0(state);
|
|
3959
4075
|
}
|
|
3960
4076
|
}
|
|
3961
|
-
var Function$0 = $TV($EXPECT($
|
|
4077
|
+
var Function$0 = $TV($EXPECT($L100, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
3962
4078
|
return { $loc, token: $1 };
|
|
3963
4079
|
});
|
|
3964
4080
|
function Function(state) {
|
|
@@ -3970,7 +4086,7 @@ var Civet = (() => {
|
|
|
3970
4086
|
return Function$0(state);
|
|
3971
4087
|
}
|
|
3972
4088
|
}
|
|
3973
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
4089
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L101, fail, 'GetOrSet "get"'), $EXPECT($L102, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3974
4090
|
return { $loc, token: $1 };
|
|
3975
4091
|
});
|
|
3976
4092
|
function GetOrSet(state) {
|
|
@@ -3982,7 +4098,7 @@ var Civet = (() => {
|
|
|
3982
4098
|
return GetOrSet$0(state);
|
|
3983
4099
|
}
|
|
3984
4100
|
}
|
|
3985
|
-
var If$0 = $TV($EXPECT($
|
|
4101
|
+
var If$0 = $TV($EXPECT($L103, fail, 'If "if"'), function($skip, $loc, $0, $1) {
|
|
3986
4102
|
return { $loc, token: $1 };
|
|
3987
4103
|
});
|
|
3988
4104
|
function If(state) {
|
|
@@ -3994,7 +4110,7 @@ var Civet = (() => {
|
|
|
3994
4110
|
return If$0(state);
|
|
3995
4111
|
}
|
|
3996
4112
|
}
|
|
3997
|
-
var Import$0 = $TS($S($EXPECT($
|
|
4113
|
+
var Import$0 = $TS($S($EXPECT($L10, fail, 'Import "import"'), $Y($EXPECT($R32, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
3998
4114
|
return { $loc, token: $1 };
|
|
3999
4115
|
});
|
|
4000
4116
|
function Import(state) {
|
|
@@ -4006,7 +4122,7 @@ var Civet = (() => {
|
|
|
4006
4122
|
return Import$0(state);
|
|
4007
4123
|
}
|
|
4008
4124
|
}
|
|
4009
|
-
var In$0 = $TV($EXPECT($
|
|
4125
|
+
var In$0 = $TV($EXPECT($L67, fail, 'In "in"'), function($skip, $loc, $0, $1) {
|
|
4010
4126
|
return { $loc, token: $1 };
|
|
4011
4127
|
});
|
|
4012
4128
|
function In(state) {
|
|
@@ -4018,7 +4134,7 @@ var Civet = (() => {
|
|
|
4018
4134
|
return In$0(state);
|
|
4019
4135
|
}
|
|
4020
4136
|
}
|
|
4021
|
-
var LetOrConst$0 = $TV($C($EXPECT($
|
|
4137
|
+
var LetOrConst$0 = $TV($C($EXPECT($L104, fail, 'LetOrConst "let"'), $EXPECT($L105, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
4022
4138
|
return { $loc, token: $1 };
|
|
4023
4139
|
});
|
|
4024
4140
|
function LetOrConst(state) {
|
|
@@ -4030,7 +4146,7 @@ var Civet = (() => {
|
|
|
4030
4146
|
return LetOrConst$0(state);
|
|
4031
4147
|
}
|
|
4032
4148
|
}
|
|
4033
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
4149
|
+
var Loop$0 = $TS($S($EXPECT($L106, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4034
4150
|
return { $loc, token: "while(true)" };
|
|
4035
4151
|
});
|
|
4036
4152
|
function Loop(state) {
|
|
@@ -4042,7 +4158,7 @@ var Civet = (() => {
|
|
|
4042
4158
|
return Loop$0(state);
|
|
4043
4159
|
}
|
|
4044
4160
|
}
|
|
4045
|
-
var New$0 = $TV($EXPECT($
|
|
4161
|
+
var New$0 = $TV($EXPECT($L107, fail, 'New "new"'), function($skip, $loc, $0, $1) {
|
|
4046
4162
|
return { $loc, token: $1 };
|
|
4047
4163
|
});
|
|
4048
4164
|
function New(state) {
|
|
@@ -4054,7 +4170,7 @@ var Civet = (() => {
|
|
|
4054
4170
|
return New$0(state);
|
|
4055
4171
|
}
|
|
4056
4172
|
}
|
|
4057
|
-
var Of$0 = $TV($EXPECT($
|
|
4173
|
+
var Of$0 = $TV($EXPECT($L108, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
4058
4174
|
return { $loc, token: $1 };
|
|
4059
4175
|
});
|
|
4060
4176
|
function Of(state) {
|
|
@@ -4066,7 +4182,7 @@ var Civet = (() => {
|
|
|
4066
4182
|
return Of$0(state);
|
|
4067
4183
|
}
|
|
4068
4184
|
}
|
|
4069
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
4185
|
+
var OpenBrace$0 = $TV($EXPECT($L109, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
4070
4186
|
return { $loc, token: $1 };
|
|
4071
4187
|
});
|
|
4072
4188
|
function OpenBrace(state) {
|
|
@@ -4078,7 +4194,7 @@ var Civet = (() => {
|
|
|
4078
4194
|
return OpenBrace$0(state);
|
|
4079
4195
|
}
|
|
4080
4196
|
}
|
|
4081
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
4197
|
+
var OpenBracket$0 = $TV($EXPECT($L110, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
4082
4198
|
return { $loc, token: $1 };
|
|
4083
4199
|
});
|
|
4084
4200
|
function OpenBracket(state) {
|
|
@@ -4090,7 +4206,7 @@ var Civet = (() => {
|
|
|
4090
4206
|
return OpenBracket$0(state);
|
|
4091
4207
|
}
|
|
4092
4208
|
}
|
|
4093
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
4209
|
+
var OpenParen$0 = $TV($EXPECT($L111, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
4094
4210
|
return { $loc, token: $1 };
|
|
4095
4211
|
});
|
|
4096
4212
|
function OpenParen(state) {
|
|
@@ -4102,7 +4218,7 @@ var Civet = (() => {
|
|
|
4102
4218
|
return OpenParen$0(state);
|
|
4103
4219
|
}
|
|
4104
4220
|
}
|
|
4105
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
4221
|
+
var QuestionMark$0 = $TV($EXPECT($L112, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
4106
4222
|
return { $loc, token: $1 };
|
|
4107
4223
|
});
|
|
4108
4224
|
function QuestionMark(state) {
|
|
@@ -4114,7 +4230,7 @@ var Civet = (() => {
|
|
|
4114
4230
|
return QuestionMark$0(state);
|
|
4115
4231
|
}
|
|
4116
4232
|
}
|
|
4117
|
-
var Return$0 = $TS($S($EXPECT($
|
|
4233
|
+
var Return$0 = $TS($S($EXPECT($L113, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4118
4234
|
return { $loc, token: $1 };
|
|
4119
4235
|
});
|
|
4120
4236
|
function Return(state) {
|
|
@@ -4126,7 +4242,7 @@ var Civet = (() => {
|
|
|
4126
4242
|
return Return$0(state);
|
|
4127
4243
|
}
|
|
4128
4244
|
}
|
|
4129
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
4245
|
+
var Semicolon$0 = $TV($EXPECT($L71, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
4130
4246
|
return { $loc, token: $1 };
|
|
4131
4247
|
});
|
|
4132
4248
|
function Semicolon(state) {
|
|
@@ -4138,7 +4254,7 @@ var Civet = (() => {
|
|
|
4138
4254
|
return Semicolon$0(state);
|
|
4139
4255
|
}
|
|
4140
4256
|
}
|
|
4141
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
4257
|
+
var SingleQuote$0 = $TV($EXPECT($L114, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
4142
4258
|
return { $loc, token: $1 };
|
|
4143
4259
|
});
|
|
4144
4260
|
function SingleQuote(state) {
|
|
@@ -4150,7 +4266,7 @@ var Civet = (() => {
|
|
|
4150
4266
|
return SingleQuote$0(state);
|
|
4151
4267
|
}
|
|
4152
4268
|
}
|
|
4153
|
-
var Star$0 = $TV($EXPECT($
|
|
4269
|
+
var Star$0 = $TV($EXPECT($L45, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
4154
4270
|
return { $loc, token: $1 };
|
|
4155
4271
|
});
|
|
4156
4272
|
function Star(state) {
|
|
@@ -4162,10 +4278,10 @@ var Civet = (() => {
|
|
|
4162
4278
|
return Star$0(state);
|
|
4163
4279
|
}
|
|
4164
4280
|
}
|
|
4165
|
-
var Static$0 = $TV($EXPECT($
|
|
4281
|
+
var Static$0 = $TV($EXPECT($L115, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
4166
4282
|
return { $loc, token: $1 };
|
|
4167
4283
|
});
|
|
4168
|
-
var Static$1 = $TS($S($EXPECT($
|
|
4284
|
+
var Static$1 = $TS($S($EXPECT($L8, fail, 'Static "@"'), $N($EXPECT($L111, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
|
|
4169
4285
|
return { $loc, token: "static " };
|
|
4170
4286
|
});
|
|
4171
4287
|
function Static(state) {
|
|
@@ -4175,7 +4291,7 @@ var Civet = (() => {
|
|
|
4175
4291
|
return Static$0(state) || Static$1(state);
|
|
4176
4292
|
}
|
|
4177
4293
|
}
|
|
4178
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
4294
|
+
var SubstitutionStart$0 = $TV($EXPECT($L116, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
4179
4295
|
return { $loc, token: $1 };
|
|
4180
4296
|
});
|
|
4181
4297
|
function SubstitutionStart(state) {
|
|
@@ -4187,7 +4303,7 @@ var Civet = (() => {
|
|
|
4187
4303
|
return SubstitutionStart$0(state);
|
|
4188
4304
|
}
|
|
4189
4305
|
}
|
|
4190
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
4306
|
+
var Switch$0 = $TS($S($EXPECT($L117, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4191
4307
|
return { $loc, token: $1 };
|
|
4192
4308
|
});
|
|
4193
4309
|
function Switch(state) {
|
|
@@ -4199,7 +4315,7 @@ var Civet = (() => {
|
|
|
4199
4315
|
return Switch$0(state);
|
|
4200
4316
|
}
|
|
4201
4317
|
}
|
|
4202
|
-
var Target$0 = $TV($EXPECT($
|
|
4318
|
+
var Target$0 = $TV($EXPECT($L118, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
|
|
4203
4319
|
return { $loc, token: $1 };
|
|
4204
4320
|
});
|
|
4205
4321
|
function Target(state) {
|
|
@@ -4211,7 +4327,7 @@ var Civet = (() => {
|
|
|
4211
4327
|
return Target$0(state);
|
|
4212
4328
|
}
|
|
4213
4329
|
}
|
|
4214
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
4330
|
+
var Throw$0 = $TS($S($EXPECT($L119, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4215
4331
|
return { $loc, token: $1 };
|
|
4216
4332
|
});
|
|
4217
4333
|
function Throw(state) {
|
|
@@ -4223,7 +4339,7 @@ var Civet = (() => {
|
|
|
4223
4339
|
return Throw$0(state);
|
|
4224
4340
|
}
|
|
4225
4341
|
}
|
|
4226
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
4342
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L120, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
4227
4343
|
return { $loc, token: "`" };
|
|
4228
4344
|
});
|
|
4229
4345
|
function TripleDoubleQuote(state) {
|
|
@@ -4235,7 +4351,7 @@ var Civet = (() => {
|
|
|
4235
4351
|
return TripleDoubleQuote$0(state);
|
|
4236
4352
|
}
|
|
4237
4353
|
}
|
|
4238
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
4354
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L121, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
4239
4355
|
return { $loc, token: "`" };
|
|
4240
4356
|
});
|
|
4241
4357
|
function TripleSingleQuote(state) {
|
|
@@ -4247,7 +4363,7 @@ var Civet = (() => {
|
|
|
4247
4363
|
return TripleSingleQuote$0(state);
|
|
4248
4364
|
}
|
|
4249
4365
|
}
|
|
4250
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
4366
|
+
var TripleTick$0 = $TV($EXPECT($L122, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
4251
4367
|
return { $loc, token: "`" };
|
|
4252
4368
|
});
|
|
4253
4369
|
function TripleTick(state) {
|
|
@@ -4259,7 +4375,7 @@ var Civet = (() => {
|
|
|
4259
4375
|
return TripleTick$0(state);
|
|
4260
4376
|
}
|
|
4261
4377
|
}
|
|
4262
|
-
var Try$0 = $TV($EXPECT($
|
|
4378
|
+
var Try$0 = $TV($EXPECT($L123, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
4263
4379
|
return { $loc, token: $1 };
|
|
4264
4380
|
});
|
|
4265
4381
|
function Try(state) {
|
|
@@ -4271,7 +4387,19 @@ var Civet = (() => {
|
|
|
4271
4387
|
return Try$0(state);
|
|
4272
4388
|
}
|
|
4273
4389
|
}
|
|
4274
|
-
var
|
|
4390
|
+
var Typeof$0 = $TS($S($EXPECT($L124, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4391
|
+
return { $loc, token: $1 };
|
|
4392
|
+
});
|
|
4393
|
+
function Typeof(state) {
|
|
4394
|
+
if (state.verbose)
|
|
4395
|
+
console.log("ENTER:", "Typeof");
|
|
4396
|
+
if (state.tokenize) {
|
|
4397
|
+
return $TOKEN("Typeof", state, Typeof$0(state));
|
|
4398
|
+
} else {
|
|
4399
|
+
return Typeof$0(state);
|
|
4400
|
+
}
|
|
4401
|
+
}
|
|
4402
|
+
var Unless$0 = $TV($EXPECT($L125, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
4275
4403
|
return { $loc, token: $1 };
|
|
4276
4404
|
});
|
|
4277
4405
|
function Unless(state) {
|
|
@@ -4283,7 +4411,19 @@ var Civet = (() => {
|
|
|
4283
4411
|
return Unless$0(state);
|
|
4284
4412
|
}
|
|
4285
4413
|
}
|
|
4286
|
-
var
|
|
4414
|
+
var Until$0 = $TS($S($EXPECT($L126, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4415
|
+
return { $loc, token: $1 };
|
|
4416
|
+
});
|
|
4417
|
+
function Until(state) {
|
|
4418
|
+
if (state.verbose)
|
|
4419
|
+
console.log("ENTER:", "Until");
|
|
4420
|
+
if (state.tokenize) {
|
|
4421
|
+
return $TOKEN("Until", state, Until$0(state));
|
|
4422
|
+
} else {
|
|
4423
|
+
return Until$0(state);
|
|
4424
|
+
}
|
|
4425
|
+
}
|
|
4426
|
+
var Var$0 = $TV($EXPECT($L127, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
4287
4427
|
return { $loc, token: $1 };
|
|
4288
4428
|
});
|
|
4289
4429
|
function Var(state) {
|
|
@@ -4295,7 +4435,19 @@ var Civet = (() => {
|
|
|
4295
4435
|
return Var$0(state);
|
|
4296
4436
|
}
|
|
4297
4437
|
}
|
|
4298
|
-
var
|
|
4438
|
+
var Void$0 = $TS($S($EXPECT($L128, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4439
|
+
return { $loc, token: $1 };
|
|
4440
|
+
});
|
|
4441
|
+
function Void(state) {
|
|
4442
|
+
if (state.verbose)
|
|
4443
|
+
console.log("ENTER:", "Void");
|
|
4444
|
+
if (state.tokenize) {
|
|
4445
|
+
return $TOKEN("Void", state, Void$0(state));
|
|
4446
|
+
} else {
|
|
4447
|
+
return Void$0(state);
|
|
4448
|
+
}
|
|
4449
|
+
}
|
|
4450
|
+
var When$0 = $TS($S($EXPECT($L129, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4299
4451
|
return { $loc, token: "case" };
|
|
4300
4452
|
});
|
|
4301
4453
|
function When(state) {
|
|
@@ -4307,6 +4459,18 @@ var Civet = (() => {
|
|
|
4307
4459
|
return When$0(state);
|
|
4308
4460
|
}
|
|
4309
4461
|
}
|
|
4462
|
+
var While$0 = $TS($S($EXPECT($L130, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4463
|
+
return { $loc, token: $1 };
|
|
4464
|
+
});
|
|
4465
|
+
function While(state) {
|
|
4466
|
+
if (state.verbose)
|
|
4467
|
+
console.log("ENTER:", "While");
|
|
4468
|
+
if (state.tokenize) {
|
|
4469
|
+
return $TOKEN("While", state, While$0(state));
|
|
4470
|
+
} else {
|
|
4471
|
+
return While$0(state);
|
|
4472
|
+
}
|
|
4473
|
+
}
|
|
4310
4474
|
var Yield$0 = $TS($S($EXPECT($L131, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4311
4475
|
return { $loc, token: $1 };
|
|
4312
4476
|
});
|
|
@@ -4333,7 +4497,7 @@ var Civet = (() => {
|
|
|
4333
4497
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
4334
4498
|
}
|
|
4335
4499
|
}
|
|
4336
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($
|
|
4500
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L132, fail, 'JSXSelfClosingElement "/>"'));
|
|
4337
4501
|
function JSXSelfClosingElement(state) {
|
|
4338
4502
|
if (state.verbose)
|
|
4339
4503
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -4343,7 +4507,7 @@ var Civet = (() => {
|
|
|
4343
4507
|
return JSXSelfClosingElement$0(state);
|
|
4344
4508
|
}
|
|
4345
4509
|
}
|
|
4346
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
4510
|
+
var JSXOpeningElement$0 = $S($EXPECT($L4, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L55, fail, 'JSXOpeningElement ">"'));
|
|
4347
4511
|
function JSXOpeningElement(state) {
|
|
4348
4512
|
if (state.verbose)
|
|
4349
4513
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -4353,7 +4517,7 @@ var Civet = (() => {
|
|
|
4353
4517
|
return JSXOpeningElement$0(state);
|
|
4354
4518
|
}
|
|
4355
4519
|
}
|
|
4356
|
-
var JSXClosingElement$0 = $S($EXPECT($L133, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($
|
|
4520
|
+
var JSXClosingElement$0 = $S($EXPECT($L133, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L55, fail, 'JSXClosingElement ">"'));
|
|
4357
4521
|
function JSXClosingElement(state) {
|
|
4358
4522
|
if (state.verbose)
|
|
4359
4523
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -4383,7 +4547,7 @@ var Civet = (() => {
|
|
|
4383
4547
|
return JSXElementName$0(state);
|
|
4384
4548
|
}
|
|
4385
4549
|
}
|
|
4386
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
4550
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R33, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
4387
4551
|
function JSXIdentifierName(state) {
|
|
4388
4552
|
if (state.verbose)
|
|
4389
4553
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -4432,8 +4596,8 @@ var Civet = (() => {
|
|
|
4432
4596
|
return JSXAttributeInitializer$0(state);
|
|
4433
4597
|
}
|
|
4434
4598
|
}
|
|
4435
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
4436
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
4599
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R34, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
4600
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R35, fail, "JSXAttributeValue /'[^']*'/"));
|
|
4437
4601
|
var JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
|
|
4438
4602
|
var JSXAttributeValue$3 = JSXElement;
|
|
4439
4603
|
var JSXAttributeValue$4 = JSXFragment;
|
|
@@ -4465,7 +4629,7 @@ var Civet = (() => {
|
|
|
4465
4629
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
4466
4630
|
}
|
|
4467
4631
|
}
|
|
4468
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
4632
|
+
var JSXText$0 = $R$0($EXPECT($R36, fail, "JSXText /[^{}<>]+/"));
|
|
4469
4633
|
function JSXText(state) {
|
|
4470
4634
|
if (state.verbose)
|
|
4471
4635
|
console.log("ENTER:", "JSXText");
|
|
@@ -4637,7 +4801,7 @@ var Civet = (() => {
|
|
|
4637
4801
|
return NestedTypeDeclaration$0(state);
|
|
4638
4802
|
}
|
|
4639
4803
|
}
|
|
4640
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
4804
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R37, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L140, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R38, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
4641
4805
|
function TypeIndexSignature(state) {
|
|
4642
4806
|
if (state.verbose)
|
|
4643
4807
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -4688,7 +4852,7 @@ var Civet = (() => {
|
|
|
4688
4852
|
return ReturnTypeSuffix$0(state);
|
|
4689
4853
|
}
|
|
4690
4854
|
}
|
|
4691
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
4855
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L58, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
4692
4856
|
if (!$2)
|
|
4693
4857
|
return $1;
|
|
4694
4858
|
return $0;
|
|
@@ -4752,7 +4916,7 @@ var Civet = (() => {
|
|
|
4752
4916
|
}
|
|
4753
4917
|
}
|
|
4754
4918
|
var TypeUnaryOp$0 = $EXPECT($L142, fail, 'TypeUnaryOp "keyof"');
|
|
4755
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
4919
|
+
var TypeUnaryOp$1 = $EXPECT($L124, fail, 'TypeUnaryOp "typeof"');
|
|
4756
4920
|
var TypeUnaryOp$2 = $EXPECT($L143, fail, 'TypeUnaryOp "infer"');
|
|
4757
4921
|
function TypeUnaryOp(state) {
|
|
4758
4922
|
if (state.tokenize) {
|
|
@@ -4828,7 +4992,7 @@ var Civet = (() => {
|
|
|
4828
4992
|
return NestedType$0(state);
|
|
4829
4993
|
}
|
|
4830
4994
|
}
|
|
4831
|
-
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($
|
|
4995
|
+
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L5, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
4832
4996
|
if ($2)
|
|
4833
4997
|
return $0;
|
|
4834
4998
|
return $1;
|
|
@@ -4843,7 +5007,7 @@ var Civet = (() => {
|
|
|
4843
5007
|
}
|
|
4844
5008
|
}
|
|
4845
5009
|
var TypeLiteral$0 = Literal;
|
|
4846
|
-
var TypeLiteral$1 = $TV($EXPECT($
|
|
5010
|
+
var TypeLiteral$1 = $TV($EXPECT($L128, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
|
|
4847
5011
|
return { $loc, token: "void" };
|
|
4848
5012
|
});
|
|
4849
5013
|
var TypeLiteral$2 = $TV($EXPECT($L144, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
@@ -4856,10 +5020,10 @@ var Civet = (() => {
|
|
|
4856
5020
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
4857
5021
|
}
|
|
4858
5022
|
}
|
|
4859
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
5023
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L70, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
4860
5024
|
return { $loc, token: "|" };
|
|
4861
5025
|
});
|
|
4862
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
5026
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L68, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
4863
5027
|
return { $loc, token: "&" };
|
|
4864
5028
|
});
|
|
4865
5029
|
function TypeBinaryOp(state) {
|
|
@@ -4869,7 +5033,7 @@ var Civet = (() => {
|
|
|
4869
5033
|
return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
|
|
4870
5034
|
}
|
|
4871
5035
|
}
|
|
4872
|
-
var FunctionType$0 = $S(Parameters, __, $EXPECT($
|
|
5036
|
+
var FunctionType$0 = $S(Parameters, __, $EXPECT($L3, fail, 'FunctionType "=>"'), Type);
|
|
4873
5037
|
function FunctionType(state) {
|
|
4874
5038
|
if (state.verbose)
|
|
4875
5039
|
console.log("ENTER:", "FunctionType");
|
|
@@ -4879,7 +5043,7 @@ var Civet = (() => {
|
|
|
4879
5043
|
return FunctionType$0(state);
|
|
4880
5044
|
}
|
|
4881
5045
|
}
|
|
4882
|
-
var TypeArguments$0 = $S(__, $EXPECT($
|
|
5046
|
+
var TypeArguments$0 = $S(__, $EXPECT($L4, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L55, fail, 'TypeArguments ">"'));
|
|
4883
5047
|
function TypeArguments(state) {
|
|
4884
5048
|
if (state.verbose)
|
|
4885
5049
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -4889,7 +5053,7 @@ var Civet = (() => {
|
|
|
4889
5053
|
return TypeArguments$0(state);
|
|
4890
5054
|
}
|
|
4891
5055
|
}
|
|
4892
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
5056
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L4, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L55, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
4893
5057
|
return { ts: true, children: $0 };
|
|
4894
5058
|
});
|
|
4895
5059
|
function TypeParameters(state) {
|
|
@@ -4911,7 +5075,7 @@ var Civet = (() => {
|
|
|
4911
5075
|
return TypeParameter$0(state);
|
|
4912
5076
|
}
|
|
4913
5077
|
}
|
|
4914
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
5078
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L5, fail, 'TypeConstraint "extends"'), Type);
|
|
4915
5079
|
function TypeConstraint(state) {
|
|
4916
5080
|
if (state.verbose)
|
|
4917
5081
|
console.log("ENTER:", "TypeConstraint");
|
|
@@ -4922,8 +5086,8 @@ var Civet = (() => {
|
|
|
4922
5086
|
}
|
|
4923
5087
|
}
|
|
4924
5088
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
4925
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
4926
|
-
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($
|
|
5089
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L55, fail, 'TypeParameterDelimiter ">"')));
|
|
5090
|
+
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L55, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
|
|
4927
5091
|
return { $loc, token: "," };
|
|
4928
5092
|
});
|
|
4929
5093
|
var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
@@ -4936,7 +5100,7 @@ var Civet = (() => {
|
|
|
4936
5100
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
4937
5101
|
}
|
|
4938
5102
|
}
|
|
4939
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
5103
|
+
var Shebang$0 = $S($R$0($EXPECT($R39, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
4940
5104
|
function Shebang(state) {
|
|
4941
5105
|
if (state.verbose)
|
|
4942
5106
|
console.log("ENTER:", "Shebang");
|
|
@@ -4946,11 +5110,11 @@ var Civet = (() => {
|
|
|
4946
5110
|
return Shebang$0(state);
|
|
4947
5111
|
}
|
|
4948
5112
|
}
|
|
4949
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
5113
|
+
var CivetPrologue$0 = $T($S($EXPECT($R40, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
4950
5114
|
var content = value[2];
|
|
4951
5115
|
return content;
|
|
4952
5116
|
});
|
|
4953
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
5117
|
+
var CivetPrologue$1 = $T($S($EXPECT($R40, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
4954
5118
|
var content = value[2];
|
|
4955
5119
|
return content;
|
|
4956
5120
|
});
|
|
@@ -4961,7 +5125,7 @@ var Civet = (() => {
|
|
|
4961
5125
|
return CivetPrologue$0(state) || CivetPrologue$1(state);
|
|
4962
5126
|
}
|
|
4963
5127
|
}
|
|
4964
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($L145, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($
|
|
5128
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L145, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R41, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
4965
5129
|
var options = $2;
|
|
4966
5130
|
return {
|
|
4967
5131
|
type: "CivetPrologue",
|
|
@@ -4978,7 +5142,7 @@ var Civet = (() => {
|
|
|
4978
5142
|
return CivetPrologueContent$0(state);
|
|
4979
5143
|
}
|
|
4980
5144
|
}
|
|
4981
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
5145
|
+
var CivetOption$0 = $TR($EXPECT($R42, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4982
5146
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
4983
5147
|
if (l)
|
|
4984
5148
|
return l.toUpperCase();
|
|
@@ -4996,7 +5160,7 @@ var Civet = (() => {
|
|
|
4996
5160
|
return CivetOption$0(state);
|
|
4997
5161
|
}
|
|
4998
5162
|
}
|
|
4999
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
5163
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R40, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
|
|
5000
5164
|
function UnknownPrologue(state) {
|
|
5001
5165
|
if (state.verbose)
|
|
5002
5166
|
console.log("ENTER:", "UnknownPrologue");
|
|
@@ -5025,7 +5189,9 @@ var Civet = (() => {
|
|
|
5025
5189
|
return EOS$0(state);
|
|
5026
5190
|
}
|
|
5027
5191
|
}
|
|
5028
|
-
var EOL$0 = $
|
|
5192
|
+
var EOL$0 = $TR($EXPECT($R43, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
5193
|
+
return { $loc, token: $0 };
|
|
5194
|
+
});
|
|
5029
5195
|
function EOL(state) {
|
|
5030
5196
|
if (state.verbose)
|
|
5031
5197
|
console.log("ENTER:", "EOL");
|
|
@@ -5035,17 +5201,7 @@ var Civet = (() => {
|
|
|
5035
5201
|
return EOL$0(state);
|
|
5036
5202
|
}
|
|
5037
5203
|
}
|
|
5038
|
-
var
|
|
5039
|
-
function EOF(state) {
|
|
5040
|
-
if (state.verbose)
|
|
5041
|
-
console.log("ENTER:", "EOF");
|
|
5042
|
-
if (state.tokenize) {
|
|
5043
|
-
return $TOKEN("EOF", state, EOF$0(state));
|
|
5044
|
-
} else {
|
|
5045
|
-
return EOF$0(state);
|
|
5046
|
-
}
|
|
5047
|
-
}
|
|
5048
|
-
var Debugger$0 = $TV($EXPECT($L1, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
5204
|
+
var Debugger$0 = $TV($EXPECT($L0, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
5049
5205
|
debugger;
|
|
5050
5206
|
});
|
|
5051
5207
|
function Debugger(state) {
|
|
@@ -5057,7 +5213,7 @@ var Civet = (() => {
|
|
|
5057
5213
|
return Debugger$0(state);
|
|
5058
5214
|
}
|
|
5059
5215
|
}
|
|
5060
|
-
var InsertOpenParen$0 = $TV($EXPECT($
|
|
5216
|
+
var InsertOpenParen$0 = $TV($EXPECT($L0, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
5061
5217
|
return { $loc, token: "(" };
|
|
5062
5218
|
});
|
|
5063
5219
|
function InsertOpenParen(state) {
|
|
@@ -5069,7 +5225,7 @@ var Civet = (() => {
|
|
|
5069
5225
|
return InsertOpenParen$0(state);
|
|
5070
5226
|
}
|
|
5071
5227
|
}
|
|
5072
|
-
var InsertCloseParen$0 = $TV($EXPECT($
|
|
5228
|
+
var InsertCloseParen$0 = $TV($EXPECT($L0, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
5073
5229
|
return { $loc, token: ")" };
|
|
5074
5230
|
});
|
|
5075
5231
|
function InsertCloseParen(state) {
|
|
@@ -5081,7 +5237,7 @@ var Civet = (() => {
|
|
|
5081
5237
|
return InsertCloseParen$0(state);
|
|
5082
5238
|
}
|
|
5083
5239
|
}
|
|
5084
|
-
var InsertOpenBrace$0 = $TV($EXPECT($
|
|
5240
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L0, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
5085
5241
|
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
5086
5242
|
});
|
|
5087
5243
|
function InsertOpenBrace(state) {
|
|
@@ -5093,7 +5249,7 @@ var Civet = (() => {
|
|
|
5093
5249
|
return InsertOpenBrace$0(state);
|
|
5094
5250
|
}
|
|
5095
5251
|
}
|
|
5096
|
-
var InsertCloseBrace$0 = $TV($EXPECT($
|
|
5252
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L0, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
5097
5253
|
return { $loc, token: "}" };
|
|
5098
5254
|
});
|
|
5099
5255
|
function InsertCloseBrace(state) {
|
|
@@ -5105,7 +5261,7 @@ var Civet = (() => {
|
|
|
5105
5261
|
return InsertCloseBrace$0(state);
|
|
5106
5262
|
}
|
|
5107
5263
|
}
|
|
5108
|
-
var InsertConst$0 = $TV($EXPECT($
|
|
5264
|
+
var InsertConst$0 = $TV($EXPECT($L0, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
5109
5265
|
return { $loc, token: "const " };
|
|
5110
5266
|
});
|
|
5111
5267
|
function InsertConst(state) {
|
|
@@ -5117,7 +5273,7 @@ var Civet = (() => {
|
|
|
5117
5273
|
return InsertConst$0(state);
|
|
5118
5274
|
}
|
|
5119
5275
|
}
|
|
5120
|
-
var InsertReadonly$0 = $TV($EXPECT($
|
|
5276
|
+
var InsertReadonly$0 = $TV($EXPECT($L0, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
5121
5277
|
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
5122
5278
|
});
|
|
5123
5279
|
function InsertReadonly(state) {
|
|
@@ -5129,7 +5285,7 @@ var Civet = (() => {
|
|
|
5129
5285
|
return InsertReadonly$0(state);
|
|
5130
5286
|
}
|
|
5131
5287
|
}
|
|
5132
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
5288
|
+
var InsertNewline$0 = $TV($EXPECT($L0, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
5133
5289
|
return "\n";
|
|
5134
5290
|
});
|
|
5135
5291
|
function InsertNewline(state) {
|
|
@@ -5141,7 +5297,7 @@ var Civet = (() => {
|
|
|
5141
5297
|
return InsertNewline$0(state);
|
|
5142
5298
|
}
|
|
5143
5299
|
}
|
|
5144
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
5300
|
+
var InsertIndent$0 = $TV($EXPECT($L0, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
5145
5301
|
return "".padStart(module.currentIndent * 2);
|
|
5146
5302
|
});
|
|
5147
5303
|
function InsertIndent(state) {
|
|
@@ -5153,7 +5309,7 @@ var Civet = (() => {
|
|
|
5153
5309
|
return InsertIndent$0(state);
|
|
5154
5310
|
}
|
|
5155
5311
|
}
|
|
5156
|
-
var InsertSpace$0 = $TV($EXPECT($
|
|
5312
|
+
var InsertSpace$0 = $TV($EXPECT($L0, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
5157
5313
|
return { $loc, token: " " };
|
|
5158
5314
|
});
|
|
5159
5315
|
function InsertSpace(state) {
|
|
@@ -5165,7 +5321,7 @@ var Civet = (() => {
|
|
|
5165
5321
|
return InsertSpace$0(state);
|
|
5166
5322
|
}
|
|
5167
5323
|
}
|
|
5168
|
-
var InsertDot$0 = $TV($EXPECT($
|
|
5324
|
+
var InsertDot$0 = $TV($EXPECT($L0, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
5169
5325
|
return { $loc, token: "." };
|
|
5170
5326
|
});
|
|
5171
5327
|
function InsertDot(state) {
|
|
@@ -5177,7 +5333,7 @@ var Civet = (() => {
|
|
|
5177
5333
|
return InsertDot$0(state);
|
|
5178
5334
|
}
|
|
5179
5335
|
}
|
|
5180
|
-
var InsertBreak$0 = $TV($EXPECT($
|
|
5336
|
+
var InsertBreak$0 = $TV($EXPECT($L0, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
5181
5337
|
return { $loc, token: ";break;" };
|
|
5182
5338
|
});
|
|
5183
5339
|
function InsertBreak(state) {
|
|
@@ -5189,7 +5345,7 @@ var Civet = (() => {
|
|
|
5189
5345
|
return InsertBreak$0(state);
|
|
5190
5346
|
}
|
|
5191
5347
|
}
|
|
5192
|
-
var CoffeeCommentEnabled$0 = $TV($EXPECT($
|
|
5348
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
5193
5349
|
if (module.config.coffeeComment)
|
|
5194
5350
|
return;
|
|
5195
5351
|
return $skip;
|
|
@@ -5203,7 +5359,7 @@ var Civet = (() => {
|
|
|
5203
5359
|
return CoffeeCommentEnabled$0(state);
|
|
5204
5360
|
}
|
|
5205
5361
|
}
|
|
5206
|
-
var CoffeeBooleansEnabled$0 = $TV($EXPECT($
|
|
5362
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
5207
5363
|
if (module.config.coffeeBooleans)
|
|
5208
5364
|
return;
|
|
5209
5365
|
return $skip;
|
|
@@ -5217,7 +5373,7 @@ var Civet = (() => {
|
|
|
5217
5373
|
return CoffeeBooleansEnabled$0(state);
|
|
5218
5374
|
}
|
|
5219
5375
|
}
|
|
5220
|
-
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($
|
|
5376
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
5221
5377
|
if (module.config.coffeeInterpolation)
|
|
5222
5378
|
return;
|
|
5223
5379
|
return $skip;
|
|
@@ -5231,7 +5387,7 @@ var Civet = (() => {
|
|
|
5231
5387
|
return CoffeeInterpolationEnabled$0(state);
|
|
5232
5388
|
}
|
|
5233
5389
|
}
|
|
5234
|
-
var Reset$0 = $TV($EXPECT($
|
|
5390
|
+
var Reset$0 = $TV($EXPECT($L0, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
5235
5391
|
module.currentIndent = 0;
|
|
5236
5392
|
module.indentLevels = [0];
|
|
5237
5393
|
module.verbose = false;
|
|
@@ -5275,26 +5431,13 @@ var Civet = (() => {
|
|
|
5275
5431
|
return Reset$0(state);
|
|
5276
5432
|
}
|
|
5277
5433
|
}
|
|
5278
|
-
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($
|
|
5434
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L0, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
5279
5435
|
var directives = $2;
|
|
5280
5436
|
directives.forEach((directive) => {
|
|
5281
5437
|
if (directive.type === "CivetPrologue") {
|
|
5282
5438
|
Object.assign(module.config, directive.config);
|
|
5283
5439
|
}
|
|
5284
5440
|
});
|
|
5285
|
-
function hasReturnStatement(node) {
|
|
5286
|
-
if (!node)
|
|
5287
|
-
return false;
|
|
5288
|
-
if (Array.isArray(node))
|
|
5289
|
-
return node.some(hasReturnStatement);
|
|
5290
|
-
if (node.type === "ReturnStatement")
|
|
5291
|
-
return true;
|
|
5292
|
-
if (node.type === "FunctionExpression")
|
|
5293
|
-
return false;
|
|
5294
|
-
if (node.children)
|
|
5295
|
-
return hasReturnStatement(node.children);
|
|
5296
|
-
return false;
|
|
5297
|
-
}
|
|
5298
5441
|
function insertReturn(node) {
|
|
5299
5442
|
if (!node)
|
|
5300
5443
|
return;
|
|
@@ -5325,7 +5468,10 @@ var Civet = (() => {
|
|
|
5325
5468
|
}
|
|
5326
5469
|
if (!Array.isArray(node))
|
|
5327
5470
|
return;
|
|
5328
|
-
const [
|
|
5471
|
+
const [, exp] = node;
|
|
5472
|
+
let indent = node[0];
|
|
5473
|
+
if (Array.isArray(indent))
|
|
5474
|
+
indent = indent[indent.length - 1];
|
|
5329
5475
|
if (!exp)
|
|
5330
5476
|
return;
|
|
5331
5477
|
switch (exp.type) {
|
|
@@ -5334,6 +5480,7 @@ var Civet = (() => {
|
|
|
5334
5480
|
case "DebuggerStatement":
|
|
5335
5481
|
case "EmptyStatement":
|
|
5336
5482
|
case "IterationStatement":
|
|
5483
|
+
case "ReturnStatement":
|
|
5337
5484
|
case "ThrowStatement":
|
|
5338
5485
|
case "VariableDeclaration":
|
|
5339
5486
|
return;
|
|
@@ -5358,11 +5505,19 @@ var Civet = (() => {
|
|
|
5358
5505
|
node.splice(1, 0, "return ");
|
|
5359
5506
|
}
|
|
5360
5507
|
module.addImplicitReturns = function(block) {
|
|
5361
|
-
if (hasReturnStatement(block))
|
|
5362
|
-
return block;
|
|
5363
5508
|
insertReturn(block);
|
|
5364
5509
|
return block;
|
|
5365
5510
|
};
|
|
5511
|
+
module.isWhitespaceOrEmpty = function(node) {
|
|
5512
|
+
if (!node)
|
|
5513
|
+
return true;
|
|
5514
|
+
if (!node.length)
|
|
5515
|
+
return true;
|
|
5516
|
+
if (typeof node === "string")
|
|
5517
|
+
return node.match(/^\s*$/);
|
|
5518
|
+
if (Array.isArray(node))
|
|
5519
|
+
return node.every(module.isWhitespaceOrEmpty);
|
|
5520
|
+
};
|
|
5366
5521
|
module.expandChainedComparisons = function([first, binops]) {
|
|
5367
5522
|
const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in", "instanceof"];
|
|
5368
5523
|
const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
|
|
@@ -5520,7 +5675,7 @@ var Civet = (() => {
|
|
|
5520
5675
|
return Indent$0(state);
|
|
5521
5676
|
}
|
|
5522
5677
|
}
|
|
5523
|
-
var TrackIndent$0 = $TV($EXPECT($
|
|
5678
|
+
var TrackIndent$0 = $TV($EXPECT($L0, fail, 'TrackIndent ""'), function($skip, $loc, $0, $1) {
|
|
5524
5679
|
module.indentLevels.push(module.currentIndent);
|
|
5525
5680
|
});
|
|
5526
5681
|
function TrackIndent(state) {
|
|
@@ -5568,7 +5723,7 @@ var Civet = (() => {
|
|
|
5568
5723
|
return IndentedFurther$0(state);
|
|
5569
5724
|
}
|
|
5570
5725
|
}
|
|
5571
|
-
var PushIndent$0 = $TV($EXPECT($
|
|
5726
|
+
var PushIndent$0 = $TV($EXPECT($L0, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
|
|
5572
5727
|
module.currentIndent++;
|
|
5573
5728
|
if (module.verbose) {
|
|
5574
5729
|
console.log("pushing indent", module.currentIndent);
|
|
@@ -5584,7 +5739,7 @@ var Civet = (() => {
|
|
|
5584
5739
|
return PushIndent$0(state);
|
|
5585
5740
|
}
|
|
5586
5741
|
}
|
|
5587
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
5742
|
+
var PopIndent$0 = $TV($EXPECT($L0, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
5588
5743
|
if (module.verbose) {
|
|
5589
5744
|
console.log("popping indent", module.indentLevels[module.indentLevels.length - 1], "->", module.indentLevels[module.indentLevels.length - 2]);
|
|
5590
5745
|
}
|