@danielx/civet 0.4.9 → 0.4.10
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 +26 -6
- package/dist/browser.js +605 -407
- package/dist/main.js +605 -407
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -413,10 +413,10 @@ var Civet = (() => {
|
|
|
413
413
|
ArgumentList,
|
|
414
414
|
NestedArgumentList,
|
|
415
415
|
NestedArgument,
|
|
416
|
+
InlineArgumentExpressions,
|
|
416
417
|
ImplicitApplication,
|
|
417
418
|
ApplicationStart,
|
|
418
419
|
IndentedApplicationAllowed,
|
|
419
|
-
CommaExpression,
|
|
420
420
|
BinaryOpExpression,
|
|
421
421
|
UnaryExpression,
|
|
422
422
|
UnaryPostfix,
|
|
@@ -457,6 +457,7 @@ var Civet = (() => {
|
|
|
457
457
|
MetaProperty,
|
|
458
458
|
Parameters,
|
|
459
459
|
NonEmptyParameters,
|
|
460
|
+
FunctionRestParameter,
|
|
460
461
|
ParameterElement,
|
|
461
462
|
ParameterElementDelimiter,
|
|
462
463
|
BindingIdentifier,
|
|
@@ -472,6 +473,7 @@ var Civet = (() => {
|
|
|
472
473
|
BindingElement,
|
|
473
474
|
BindingRestElement,
|
|
474
475
|
FunctionDeclaration,
|
|
476
|
+
FunctionSignature,
|
|
475
477
|
FunctionExpression,
|
|
476
478
|
ThinArrowFunction,
|
|
477
479
|
Arrow,
|
|
@@ -485,6 +487,7 @@ var Civet = (() => {
|
|
|
485
487
|
Literal,
|
|
486
488
|
NullLiteral,
|
|
487
489
|
BooleanLiteral,
|
|
490
|
+
CoffeeScriptBooleanLiteral,
|
|
488
491
|
Comma,
|
|
489
492
|
Identifier,
|
|
490
493
|
IdentifierName,
|
|
@@ -579,6 +582,7 @@ var Civet = (() => {
|
|
|
579
582
|
NumericLiteralKind,
|
|
580
583
|
DecimalBigIntegerLiteral,
|
|
581
584
|
DecimalLiteral,
|
|
585
|
+
ExponentPart,
|
|
582
586
|
BinaryIntegerLiteral,
|
|
583
587
|
OctalIntegerLiteral,
|
|
584
588
|
HexLiteral,
|
|
@@ -630,6 +634,7 @@ var Civet = (() => {
|
|
|
630
634
|
ConstructorShorthand,
|
|
631
635
|
Default,
|
|
632
636
|
Dot,
|
|
637
|
+
DotDotDot,
|
|
633
638
|
DoubleQuote,
|
|
634
639
|
Else,
|
|
635
640
|
Equals,
|
|
@@ -708,6 +713,10 @@ var Civet = (() => {
|
|
|
708
713
|
TypeUnaryOp,
|
|
709
714
|
TypeIndexedAccess,
|
|
710
715
|
TypePrimary,
|
|
716
|
+
TypeTuple,
|
|
717
|
+
TypeList,
|
|
718
|
+
NestedTypeList,
|
|
719
|
+
NestedType,
|
|
711
720
|
TypeConditional,
|
|
712
721
|
TypeLiteral,
|
|
713
722
|
TypeBinaryOp,
|
|
@@ -739,6 +748,7 @@ var Civet = (() => {
|
|
|
739
748
|
InsertDot,
|
|
740
749
|
InsertBreak,
|
|
741
750
|
CoffeeCommentEnabled,
|
|
751
|
+
CoffeeBooleansEnabled,
|
|
742
752
|
CoffeeInterpolationEnabled,
|
|
743
753
|
Reset,
|
|
744
754
|
Init,
|
|
@@ -767,173 +777,181 @@ var Civet = (() => {
|
|
|
767
777
|
var $L14 = $L("super[");
|
|
768
778
|
var $L15 = $L("import.meta");
|
|
769
779
|
var $L16 = $L(")");
|
|
770
|
-
var $L17 = $L("
|
|
771
|
-
var $L18 = $L("
|
|
772
|
-
var $L19 = $L("
|
|
773
|
-
var $L20 = $L("
|
|
774
|
-
var $L21 = $L("
|
|
775
|
-
var $L22 = $L("
|
|
776
|
-
var $L23 = $L("
|
|
777
|
-
var $L24 = $L("
|
|
778
|
-
var $L25 = $L("
|
|
779
|
-
var $L26 = $L("
|
|
780
|
-
var $L27 = $L("
|
|
781
|
-
var $L28 = $L("
|
|
782
|
-
var $L29 = $L("
|
|
783
|
-
var $L30 = $L("
|
|
784
|
-
var $L31 = $L("
|
|
785
|
-
var $L32 = $L("
|
|
786
|
-
var $L33 = $L("
|
|
787
|
-
var $L34 = $L("
|
|
788
|
-
var $L35 = $L("
|
|
789
|
-
var $L36 = $L("
|
|
790
|
-
var $L37 = $L("
|
|
791
|
-
var $L38 = $L("
|
|
792
|
-
var $L39 = $L("
|
|
793
|
-
var $L40 = $L("
|
|
794
|
-
var $L41 = $L("
|
|
795
|
-
var $L42 = $L("
|
|
796
|
-
var $L43 = $L("
|
|
797
|
-
var $L44 = $L("
|
|
798
|
-
var $L45 = $L("
|
|
799
|
-
var $L46 = $L("
|
|
800
|
-
var $L47 = $L("
|
|
801
|
-
var $L48 = $L("
|
|
802
|
-
var $L49 = $L("
|
|
803
|
-
var $L50 = $L("
|
|
804
|
-
var $L51 = $L("
|
|
805
|
-
var $L52 = $L("
|
|
806
|
-
var $L53 = $L("
|
|
807
|
-
var $L54 = $L("
|
|
808
|
-
var $L55 = $L("
|
|
809
|
-
var $L56 = $L("
|
|
810
|
-
var $L57 = $L("
|
|
811
|
-
var $L58 = $L("
|
|
812
|
-
var $L59 = $L("
|
|
813
|
-
var $L60 = $L("
|
|
814
|
-
var $L61 = $L("
|
|
815
|
-
var $L62 = $L("
|
|
816
|
-
var $L63 = $L("
|
|
817
|
-
var $L64 = $L("
|
|
818
|
-
var $L65 = $L("
|
|
819
|
-
var $L66 = $L("
|
|
820
|
-
var $L67 = $L("
|
|
821
|
-
var $L68 = $L("
|
|
822
|
-
var $L69 = $L("
|
|
823
|
-
var $L70 = $L("
|
|
824
|
-
var $L71 = $L("
|
|
825
|
-
var $L72 = $L("
|
|
826
|
-
var $L73 = $L("
|
|
827
|
-
var $L74 = $L("
|
|
828
|
-
var $L75 = $L("
|
|
829
|
-
var $L76 = $L("
|
|
830
|
-
var $L77 = $L("
|
|
831
|
-
var $L78 = $L("
|
|
832
|
-
var $L79 = $L("
|
|
833
|
-
var $L80 = $L("
|
|
834
|
-
var $L81 = $L("
|
|
835
|
-
var $L82 = $L("
|
|
836
|
-
var $L83 = $L("
|
|
837
|
-
var $L84 = $L("
|
|
838
|
-
var $L85 = $L("
|
|
839
|
-
var $L86 = $L("
|
|
840
|
-
var $L87 = $L("
|
|
841
|
-
var $L88 = $L("
|
|
842
|
-
var $L89 = $L("
|
|
843
|
-
var $L90 = $L("
|
|
844
|
-
var $L91 = $L("
|
|
845
|
-
var $L92 = $L("
|
|
846
|
-
var $L93 = $L("
|
|
847
|
-
var $L94 = $L("
|
|
848
|
-
var $L95 = $L(
|
|
849
|
-
var $L96 = $L("
|
|
850
|
-
var $L97 = $L("
|
|
851
|
-
var $L98 = $L("
|
|
852
|
-
var $L99 = $L("
|
|
853
|
-
var $L100 = $L("
|
|
854
|
-
var $L101 = $L("
|
|
855
|
-
var $L102 = $L("
|
|
856
|
-
var $L103 = $L("
|
|
857
|
-
var $L104 = $L("
|
|
858
|
-
var $L105 = $L("
|
|
859
|
-
var $L106 = $L("
|
|
860
|
-
var $L107 = $L("
|
|
861
|
-
var $L108 = $L("
|
|
862
|
-
var $L109 = $L("
|
|
863
|
-
var $L110 = $L("
|
|
864
|
-
var $L111 = $L("
|
|
865
|
-
var $L112 = $L("
|
|
866
|
-
var $L113 = $L("
|
|
867
|
-
var $L114 = $L("
|
|
868
|
-
var $L115 = $L("
|
|
869
|
-
var $L116 = $L("
|
|
870
|
-
var $L117 = $L("
|
|
871
|
-
var $L118 = $L("
|
|
872
|
-
var $L119 = $L("
|
|
873
|
-
var $L120 = $L(
|
|
874
|
-
var $L121 = $L("
|
|
875
|
-
var $L122 = $L("
|
|
876
|
-
var $L123 = $L("
|
|
877
|
-
var $L124 = $L("
|
|
878
|
-
var $L125 = $L("
|
|
879
|
-
var $L126 = $L("
|
|
880
|
-
var $L127 = $L("
|
|
881
|
-
var $L128 = $L("
|
|
882
|
-
var $L129 = $L("
|
|
883
|
-
var $L130 = $L("
|
|
884
|
-
var $L131 = $L("
|
|
885
|
-
var $L132 = $L("
|
|
886
|
-
var $L133 = $L("
|
|
887
|
-
var $L134 = $L("
|
|
888
|
-
var $L135 = $L("
|
|
889
|
-
var $L136 = $L("
|
|
890
|
-
var $L137 = $L("
|
|
891
|
-
var $L138 = $L("
|
|
892
|
-
var $L139 = $L("
|
|
893
|
-
var $L140 = $L("
|
|
894
|
-
var $L141 = $L("
|
|
895
|
-
var $L142 = $L("
|
|
896
|
-
var $L143 = $L("
|
|
780
|
+
var $L17 = $L("->");
|
|
781
|
+
var $L18 = $L("null");
|
|
782
|
+
var $L19 = $L("true");
|
|
783
|
+
var $L20 = $L("false");
|
|
784
|
+
var $L21 = $L("yes");
|
|
785
|
+
var $L22 = $L("on");
|
|
786
|
+
var $L23 = $L("no");
|
|
787
|
+
var $L24 = $L("off");
|
|
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("is");
|
|
823
|
+
var $L60 = $L("===");
|
|
824
|
+
var $L61 = $L("==");
|
|
825
|
+
var $L62 = $L("and");
|
|
826
|
+
var $L63 = $L("&&");
|
|
827
|
+
var $L64 = $L("or");
|
|
828
|
+
var $L65 = $L("||");
|
|
829
|
+
var $L66 = $L("??");
|
|
830
|
+
var $L67 = $L("instanceof");
|
|
831
|
+
var $L68 = $L("in");
|
|
832
|
+
var $L69 = $L("&");
|
|
833
|
+
var $L70 = $L("^");
|
|
834
|
+
var $L71 = $L("|");
|
|
835
|
+
var $L72 = $L("delete");
|
|
836
|
+
var $L73 = $L("void");
|
|
837
|
+
var $L74 = $L("typeof");
|
|
838
|
+
var $L75 = $L(";");
|
|
839
|
+
var $L76 = $L("do");
|
|
840
|
+
var $L77 = $L("while");
|
|
841
|
+
var $L78 = $L("until");
|
|
842
|
+
var $L79 = $L("finally");
|
|
843
|
+
var $L80 = $L("break");
|
|
844
|
+
var $L81 = $L("continue");
|
|
845
|
+
var $L82 = $L("debugger");
|
|
846
|
+
var $L83 = $L("import type");
|
|
847
|
+
var $L84 = $L("default");
|
|
848
|
+
var $L85 = $L(":=");
|
|
849
|
+
var $L86 = $L("/*");
|
|
850
|
+
var $L87 = $L("*/");
|
|
851
|
+
var $L88 = $L("###");
|
|
852
|
+
var $L89 = $L("as");
|
|
853
|
+
var $L90 = $L("async");
|
|
854
|
+
var $L91 = $L("await");
|
|
855
|
+
var $L92 = $L("case");
|
|
856
|
+
var $L93 = $L("catch");
|
|
857
|
+
var $L94 = $L("class");
|
|
858
|
+
var $L95 = $L("#{");
|
|
859
|
+
var $L96 = $L(":");
|
|
860
|
+
var $L97 = $L(".");
|
|
861
|
+
var $L98 = $L("...");
|
|
862
|
+
var $L99 = $L('"');
|
|
863
|
+
var $L100 = $L("else");
|
|
864
|
+
var $L101 = $L("export");
|
|
865
|
+
var $L102 = $L("for");
|
|
866
|
+
var $L103 = $L("from");
|
|
867
|
+
var $L104 = $L("function");
|
|
868
|
+
var $L105 = $L("get");
|
|
869
|
+
var $L106 = $L("set");
|
|
870
|
+
var $L107 = $L("if");
|
|
871
|
+
var $L108 = $L("let");
|
|
872
|
+
var $L109 = $L("const");
|
|
873
|
+
var $L110 = $L("loop");
|
|
874
|
+
var $L111 = $L("new");
|
|
875
|
+
var $L112 = $L("of");
|
|
876
|
+
var $L113 = $L("{");
|
|
877
|
+
var $L114 = $L("[");
|
|
878
|
+
var $L115 = $L("(");
|
|
879
|
+
var $L116 = $L("?");
|
|
880
|
+
var $L117 = $L("return");
|
|
881
|
+
var $L118 = $L("'");
|
|
882
|
+
var $L119 = $L("static");
|
|
883
|
+
var $L120 = $L("${");
|
|
884
|
+
var $L121 = $L("switch");
|
|
885
|
+
var $L122 = $L("target");
|
|
886
|
+
var $L123 = $L("throw");
|
|
887
|
+
var $L124 = $L('"""');
|
|
888
|
+
var $L125 = $L("'''");
|
|
889
|
+
var $L126 = $L("```");
|
|
890
|
+
var $L127 = $L("try");
|
|
891
|
+
var $L128 = $L("unless");
|
|
892
|
+
var $L129 = $L("var");
|
|
893
|
+
var $L130 = $L("when");
|
|
894
|
+
var $L131 = $L("yield");
|
|
895
|
+
var $L132 = $L("/>");
|
|
896
|
+
var $L133 = $L("</");
|
|
897
|
+
var $L134 = $L("<>");
|
|
898
|
+
var $L135 = $L("</>");
|
|
899
|
+
var $L136 = $L("declare");
|
|
900
|
+
var $L137 = $L("type");
|
|
901
|
+
var $L138 = $L("interface");
|
|
902
|
+
var $L139 = $L("namespace");
|
|
903
|
+
var $L140 = $L("readonly");
|
|
904
|
+
var $L141 = $L("asserts");
|
|
905
|
+
var $L142 = $L("keyof");
|
|
906
|
+
var $L143 = $L("infer");
|
|
907
|
+
var $L144 = $L("[]");
|
|
908
|
+
var $L145 = $L("civet");
|
|
909
|
+
var $L146 = $L(" ");
|
|
910
|
+
var $L147 = $L(" ");
|
|
897
911
|
var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
898
912
|
var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
899
913
|
var $R2 = $R(new RegExp("[!~+-]", "suy"));
|
|
900
914
|
var $R3 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
901
915
|
var $R4 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
902
|
-
var $R5 = $R(new RegExp("
|
|
903
|
-
var $R6 = $R(new RegExp("0[
|
|
904
|
-
var $R7 = $R(new RegExp("
|
|
905
|
-
var $R8 = $R(new RegExp("
|
|
906
|
-
var $R9 = $R(new RegExp(
|
|
907
|
-
var $R10 = $R(new RegExp("(
|
|
908
|
-
var $R11 = $R(new RegExp(
|
|
909
|
-
var $R12 = $R(new RegExp(
|
|
910
|
-
var $R13 = $R(new RegExp(
|
|
911
|
-
var $R14 = $R(new RegExp("[
|
|
912
|
-
var $R15 = $R(new RegExp("(
|
|
913
|
-
var $R16 = $R(new RegExp(
|
|
914
|
-
var $R17 = $R(new RegExp("
|
|
915
|
-
var $R18 = $R(new RegExp("(
|
|
916
|
-
var $R19 = $R(new RegExp("(
|
|
917
|
-
var $R20 = $R(new RegExp("
|
|
918
|
-
var $R21 = $R(new RegExp("
|
|
919
|
-
var $R22 = $R(new RegExp("
|
|
920
|
-
var $R23 = $R(new RegExp("
|
|
921
|
-
var $R24 = $R(new RegExp("[
|
|
922
|
-
var $R25 = $R(new RegExp("
|
|
923
|
-
var $R26 = $R(new RegExp("(
|
|
924
|
-
var $R27 = $R(new RegExp("\\
|
|
925
|
-
var $R28 = $R(new RegExp("
|
|
926
|
-
var $R29 = $R(new RegExp(
|
|
927
|
-
var $R30 = $R(new RegExp("
|
|
928
|
-
var $R31 = $R(new RegExp("
|
|
929
|
-
var $R32 = $R(new RegExp("[
|
|
930
|
-
var $R33 = $R(new RegExp("[
|
|
931
|
-
var $R34 = $R(new RegExp("
|
|
932
|
-
var $R35 = $R(new RegExp("[
|
|
933
|
-
var $R36 = $R(new RegExp("[
|
|
934
|
-
var $R37 = $R(new RegExp("
|
|
935
|
-
var $R38 = $R(new RegExp("
|
|
936
|
-
var $R39 = $R(new RegExp("
|
|
916
|
+
var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
917
|
+
var $R6 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*)?)?", "suy"));
|
|
918
|
+
var $R7 = $R(new RegExp("(?:\\.(?!\\p{ID_Start})[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
919
|
+
var $R8 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
920
|
+
var $R9 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
921
|
+
var $R10 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
922
|
+
var $R11 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
923
|
+
var $R12 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
924
|
+
var $R13 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
925
|
+
var $R14 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
926
|
+
var $R15 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
927
|
+
var $R16 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
928
|
+
var $R17 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
929
|
+
var $R18 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
|
|
930
|
+
var $R19 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
931
|
+
var $R20 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
932
|
+
var $R21 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
933
|
+
var $R22 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
934
|
+
var $R23 = $R(new RegExp("(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
935
|
+
var $R24 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
936
|
+
var $R25 = $R(new RegExp(".", "suy"));
|
|
937
|
+
var $R26 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
938
|
+
var $R27 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
939
|
+
var $R28 = $R(new RegExp("[ \\t]+", "suy"));
|
|
940
|
+
var $R29 = $R(new RegExp("[\\s]+", "suy"));
|
|
941
|
+
var $R30 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
942
|
+
var $R31 = $R(new RegExp("\\s", "suy"));
|
|
943
|
+
var $R32 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
944
|
+
var $R33 = $R(new RegExp('"[^"]*"', "suy"));
|
|
945
|
+
var $R34 = $R(new RegExp("'[^']*'", "suy"));
|
|
946
|
+
var $R35 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
947
|
+
var $R36 = $R(new RegExp("[+-]?", "suy"));
|
|
948
|
+
var $R37 = $R(new RegExp("[+-]", "suy"));
|
|
949
|
+
var $R38 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
950
|
+
var $R39 = $R(new RegExp("[\\t ]*", "suy"));
|
|
951
|
+
var $R40 = $R(new RegExp("[\\s]*", "suy"));
|
|
952
|
+
var $R41 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
|
|
953
|
+
var $R42 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
954
|
+
var $R43 = $R(new RegExp("$", "suy"));
|
|
937
955
|
var Program$0 = $S(Reset, Init, __, $Q(TopLevelStatement), __);
|
|
938
956
|
function Program(state) {
|
|
939
957
|
if (state.verbose)
|
|
@@ -992,7 +1010,7 @@ var Civet = (() => {
|
|
|
992
1010
|
}
|
|
993
1011
|
}
|
|
994
1012
|
var ArgumentList$0 = $S($Y(EOS), NestedArgumentList);
|
|
995
|
-
var ArgumentList$1 =
|
|
1013
|
+
var ArgumentList$1 = InlineArgumentExpressions;
|
|
996
1014
|
function ArgumentList(state) {
|
|
997
1015
|
if (state.tokenize) {
|
|
998
1016
|
return $TOKEN("ArgumentList", state, ArgumentList$0(state) || ArgumentList$1(state));
|
|
@@ -1015,7 +1033,7 @@ var Civet = (() => {
|
|
|
1015
1033
|
return NestedArgumentList$0(state);
|
|
1016
1034
|
}
|
|
1017
1035
|
}
|
|
1018
|
-
var NestedArgument$0 = $S(Nested,
|
|
1036
|
+
var NestedArgument$0 = $S(Nested, InlineArgumentExpressions, ParameterElementDelimiter);
|
|
1019
1037
|
function NestedArgument(state) {
|
|
1020
1038
|
if (state.verbose)
|
|
1021
1039
|
console.log("ENTER:", "NestedArgument");
|
|
@@ -1025,6 +1043,20 @@ var Civet = (() => {
|
|
|
1025
1043
|
return NestedArgument$0(state);
|
|
1026
1044
|
}
|
|
1027
1045
|
}
|
|
1046
|
+
var InlineArgumentExpressions$0 = $TS($S($S($E(DotDotDot), AssignmentExpressionRest), $Q($S(__, Comma, $Q(TrailingComment), $E(DotDotDot), AssignmentExpressionRest))), function($skip, $loc, $0, $1, $2) {
|
|
1047
|
+
if ($2.length == 0)
|
|
1048
|
+
return $1;
|
|
1049
|
+
return $0;
|
|
1050
|
+
});
|
|
1051
|
+
function InlineArgumentExpressions(state) {
|
|
1052
|
+
if (state.verbose)
|
|
1053
|
+
console.log("ENTER:", "InlineArgumentExpressions");
|
|
1054
|
+
if (state.tokenize) {
|
|
1055
|
+
return $TOKEN("InlineArgumentExpressions", state, InlineArgumentExpressions$0(state));
|
|
1056
|
+
} else {
|
|
1057
|
+
return InlineArgumentExpressions$0(state);
|
|
1058
|
+
}
|
|
1059
|
+
}
|
|
1028
1060
|
var ImplicitApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen);
|
|
1029
1061
|
function ImplicitApplication(state) {
|
|
1030
1062
|
if (state.verbose)
|
|
@@ -1063,19 +1095,10 @@ var Civet = (() => {
|
|
|
1063
1095
|
return IndentedApplicationAllowed$0(state);
|
|
1064
1096
|
}
|
|
1065
1097
|
}
|
|
1066
|
-
var CommaExpression$0 = $S(__, Comma, Expression);
|
|
1067
|
-
function CommaExpression(state) {
|
|
1068
|
-
if (state.verbose)
|
|
1069
|
-
console.log("ENTER:", "CommaExpression");
|
|
1070
|
-
if (state.tokenize) {
|
|
1071
|
-
return $TOKEN("CommaExpression", state, CommaExpression$0(state));
|
|
1072
|
-
} else {
|
|
1073
|
-
return CommaExpression$0(state);
|
|
1074
|
-
}
|
|
1075
|
-
}
|
|
1076
1098
|
var BinaryOpExpression$0 = $TS($S(UnaryExpression, $Q($S(__, BinaryOp, __, UnaryExpression))), function($skip, $loc, $0, $1, $2) {
|
|
1077
|
-
if ($2.length)
|
|
1078
|
-
return $0;
|
|
1099
|
+
if ($2.length) {
|
|
1100
|
+
return module.expandChainedComparisons($0);
|
|
1101
|
+
}
|
|
1079
1102
|
return $1;
|
|
1080
1103
|
});
|
|
1081
1104
|
function BinaryOpExpression(state) {
|
|
@@ -1092,9 +1115,16 @@ var Civet = (() => {
|
|
|
1092
1115
|
var exp = $2;
|
|
1093
1116
|
var post = $3;
|
|
1094
1117
|
if (post?.token === "?") {
|
|
1095
|
-
return ["(", pre,
|
|
1096
|
-
}
|
|
1097
|
-
|
|
1118
|
+
return ["(", pre, "(", exp, ") != null)"];
|
|
1119
|
+
}
|
|
1120
|
+
const result = [pre, exp, post];
|
|
1121
|
+
if (!post)
|
|
1122
|
+
result.pop();
|
|
1123
|
+
if (!pre.length)
|
|
1124
|
+
result.shift();
|
|
1125
|
+
if (result.length === 1)
|
|
1126
|
+
return result[0];
|
|
1127
|
+
return result;
|
|
1098
1128
|
});
|
|
1099
1129
|
function UnaryExpression(state) {
|
|
1100
1130
|
if (state.verbose)
|
|
@@ -1106,7 +1136,7 @@ var Civet = (() => {
|
|
|
1106
1136
|
}
|
|
1107
1137
|
}
|
|
1108
1138
|
var UnaryPostfix$0 = QuestionMark;
|
|
1109
|
-
var UnaryPostfix$1 = $T($S(__, As,
|
|
1139
|
+
var UnaryPostfix$1 = $T($P($S(__, As, Type)), function(value) {
|
|
1110
1140
|
return { "ts": true, "children": value };
|
|
1111
1141
|
});
|
|
1112
1142
|
function UnaryPostfix(state) {
|
|
@@ -1561,7 +1591,7 @@ var Civet = (() => {
|
|
|
1561
1591
|
return Parameters$0(state) || Parameters$1(state);
|
|
1562
1592
|
}
|
|
1563
1593
|
}
|
|
1564
|
-
var NonEmptyParameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), __, CloseParen);
|
|
1594
|
+
var NonEmptyParameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), $E(FunctionRestParameter), __, CloseParen);
|
|
1565
1595
|
function NonEmptyParameters(state) {
|
|
1566
1596
|
if (state.verbose)
|
|
1567
1597
|
console.log("ENTER:", "NonEmptyParameters");
|
|
@@ -1571,6 +1601,16 @@ var Civet = (() => {
|
|
|
1571
1601
|
return NonEmptyParameters$0(state);
|
|
1572
1602
|
}
|
|
1573
1603
|
}
|
|
1604
|
+
var FunctionRestParameter$0 = $S(__, BindingRestElement, $E(TypeSuffix));
|
|
1605
|
+
function FunctionRestParameter(state) {
|
|
1606
|
+
if (state.verbose)
|
|
1607
|
+
console.log("ENTER:", "FunctionRestParameter");
|
|
1608
|
+
if (state.tokenize) {
|
|
1609
|
+
return $TOKEN("FunctionRestParameter", state, FunctionRestParameter$0(state));
|
|
1610
|
+
} else {
|
|
1611
|
+
return FunctionRestParameter$0(state);
|
|
1612
|
+
}
|
|
1613
|
+
}
|
|
1574
1614
|
var ParameterElement$0 = $S(__, $C(BindingIdentifier, BindingPattern), $E(TypeSuffix), $E(Initializer), ParameterElementDelimiter);
|
|
1575
1615
|
function ParameterElement(state) {
|
|
1576
1616
|
if (state.verbose)
|
|
@@ -1582,18 +1622,15 @@ var Civet = (() => {
|
|
|
1582
1622
|
}
|
|
1583
1623
|
}
|
|
1584
1624
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
1585
|
-
var ParameterElementDelimiter$1 = $Y($S(
|
|
1586
|
-
var ParameterElementDelimiter$2 = $TV($Y(
|
|
1587
|
-
return { $loc, token: "," };
|
|
1588
|
-
});
|
|
1589
|
-
var ParameterElementDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1625
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L16, fail, 'ParameterElementDelimiter ")"')));
|
|
1626
|
+
var ParameterElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1590
1627
|
return { $loc, token: "," };
|
|
1591
1628
|
});
|
|
1592
1629
|
function ParameterElementDelimiter(state) {
|
|
1593
1630
|
if (state.tokenize) {
|
|
1594
|
-
return $TOKEN("ParameterElementDelimiter", state, ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state)
|
|
1631
|
+
return $TOKEN("ParameterElementDelimiter", state, ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state));
|
|
1595
1632
|
} else {
|
|
1596
|
-
return ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state)
|
|
1633
|
+
return ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state);
|
|
1597
1634
|
}
|
|
1598
1635
|
}
|
|
1599
1636
|
var BindingIdentifier$0 = $S(__, Identifier);
|
|
@@ -1670,7 +1707,7 @@ var Civet = (() => {
|
|
|
1670
1707
|
return BindingProperty$0(state) || BindingProperty$1(state);
|
|
1671
1708
|
}
|
|
1672
1709
|
}
|
|
1673
|
-
var BindingRestProperty$0 = $S(
|
|
1710
|
+
var BindingRestProperty$0 = $S(DotDotDot, BindingIdentifier);
|
|
1674
1711
|
function BindingRestProperty(state) {
|
|
1675
1712
|
if (state.verbose)
|
|
1676
1713
|
console.log("ENTER:", "BindingRestProperty");
|
|
@@ -1718,7 +1755,7 @@ var Civet = (() => {
|
|
|
1718
1755
|
return BindingElement$0(state);
|
|
1719
1756
|
}
|
|
1720
1757
|
}
|
|
1721
|
-
var BindingRestElement$0 = $S(
|
|
1758
|
+
var BindingRestElement$0 = $S(DotDotDot, __, $C(BindingIdentifier, BindingPattern));
|
|
1722
1759
|
function BindingRestElement(state) {
|
|
1723
1760
|
if (state.verbose)
|
|
1724
1761
|
console.log("ENTER:", "BindingRestElement");
|
|
@@ -1738,17 +1775,35 @@ var Civet = (() => {
|
|
|
1738
1775
|
return FunctionDeclaration$0(state);
|
|
1739
1776
|
}
|
|
1740
1777
|
}
|
|
1778
|
+
var FunctionSignature$0 = $S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix));
|
|
1779
|
+
function FunctionSignature(state) {
|
|
1780
|
+
if (state.verbose)
|
|
1781
|
+
console.log("ENTER:", "FunctionSignature");
|
|
1782
|
+
if (state.tokenize) {
|
|
1783
|
+
return $TOKEN("FunctionSignature", state, FunctionSignature$0(state));
|
|
1784
|
+
} else {
|
|
1785
|
+
return FunctionSignature$0(state);
|
|
1786
|
+
}
|
|
1787
|
+
}
|
|
1741
1788
|
var FunctionExpression$0 = ThinArrowFunction;
|
|
1742
|
-
var FunctionExpression$1 = $TS($S(
|
|
1743
|
-
var
|
|
1744
|
-
|
|
1789
|
+
var FunctionExpression$1 = $TS($S(FunctionSignature, $E(BracedBlock)), function($skip, $loc, $0, $1, $2) {
|
|
1790
|
+
var block = $2;
|
|
1791
|
+
if (!block) {
|
|
1792
|
+
return {
|
|
1793
|
+
type: "FunctionDeclaration",
|
|
1794
|
+
ts: true,
|
|
1795
|
+
children: $1
|
|
1796
|
+
};
|
|
1797
|
+
}
|
|
1798
|
+
const suffix = $1[$1.length - 1];
|
|
1745
1799
|
const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
|
|
1746
1800
|
if (module.config.implicitReturns && !isVoid) {
|
|
1747
1801
|
module.addImplicitReturns(block);
|
|
1748
1802
|
}
|
|
1803
|
+
$1.push(block);
|
|
1749
1804
|
return {
|
|
1750
1805
|
type: "FunctionExpression",
|
|
1751
|
-
children: $
|
|
1806
|
+
children: $1
|
|
1752
1807
|
};
|
|
1753
1808
|
});
|
|
1754
1809
|
function FunctionExpression(state) {
|
|
@@ -1786,7 +1841,7 @@ var Civet = (() => {
|
|
|
1786
1841
|
return ThinArrowFunction$0(state);
|
|
1787
1842
|
}
|
|
1788
1843
|
}
|
|
1789
|
-
var Arrow$0 = $TV($EXPECT($
|
|
1844
|
+
var Arrow$0 = $TV($EXPECT($L17, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
1790
1845
|
return { $loc, token: $1 };
|
|
1791
1846
|
});
|
|
1792
1847
|
function Arrow(state) {
|
|
@@ -1910,7 +1965,7 @@ var Civet = (() => {
|
|
|
1910
1965
|
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
|
|
1911
1966
|
}
|
|
1912
1967
|
}
|
|
1913
|
-
var NullLiteral$0 = $TV($EXPECT($
|
|
1968
|
+
var NullLiteral$0 = $TV($EXPECT($L18, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
1914
1969
|
return { $loc, token: $1 };
|
|
1915
1970
|
});
|
|
1916
1971
|
function NullLiteral(state) {
|
|
@@ -1922,19 +1977,31 @@ var Civet = (() => {
|
|
|
1922
1977
|
return NullLiteral$0(state);
|
|
1923
1978
|
}
|
|
1924
1979
|
}
|
|
1925
|
-
var BooleanLiteral$0 =
|
|
1980
|
+
var BooleanLiteral$0 = CoffeeScriptBooleanLiteral;
|
|
1981
|
+
var BooleanLiteral$1 = $TV($C($EXPECT($L19, fail, 'BooleanLiteral "true"'), $EXPECT($L20, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
|
|
1926
1982
|
return { $loc, token: $1 };
|
|
1927
1983
|
});
|
|
1928
1984
|
function BooleanLiteral(state) {
|
|
1929
|
-
if (state.verbose)
|
|
1930
|
-
console.log("ENTER:", "BooleanLiteral");
|
|
1931
1985
|
if (state.tokenize) {
|
|
1932
|
-
return $TOKEN("BooleanLiteral", state, BooleanLiteral$0(state));
|
|
1986
|
+
return $TOKEN("BooleanLiteral", state, BooleanLiteral$0(state) || BooleanLiteral$1(state));
|
|
1987
|
+
} else {
|
|
1988
|
+
return BooleanLiteral$0(state) || BooleanLiteral$1(state);
|
|
1989
|
+
}
|
|
1990
|
+
}
|
|
1991
|
+
var CoffeeScriptBooleanLiteral$0 = $TV($C($EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "on"')), function($skip, $loc, $0, $1) {
|
|
1992
|
+
return { $loc, token: "true" };
|
|
1993
|
+
});
|
|
1994
|
+
var CoffeeScriptBooleanLiteral$1 = $TV($C($EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L24, fail, 'CoffeeScriptBooleanLiteral "off"')), function($skip, $loc, $0, $1) {
|
|
1995
|
+
return { $loc, token: "false" };
|
|
1996
|
+
});
|
|
1997
|
+
function CoffeeScriptBooleanLiteral(state) {
|
|
1998
|
+
if (state.tokenize) {
|
|
1999
|
+
return $TOKEN("CoffeeScriptBooleanLiteral", state, CoffeeScriptBooleanLiteral$0(state) || CoffeeScriptBooleanLiteral$1(state));
|
|
1933
2000
|
} else {
|
|
1934
|
-
return
|
|
2001
|
+
return CoffeeScriptBooleanLiteral$0(state) || CoffeeScriptBooleanLiteral$1(state);
|
|
1935
2002
|
}
|
|
1936
2003
|
}
|
|
1937
|
-
var Comma$0 = $TV($EXPECT($
|
|
2004
|
+
var Comma$0 = $TV($EXPECT($L25, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
1938
2005
|
return { $loc, token: $1 };
|
|
1939
2006
|
});
|
|
1940
2007
|
function Comma(state) {
|
|
@@ -1960,6 +2027,7 @@ var Civet = (() => {
|
|
|
1960
2027
|
}
|
|
1961
2028
|
var IdentifierName$0 = $TR($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
1962
2029
|
return {
|
|
2030
|
+
type: "Identifier",
|
|
1963
2031
|
$loc,
|
|
1964
2032
|
token: $0
|
|
1965
2033
|
};
|
|
@@ -2018,7 +2086,7 @@ var Civet = (() => {
|
|
|
2018
2086
|
}
|
|
2019
2087
|
}
|
|
2020
2088
|
var ArrayElementDelimiter$0 = $S($Q(_), Comma);
|
|
2021
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2089
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
|
|
2022
2090
|
var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2023
2091
|
return { $loc, token: "," };
|
|
2024
2092
|
});
|
|
@@ -2049,7 +2117,7 @@ var Civet = (() => {
|
|
|
2049
2117
|
return InlineElementList$0(state);
|
|
2050
2118
|
}
|
|
2051
2119
|
}
|
|
2052
|
-
var ArrayElementExpression$0 = $E($S($E($S(
|
|
2120
|
+
var ArrayElementExpression$0 = $E($S($E($S(DotDotDot, __)), AssignmentExpression));
|
|
2053
2121
|
function ArrayElementExpression(state) {
|
|
2054
2122
|
if (state.verbose)
|
|
2055
2123
|
console.log("ENTER:", "ArrayElementExpression");
|
|
@@ -2116,7 +2184,7 @@ var Civet = (() => {
|
|
|
2116
2184
|
}
|
|
2117
2185
|
}
|
|
2118
2186
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
2119
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2187
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L27, fail, 'ObjectPropertyDelimiter "}"')));
|
|
2120
2188
|
var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2121
2189
|
return { $loc, token: "," };
|
|
2122
2190
|
});
|
|
@@ -2139,7 +2207,7 @@ var Civet = (() => {
|
|
|
2139
2207
|
}
|
|
2140
2208
|
var PropertyDefinition$0 = $S(PropertyName, __, Colon, AssignmentExpression);
|
|
2141
2209
|
var PropertyDefinition$1 = MethodDefinition;
|
|
2142
|
-
var PropertyDefinition$2 = $S(
|
|
2210
|
+
var PropertyDefinition$2 = $S(DotDotDot, AssignmentExpression);
|
|
2143
2211
|
var PropertyDefinition$3 = IdentifierReference;
|
|
2144
2212
|
function PropertyDefinition(state) {
|
|
2145
2213
|
if (state.tokenize) {
|
|
@@ -2151,7 +2219,7 @@ var Civet = (() => {
|
|
|
2151
2219
|
var PropertyName$0 = NumericLiteral;
|
|
2152
2220
|
var PropertyName$1 = StringLiteral;
|
|
2153
2221
|
var PropertyName$2 = IdentifierName;
|
|
2154
|
-
var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($
|
|
2222
|
+
var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L26, fail, 'PropertyName "]"'));
|
|
2155
2223
|
function PropertyName(state) {
|
|
2156
2224
|
if (state.tokenize) {
|
|
2157
2225
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -2253,25 +2321,25 @@ var Civet = (() => {
|
|
|
2253
2321
|
return AssignmentOp$0(state);
|
|
2254
2322
|
}
|
|
2255
2323
|
}
|
|
2256
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
2257
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
2258
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
2259
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
2260
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
2261
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
2262
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
2263
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
2264
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
2265
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
2266
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
2267
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
2268
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
2269
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
2270
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
2271
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
2324
|
+
var AssignmentOpSymbol$0 = $EXPECT($L28, fail, 'AssignmentOpSymbol "**="');
|
|
2325
|
+
var AssignmentOpSymbol$1 = $EXPECT($L29, fail, 'AssignmentOpSymbol "*="');
|
|
2326
|
+
var AssignmentOpSymbol$2 = $EXPECT($L30, fail, 'AssignmentOpSymbol "/="');
|
|
2327
|
+
var AssignmentOpSymbol$3 = $EXPECT($L31, fail, 'AssignmentOpSymbol "%="');
|
|
2328
|
+
var AssignmentOpSymbol$4 = $EXPECT($L32, fail, 'AssignmentOpSymbol "+="');
|
|
2329
|
+
var AssignmentOpSymbol$5 = $EXPECT($L33, fail, 'AssignmentOpSymbol "-="');
|
|
2330
|
+
var AssignmentOpSymbol$6 = $EXPECT($L34, fail, 'AssignmentOpSymbol "<<="');
|
|
2331
|
+
var AssignmentOpSymbol$7 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>>="');
|
|
2332
|
+
var AssignmentOpSymbol$8 = $EXPECT($L36, fail, 'AssignmentOpSymbol ">>="');
|
|
2333
|
+
var AssignmentOpSymbol$9 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&&="');
|
|
2334
|
+
var AssignmentOpSymbol$10 = $EXPECT($L38, fail, 'AssignmentOpSymbol "&="');
|
|
2335
|
+
var AssignmentOpSymbol$11 = $EXPECT($L39, fail, 'AssignmentOpSymbol "^="');
|
|
2336
|
+
var AssignmentOpSymbol$12 = $EXPECT($L40, fail, 'AssignmentOpSymbol "||="');
|
|
2337
|
+
var AssignmentOpSymbol$13 = $EXPECT($L41, fail, 'AssignmentOpSymbol "|="');
|
|
2338
|
+
var AssignmentOpSymbol$14 = $EXPECT($L42, fail, 'AssignmentOpSymbol "??="');
|
|
2339
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L43, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
2272
2340
|
return "??=";
|
|
2273
2341
|
});
|
|
2274
|
-
var AssignmentOpSymbol$16 = $EXPECT($
|
|
2342
|
+
var AssignmentOpSymbol$16 = $EXPECT($L44, fail, 'AssignmentOpSymbol "="');
|
|
2275
2343
|
function AssignmentOpSymbol(state) {
|
|
2276
2344
|
if (state.tokenize) {
|
|
2277
2345
|
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));
|
|
@@ -2291,52 +2359,52 @@ var Civet = (() => {
|
|
|
2291
2359
|
return BinaryOp$0(state);
|
|
2292
2360
|
}
|
|
2293
2361
|
}
|
|
2294
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
2295
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
2296
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
2297
|
-
var BinaryOpSymbol$3 = $EXPECT($
|
|
2298
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
2299
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
2300
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
2301
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
2302
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
2362
|
+
var BinaryOpSymbol$0 = $EXPECT($L45, fail, 'BinaryOpSymbol "**"');
|
|
2363
|
+
var BinaryOpSymbol$1 = $EXPECT($L46, fail, 'BinaryOpSymbol "*"');
|
|
2364
|
+
var BinaryOpSymbol$2 = $EXPECT($L47, fail, 'BinaryOpSymbol "/"');
|
|
2365
|
+
var BinaryOpSymbol$3 = $EXPECT($L48, fail, 'BinaryOpSymbol "%"');
|
|
2366
|
+
var BinaryOpSymbol$4 = $EXPECT($L49, fail, 'BinaryOpSymbol "+"');
|
|
2367
|
+
var BinaryOpSymbol$5 = $EXPECT($L50, fail, 'BinaryOpSymbol "-"');
|
|
2368
|
+
var BinaryOpSymbol$6 = $EXPECT($L51, fail, 'BinaryOpSymbol "<="');
|
|
2369
|
+
var BinaryOpSymbol$7 = $EXPECT($L52, fail, 'BinaryOpSymbol ">="');
|
|
2370
|
+
var BinaryOpSymbol$8 = $EXPECT($L53, fail, 'BinaryOpSymbol "<<"');
|
|
2303
2371
|
var BinaryOpSymbol$9 = $EXPECT($L5, fail, 'BinaryOpSymbol "<"');
|
|
2304
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
2305
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
2306
|
-
var BinaryOpSymbol$12 = $EXPECT($
|
|
2307
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
2308
|
-
var BinaryOpSymbol$14 = $TV($EXPECT($
|
|
2372
|
+
var BinaryOpSymbol$10 = $EXPECT($L54, fail, 'BinaryOpSymbol ">>>"');
|
|
2373
|
+
var BinaryOpSymbol$11 = $EXPECT($L55, fail, 'BinaryOpSymbol ">>"');
|
|
2374
|
+
var BinaryOpSymbol$12 = $EXPECT($L56, fail, 'BinaryOpSymbol ">"');
|
|
2375
|
+
var BinaryOpSymbol$13 = $EXPECT($L57, fail, 'BinaryOpSymbol "!=="');
|
|
2376
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L58, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
2309
2377
|
if (module.config.coffeeEq)
|
|
2310
2378
|
return "!==";
|
|
2311
2379
|
return $1;
|
|
2312
2380
|
});
|
|
2313
|
-
var BinaryOpSymbol$15 = $T($S($EXPECT($
|
|
2381
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L59, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
2314
2382
|
return "===";
|
|
2315
2383
|
});
|
|
2316
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
2317
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
2384
|
+
var BinaryOpSymbol$16 = $EXPECT($L60, fail, 'BinaryOpSymbol "==="');
|
|
2385
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
2318
2386
|
if (module.config.coffeeEq)
|
|
2319
2387
|
return "===";
|
|
2320
2388
|
return $1;
|
|
2321
2389
|
});
|
|
2322
|
-
var BinaryOpSymbol$18 = $T($S($EXPECT($
|
|
2390
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
2323
2391
|
return "&&";
|
|
2324
2392
|
});
|
|
2325
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
2326
|
-
var BinaryOpSymbol$20 = $T($S($EXPECT($
|
|
2393
|
+
var BinaryOpSymbol$19 = $EXPECT($L63, fail, 'BinaryOpSymbol "&&"');
|
|
2394
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L64, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
2327
2395
|
return "||";
|
|
2328
2396
|
});
|
|
2329
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
2330
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
2331
|
-
var BinaryOpSymbol$23 = $TS($S($EXPECT($
|
|
2397
|
+
var BinaryOpSymbol$21 = $EXPECT($L65, fail, 'BinaryOpSymbol "||"');
|
|
2398
|
+
var BinaryOpSymbol$22 = $EXPECT($L66, fail, 'BinaryOpSymbol "??"');
|
|
2399
|
+
var BinaryOpSymbol$23 = $TS($S($EXPECT($L67, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2332
2400
|
return $1;
|
|
2333
2401
|
});
|
|
2334
|
-
var BinaryOpSymbol$24 = $TS($S($EXPECT($
|
|
2402
|
+
var BinaryOpSymbol$24 = $TS($S($EXPECT($L68, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2335
2403
|
return $1;
|
|
2336
2404
|
});
|
|
2337
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
2338
|
-
var BinaryOpSymbol$26 = $EXPECT($
|
|
2339
|
-
var BinaryOpSymbol$27 = $EXPECT($
|
|
2405
|
+
var BinaryOpSymbol$25 = $EXPECT($L69, fail, 'BinaryOpSymbol "&"');
|
|
2406
|
+
var BinaryOpSymbol$26 = $EXPECT($L70, fail, 'BinaryOpSymbol "^"');
|
|
2407
|
+
var BinaryOpSymbol$27 = $EXPECT($L71, fail, 'BinaryOpSymbol "|"');
|
|
2340
2408
|
function BinaryOpSymbol(state) {
|
|
2341
2409
|
if (state.tokenize) {
|
|
2342
2410
|
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));
|
|
@@ -2345,7 +2413,7 @@ var Civet = (() => {
|
|
|
2345
2413
|
}
|
|
2346
2414
|
}
|
|
2347
2415
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
2348
|
-
var UnaryOp$1 = $S($C($EXPECT($
|
|
2416
|
+
var UnaryOp$1 = $S($C($EXPECT($L72, fail, 'UnaryOp "delete"'), $EXPECT($L73, fail, 'UnaryOp "void"'), $EXPECT($L74, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
|
|
2349
2417
|
function UnaryOp(state) {
|
|
2350
2418
|
if (state.tokenize) {
|
|
2351
2419
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -2424,7 +2492,7 @@ var Civet = (() => {
|
|
|
2424
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);
|
|
2425
2493
|
}
|
|
2426
2494
|
}
|
|
2427
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
2495
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L75, fail, 'EmptyStatement ";"'))), function(value) {
|
|
2428
2496
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
2429
2497
|
});
|
|
2430
2498
|
function EmptyStatement(state) {
|
|
@@ -2505,7 +2573,7 @@ var Civet = (() => {
|
|
|
2505
2573
|
return LoopStatement$0(state);
|
|
2506
2574
|
}
|
|
2507
2575
|
}
|
|
2508
|
-
var DoWhileStatement$0 = $T($S($EXPECT($
|
|
2576
|
+
var DoWhileStatement$0 = $T($S($EXPECT($L76, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause), function(value) {
|
|
2509
2577
|
return { "type": "IterationStatement", "children": value };
|
|
2510
2578
|
});
|
|
2511
2579
|
function DoWhileStatement(state) {
|
|
@@ -2529,7 +2597,7 @@ var Civet = (() => {
|
|
|
2529
2597
|
return WhileStatement$0(state);
|
|
2530
2598
|
}
|
|
2531
2599
|
}
|
|
2532
|
-
var WhileClause$0 = $TS($S($C($EXPECT($
|
|
2600
|
+
var WhileClause$0 = $TS($S($C($EXPECT($L77, fail, 'WhileClause "while"'), $EXPECT($L78, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
|
|
2533
2601
|
var kind = $1;
|
|
2534
2602
|
var cond = $3;
|
|
2535
2603
|
if (kind === "until") {
|
|
@@ -2767,7 +2835,7 @@ var Civet = (() => {
|
|
|
2767
2835
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2768
2836
|
}
|
|
2769
2837
|
}
|
|
2770
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2838
|
+
var Finally$0 = $S(__, $EXPECT($L79, fail, 'Finally "finally"'), BracedBlock);
|
|
2771
2839
|
function Finally(state) {
|
|
2772
2840
|
if (state.verbose)
|
|
2773
2841
|
console.log("ENTER:", "Finally");
|
|
@@ -2833,13 +2901,13 @@ var Civet = (() => {
|
|
|
2833
2901
|
return ExpressionStatement$0(state);
|
|
2834
2902
|
}
|
|
2835
2903
|
}
|
|
2836
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
2904
|
+
var KeywordStatement$0 = $T($S($EXPECT($L80, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
2837
2905
|
return { "type": "BreakStatement", "children": value };
|
|
2838
2906
|
});
|
|
2839
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
2907
|
+
var KeywordStatement$1 = $T($S($EXPECT($L81, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
2840
2908
|
return { "type": "ContinueStatement", "children": value };
|
|
2841
2909
|
});
|
|
2842
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
2910
|
+
var KeywordStatement$2 = $T($S($EXPECT($L82, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
2843
2911
|
return { "type": "DebuggerStatement", "children": value };
|
|
2844
2912
|
});
|
|
2845
2913
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -2864,7 +2932,7 @@ var Civet = (() => {
|
|
|
2864
2932
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2865
2933
|
}
|
|
2866
2934
|
}
|
|
2867
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2935
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L83, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2868
2936
|
return { "ts": true, "children": value };
|
|
2869
2937
|
});
|
|
2870
2938
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
@@ -3002,7 +3070,7 @@ var Civet = (() => {
|
|
|
3002
3070
|
return ImportedBinding$0(state);
|
|
3003
3071
|
}
|
|
3004
3072
|
}
|
|
3005
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
3073
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L84, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
3006
3074
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
3007
3075
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
3008
3076
|
function ExportDeclaration(state) {
|
|
@@ -3084,7 +3152,7 @@ var Civet = (() => {
|
|
|
3084
3152
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
3085
3153
|
}
|
|
3086
3154
|
}
|
|
3087
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
3155
|
+
var ConstAssignment$0 = $TV($EXPECT($L85, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
3088
3156
|
return { $loc, token: "=" };
|
|
3089
3157
|
});
|
|
3090
3158
|
function ConstAssignment(state) {
|
|
@@ -3180,17 +3248,29 @@ var Civet = (() => {
|
|
|
3180
3248
|
return DecimalBigIntegerLiteral$0(state);
|
|
3181
3249
|
}
|
|
3182
3250
|
}
|
|
3183
|
-
var DecimalLiteral$0 = $
|
|
3251
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R5, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
3252
|
+
return $1 + ".";
|
|
3253
|
+
});
|
|
3254
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R6, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*)?)?/"), $E(ExponentPart)));
|
|
3255
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R7, fail, "DecimalLiteral /(?:\\.(?!\\p{ID_Start})[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
3184
3256
|
function DecimalLiteral(state) {
|
|
3257
|
+
if (state.tokenize) {
|
|
3258
|
+
return $TOKEN("DecimalLiteral", state, DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state));
|
|
3259
|
+
} else {
|
|
3260
|
+
return DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state);
|
|
3261
|
+
}
|
|
3262
|
+
}
|
|
3263
|
+
var ExponentPart$0 = $R$0($EXPECT($R8, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
3264
|
+
function ExponentPart(state) {
|
|
3185
3265
|
if (state.verbose)
|
|
3186
|
-
console.log("ENTER:", "
|
|
3266
|
+
console.log("ENTER:", "ExponentPart");
|
|
3187
3267
|
if (state.tokenize) {
|
|
3188
|
-
return $TOKEN("
|
|
3268
|
+
return $TOKEN("ExponentPart", state, ExponentPart$0(state));
|
|
3189
3269
|
} else {
|
|
3190
|
-
return
|
|
3270
|
+
return ExponentPart$0(state);
|
|
3191
3271
|
}
|
|
3192
3272
|
}
|
|
3193
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
3273
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R9, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
3194
3274
|
function BinaryIntegerLiteral(state) {
|
|
3195
3275
|
if (state.verbose)
|
|
3196
3276
|
console.log("ENTER:", "BinaryIntegerLiteral");
|
|
@@ -3200,7 +3280,7 @@ var Civet = (() => {
|
|
|
3200
3280
|
return BinaryIntegerLiteral$0(state);
|
|
3201
3281
|
}
|
|
3202
3282
|
}
|
|
3203
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
3283
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R10, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
3204
3284
|
function OctalIntegerLiteral(state) {
|
|
3205
3285
|
if (state.verbose)
|
|
3206
3286
|
console.log("ENTER:", "OctalIntegerLiteral");
|
|
@@ -3210,7 +3290,7 @@ var Civet = (() => {
|
|
|
3210
3290
|
return OctalIntegerLiteral$0(state);
|
|
3211
3291
|
}
|
|
3212
3292
|
}
|
|
3213
|
-
var HexLiteral$0 = $R$0($EXPECT($
|
|
3293
|
+
var HexLiteral$0 = $R$0($EXPECT($R11, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
3214
3294
|
function HexLiteral(state) {
|
|
3215
3295
|
if (state.verbose)
|
|
3216
3296
|
console.log("ENTER:", "HexLiteral");
|
|
@@ -3259,7 +3339,7 @@ var Civet = (() => {
|
|
|
3259
3339
|
return BasicStringLiteral$0(state) || BasicStringLiteral$1(state);
|
|
3260
3340
|
}
|
|
3261
3341
|
}
|
|
3262
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
3342
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R12, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3263
3343
|
return { $loc, token: $0 };
|
|
3264
3344
|
});
|
|
3265
3345
|
function DoubleStringCharacters(state) {
|
|
@@ -3271,7 +3351,7 @@ var Civet = (() => {
|
|
|
3271
3351
|
return DoubleStringCharacters$0(state);
|
|
3272
3352
|
}
|
|
3273
3353
|
}
|
|
3274
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
3354
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R13, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3275
3355
|
return { $loc, token: $0 };
|
|
3276
3356
|
});
|
|
3277
3357
|
function SingleStringCharacters(state) {
|
|
@@ -3283,7 +3363,7 @@ var Civet = (() => {
|
|
|
3283
3363
|
return SingleStringCharacters$0(state);
|
|
3284
3364
|
}
|
|
3285
3365
|
}
|
|
3286
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
3366
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R14, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3287
3367
|
return { $loc, token: $0 };
|
|
3288
3368
|
});
|
|
3289
3369
|
function TripleDoubleStringCharacters(state) {
|
|
@@ -3295,7 +3375,7 @@ var Civet = (() => {
|
|
|
3295
3375
|
return TripleDoubleStringCharacters$0(state);
|
|
3296
3376
|
}
|
|
3297
3377
|
}
|
|
3298
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
3378
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R15, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3299
3379
|
return { $loc, token: $0 };
|
|
3300
3380
|
});
|
|
3301
3381
|
function TripleSingleStringCharacters(state) {
|
|
@@ -3346,7 +3426,7 @@ var Civet = (() => {
|
|
|
3346
3426
|
return CoffeeInterpolatedDoubleQuotedString$0(state);
|
|
3347
3427
|
}
|
|
3348
3428
|
}
|
|
3349
|
-
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($
|
|
3429
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R16, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3350
3430
|
return { $loc, token: $0 };
|
|
3351
3431
|
});
|
|
3352
3432
|
function CoffeeDoubleQuotedStringCharacters(state) {
|
|
@@ -3358,7 +3438,7 @@ var Civet = (() => {
|
|
|
3358
3438
|
return CoffeeDoubleQuotedStringCharacters$0(state);
|
|
3359
3439
|
}
|
|
3360
3440
|
}
|
|
3361
|
-
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($
|
|
3441
|
+
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L47, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L47, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
3362
3442
|
return { $loc, token: $1 };
|
|
3363
3443
|
});
|
|
3364
3444
|
function RegularExpressionLiteral(state) {
|
|
@@ -3370,7 +3450,7 @@ var Civet = (() => {
|
|
|
3370
3450
|
return RegularExpressionLiteral$0(state);
|
|
3371
3451
|
}
|
|
3372
3452
|
}
|
|
3373
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
3453
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R17, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
|
|
3374
3454
|
function RegularExpressionBody(state) {
|
|
3375
3455
|
if (state.verbose)
|
|
3376
3456
|
console.log("ENTER:", "RegularExpressionBody");
|
|
@@ -3380,7 +3460,7 @@ var Civet = (() => {
|
|
|
3380
3460
|
return RegularExpressionBody$0(state);
|
|
3381
3461
|
}
|
|
3382
3462
|
}
|
|
3383
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
3463
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R18, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
3384
3464
|
function RegExpCharacter(state) {
|
|
3385
3465
|
if (state.verbose)
|
|
3386
3466
|
console.log("ENTER:", "RegExpCharacter");
|
|
@@ -3390,7 +3470,7 @@ var Civet = (() => {
|
|
|
3390
3470
|
return RegExpCharacter$0(state);
|
|
3391
3471
|
}
|
|
3392
3472
|
}
|
|
3393
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
3473
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R19, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
3394
3474
|
function RegularExpressionFlags(state) {
|
|
3395
3475
|
if (state.verbose)
|
|
3396
3476
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -3421,7 +3501,7 @@ var Civet = (() => {
|
|
|
3421
3501
|
return TemplateSubstitution$0(state);
|
|
3422
3502
|
}
|
|
3423
3503
|
}
|
|
3424
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
3504
|
+
var TemplateCharacters$0 = $TR($EXPECT($R20, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3425
3505
|
return { $loc, token: $0 };
|
|
3426
3506
|
});
|
|
3427
3507
|
function TemplateCharacters(state) {
|
|
@@ -3433,7 +3513,7 @@ var Civet = (() => {
|
|
|
3433
3513
|
return TemplateCharacters$0(state);
|
|
3434
3514
|
}
|
|
3435
3515
|
}
|
|
3436
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
3516
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R21, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3437
3517
|
return { $loc, token: $0 };
|
|
3438
3518
|
});
|
|
3439
3519
|
function TemplateBlockCharacters(state) {
|
|
@@ -3445,14 +3525,13 @@ var Civet = (() => {
|
|
|
3445
3525
|
return TemplateBlockCharacters$0(state);
|
|
3446
3526
|
}
|
|
3447
3527
|
}
|
|
3448
|
-
var ReservedWord$0 = $R$0($EXPECT($
|
|
3528
|
+
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R22, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
|
|
3529
|
+
var ReservedWord$1 = $R$0($EXPECT($R23, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
3449
3530
|
function ReservedWord(state) {
|
|
3450
|
-
if (state.verbose)
|
|
3451
|
-
console.log("ENTER:", "ReservedWord");
|
|
3452
3531
|
if (state.tokenize) {
|
|
3453
|
-
return $TOKEN("ReservedWord", state, ReservedWord$0(state));
|
|
3532
|
+
return $TOKEN("ReservedWord", state, ReservedWord$0(state) || ReservedWord$1(state));
|
|
3454
3533
|
} else {
|
|
3455
|
-
return ReservedWord$0(state);
|
|
3534
|
+
return ReservedWord$0(state) || ReservedWord$1(state);
|
|
3456
3535
|
}
|
|
3457
3536
|
}
|
|
3458
3537
|
var Comment$0 = MultiLineComment;
|
|
@@ -3464,7 +3543,7 @@ var Civet = (() => {
|
|
|
3464
3543
|
return Comment$0(state) || Comment$1(state);
|
|
3465
3544
|
}
|
|
3466
3545
|
}
|
|
3467
|
-
var SingleLineComment$0 = $TR($EXPECT($
|
|
3546
|
+
var SingleLineComment$0 = $TR($EXPECT($R24, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3468
3547
|
return { $loc, token: $0 };
|
|
3469
3548
|
});
|
|
3470
3549
|
var SingleLineComment$1 = $S(CoffeeCommentEnabled, CoffeeSingleLineComment);
|
|
@@ -3484,7 +3563,7 @@ var Civet = (() => {
|
|
|
3484
3563
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
3485
3564
|
}
|
|
3486
3565
|
}
|
|
3487
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
3566
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L86, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L87, fail, 'JSMultiLineComment "*/"')), $EXPECT($R25, fail, "JSMultiLineComment /./"))), $EXPECT($L87, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
3488
3567
|
return { $loc, token: $1 };
|
|
3489
3568
|
});
|
|
3490
3569
|
function JSMultiLineComment(state) {
|
|
@@ -3496,7 +3575,7 @@ var Civet = (() => {
|
|
|
3496
3575
|
return JSMultiLineComment$0(state);
|
|
3497
3576
|
}
|
|
3498
3577
|
}
|
|
3499
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
3578
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R26, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3500
3579
|
return { $loc, token: `//${$1}` };
|
|
3501
3580
|
});
|
|
3502
3581
|
function CoffeeSingleLineComment(state) {
|
|
@@ -3508,7 +3587,7 @@ var Civet = (() => {
|
|
|
3508
3587
|
return CoffeeSingleLineComment$0(state);
|
|
3509
3588
|
}
|
|
3510
3589
|
}
|
|
3511
|
-
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($
|
|
3590
|
+
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L88, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L88, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L87, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R25, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L88, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3512
3591
|
return { $loc, token: `/*${$2}*/` };
|
|
3513
3592
|
});
|
|
3514
3593
|
function CoffeeMultiLineComment(state) {
|
|
@@ -3520,7 +3599,7 @@ var Civet = (() => {
|
|
|
3520
3599
|
return CoffeeMultiLineComment$0(state);
|
|
3521
3600
|
}
|
|
3522
3601
|
}
|
|
3523
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
3602
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L86, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L87, fail, 'InlineComment "*/"')), $EXPECT($R27, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L87, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
3524
3603
|
return { $loc, token: $1 };
|
|
3525
3604
|
});
|
|
3526
3605
|
function InlineComment(state) {
|
|
@@ -3562,7 +3641,7 @@ var Civet = (() => {
|
|
|
3562
3641
|
return _$0(state);
|
|
3563
3642
|
}
|
|
3564
3643
|
}
|
|
3565
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
3644
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R28, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3566
3645
|
return { $loc, token: $0 };
|
|
3567
3646
|
});
|
|
3568
3647
|
function NonNewlineWhitespace(state) {
|
|
@@ -3584,7 +3663,7 @@ var Civet = (() => {
|
|
|
3584
3663
|
return __$0(state);
|
|
3585
3664
|
}
|
|
3586
3665
|
}
|
|
3587
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
3666
|
+
var Whitespace$0 = $TR($EXPECT($R29, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3588
3667
|
return { $loc, token: $0 };
|
|
3589
3668
|
});
|
|
3590
3669
|
function Whitespace(state) {
|
|
@@ -3607,7 +3686,7 @@ var Civet = (() => {
|
|
|
3607
3686
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
3608
3687
|
}
|
|
3609
3688
|
}
|
|
3610
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3689
|
+
var NonIdContinue$0 = $R$0($EXPECT($R30, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
3611
3690
|
function NonIdContinue(state) {
|
|
3612
3691
|
if (state.verbose)
|
|
3613
3692
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -3629,7 +3708,7 @@ var Civet = (() => {
|
|
|
3629
3708
|
return Loc$0(state);
|
|
3630
3709
|
}
|
|
3631
3710
|
}
|
|
3632
|
-
var As$0 = $TS($S($EXPECT($
|
|
3711
|
+
var As$0 = $TS($S($EXPECT($L89, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3633
3712
|
return { $loc, token: $1 };
|
|
3634
3713
|
});
|
|
3635
3714
|
function As(state) {
|
|
@@ -3641,7 +3720,7 @@ var Civet = (() => {
|
|
|
3641
3720
|
return As$0(state);
|
|
3642
3721
|
}
|
|
3643
3722
|
}
|
|
3644
|
-
var Async$0 = $TV($EXPECT($
|
|
3723
|
+
var Async$0 = $TV($EXPECT($L90, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
|
|
3645
3724
|
return { $loc, token: $1 };
|
|
3646
3725
|
});
|
|
3647
3726
|
function Async(state) {
|
|
@@ -3653,7 +3732,7 @@ var Civet = (() => {
|
|
|
3653
3732
|
return Async$0(state);
|
|
3654
3733
|
}
|
|
3655
3734
|
}
|
|
3656
|
-
var Await$0 = $TS($S($EXPECT($
|
|
3735
|
+
var Await$0 = $TS($S($EXPECT($L91, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3657
3736
|
return { $loc, token: $1 };
|
|
3658
3737
|
});
|
|
3659
3738
|
function Await(state) {
|
|
@@ -3665,7 +3744,7 @@ var Civet = (() => {
|
|
|
3665
3744
|
return Await$0(state);
|
|
3666
3745
|
}
|
|
3667
3746
|
}
|
|
3668
|
-
var Case$0 = $TS($S($EXPECT($
|
|
3747
|
+
var Case$0 = $TS($S($EXPECT($L92, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3669
3748
|
return { $loc, token: $1 };
|
|
3670
3749
|
});
|
|
3671
3750
|
function Case(state) {
|
|
@@ -3677,7 +3756,7 @@ var Civet = (() => {
|
|
|
3677
3756
|
return Case$0(state);
|
|
3678
3757
|
}
|
|
3679
3758
|
}
|
|
3680
|
-
var Catch$0 = $TV($EXPECT($
|
|
3759
|
+
var Catch$0 = $TV($EXPECT($L93, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
3681
3760
|
return { $loc, token: $1 };
|
|
3682
3761
|
});
|
|
3683
3762
|
function Catch(state) {
|
|
@@ -3689,7 +3768,7 @@ var Civet = (() => {
|
|
|
3689
3768
|
return Catch$0(state);
|
|
3690
3769
|
}
|
|
3691
3770
|
}
|
|
3692
|
-
var Class$0 = $TV($EXPECT($
|
|
3771
|
+
var Class$0 = $TV($EXPECT($L94, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
3693
3772
|
return { $loc, token: $1 };
|
|
3694
3773
|
});
|
|
3695
3774
|
function Class(state) {
|
|
@@ -3701,7 +3780,7 @@ var Civet = (() => {
|
|
|
3701
3780
|
return Class$0(state);
|
|
3702
3781
|
}
|
|
3703
3782
|
}
|
|
3704
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
3783
|
+
var CloseBrace$0 = $TV($EXPECT($L27, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
3705
3784
|
return { $loc, token: $1 };
|
|
3706
3785
|
});
|
|
3707
3786
|
function CloseBrace(state) {
|
|
@@ -3713,7 +3792,7 @@ var Civet = (() => {
|
|
|
3713
3792
|
return CloseBrace$0(state);
|
|
3714
3793
|
}
|
|
3715
3794
|
}
|
|
3716
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
3795
|
+
var CloseBracket$0 = $TV($EXPECT($L26, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
3717
3796
|
return { $loc, token: $1 };
|
|
3718
3797
|
});
|
|
3719
3798
|
function CloseBracket(state) {
|
|
@@ -3737,7 +3816,7 @@ var Civet = (() => {
|
|
|
3737
3816
|
return CloseParen$0(state);
|
|
3738
3817
|
}
|
|
3739
3818
|
}
|
|
3740
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
3819
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L95, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
3741
3820
|
return { $loc, token: "${" };
|
|
3742
3821
|
});
|
|
3743
3822
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -3749,7 +3828,7 @@ var Civet = (() => {
|
|
|
3749
3828
|
return CoffeeSubstitutionStart$0(state);
|
|
3750
3829
|
}
|
|
3751
3830
|
}
|
|
3752
|
-
var Colon$0 = $TV($EXPECT($
|
|
3831
|
+
var Colon$0 = $TV($EXPECT($L96, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
3753
3832
|
return { $loc, token: $1 };
|
|
3754
3833
|
});
|
|
3755
3834
|
function Colon(state) {
|
|
@@ -3773,7 +3852,7 @@ var Civet = (() => {
|
|
|
3773
3852
|
return ConstructorShorthand$0(state);
|
|
3774
3853
|
}
|
|
3775
3854
|
}
|
|
3776
|
-
var Default$0 = $TS($S($EXPECT($
|
|
3855
|
+
var Default$0 = $TS($S($EXPECT($L84, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3777
3856
|
return { $loc, token: $1 };
|
|
3778
3857
|
});
|
|
3779
3858
|
function Default(state) {
|
|
@@ -3785,7 +3864,7 @@ var Civet = (() => {
|
|
|
3785
3864
|
return Default$0(state);
|
|
3786
3865
|
}
|
|
3787
3866
|
}
|
|
3788
|
-
var Dot$0 = $TV($EXPECT($
|
|
3867
|
+
var Dot$0 = $TV($EXPECT($L97, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
3789
3868
|
return { $loc, token: $1 };
|
|
3790
3869
|
});
|
|
3791
3870
|
function Dot(state) {
|
|
@@ -3797,7 +3876,19 @@ var Civet = (() => {
|
|
|
3797
3876
|
return Dot$0(state);
|
|
3798
3877
|
}
|
|
3799
3878
|
}
|
|
3800
|
-
var
|
|
3879
|
+
var DotDotDot$0 = $TV($EXPECT($L98, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
3880
|
+
return { $loc, token: $1 };
|
|
3881
|
+
});
|
|
3882
|
+
function DotDotDot(state) {
|
|
3883
|
+
if (state.verbose)
|
|
3884
|
+
console.log("ENTER:", "DotDotDot");
|
|
3885
|
+
if (state.tokenize) {
|
|
3886
|
+
return $TOKEN("DotDotDot", state, DotDotDot$0(state));
|
|
3887
|
+
} else {
|
|
3888
|
+
return DotDotDot$0(state);
|
|
3889
|
+
}
|
|
3890
|
+
}
|
|
3891
|
+
var DoubleQuote$0 = $TV($EXPECT($L99, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
3801
3892
|
return { $loc, token: $1 };
|
|
3802
3893
|
});
|
|
3803
3894
|
function DoubleQuote(state) {
|
|
@@ -3809,7 +3900,7 @@ var Civet = (() => {
|
|
|
3809
3900
|
return DoubleQuote$0(state);
|
|
3810
3901
|
}
|
|
3811
3902
|
}
|
|
3812
|
-
var Else$0 = $TV($EXPECT($
|
|
3903
|
+
var Else$0 = $TV($EXPECT($L100, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
3813
3904
|
return { $loc, token: $1 };
|
|
3814
3905
|
});
|
|
3815
3906
|
function Else(state) {
|
|
@@ -3821,7 +3912,7 @@ var Civet = (() => {
|
|
|
3821
3912
|
return Else$0(state);
|
|
3822
3913
|
}
|
|
3823
3914
|
}
|
|
3824
|
-
var Equals$0 = $TV($EXPECT($
|
|
3915
|
+
var Equals$0 = $TV($EXPECT($L44, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
3825
3916
|
return { $loc, token: $1 };
|
|
3826
3917
|
});
|
|
3827
3918
|
function Equals(state) {
|
|
@@ -3833,7 +3924,7 @@ var Civet = (() => {
|
|
|
3833
3924
|
return Equals$0(state);
|
|
3834
3925
|
}
|
|
3835
3926
|
}
|
|
3836
|
-
var Export$0 = $TS($S($EXPECT($
|
|
3927
|
+
var Export$0 = $TS($S($EXPECT($L101, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3837
3928
|
return { $loc, token: $1 };
|
|
3838
3929
|
});
|
|
3839
3930
|
function Export(state) {
|
|
@@ -3845,7 +3936,7 @@ var Civet = (() => {
|
|
|
3845
3936
|
return Export$0(state);
|
|
3846
3937
|
}
|
|
3847
3938
|
}
|
|
3848
|
-
var For$0 = $TS($S($EXPECT($
|
|
3939
|
+
var For$0 = $TS($S($EXPECT($L102, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3849
3940
|
return { $loc, token: $1 };
|
|
3850
3941
|
});
|
|
3851
3942
|
function For(state) {
|
|
@@ -3857,7 +3948,7 @@ var Civet = (() => {
|
|
|
3857
3948
|
return For$0(state);
|
|
3858
3949
|
}
|
|
3859
3950
|
}
|
|
3860
|
-
var From$0 = $TS($S($EXPECT($
|
|
3951
|
+
var From$0 = $TS($S($EXPECT($L103, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3861
3952
|
return { $loc, token: $1 };
|
|
3862
3953
|
});
|
|
3863
3954
|
function From(state) {
|
|
@@ -3869,7 +3960,7 @@ var Civet = (() => {
|
|
|
3869
3960
|
return From$0(state);
|
|
3870
3961
|
}
|
|
3871
3962
|
}
|
|
3872
|
-
var Function$0 = $TV($EXPECT($
|
|
3963
|
+
var Function$0 = $TV($EXPECT($L104, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
3873
3964
|
return { $loc, token: $1 };
|
|
3874
3965
|
});
|
|
3875
3966
|
function Function(state) {
|
|
@@ -3881,7 +3972,7 @@ var Civet = (() => {
|
|
|
3881
3972
|
return Function$0(state);
|
|
3882
3973
|
}
|
|
3883
3974
|
}
|
|
3884
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
3975
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L105, fail, 'GetOrSet "get"'), $EXPECT($L106, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3885
3976
|
return { $loc, token: $1 };
|
|
3886
3977
|
});
|
|
3887
3978
|
function GetOrSet(state) {
|
|
@@ -3893,7 +3984,7 @@ var Civet = (() => {
|
|
|
3893
3984
|
return GetOrSet$0(state);
|
|
3894
3985
|
}
|
|
3895
3986
|
}
|
|
3896
|
-
var If$0 = $TV($EXPECT($
|
|
3987
|
+
var If$0 = $TV($EXPECT($L107, fail, 'If "if"'), function($skip, $loc, $0, $1) {
|
|
3897
3988
|
return { $loc, token: $1 };
|
|
3898
3989
|
});
|
|
3899
3990
|
function If(state) {
|
|
@@ -3905,7 +3996,7 @@ var Civet = (() => {
|
|
|
3905
3996
|
return If$0(state);
|
|
3906
3997
|
}
|
|
3907
3998
|
}
|
|
3908
|
-
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($
|
|
3999
|
+
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R31, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
3909
4000
|
return { $loc, token: $1 };
|
|
3910
4001
|
});
|
|
3911
4002
|
function Import(state) {
|
|
@@ -3917,7 +4008,7 @@ var Civet = (() => {
|
|
|
3917
4008
|
return Import$0(state);
|
|
3918
4009
|
}
|
|
3919
4010
|
}
|
|
3920
|
-
var In$0 = $TV($EXPECT($
|
|
4011
|
+
var In$0 = $TV($EXPECT($L68, fail, 'In "in"'), function($skip, $loc, $0, $1) {
|
|
3921
4012
|
return { $loc, token: $1 };
|
|
3922
4013
|
});
|
|
3923
4014
|
function In(state) {
|
|
@@ -3929,7 +4020,7 @@ var Civet = (() => {
|
|
|
3929
4020
|
return In$0(state);
|
|
3930
4021
|
}
|
|
3931
4022
|
}
|
|
3932
|
-
var LetOrConst$0 = $TV($C($EXPECT($
|
|
4023
|
+
var LetOrConst$0 = $TV($C($EXPECT($L108, fail, 'LetOrConst "let"'), $EXPECT($L109, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
3933
4024
|
return { $loc, token: $1 };
|
|
3934
4025
|
});
|
|
3935
4026
|
function LetOrConst(state) {
|
|
@@ -3941,7 +4032,7 @@ var Civet = (() => {
|
|
|
3941
4032
|
return LetOrConst$0(state);
|
|
3942
4033
|
}
|
|
3943
4034
|
}
|
|
3944
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
4035
|
+
var Loop$0 = $TS($S($EXPECT($L110, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3945
4036
|
return { $loc, token: "while(true)" };
|
|
3946
4037
|
});
|
|
3947
4038
|
function Loop(state) {
|
|
@@ -3953,7 +4044,7 @@ var Civet = (() => {
|
|
|
3953
4044
|
return Loop$0(state);
|
|
3954
4045
|
}
|
|
3955
4046
|
}
|
|
3956
|
-
var New$0 = $TV($EXPECT($
|
|
4047
|
+
var New$0 = $TV($EXPECT($L111, fail, 'New "new"'), function($skip, $loc, $0, $1) {
|
|
3957
4048
|
return { $loc, token: $1 };
|
|
3958
4049
|
});
|
|
3959
4050
|
function New(state) {
|
|
@@ -3965,7 +4056,7 @@ var Civet = (() => {
|
|
|
3965
4056
|
return New$0(state);
|
|
3966
4057
|
}
|
|
3967
4058
|
}
|
|
3968
|
-
var Of$0 = $TV($EXPECT($
|
|
4059
|
+
var Of$0 = $TV($EXPECT($L112, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
3969
4060
|
return { $loc, token: $1 };
|
|
3970
4061
|
});
|
|
3971
4062
|
function Of(state) {
|
|
@@ -3977,7 +4068,7 @@ var Civet = (() => {
|
|
|
3977
4068
|
return Of$0(state);
|
|
3978
4069
|
}
|
|
3979
4070
|
}
|
|
3980
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
4071
|
+
var OpenBrace$0 = $TV($EXPECT($L113, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
3981
4072
|
return { $loc, token: $1 };
|
|
3982
4073
|
});
|
|
3983
4074
|
function OpenBrace(state) {
|
|
@@ -3989,7 +4080,7 @@ var Civet = (() => {
|
|
|
3989
4080
|
return OpenBrace$0(state);
|
|
3990
4081
|
}
|
|
3991
4082
|
}
|
|
3992
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
4083
|
+
var OpenBracket$0 = $TV($EXPECT($L114, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
3993
4084
|
return { $loc, token: $1 };
|
|
3994
4085
|
});
|
|
3995
4086
|
function OpenBracket(state) {
|
|
@@ -4001,7 +4092,7 @@ var Civet = (() => {
|
|
|
4001
4092
|
return OpenBracket$0(state);
|
|
4002
4093
|
}
|
|
4003
4094
|
}
|
|
4004
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
4095
|
+
var OpenParen$0 = $TV($EXPECT($L115, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
4005
4096
|
return { $loc, token: $1 };
|
|
4006
4097
|
});
|
|
4007
4098
|
function OpenParen(state) {
|
|
@@ -4013,7 +4104,7 @@ var Civet = (() => {
|
|
|
4013
4104
|
return OpenParen$0(state);
|
|
4014
4105
|
}
|
|
4015
4106
|
}
|
|
4016
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
4107
|
+
var QuestionMark$0 = $TV($EXPECT($L116, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
4017
4108
|
return { $loc, token: $1 };
|
|
4018
4109
|
});
|
|
4019
4110
|
function QuestionMark(state) {
|
|
@@ -4025,7 +4116,7 @@ var Civet = (() => {
|
|
|
4025
4116
|
return QuestionMark$0(state);
|
|
4026
4117
|
}
|
|
4027
4118
|
}
|
|
4028
|
-
var Return$0 = $TS($S($EXPECT($
|
|
4119
|
+
var Return$0 = $TS($S($EXPECT($L117, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4029
4120
|
return { $loc, token: $1 };
|
|
4030
4121
|
});
|
|
4031
4122
|
function Return(state) {
|
|
@@ -4037,7 +4128,7 @@ var Civet = (() => {
|
|
|
4037
4128
|
return Return$0(state);
|
|
4038
4129
|
}
|
|
4039
4130
|
}
|
|
4040
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
4131
|
+
var Semicolon$0 = $TV($EXPECT($L75, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
4041
4132
|
return { $loc, token: $1 };
|
|
4042
4133
|
});
|
|
4043
4134
|
function Semicolon(state) {
|
|
@@ -4049,7 +4140,7 @@ var Civet = (() => {
|
|
|
4049
4140
|
return Semicolon$0(state);
|
|
4050
4141
|
}
|
|
4051
4142
|
}
|
|
4052
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
4143
|
+
var SingleQuote$0 = $TV($EXPECT($L118, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
4053
4144
|
return { $loc, token: $1 };
|
|
4054
4145
|
});
|
|
4055
4146
|
function SingleQuote(state) {
|
|
@@ -4061,7 +4152,7 @@ var Civet = (() => {
|
|
|
4061
4152
|
return SingleQuote$0(state);
|
|
4062
4153
|
}
|
|
4063
4154
|
}
|
|
4064
|
-
var Star$0 = $TV($EXPECT($
|
|
4155
|
+
var Star$0 = $TV($EXPECT($L46, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
4065
4156
|
return { $loc, token: $1 };
|
|
4066
4157
|
});
|
|
4067
4158
|
function Star(state) {
|
|
@@ -4073,10 +4164,10 @@ var Civet = (() => {
|
|
|
4073
4164
|
return Star$0(state);
|
|
4074
4165
|
}
|
|
4075
4166
|
}
|
|
4076
|
-
var Static$0 = $TV($EXPECT($
|
|
4167
|
+
var Static$0 = $TV($EXPECT($L119, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
4077
4168
|
return { $loc, token: $1 };
|
|
4078
4169
|
});
|
|
4079
|
-
var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($
|
|
4170
|
+
var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L115, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
|
|
4080
4171
|
return { $loc, token: "static " };
|
|
4081
4172
|
});
|
|
4082
4173
|
function Static(state) {
|
|
@@ -4086,7 +4177,7 @@ var Civet = (() => {
|
|
|
4086
4177
|
return Static$0(state) || Static$1(state);
|
|
4087
4178
|
}
|
|
4088
4179
|
}
|
|
4089
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
4180
|
+
var SubstitutionStart$0 = $TV($EXPECT($L120, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
4090
4181
|
return { $loc, token: $1 };
|
|
4091
4182
|
});
|
|
4092
4183
|
function SubstitutionStart(state) {
|
|
@@ -4098,7 +4189,7 @@ var Civet = (() => {
|
|
|
4098
4189
|
return SubstitutionStart$0(state);
|
|
4099
4190
|
}
|
|
4100
4191
|
}
|
|
4101
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
4192
|
+
var Switch$0 = $TS($S($EXPECT($L121, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4102
4193
|
return { $loc, token: $1 };
|
|
4103
4194
|
});
|
|
4104
4195
|
function Switch(state) {
|
|
@@ -4110,7 +4201,7 @@ var Civet = (() => {
|
|
|
4110
4201
|
return Switch$0(state);
|
|
4111
4202
|
}
|
|
4112
4203
|
}
|
|
4113
|
-
var Target$0 = $TV($EXPECT($
|
|
4204
|
+
var Target$0 = $TV($EXPECT($L122, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
|
|
4114
4205
|
return { $loc, token: $1 };
|
|
4115
4206
|
});
|
|
4116
4207
|
function Target(state) {
|
|
@@ -4122,7 +4213,7 @@ var Civet = (() => {
|
|
|
4122
4213
|
return Target$0(state);
|
|
4123
4214
|
}
|
|
4124
4215
|
}
|
|
4125
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
4216
|
+
var Throw$0 = $TS($S($EXPECT($L123, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4126
4217
|
return { $loc, token: $1 };
|
|
4127
4218
|
});
|
|
4128
4219
|
function Throw(state) {
|
|
@@ -4134,7 +4225,7 @@ var Civet = (() => {
|
|
|
4134
4225
|
return Throw$0(state);
|
|
4135
4226
|
}
|
|
4136
4227
|
}
|
|
4137
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
4228
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L124, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
4138
4229
|
return { $loc, token: "`" };
|
|
4139
4230
|
});
|
|
4140
4231
|
function TripleDoubleQuote(state) {
|
|
@@ -4146,7 +4237,7 @@ var Civet = (() => {
|
|
|
4146
4237
|
return TripleDoubleQuote$0(state);
|
|
4147
4238
|
}
|
|
4148
4239
|
}
|
|
4149
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
4240
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L125, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
4150
4241
|
return { $loc, token: "`" };
|
|
4151
4242
|
});
|
|
4152
4243
|
function TripleSingleQuote(state) {
|
|
@@ -4158,7 +4249,7 @@ var Civet = (() => {
|
|
|
4158
4249
|
return TripleSingleQuote$0(state);
|
|
4159
4250
|
}
|
|
4160
4251
|
}
|
|
4161
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
4252
|
+
var TripleTick$0 = $TV($EXPECT($L126, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
4162
4253
|
return { $loc, token: "`" };
|
|
4163
4254
|
});
|
|
4164
4255
|
function TripleTick(state) {
|
|
@@ -4170,7 +4261,7 @@ var Civet = (() => {
|
|
|
4170
4261
|
return TripleTick$0(state);
|
|
4171
4262
|
}
|
|
4172
4263
|
}
|
|
4173
|
-
var Try$0 = $TV($EXPECT($
|
|
4264
|
+
var Try$0 = $TV($EXPECT($L127, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
4174
4265
|
return { $loc, token: $1 };
|
|
4175
4266
|
});
|
|
4176
4267
|
function Try(state) {
|
|
@@ -4182,7 +4273,7 @@ var Civet = (() => {
|
|
|
4182
4273
|
return Try$0(state);
|
|
4183
4274
|
}
|
|
4184
4275
|
}
|
|
4185
|
-
var Unless$0 = $TV($EXPECT($
|
|
4276
|
+
var Unless$0 = $TV($EXPECT($L128, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
4186
4277
|
return { $loc, token: $1 };
|
|
4187
4278
|
});
|
|
4188
4279
|
function Unless(state) {
|
|
@@ -4194,7 +4285,7 @@ var Civet = (() => {
|
|
|
4194
4285
|
return Unless$0(state);
|
|
4195
4286
|
}
|
|
4196
4287
|
}
|
|
4197
|
-
var Var$0 = $TV($EXPECT($
|
|
4288
|
+
var Var$0 = $TV($EXPECT($L129, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
4198
4289
|
return { $loc, token: $1 };
|
|
4199
4290
|
});
|
|
4200
4291
|
function Var(state) {
|
|
@@ -4206,7 +4297,7 @@ var Civet = (() => {
|
|
|
4206
4297
|
return Var$0(state);
|
|
4207
4298
|
}
|
|
4208
4299
|
}
|
|
4209
|
-
var When$0 = $TS($S($EXPECT($
|
|
4300
|
+
var When$0 = $TS($S($EXPECT($L130, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4210
4301
|
return { $loc, token: "case" };
|
|
4211
4302
|
});
|
|
4212
4303
|
function When(state) {
|
|
@@ -4218,7 +4309,7 @@ var Civet = (() => {
|
|
|
4218
4309
|
return When$0(state);
|
|
4219
4310
|
}
|
|
4220
4311
|
}
|
|
4221
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
4312
|
+
var Yield$0 = $TS($S($EXPECT($L131, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4222
4313
|
return { $loc, token: $1 };
|
|
4223
4314
|
});
|
|
4224
4315
|
function Yield(state) {
|
|
@@ -4244,7 +4335,7 @@ var Civet = (() => {
|
|
|
4244
4335
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
4245
4336
|
}
|
|
4246
4337
|
}
|
|
4247
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
4338
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L132, fail, 'JSXSelfClosingElement "/>"'));
|
|
4248
4339
|
function JSXSelfClosingElement(state) {
|
|
4249
4340
|
if (state.verbose)
|
|
4250
4341
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -4254,7 +4345,7 @@ var Civet = (() => {
|
|
|
4254
4345
|
return JSXSelfClosingElement$0(state);
|
|
4255
4346
|
}
|
|
4256
4347
|
}
|
|
4257
|
-
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
4348
|
+
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L56, fail, 'JSXOpeningElement ">"'));
|
|
4258
4349
|
function JSXOpeningElement(state) {
|
|
4259
4350
|
if (state.verbose)
|
|
4260
4351
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -4264,7 +4355,7 @@ var Civet = (() => {
|
|
|
4264
4355
|
return JSXOpeningElement$0(state);
|
|
4265
4356
|
}
|
|
4266
4357
|
}
|
|
4267
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
4358
|
+
var JSXClosingElement$0 = $S($EXPECT($L133, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L56, fail, 'JSXClosingElement ">"'));
|
|
4268
4359
|
function JSXClosingElement(state) {
|
|
4269
4360
|
if (state.verbose)
|
|
4270
4361
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -4274,7 +4365,7 @@ var Civet = (() => {
|
|
|
4274
4365
|
return JSXClosingElement$0(state);
|
|
4275
4366
|
}
|
|
4276
4367
|
}
|
|
4277
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
4368
|
+
var JSXFragment$0 = $S($EXPECT($L134, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L135, fail, 'JSXFragment "</>"'));
|
|
4278
4369
|
function JSXFragment(state) {
|
|
4279
4370
|
if (state.verbose)
|
|
4280
4371
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -4294,7 +4385,7 @@ var Civet = (() => {
|
|
|
4294
4385
|
return JSXElementName$0(state);
|
|
4295
4386
|
}
|
|
4296
4387
|
}
|
|
4297
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
4388
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R32, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
4298
4389
|
function JSXIdentifierName(state) {
|
|
4299
4390
|
if (state.verbose)
|
|
4300
4391
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -4314,7 +4405,7 @@ var Civet = (() => {
|
|
|
4314
4405
|
return JSXAttributes$0(state);
|
|
4315
4406
|
}
|
|
4316
4407
|
}
|
|
4317
|
-
var JSXAttribute$0 = $S(OpenBrace, __,
|
|
4408
|
+
var JSXAttribute$0 = $S(OpenBrace, __, DotDotDot, __, AssignmentExpression, __, CloseBrace);
|
|
4318
4409
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
4319
4410
|
function JSXAttribute(state) {
|
|
4320
4411
|
if (state.tokenize) {
|
|
@@ -4343,8 +4434,8 @@ var Civet = (() => {
|
|
|
4343
4434
|
return JSXAttributeInitializer$0(state);
|
|
4344
4435
|
}
|
|
4345
4436
|
}
|
|
4346
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
4347
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
4437
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R33, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
4438
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R34, fail, "JSXAttributeValue /'[^']*'/"));
|
|
4348
4439
|
var JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
|
|
4349
4440
|
var JSXAttributeValue$3 = JSXElement;
|
|
4350
4441
|
var JSXAttributeValue$4 = JSXFragment;
|
|
@@ -4376,7 +4467,7 @@ var Civet = (() => {
|
|
|
4376
4467
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
4377
4468
|
}
|
|
4378
4469
|
}
|
|
4379
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
4470
|
+
var JSXText$0 = $R$0($EXPECT($R35, fail, "JSXText /[^{}<>]+/"));
|
|
4380
4471
|
function JSXText(state) {
|
|
4381
4472
|
if (state.verbose)
|
|
4382
4473
|
console.log("ENTER:", "JSXText");
|
|
@@ -4386,7 +4477,7 @@ var Civet = (() => {
|
|
|
4386
4477
|
return JSXText$0(state);
|
|
4387
4478
|
}
|
|
4388
4479
|
}
|
|
4389
|
-
var JSXChildExpression$0 = $S(__, $E($S(
|
|
4480
|
+
var JSXChildExpression$0 = $S(__, $E($S(DotDotDot, __)), AssignmentExpression);
|
|
4390
4481
|
function JSXChildExpression(state) {
|
|
4391
4482
|
if (state.verbose)
|
|
4392
4483
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -4408,7 +4499,7 @@ var Civet = (() => {
|
|
|
4408
4499
|
return TypeDeclaration$0(state);
|
|
4409
4500
|
}
|
|
4410
4501
|
}
|
|
4411
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
4502
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L136, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
4412
4503
|
var TypeDeclarationModifier$1 = Export;
|
|
4413
4504
|
function TypeDeclarationModifier(state) {
|
|
4414
4505
|
if (state.tokenize) {
|
|
@@ -4418,16 +4509,17 @@ var Civet = (() => {
|
|
|
4418
4509
|
}
|
|
4419
4510
|
}
|
|
4420
4511
|
var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, Equals, __, Type);
|
|
4421
|
-
var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, InterfaceBlock);
|
|
4512
|
+
var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, $E(TypeParameters), InterfaceBlock);
|
|
4422
4513
|
var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
|
|
4514
|
+
var TypeDeclarationRest$3 = FunctionSignature;
|
|
4423
4515
|
function TypeDeclarationRest(state) {
|
|
4424
4516
|
if (state.tokenize) {
|
|
4425
|
-
return $TOKEN("TypeDeclarationRest", state, TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state));
|
|
4517
|
+
return $TOKEN("TypeDeclarationRest", state, TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state));
|
|
4426
4518
|
} else {
|
|
4427
|
-
return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state);
|
|
4519
|
+
return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state);
|
|
4428
4520
|
}
|
|
4429
4521
|
}
|
|
4430
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
4522
|
+
var TypeKeyword$0 = $S($EXPECT($L137, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
4431
4523
|
function TypeKeyword(state) {
|
|
4432
4524
|
if (state.verbose)
|
|
4433
4525
|
console.log("ENTER:", "TypeKeyword");
|
|
@@ -4437,7 +4529,7 @@ var Civet = (() => {
|
|
|
4437
4529
|
return TypeKeyword$0(state);
|
|
4438
4530
|
}
|
|
4439
4531
|
}
|
|
4440
|
-
var Interface$0 = $S($EXPECT($
|
|
4532
|
+
var Interface$0 = $S($EXPECT($L138, fail, 'Interface "interface"'), NonIdContinue);
|
|
4441
4533
|
function Interface(state) {
|
|
4442
4534
|
if (state.verbose)
|
|
4443
4535
|
console.log("ENTER:", "Interface");
|
|
@@ -4447,7 +4539,7 @@ var Civet = (() => {
|
|
|
4447
4539
|
return Interface$0(state);
|
|
4448
4540
|
}
|
|
4449
4541
|
}
|
|
4450
|
-
var Namespace$0 = $S($EXPECT($
|
|
4542
|
+
var Namespace$0 = $S($EXPECT($L139, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
4451
4543
|
function Namespace(state) {
|
|
4452
4544
|
if (state.verbose)
|
|
4453
4545
|
console.log("ENTER:", "Namespace");
|
|
@@ -4493,27 +4585,23 @@ var Civet = (() => {
|
|
|
4493
4585
|
}
|
|
4494
4586
|
}
|
|
4495
4587
|
var InterfaceProperty$0 = $S($C(TypeIndexSignature, PropertyName), TypeSuffix, InterfacePropertyDelimiter);
|
|
4496
|
-
var InterfaceProperty$1 =
|
|
4588
|
+
var InterfaceProperty$1 = $S(NonEmptyParameters, TypeSuffix, InterfacePropertyDelimiter);
|
|
4589
|
+
var InterfaceProperty$2 = $S(MethodSignature, InterfacePropertyDelimiter);
|
|
4497
4590
|
function InterfaceProperty(state) {
|
|
4498
4591
|
if (state.tokenize) {
|
|
4499
|
-
return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state));
|
|
4592
|
+
return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state) || InterfaceProperty$2(state));
|
|
4500
4593
|
} else {
|
|
4501
|
-
return InterfaceProperty$0(state) || InterfaceProperty$1(state);
|
|
4594
|
+
return InterfaceProperty$0(state) || InterfaceProperty$1(state) || InterfaceProperty$2(state);
|
|
4502
4595
|
}
|
|
4503
4596
|
}
|
|
4504
|
-
var InterfacePropertyDelimiter$0 = $S($Q(_), Semicolon);
|
|
4505
|
-
var InterfacePropertyDelimiter$1 = $Y($S(
|
|
4506
|
-
var InterfacePropertyDelimiter$2 = $
|
|
4507
|
-
return { $loc, token: ";" };
|
|
4508
|
-
});
|
|
4509
|
-
var InterfacePropertyDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
4510
|
-
return { $loc, token: ";" };
|
|
4511
|
-
});
|
|
4597
|
+
var InterfacePropertyDelimiter$0 = $S($Q(_), $C(Semicolon, Comma));
|
|
4598
|
+
var InterfacePropertyDelimiter$1 = $Y($S(__, CloseBrace));
|
|
4599
|
+
var InterfacePropertyDelimiter$2 = $Y(EOS);
|
|
4512
4600
|
function InterfacePropertyDelimiter(state) {
|
|
4513
4601
|
if (state.tokenize) {
|
|
4514
|
-
return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state)
|
|
4602
|
+
return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state));
|
|
4515
4603
|
} else {
|
|
4516
|
-
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state)
|
|
4604
|
+
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state);
|
|
4517
4605
|
}
|
|
4518
4606
|
}
|
|
4519
4607
|
var NamespaceBlock$0 = $S(__, OpenBrace, EOS, NestedTypeDeclarations, __, CloseBrace);
|
|
@@ -4551,7 +4639,7 @@ var Civet = (() => {
|
|
|
4551
4639
|
return NestedTypeDeclaration$0(state);
|
|
4552
4640
|
}
|
|
4553
4641
|
}
|
|
4554
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
4642
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R36, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L140, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R37, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
4555
4643
|
function TypeIndexSignature(state) {
|
|
4556
4644
|
if (state.verbose)
|
|
4557
4645
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -4582,7 +4670,7 @@ var Civet = (() => {
|
|
|
4582
4670
|
return TypeSuffix$0(state);
|
|
4583
4671
|
}
|
|
4584
4672
|
}
|
|
4585
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
4673
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L141, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
4586
4674
|
if (!$3)
|
|
4587
4675
|
$0.splice(2, 1);
|
|
4588
4676
|
if ($1.length === 0)
|
|
@@ -4602,7 +4690,7 @@ var Civet = (() => {
|
|
|
4602
4690
|
return ReturnTypeSuffix$0(state);
|
|
4603
4691
|
}
|
|
4604
4692
|
}
|
|
4605
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
4693
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L59, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
4606
4694
|
if (!$2)
|
|
4607
4695
|
return $1;
|
|
4608
4696
|
return $0;
|
|
@@ -4657,18 +4745,17 @@ var Civet = (() => {
|
|
|
4657
4745
|
}
|
|
4658
4746
|
}
|
|
4659
4747
|
var TypeUnarySuffix$0 = TypeIndexedAccess;
|
|
4748
|
+
var TypeUnarySuffix$1 = QuestionMark;
|
|
4660
4749
|
function TypeUnarySuffix(state) {
|
|
4661
|
-
if (state.verbose)
|
|
4662
|
-
console.log("ENTER:", "TypeUnarySuffix");
|
|
4663
4750
|
if (state.tokenize) {
|
|
4664
|
-
return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state));
|
|
4751
|
+
return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state));
|
|
4665
4752
|
} else {
|
|
4666
|
-
return TypeUnarySuffix$0(state);
|
|
4753
|
+
return TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state);
|
|
4667
4754
|
}
|
|
4668
4755
|
}
|
|
4669
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
4670
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
4671
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
4756
|
+
var TypeUnaryOp$0 = $EXPECT($L142, fail, 'TypeUnaryOp "keyof"');
|
|
4757
|
+
var TypeUnaryOp$1 = $EXPECT($L74, fail, 'TypeUnaryOp "typeof"');
|
|
4758
|
+
var TypeUnaryOp$2 = $EXPECT($L143, fail, 'TypeUnaryOp "infer"');
|
|
4672
4759
|
function TypeUnaryOp(state) {
|
|
4673
4760
|
if (state.tokenize) {
|
|
4674
4761
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -4688,14 +4775,59 @@ var Civet = (() => {
|
|
|
4688
4775
|
}
|
|
4689
4776
|
var TypePrimary$0 = InterfaceBlock;
|
|
4690
4777
|
var TypePrimary$1 = $S(__, OpenParen, Type, __, CloseParen);
|
|
4691
|
-
var TypePrimary$2 = $S(
|
|
4692
|
-
var TypePrimary$3 = $S($Q(_),
|
|
4693
|
-
var TypePrimary$4 = $S($Q(_),
|
|
4778
|
+
var TypePrimary$2 = $S(__, TypeTuple);
|
|
4779
|
+
var TypePrimary$3 = $S($Q(_), FunctionType);
|
|
4780
|
+
var TypePrimary$4 = $S($Q(_), TypeLiteral);
|
|
4781
|
+
var TypePrimary$5 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
4694
4782
|
function TypePrimary(state) {
|
|
4695
4783
|
if (state.tokenize) {
|
|
4696
|
-
return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state));
|
|
4784
|
+
return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state));
|
|
4785
|
+
} else {
|
|
4786
|
+
return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state);
|
|
4787
|
+
}
|
|
4788
|
+
}
|
|
4789
|
+
var TypeTuple$0 = $S(OpenBracket, NestedTypeList, __, CloseBracket);
|
|
4790
|
+
var TypeTuple$1 = $S(OpenBracket, $E(TypeList), __, CloseBracket);
|
|
4791
|
+
function TypeTuple(state) {
|
|
4792
|
+
if (state.tokenize) {
|
|
4793
|
+
return $TOKEN("TypeTuple", state, TypeTuple$0(state) || TypeTuple$1(state));
|
|
4794
|
+
} else {
|
|
4795
|
+
return TypeTuple$0(state) || TypeTuple$1(state);
|
|
4796
|
+
}
|
|
4797
|
+
}
|
|
4798
|
+
var TypeList$0 = $S(Type, $Q($S(__, Comma, Type)));
|
|
4799
|
+
function TypeList(state) {
|
|
4800
|
+
if (state.verbose)
|
|
4801
|
+
console.log("ENTER:", "TypeList");
|
|
4802
|
+
if (state.tokenize) {
|
|
4803
|
+
return $TOKEN("TypeList", state, TypeList$0(state));
|
|
4804
|
+
} else {
|
|
4805
|
+
return TypeList$0(state);
|
|
4806
|
+
}
|
|
4807
|
+
}
|
|
4808
|
+
var NestedTypeList$0 = $TS($S(PushIndent, $Q(NestedType), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
4809
|
+
var types = $2;
|
|
4810
|
+
if (types.length)
|
|
4811
|
+
return types;
|
|
4812
|
+
return $skip;
|
|
4813
|
+
});
|
|
4814
|
+
function NestedTypeList(state) {
|
|
4815
|
+
if (state.verbose)
|
|
4816
|
+
console.log("ENTER:", "NestedTypeList");
|
|
4817
|
+
if (state.tokenize) {
|
|
4818
|
+
return $TOKEN("NestedTypeList", state, NestedTypeList$0(state));
|
|
4819
|
+
} else {
|
|
4820
|
+
return NestedTypeList$0(state);
|
|
4821
|
+
}
|
|
4822
|
+
}
|
|
4823
|
+
var NestedType$0 = $S(Nested, Type, ArrayElementDelimiter);
|
|
4824
|
+
function NestedType(state) {
|
|
4825
|
+
if (state.verbose)
|
|
4826
|
+
console.log("ENTER:", "NestedType");
|
|
4827
|
+
if (state.tokenize) {
|
|
4828
|
+
return $TOKEN("NestedType", state, NestedType$0(state));
|
|
4697
4829
|
} else {
|
|
4698
|
-
return
|
|
4830
|
+
return NestedType$0(state);
|
|
4699
4831
|
}
|
|
4700
4832
|
}
|
|
4701
4833
|
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
@@ -4713,10 +4845,10 @@ var Civet = (() => {
|
|
|
4713
4845
|
}
|
|
4714
4846
|
}
|
|
4715
4847
|
var TypeLiteral$0 = Literal;
|
|
4716
|
-
var TypeLiteral$1 = $TV($EXPECT($
|
|
4848
|
+
var TypeLiteral$1 = $TV($EXPECT($L73, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
|
|
4717
4849
|
return { $loc, token: "void" };
|
|
4718
4850
|
});
|
|
4719
|
-
var TypeLiteral$2 = $TV($EXPECT($
|
|
4851
|
+
var TypeLiteral$2 = $TV($EXPECT($L144, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
4720
4852
|
return { $loc, token: "[]" };
|
|
4721
4853
|
});
|
|
4722
4854
|
function TypeLiteral(state) {
|
|
@@ -4726,10 +4858,10 @@ var Civet = (() => {
|
|
|
4726
4858
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
4727
4859
|
}
|
|
4728
4860
|
}
|
|
4729
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
4861
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L71, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
4730
4862
|
return { $loc, token: "|" };
|
|
4731
4863
|
});
|
|
4732
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
4864
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L69, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
4733
4865
|
return { $loc, token: "&" };
|
|
4734
4866
|
});
|
|
4735
4867
|
function TypeBinaryOp(state) {
|
|
@@ -4749,7 +4881,7 @@ var Civet = (() => {
|
|
|
4749
4881
|
return FunctionType$0(state);
|
|
4750
4882
|
}
|
|
4751
4883
|
}
|
|
4752
|
-
var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
4884
|
+
var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L56, fail, 'TypeArguments ">"'));
|
|
4753
4885
|
function TypeArguments(state) {
|
|
4754
4886
|
if (state.verbose)
|
|
4755
4887
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -4759,7 +4891,7 @@ var Civet = (() => {
|
|
|
4759
4891
|
return TypeArguments$0(state);
|
|
4760
4892
|
}
|
|
4761
4893
|
}
|
|
4762
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
4894
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L56, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
4763
4895
|
return { ts: true, children: $0 };
|
|
4764
4896
|
});
|
|
4765
4897
|
function TypeParameters(state) {
|
|
@@ -4792,8 +4924,8 @@ var Civet = (() => {
|
|
|
4792
4924
|
}
|
|
4793
4925
|
}
|
|
4794
4926
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
4795
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
4796
|
-
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($
|
|
4927
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L56, fail, 'TypeParameterDelimiter ">"')));
|
|
4928
|
+
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L56, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
|
|
4797
4929
|
return { $loc, token: "," };
|
|
4798
4930
|
});
|
|
4799
4931
|
var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
@@ -4806,7 +4938,7 @@ var Civet = (() => {
|
|
|
4806
4938
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
4807
4939
|
}
|
|
4808
4940
|
}
|
|
4809
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
4941
|
+
var Shebang$0 = $S($R$0($EXPECT($R38, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
4810
4942
|
function Shebang(state) {
|
|
4811
4943
|
if (state.verbose)
|
|
4812
4944
|
console.log("ENTER:", "Shebang");
|
|
@@ -4816,11 +4948,11 @@ var Civet = (() => {
|
|
|
4816
4948
|
return Shebang$0(state);
|
|
4817
4949
|
}
|
|
4818
4950
|
}
|
|
4819
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
4951
|
+
var CivetPrologue$0 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
4820
4952
|
var content = value[2];
|
|
4821
4953
|
return content;
|
|
4822
4954
|
});
|
|
4823
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
4955
|
+
var CivetPrologue$1 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
4824
4956
|
var content = value[2];
|
|
4825
4957
|
return content;
|
|
4826
4958
|
});
|
|
@@ -4831,7 +4963,7 @@ var Civet = (() => {
|
|
|
4831
4963
|
return CivetPrologue$0(state) || CivetPrologue$1(state);
|
|
4832
4964
|
}
|
|
4833
4965
|
}
|
|
4834
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
4966
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L145, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R40, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
4835
4967
|
var options = $2;
|
|
4836
4968
|
return {
|
|
4837
4969
|
type: "CivetPrologue",
|
|
@@ -4848,8 +4980,8 @@ var Civet = (() => {
|
|
|
4848
4980
|
return CivetPrologueContent$0(state);
|
|
4849
4981
|
}
|
|
4850
4982
|
}
|
|
4851
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
4852
|
-
const optionName = $2.
|
|
4983
|
+
var CivetOption$0 = $TR($EXPECT($R41, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4984
|
+
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
4853
4985
|
if (l)
|
|
4854
4986
|
return l.toUpperCase();
|
|
4855
4987
|
return "";
|
|
@@ -4866,7 +4998,7 @@ var Civet = (() => {
|
|
|
4866
4998
|
return CivetOption$0(state);
|
|
4867
4999
|
}
|
|
4868
5000
|
}
|
|
4869
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
5001
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R39, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
|
|
4870
5002
|
function UnknownPrologue(state) {
|
|
4871
5003
|
if (state.verbose)
|
|
4872
5004
|
console.log("ENTER:", "UnknownPrologue");
|
|
@@ -4895,7 +5027,7 @@ var Civet = (() => {
|
|
|
4895
5027
|
return EOS$0(state);
|
|
4896
5028
|
}
|
|
4897
5029
|
}
|
|
4898
|
-
var EOL$0 = $R$0($EXPECT($
|
|
5030
|
+
var EOL$0 = $R$0($EXPECT($R42, fail, "EOL /\\r\\n|\\n|\\r|$/"));
|
|
4899
5031
|
function EOL(state) {
|
|
4900
5032
|
if (state.verbose)
|
|
4901
5033
|
console.log("ENTER:", "EOL");
|
|
@@ -4905,7 +5037,7 @@ var Civet = (() => {
|
|
|
4905
5037
|
return EOL$0(state);
|
|
4906
5038
|
}
|
|
4907
5039
|
}
|
|
4908
|
-
var EOF$0 = $R$0($EXPECT($
|
|
5040
|
+
var EOF$0 = $R$0($EXPECT($R43, fail, "EOF /$/"));
|
|
4909
5041
|
function EOF(state) {
|
|
4910
5042
|
if (state.verbose)
|
|
4911
5043
|
console.log("ENTER:", "EOF");
|
|
@@ -5073,6 +5205,20 @@ var Civet = (() => {
|
|
|
5073
5205
|
return CoffeeCommentEnabled$0(state);
|
|
5074
5206
|
}
|
|
5075
5207
|
}
|
|
5208
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
5209
|
+
if (module.config.coffeeBooleans)
|
|
5210
|
+
return;
|
|
5211
|
+
return $skip;
|
|
5212
|
+
});
|
|
5213
|
+
function CoffeeBooleansEnabled(state) {
|
|
5214
|
+
if (state.verbose)
|
|
5215
|
+
console.log("ENTER:", "CoffeeBooleansEnabled");
|
|
5216
|
+
if (state.tokenize) {
|
|
5217
|
+
return $TOKEN("CoffeeBooleansEnabled", state, CoffeeBooleansEnabled$0(state));
|
|
5218
|
+
} else {
|
|
5219
|
+
return CoffeeBooleansEnabled$0(state);
|
|
5220
|
+
}
|
|
5221
|
+
}
|
|
5076
5222
|
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
5077
5223
|
if (module.config.coffeeInterpolation)
|
|
5078
5224
|
return;
|
|
@@ -5093,6 +5239,7 @@ var Civet = (() => {
|
|
|
5093
5239
|
module.verbose = false;
|
|
5094
5240
|
module.config = {
|
|
5095
5241
|
autoVar: false,
|
|
5242
|
+
coffeeBooleans: false,
|
|
5096
5243
|
coffeeComment: false,
|
|
5097
5244
|
coffeeEq: false,
|
|
5098
5245
|
coffeeInterpolation: false,
|
|
@@ -5102,12 +5249,14 @@ var Civet = (() => {
|
|
|
5102
5249
|
set(b) {
|
|
5103
5250
|
if (b) {
|
|
5104
5251
|
this.autoVar = true;
|
|
5252
|
+
this.coffeeBooleans = true;
|
|
5105
5253
|
this.coffeeComment = true;
|
|
5106
5254
|
this.coffeeEq = true;
|
|
5107
5255
|
this.coffeeInterpolation = true;
|
|
5108
5256
|
this.implicitReturns = true;
|
|
5109
5257
|
} else {
|
|
5110
5258
|
this.autoVar = false;
|
|
5259
|
+
this.coffeeBooleans = false;
|
|
5111
5260
|
this.coffeeComment = false;
|
|
5112
5261
|
this.coffeeEq = false;
|
|
5113
5262
|
this.coffeeInterpolation = false;
|
|
@@ -5155,6 +5304,9 @@ var Civet = (() => {
|
|
|
5155
5304
|
case "AssignmentExpression":
|
|
5156
5305
|
node.children.unshift("return ");
|
|
5157
5306
|
return;
|
|
5307
|
+
case "Identifier":
|
|
5308
|
+
node.token = "return " + node.token;
|
|
5309
|
+
return;
|
|
5158
5310
|
case "BlockStatement":
|
|
5159
5311
|
insertReturn(node.expressions[node.expressions.length - 1]);
|
|
5160
5312
|
return;
|
|
@@ -5175,7 +5327,7 @@ var Civet = (() => {
|
|
|
5175
5327
|
}
|
|
5176
5328
|
if (!Array.isArray(node))
|
|
5177
5329
|
return;
|
|
5178
|
-
const [, exp] = node;
|
|
5330
|
+
const [indent, exp] = node;
|
|
5179
5331
|
if (!exp)
|
|
5180
5332
|
return;
|
|
5181
5333
|
switch (exp.type) {
|
|
@@ -5194,6 +5346,8 @@ var Civet = (() => {
|
|
|
5194
5346
|
insertReturn(exp.children[2]);
|
|
5195
5347
|
if (exp.children[3])
|
|
5196
5348
|
insertReturn(exp.children[3][2]);
|
|
5349
|
+
else
|
|
5350
|
+
exp.children.push(["\n", indent, "return"]);
|
|
5197
5351
|
return;
|
|
5198
5352
|
case "SwitchStatement":
|
|
5199
5353
|
insertReturn(exp.children[2]);
|
|
@@ -5211,6 +5365,50 @@ var Civet = (() => {
|
|
|
5211
5365
|
insertReturn(block);
|
|
5212
5366
|
return block;
|
|
5213
5367
|
};
|
|
5368
|
+
module.expandChainedComparisons = function([first, binops]) {
|
|
5369
|
+
const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in", "instanceof"];
|
|
5370
|
+
const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
|
|
5371
|
+
let results = [];
|
|
5372
|
+
let i = 0;
|
|
5373
|
+
let l = binops.length;
|
|
5374
|
+
let start = 0;
|
|
5375
|
+
let chains = [];
|
|
5376
|
+
while (i < l) {
|
|
5377
|
+
const [, op] = binops[i];
|
|
5378
|
+
if (relationalOps.includes(op.token)) {
|
|
5379
|
+
chains.push(i);
|
|
5380
|
+
} else if (lowerPrecedenceOps.includes(op.token)) {
|
|
5381
|
+
processChains();
|
|
5382
|
+
first = [];
|
|
5383
|
+
}
|
|
5384
|
+
i++;
|
|
5385
|
+
}
|
|
5386
|
+
processChains();
|
|
5387
|
+
return results;
|
|
5388
|
+
function processChains() {
|
|
5389
|
+
if (chains.length > 1) {
|
|
5390
|
+
chains.forEach((index, k) => {
|
|
5391
|
+
if (k > 0) {
|
|
5392
|
+
results.push(" && ");
|
|
5393
|
+
}
|
|
5394
|
+
const [pre, op, post, exp] = binops[index];
|
|
5395
|
+
let endIndex;
|
|
5396
|
+
if (k < chains.length - 1) {
|
|
5397
|
+
endIndex = chains[k + 1];
|
|
5398
|
+
} else {
|
|
5399
|
+
endIndex = i + 1;
|
|
5400
|
+
}
|
|
5401
|
+
results = results.concat(first, ...binops.slice(start, endIndex));
|
|
5402
|
+
first = [exp].concat(binops.slice(index + 1, endIndex));
|
|
5403
|
+
start = endIndex;
|
|
5404
|
+
});
|
|
5405
|
+
} else {
|
|
5406
|
+
results = results.concat(first, ...binops.slice(start, i + 1));
|
|
5407
|
+
start = i + 1;
|
|
5408
|
+
}
|
|
5409
|
+
chains.length = 0;
|
|
5410
|
+
}
|
|
5411
|
+
};
|
|
5214
5412
|
module.parsePosition = function() {
|
|
5215
5413
|
let s = Error().stack.split(/\n at /);
|
|
5216
5414
|
s.shift();
|
|
@@ -5307,7 +5505,7 @@ var Civet = (() => {
|
|
|
5307
5505
|
return Init$0(state);
|
|
5308
5506
|
}
|
|
5309
5507
|
}
|
|
5310
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
5508
|
+
var Indent$0 = $TV($Q($C($EXPECT($L146, fail, 'Indent " "'), $EXPECT($L147, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
5311
5509
|
const level = $1.length;
|
|
5312
5510
|
return {
|
|
5313
5511
|
$loc,
|