@danielx/civet 0.4.9 → 0.4.11
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 +607 -411
- package/dist/esbuild-plugin.js +10 -10
- package/dist/esm.mjs +47 -47
- package/dist/main.js +607 -411
- 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) {
|
|
@@ -3597,9 +3676,7 @@ var Civet = (() => {
|
|
|
3597
3676
|
}
|
|
3598
3677
|
}
|
|
3599
3678
|
var StatementDelimiter$0 = $S($Q(TrailingComment), Semicolon, $Q(TrailingComment));
|
|
3600
|
-
var StatementDelimiter$1 = $
|
|
3601
|
-
return { $loc, token: ";" };
|
|
3602
|
-
});
|
|
3679
|
+
var StatementDelimiter$1 = $Y(EOS);
|
|
3603
3680
|
function StatementDelimiter(state) {
|
|
3604
3681
|
if (state.tokenize) {
|
|
3605
3682
|
return $TOKEN("StatementDelimiter", state, StatementDelimiter$0(state) || StatementDelimiter$1(state));
|
|
@@ -3607,7 +3684,7 @@ var Civet = (() => {
|
|
|
3607
3684
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
3608
3685
|
}
|
|
3609
3686
|
}
|
|
3610
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3687
|
+
var NonIdContinue$0 = $R$0($EXPECT($R30, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
3611
3688
|
function NonIdContinue(state) {
|
|
3612
3689
|
if (state.verbose)
|
|
3613
3690
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -3629,7 +3706,7 @@ var Civet = (() => {
|
|
|
3629
3706
|
return Loc$0(state);
|
|
3630
3707
|
}
|
|
3631
3708
|
}
|
|
3632
|
-
var As$0 = $TS($S($EXPECT($
|
|
3709
|
+
var As$0 = $TS($S($EXPECT($L89, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3633
3710
|
return { $loc, token: $1 };
|
|
3634
3711
|
});
|
|
3635
3712
|
function As(state) {
|
|
@@ -3641,7 +3718,7 @@ var Civet = (() => {
|
|
|
3641
3718
|
return As$0(state);
|
|
3642
3719
|
}
|
|
3643
3720
|
}
|
|
3644
|
-
var Async$0 = $TV($EXPECT($
|
|
3721
|
+
var Async$0 = $TV($EXPECT($L90, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
|
|
3645
3722
|
return { $loc, token: $1 };
|
|
3646
3723
|
});
|
|
3647
3724
|
function Async(state) {
|
|
@@ -3653,7 +3730,7 @@ var Civet = (() => {
|
|
|
3653
3730
|
return Async$0(state);
|
|
3654
3731
|
}
|
|
3655
3732
|
}
|
|
3656
|
-
var Await$0 = $TS($S($EXPECT($
|
|
3733
|
+
var Await$0 = $TS($S($EXPECT($L91, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3657
3734
|
return { $loc, token: $1 };
|
|
3658
3735
|
});
|
|
3659
3736
|
function Await(state) {
|
|
@@ -3665,7 +3742,7 @@ var Civet = (() => {
|
|
|
3665
3742
|
return Await$0(state);
|
|
3666
3743
|
}
|
|
3667
3744
|
}
|
|
3668
|
-
var Case$0 = $TS($S($EXPECT($
|
|
3745
|
+
var Case$0 = $TS($S($EXPECT($L92, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3669
3746
|
return { $loc, token: $1 };
|
|
3670
3747
|
});
|
|
3671
3748
|
function Case(state) {
|
|
@@ -3677,7 +3754,7 @@ var Civet = (() => {
|
|
|
3677
3754
|
return Case$0(state);
|
|
3678
3755
|
}
|
|
3679
3756
|
}
|
|
3680
|
-
var Catch$0 = $TV($EXPECT($
|
|
3757
|
+
var Catch$0 = $TV($EXPECT($L93, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
3681
3758
|
return { $loc, token: $1 };
|
|
3682
3759
|
});
|
|
3683
3760
|
function Catch(state) {
|
|
@@ -3689,7 +3766,7 @@ var Civet = (() => {
|
|
|
3689
3766
|
return Catch$0(state);
|
|
3690
3767
|
}
|
|
3691
3768
|
}
|
|
3692
|
-
var Class$0 = $TV($EXPECT($
|
|
3769
|
+
var Class$0 = $TV($EXPECT($L94, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
3693
3770
|
return { $loc, token: $1 };
|
|
3694
3771
|
});
|
|
3695
3772
|
function Class(state) {
|
|
@@ -3701,7 +3778,7 @@ var Civet = (() => {
|
|
|
3701
3778
|
return Class$0(state);
|
|
3702
3779
|
}
|
|
3703
3780
|
}
|
|
3704
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
3781
|
+
var CloseBrace$0 = $TV($EXPECT($L27, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
3705
3782
|
return { $loc, token: $1 };
|
|
3706
3783
|
});
|
|
3707
3784
|
function CloseBrace(state) {
|
|
@@ -3713,7 +3790,7 @@ var Civet = (() => {
|
|
|
3713
3790
|
return CloseBrace$0(state);
|
|
3714
3791
|
}
|
|
3715
3792
|
}
|
|
3716
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
3793
|
+
var CloseBracket$0 = $TV($EXPECT($L26, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
3717
3794
|
return { $loc, token: $1 };
|
|
3718
3795
|
});
|
|
3719
3796
|
function CloseBracket(state) {
|
|
@@ -3737,7 +3814,7 @@ var Civet = (() => {
|
|
|
3737
3814
|
return CloseParen$0(state);
|
|
3738
3815
|
}
|
|
3739
3816
|
}
|
|
3740
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
3817
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L95, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
3741
3818
|
return { $loc, token: "${" };
|
|
3742
3819
|
});
|
|
3743
3820
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -3749,7 +3826,7 @@ var Civet = (() => {
|
|
|
3749
3826
|
return CoffeeSubstitutionStart$0(state);
|
|
3750
3827
|
}
|
|
3751
3828
|
}
|
|
3752
|
-
var Colon$0 = $TV($EXPECT($
|
|
3829
|
+
var Colon$0 = $TV($EXPECT($L96, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
3753
3830
|
return { $loc, token: $1 };
|
|
3754
3831
|
});
|
|
3755
3832
|
function Colon(state) {
|
|
@@ -3773,7 +3850,7 @@ var Civet = (() => {
|
|
|
3773
3850
|
return ConstructorShorthand$0(state);
|
|
3774
3851
|
}
|
|
3775
3852
|
}
|
|
3776
|
-
var Default$0 = $TS($S($EXPECT($
|
|
3853
|
+
var Default$0 = $TS($S($EXPECT($L84, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3777
3854
|
return { $loc, token: $1 };
|
|
3778
3855
|
});
|
|
3779
3856
|
function Default(state) {
|
|
@@ -3785,7 +3862,7 @@ var Civet = (() => {
|
|
|
3785
3862
|
return Default$0(state);
|
|
3786
3863
|
}
|
|
3787
3864
|
}
|
|
3788
|
-
var Dot$0 = $TV($EXPECT($
|
|
3865
|
+
var Dot$0 = $TV($EXPECT($L97, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
3789
3866
|
return { $loc, token: $1 };
|
|
3790
3867
|
});
|
|
3791
3868
|
function Dot(state) {
|
|
@@ -3797,7 +3874,19 @@ var Civet = (() => {
|
|
|
3797
3874
|
return Dot$0(state);
|
|
3798
3875
|
}
|
|
3799
3876
|
}
|
|
3800
|
-
var
|
|
3877
|
+
var DotDotDot$0 = $TV($EXPECT($L98, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
3878
|
+
return { $loc, token: $1 };
|
|
3879
|
+
});
|
|
3880
|
+
function DotDotDot(state) {
|
|
3881
|
+
if (state.verbose)
|
|
3882
|
+
console.log("ENTER:", "DotDotDot");
|
|
3883
|
+
if (state.tokenize) {
|
|
3884
|
+
return $TOKEN("DotDotDot", state, DotDotDot$0(state));
|
|
3885
|
+
} else {
|
|
3886
|
+
return DotDotDot$0(state);
|
|
3887
|
+
}
|
|
3888
|
+
}
|
|
3889
|
+
var DoubleQuote$0 = $TV($EXPECT($L99, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
3801
3890
|
return { $loc, token: $1 };
|
|
3802
3891
|
});
|
|
3803
3892
|
function DoubleQuote(state) {
|
|
@@ -3809,7 +3898,7 @@ var Civet = (() => {
|
|
|
3809
3898
|
return DoubleQuote$0(state);
|
|
3810
3899
|
}
|
|
3811
3900
|
}
|
|
3812
|
-
var Else$0 = $TV($EXPECT($
|
|
3901
|
+
var Else$0 = $TV($EXPECT($L100, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
3813
3902
|
return { $loc, token: $1 };
|
|
3814
3903
|
});
|
|
3815
3904
|
function Else(state) {
|
|
@@ -3821,7 +3910,7 @@ var Civet = (() => {
|
|
|
3821
3910
|
return Else$0(state);
|
|
3822
3911
|
}
|
|
3823
3912
|
}
|
|
3824
|
-
var Equals$0 = $TV($EXPECT($
|
|
3913
|
+
var Equals$0 = $TV($EXPECT($L44, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
3825
3914
|
return { $loc, token: $1 };
|
|
3826
3915
|
});
|
|
3827
3916
|
function Equals(state) {
|
|
@@ -3833,7 +3922,7 @@ var Civet = (() => {
|
|
|
3833
3922
|
return Equals$0(state);
|
|
3834
3923
|
}
|
|
3835
3924
|
}
|
|
3836
|
-
var Export$0 = $TS($S($EXPECT($
|
|
3925
|
+
var Export$0 = $TS($S($EXPECT($L101, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3837
3926
|
return { $loc, token: $1 };
|
|
3838
3927
|
});
|
|
3839
3928
|
function Export(state) {
|
|
@@ -3845,7 +3934,7 @@ var Civet = (() => {
|
|
|
3845
3934
|
return Export$0(state);
|
|
3846
3935
|
}
|
|
3847
3936
|
}
|
|
3848
|
-
var For$0 = $TS($S($EXPECT($
|
|
3937
|
+
var For$0 = $TS($S($EXPECT($L102, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3849
3938
|
return { $loc, token: $1 };
|
|
3850
3939
|
});
|
|
3851
3940
|
function For(state) {
|
|
@@ -3857,7 +3946,7 @@ var Civet = (() => {
|
|
|
3857
3946
|
return For$0(state);
|
|
3858
3947
|
}
|
|
3859
3948
|
}
|
|
3860
|
-
var From$0 = $TS($S($EXPECT($
|
|
3949
|
+
var From$0 = $TS($S($EXPECT($L103, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3861
3950
|
return { $loc, token: $1 };
|
|
3862
3951
|
});
|
|
3863
3952
|
function From(state) {
|
|
@@ -3869,7 +3958,7 @@ var Civet = (() => {
|
|
|
3869
3958
|
return From$0(state);
|
|
3870
3959
|
}
|
|
3871
3960
|
}
|
|
3872
|
-
var Function$0 = $TV($EXPECT($
|
|
3961
|
+
var Function$0 = $TV($EXPECT($L104, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
3873
3962
|
return { $loc, token: $1 };
|
|
3874
3963
|
});
|
|
3875
3964
|
function Function(state) {
|
|
@@ -3881,7 +3970,7 @@ var Civet = (() => {
|
|
|
3881
3970
|
return Function$0(state);
|
|
3882
3971
|
}
|
|
3883
3972
|
}
|
|
3884
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
3973
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L105, fail, 'GetOrSet "get"'), $EXPECT($L106, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3885
3974
|
return { $loc, token: $1 };
|
|
3886
3975
|
});
|
|
3887
3976
|
function GetOrSet(state) {
|
|
@@ -3893,7 +3982,7 @@ var Civet = (() => {
|
|
|
3893
3982
|
return GetOrSet$0(state);
|
|
3894
3983
|
}
|
|
3895
3984
|
}
|
|
3896
|
-
var If$0 = $TV($EXPECT($
|
|
3985
|
+
var If$0 = $TV($EXPECT($L107, fail, 'If "if"'), function($skip, $loc, $0, $1) {
|
|
3897
3986
|
return { $loc, token: $1 };
|
|
3898
3987
|
});
|
|
3899
3988
|
function If(state) {
|
|
@@ -3905,7 +3994,7 @@ var Civet = (() => {
|
|
|
3905
3994
|
return If$0(state);
|
|
3906
3995
|
}
|
|
3907
3996
|
}
|
|
3908
|
-
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($
|
|
3997
|
+
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R31, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
3909
3998
|
return { $loc, token: $1 };
|
|
3910
3999
|
});
|
|
3911
4000
|
function Import(state) {
|
|
@@ -3917,7 +4006,7 @@ var Civet = (() => {
|
|
|
3917
4006
|
return Import$0(state);
|
|
3918
4007
|
}
|
|
3919
4008
|
}
|
|
3920
|
-
var In$0 = $TV($EXPECT($
|
|
4009
|
+
var In$0 = $TV($EXPECT($L68, fail, 'In "in"'), function($skip, $loc, $0, $1) {
|
|
3921
4010
|
return { $loc, token: $1 };
|
|
3922
4011
|
});
|
|
3923
4012
|
function In(state) {
|
|
@@ -3929,7 +4018,7 @@ var Civet = (() => {
|
|
|
3929
4018
|
return In$0(state);
|
|
3930
4019
|
}
|
|
3931
4020
|
}
|
|
3932
|
-
var LetOrConst$0 = $TV($C($EXPECT($
|
|
4021
|
+
var LetOrConst$0 = $TV($C($EXPECT($L108, fail, 'LetOrConst "let"'), $EXPECT($L109, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
3933
4022
|
return { $loc, token: $1 };
|
|
3934
4023
|
});
|
|
3935
4024
|
function LetOrConst(state) {
|
|
@@ -3941,7 +4030,7 @@ var Civet = (() => {
|
|
|
3941
4030
|
return LetOrConst$0(state);
|
|
3942
4031
|
}
|
|
3943
4032
|
}
|
|
3944
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
4033
|
+
var Loop$0 = $TS($S($EXPECT($L110, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3945
4034
|
return { $loc, token: "while(true)" };
|
|
3946
4035
|
});
|
|
3947
4036
|
function Loop(state) {
|
|
@@ -3953,7 +4042,7 @@ var Civet = (() => {
|
|
|
3953
4042
|
return Loop$0(state);
|
|
3954
4043
|
}
|
|
3955
4044
|
}
|
|
3956
|
-
var New$0 = $TV($EXPECT($
|
|
4045
|
+
var New$0 = $TV($EXPECT($L111, fail, 'New "new"'), function($skip, $loc, $0, $1) {
|
|
3957
4046
|
return { $loc, token: $1 };
|
|
3958
4047
|
});
|
|
3959
4048
|
function New(state) {
|
|
@@ -3965,7 +4054,7 @@ var Civet = (() => {
|
|
|
3965
4054
|
return New$0(state);
|
|
3966
4055
|
}
|
|
3967
4056
|
}
|
|
3968
|
-
var Of$0 = $TV($EXPECT($
|
|
4057
|
+
var Of$0 = $TV($EXPECT($L112, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
3969
4058
|
return { $loc, token: $1 };
|
|
3970
4059
|
});
|
|
3971
4060
|
function Of(state) {
|
|
@@ -3977,7 +4066,7 @@ var Civet = (() => {
|
|
|
3977
4066
|
return Of$0(state);
|
|
3978
4067
|
}
|
|
3979
4068
|
}
|
|
3980
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
4069
|
+
var OpenBrace$0 = $TV($EXPECT($L113, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
3981
4070
|
return { $loc, token: $1 };
|
|
3982
4071
|
});
|
|
3983
4072
|
function OpenBrace(state) {
|
|
@@ -3989,7 +4078,7 @@ var Civet = (() => {
|
|
|
3989
4078
|
return OpenBrace$0(state);
|
|
3990
4079
|
}
|
|
3991
4080
|
}
|
|
3992
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
4081
|
+
var OpenBracket$0 = $TV($EXPECT($L114, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
3993
4082
|
return { $loc, token: $1 };
|
|
3994
4083
|
});
|
|
3995
4084
|
function OpenBracket(state) {
|
|
@@ -4001,7 +4090,7 @@ var Civet = (() => {
|
|
|
4001
4090
|
return OpenBracket$0(state);
|
|
4002
4091
|
}
|
|
4003
4092
|
}
|
|
4004
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
4093
|
+
var OpenParen$0 = $TV($EXPECT($L115, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
4005
4094
|
return { $loc, token: $1 };
|
|
4006
4095
|
});
|
|
4007
4096
|
function OpenParen(state) {
|
|
@@ -4013,7 +4102,7 @@ var Civet = (() => {
|
|
|
4013
4102
|
return OpenParen$0(state);
|
|
4014
4103
|
}
|
|
4015
4104
|
}
|
|
4016
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
4105
|
+
var QuestionMark$0 = $TV($EXPECT($L116, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
4017
4106
|
return { $loc, token: $1 };
|
|
4018
4107
|
});
|
|
4019
4108
|
function QuestionMark(state) {
|
|
@@ -4025,7 +4114,7 @@ var Civet = (() => {
|
|
|
4025
4114
|
return QuestionMark$0(state);
|
|
4026
4115
|
}
|
|
4027
4116
|
}
|
|
4028
|
-
var Return$0 = $TS($S($EXPECT($
|
|
4117
|
+
var Return$0 = $TS($S($EXPECT($L117, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4029
4118
|
return { $loc, token: $1 };
|
|
4030
4119
|
});
|
|
4031
4120
|
function Return(state) {
|
|
@@ -4037,7 +4126,7 @@ var Civet = (() => {
|
|
|
4037
4126
|
return Return$0(state);
|
|
4038
4127
|
}
|
|
4039
4128
|
}
|
|
4040
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
4129
|
+
var Semicolon$0 = $TV($EXPECT($L75, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
4041
4130
|
return { $loc, token: $1 };
|
|
4042
4131
|
});
|
|
4043
4132
|
function Semicolon(state) {
|
|
@@ -4049,7 +4138,7 @@ var Civet = (() => {
|
|
|
4049
4138
|
return Semicolon$0(state);
|
|
4050
4139
|
}
|
|
4051
4140
|
}
|
|
4052
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
4141
|
+
var SingleQuote$0 = $TV($EXPECT($L118, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
4053
4142
|
return { $loc, token: $1 };
|
|
4054
4143
|
});
|
|
4055
4144
|
function SingleQuote(state) {
|
|
@@ -4061,7 +4150,7 @@ var Civet = (() => {
|
|
|
4061
4150
|
return SingleQuote$0(state);
|
|
4062
4151
|
}
|
|
4063
4152
|
}
|
|
4064
|
-
var Star$0 = $TV($EXPECT($
|
|
4153
|
+
var Star$0 = $TV($EXPECT($L46, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
4065
4154
|
return { $loc, token: $1 };
|
|
4066
4155
|
});
|
|
4067
4156
|
function Star(state) {
|
|
@@ -4073,10 +4162,10 @@ var Civet = (() => {
|
|
|
4073
4162
|
return Star$0(state);
|
|
4074
4163
|
}
|
|
4075
4164
|
}
|
|
4076
|
-
var Static$0 = $TV($EXPECT($
|
|
4165
|
+
var Static$0 = $TV($EXPECT($L119, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
4077
4166
|
return { $loc, token: $1 };
|
|
4078
4167
|
});
|
|
4079
|
-
var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($
|
|
4168
|
+
var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L115, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
|
|
4080
4169
|
return { $loc, token: "static " };
|
|
4081
4170
|
});
|
|
4082
4171
|
function Static(state) {
|
|
@@ -4086,7 +4175,7 @@ var Civet = (() => {
|
|
|
4086
4175
|
return Static$0(state) || Static$1(state);
|
|
4087
4176
|
}
|
|
4088
4177
|
}
|
|
4089
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
4178
|
+
var SubstitutionStart$0 = $TV($EXPECT($L120, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
4090
4179
|
return { $loc, token: $1 };
|
|
4091
4180
|
});
|
|
4092
4181
|
function SubstitutionStart(state) {
|
|
@@ -4098,7 +4187,7 @@ var Civet = (() => {
|
|
|
4098
4187
|
return SubstitutionStart$0(state);
|
|
4099
4188
|
}
|
|
4100
4189
|
}
|
|
4101
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
4190
|
+
var Switch$0 = $TS($S($EXPECT($L121, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4102
4191
|
return { $loc, token: $1 };
|
|
4103
4192
|
});
|
|
4104
4193
|
function Switch(state) {
|
|
@@ -4110,7 +4199,7 @@ var Civet = (() => {
|
|
|
4110
4199
|
return Switch$0(state);
|
|
4111
4200
|
}
|
|
4112
4201
|
}
|
|
4113
|
-
var Target$0 = $TV($EXPECT($
|
|
4202
|
+
var Target$0 = $TV($EXPECT($L122, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
|
|
4114
4203
|
return { $loc, token: $1 };
|
|
4115
4204
|
});
|
|
4116
4205
|
function Target(state) {
|
|
@@ -4122,7 +4211,7 @@ var Civet = (() => {
|
|
|
4122
4211
|
return Target$0(state);
|
|
4123
4212
|
}
|
|
4124
4213
|
}
|
|
4125
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
4214
|
+
var Throw$0 = $TS($S($EXPECT($L123, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4126
4215
|
return { $loc, token: $1 };
|
|
4127
4216
|
});
|
|
4128
4217
|
function Throw(state) {
|
|
@@ -4134,7 +4223,7 @@ var Civet = (() => {
|
|
|
4134
4223
|
return Throw$0(state);
|
|
4135
4224
|
}
|
|
4136
4225
|
}
|
|
4137
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
4226
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L124, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
4138
4227
|
return { $loc, token: "`" };
|
|
4139
4228
|
});
|
|
4140
4229
|
function TripleDoubleQuote(state) {
|
|
@@ -4146,7 +4235,7 @@ var Civet = (() => {
|
|
|
4146
4235
|
return TripleDoubleQuote$0(state);
|
|
4147
4236
|
}
|
|
4148
4237
|
}
|
|
4149
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
4238
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L125, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
4150
4239
|
return { $loc, token: "`" };
|
|
4151
4240
|
});
|
|
4152
4241
|
function TripleSingleQuote(state) {
|
|
@@ -4158,7 +4247,7 @@ var Civet = (() => {
|
|
|
4158
4247
|
return TripleSingleQuote$0(state);
|
|
4159
4248
|
}
|
|
4160
4249
|
}
|
|
4161
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
4250
|
+
var TripleTick$0 = $TV($EXPECT($L126, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
4162
4251
|
return { $loc, token: "`" };
|
|
4163
4252
|
});
|
|
4164
4253
|
function TripleTick(state) {
|
|
@@ -4170,7 +4259,7 @@ var Civet = (() => {
|
|
|
4170
4259
|
return TripleTick$0(state);
|
|
4171
4260
|
}
|
|
4172
4261
|
}
|
|
4173
|
-
var Try$0 = $TV($EXPECT($
|
|
4262
|
+
var Try$0 = $TV($EXPECT($L127, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
4174
4263
|
return { $loc, token: $1 };
|
|
4175
4264
|
});
|
|
4176
4265
|
function Try(state) {
|
|
@@ -4182,7 +4271,7 @@ var Civet = (() => {
|
|
|
4182
4271
|
return Try$0(state);
|
|
4183
4272
|
}
|
|
4184
4273
|
}
|
|
4185
|
-
var Unless$0 = $TV($EXPECT($
|
|
4274
|
+
var Unless$0 = $TV($EXPECT($L128, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
4186
4275
|
return { $loc, token: $1 };
|
|
4187
4276
|
});
|
|
4188
4277
|
function Unless(state) {
|
|
@@ -4194,7 +4283,7 @@ var Civet = (() => {
|
|
|
4194
4283
|
return Unless$0(state);
|
|
4195
4284
|
}
|
|
4196
4285
|
}
|
|
4197
|
-
var Var$0 = $TV($EXPECT($
|
|
4286
|
+
var Var$0 = $TV($EXPECT($L129, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
4198
4287
|
return { $loc, token: $1 };
|
|
4199
4288
|
});
|
|
4200
4289
|
function Var(state) {
|
|
@@ -4206,7 +4295,7 @@ var Civet = (() => {
|
|
|
4206
4295
|
return Var$0(state);
|
|
4207
4296
|
}
|
|
4208
4297
|
}
|
|
4209
|
-
var When$0 = $TS($S($EXPECT($
|
|
4298
|
+
var When$0 = $TS($S($EXPECT($L130, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4210
4299
|
return { $loc, token: "case" };
|
|
4211
4300
|
});
|
|
4212
4301
|
function When(state) {
|
|
@@ -4218,7 +4307,7 @@ var Civet = (() => {
|
|
|
4218
4307
|
return When$0(state);
|
|
4219
4308
|
}
|
|
4220
4309
|
}
|
|
4221
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
4310
|
+
var Yield$0 = $TS($S($EXPECT($L131, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4222
4311
|
return { $loc, token: $1 };
|
|
4223
4312
|
});
|
|
4224
4313
|
function Yield(state) {
|
|
@@ -4244,7 +4333,7 @@ var Civet = (() => {
|
|
|
4244
4333
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
4245
4334
|
}
|
|
4246
4335
|
}
|
|
4247
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
4336
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L132, fail, 'JSXSelfClosingElement "/>"'));
|
|
4248
4337
|
function JSXSelfClosingElement(state) {
|
|
4249
4338
|
if (state.verbose)
|
|
4250
4339
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -4254,7 +4343,7 @@ var Civet = (() => {
|
|
|
4254
4343
|
return JSXSelfClosingElement$0(state);
|
|
4255
4344
|
}
|
|
4256
4345
|
}
|
|
4257
|
-
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
4346
|
+
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L56, fail, 'JSXOpeningElement ">"'));
|
|
4258
4347
|
function JSXOpeningElement(state) {
|
|
4259
4348
|
if (state.verbose)
|
|
4260
4349
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -4264,7 +4353,7 @@ var Civet = (() => {
|
|
|
4264
4353
|
return JSXOpeningElement$0(state);
|
|
4265
4354
|
}
|
|
4266
4355
|
}
|
|
4267
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
4356
|
+
var JSXClosingElement$0 = $S($EXPECT($L133, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L56, fail, 'JSXClosingElement ">"'));
|
|
4268
4357
|
function JSXClosingElement(state) {
|
|
4269
4358
|
if (state.verbose)
|
|
4270
4359
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -4274,7 +4363,7 @@ var Civet = (() => {
|
|
|
4274
4363
|
return JSXClosingElement$0(state);
|
|
4275
4364
|
}
|
|
4276
4365
|
}
|
|
4277
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
4366
|
+
var JSXFragment$0 = $S($EXPECT($L134, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L135, fail, 'JSXFragment "</>"'));
|
|
4278
4367
|
function JSXFragment(state) {
|
|
4279
4368
|
if (state.verbose)
|
|
4280
4369
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -4294,7 +4383,7 @@ var Civet = (() => {
|
|
|
4294
4383
|
return JSXElementName$0(state);
|
|
4295
4384
|
}
|
|
4296
4385
|
}
|
|
4297
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
4386
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R32, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
4298
4387
|
function JSXIdentifierName(state) {
|
|
4299
4388
|
if (state.verbose)
|
|
4300
4389
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -4314,7 +4403,7 @@ var Civet = (() => {
|
|
|
4314
4403
|
return JSXAttributes$0(state);
|
|
4315
4404
|
}
|
|
4316
4405
|
}
|
|
4317
|
-
var JSXAttribute$0 = $S(OpenBrace, __,
|
|
4406
|
+
var JSXAttribute$0 = $S(OpenBrace, __, DotDotDot, __, AssignmentExpression, __, CloseBrace);
|
|
4318
4407
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
4319
4408
|
function JSXAttribute(state) {
|
|
4320
4409
|
if (state.tokenize) {
|
|
@@ -4343,8 +4432,8 @@ var Civet = (() => {
|
|
|
4343
4432
|
return JSXAttributeInitializer$0(state);
|
|
4344
4433
|
}
|
|
4345
4434
|
}
|
|
4346
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
4347
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
4435
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R33, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
4436
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R34, fail, "JSXAttributeValue /'[^']*'/"));
|
|
4348
4437
|
var JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
|
|
4349
4438
|
var JSXAttributeValue$3 = JSXElement;
|
|
4350
4439
|
var JSXAttributeValue$4 = JSXFragment;
|
|
@@ -4376,7 +4465,7 @@ var Civet = (() => {
|
|
|
4376
4465
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
4377
4466
|
}
|
|
4378
4467
|
}
|
|
4379
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
4468
|
+
var JSXText$0 = $R$0($EXPECT($R35, fail, "JSXText /[^{}<>]+/"));
|
|
4380
4469
|
function JSXText(state) {
|
|
4381
4470
|
if (state.verbose)
|
|
4382
4471
|
console.log("ENTER:", "JSXText");
|
|
@@ -4386,7 +4475,7 @@ var Civet = (() => {
|
|
|
4386
4475
|
return JSXText$0(state);
|
|
4387
4476
|
}
|
|
4388
4477
|
}
|
|
4389
|
-
var JSXChildExpression$0 = $S(__, $E($S(
|
|
4478
|
+
var JSXChildExpression$0 = $S(__, $E($S(DotDotDot, __)), AssignmentExpression);
|
|
4390
4479
|
function JSXChildExpression(state) {
|
|
4391
4480
|
if (state.verbose)
|
|
4392
4481
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -4408,7 +4497,7 @@ var Civet = (() => {
|
|
|
4408
4497
|
return TypeDeclaration$0(state);
|
|
4409
4498
|
}
|
|
4410
4499
|
}
|
|
4411
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
4500
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L136, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
4412
4501
|
var TypeDeclarationModifier$1 = Export;
|
|
4413
4502
|
function TypeDeclarationModifier(state) {
|
|
4414
4503
|
if (state.tokenize) {
|
|
@@ -4418,16 +4507,17 @@ var Civet = (() => {
|
|
|
4418
4507
|
}
|
|
4419
4508
|
}
|
|
4420
4509
|
var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, Equals, __, Type);
|
|
4421
|
-
var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, InterfaceBlock);
|
|
4510
|
+
var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, $E(TypeParameters), InterfaceBlock);
|
|
4422
4511
|
var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
|
|
4512
|
+
var TypeDeclarationRest$3 = FunctionSignature;
|
|
4423
4513
|
function TypeDeclarationRest(state) {
|
|
4424
4514
|
if (state.tokenize) {
|
|
4425
|
-
return $TOKEN("TypeDeclarationRest", state, TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state));
|
|
4515
|
+
return $TOKEN("TypeDeclarationRest", state, TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state));
|
|
4426
4516
|
} else {
|
|
4427
|
-
return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state);
|
|
4517
|
+
return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state);
|
|
4428
4518
|
}
|
|
4429
4519
|
}
|
|
4430
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
4520
|
+
var TypeKeyword$0 = $S($EXPECT($L137, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
4431
4521
|
function TypeKeyword(state) {
|
|
4432
4522
|
if (state.verbose)
|
|
4433
4523
|
console.log("ENTER:", "TypeKeyword");
|
|
@@ -4437,7 +4527,7 @@ var Civet = (() => {
|
|
|
4437
4527
|
return TypeKeyword$0(state);
|
|
4438
4528
|
}
|
|
4439
4529
|
}
|
|
4440
|
-
var Interface$0 = $S($EXPECT($
|
|
4530
|
+
var Interface$0 = $S($EXPECT($L138, fail, 'Interface "interface"'), NonIdContinue);
|
|
4441
4531
|
function Interface(state) {
|
|
4442
4532
|
if (state.verbose)
|
|
4443
4533
|
console.log("ENTER:", "Interface");
|
|
@@ -4447,7 +4537,7 @@ var Civet = (() => {
|
|
|
4447
4537
|
return Interface$0(state);
|
|
4448
4538
|
}
|
|
4449
4539
|
}
|
|
4450
|
-
var Namespace$0 = $S($EXPECT($
|
|
4540
|
+
var Namespace$0 = $S($EXPECT($L139, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
4451
4541
|
function Namespace(state) {
|
|
4452
4542
|
if (state.verbose)
|
|
4453
4543
|
console.log("ENTER:", "Namespace");
|
|
@@ -4493,27 +4583,23 @@ var Civet = (() => {
|
|
|
4493
4583
|
}
|
|
4494
4584
|
}
|
|
4495
4585
|
var InterfaceProperty$0 = $S($C(TypeIndexSignature, PropertyName), TypeSuffix, InterfacePropertyDelimiter);
|
|
4496
|
-
var InterfaceProperty$1 =
|
|
4586
|
+
var InterfaceProperty$1 = $S(NonEmptyParameters, TypeSuffix, InterfacePropertyDelimiter);
|
|
4587
|
+
var InterfaceProperty$2 = $S(MethodSignature, InterfacePropertyDelimiter);
|
|
4497
4588
|
function InterfaceProperty(state) {
|
|
4498
4589
|
if (state.tokenize) {
|
|
4499
|
-
return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state));
|
|
4590
|
+
return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state) || InterfaceProperty$2(state));
|
|
4500
4591
|
} else {
|
|
4501
|
-
return InterfaceProperty$0(state) || InterfaceProperty$1(state);
|
|
4592
|
+
return InterfaceProperty$0(state) || InterfaceProperty$1(state) || InterfaceProperty$2(state);
|
|
4502
4593
|
}
|
|
4503
4594
|
}
|
|
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
|
-
});
|
|
4595
|
+
var InterfacePropertyDelimiter$0 = $S($Q(_), $C(Semicolon, Comma));
|
|
4596
|
+
var InterfacePropertyDelimiter$1 = $Y($S(__, CloseBrace));
|
|
4597
|
+
var InterfacePropertyDelimiter$2 = $Y(EOS);
|
|
4512
4598
|
function InterfacePropertyDelimiter(state) {
|
|
4513
4599
|
if (state.tokenize) {
|
|
4514
|
-
return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state)
|
|
4600
|
+
return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state));
|
|
4515
4601
|
} else {
|
|
4516
|
-
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state)
|
|
4602
|
+
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state);
|
|
4517
4603
|
}
|
|
4518
4604
|
}
|
|
4519
4605
|
var NamespaceBlock$0 = $S(__, OpenBrace, EOS, NestedTypeDeclarations, __, CloseBrace);
|
|
@@ -4551,7 +4637,7 @@ var Civet = (() => {
|
|
|
4551
4637
|
return NestedTypeDeclaration$0(state);
|
|
4552
4638
|
}
|
|
4553
4639
|
}
|
|
4554
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
4640
|
+
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
4641
|
function TypeIndexSignature(state) {
|
|
4556
4642
|
if (state.verbose)
|
|
4557
4643
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -4582,7 +4668,7 @@ var Civet = (() => {
|
|
|
4582
4668
|
return TypeSuffix$0(state);
|
|
4583
4669
|
}
|
|
4584
4670
|
}
|
|
4585
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
4671
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L141, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
4586
4672
|
if (!$3)
|
|
4587
4673
|
$0.splice(2, 1);
|
|
4588
4674
|
if ($1.length === 0)
|
|
@@ -4602,7 +4688,7 @@ var Civet = (() => {
|
|
|
4602
4688
|
return ReturnTypeSuffix$0(state);
|
|
4603
4689
|
}
|
|
4604
4690
|
}
|
|
4605
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
4691
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L59, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
4606
4692
|
if (!$2)
|
|
4607
4693
|
return $1;
|
|
4608
4694
|
return $0;
|
|
@@ -4657,18 +4743,17 @@ var Civet = (() => {
|
|
|
4657
4743
|
}
|
|
4658
4744
|
}
|
|
4659
4745
|
var TypeUnarySuffix$0 = TypeIndexedAccess;
|
|
4746
|
+
var TypeUnarySuffix$1 = QuestionMark;
|
|
4660
4747
|
function TypeUnarySuffix(state) {
|
|
4661
|
-
if (state.verbose)
|
|
4662
|
-
console.log("ENTER:", "TypeUnarySuffix");
|
|
4663
4748
|
if (state.tokenize) {
|
|
4664
|
-
return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state));
|
|
4749
|
+
return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state));
|
|
4665
4750
|
} else {
|
|
4666
|
-
return TypeUnarySuffix$0(state);
|
|
4751
|
+
return TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state);
|
|
4667
4752
|
}
|
|
4668
4753
|
}
|
|
4669
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
4670
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
4671
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
4754
|
+
var TypeUnaryOp$0 = $EXPECT($L142, fail, 'TypeUnaryOp "keyof"');
|
|
4755
|
+
var TypeUnaryOp$1 = $EXPECT($L74, fail, 'TypeUnaryOp "typeof"');
|
|
4756
|
+
var TypeUnaryOp$2 = $EXPECT($L143, fail, 'TypeUnaryOp "infer"');
|
|
4672
4757
|
function TypeUnaryOp(state) {
|
|
4673
4758
|
if (state.tokenize) {
|
|
4674
4759
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -4688,14 +4773,59 @@ var Civet = (() => {
|
|
|
4688
4773
|
}
|
|
4689
4774
|
var TypePrimary$0 = InterfaceBlock;
|
|
4690
4775
|
var TypePrimary$1 = $S(__, OpenParen, Type, __, CloseParen);
|
|
4691
|
-
var TypePrimary$2 = $S(
|
|
4692
|
-
var TypePrimary$3 = $S($Q(_),
|
|
4693
|
-
var TypePrimary$4 = $S($Q(_),
|
|
4776
|
+
var TypePrimary$2 = $S(__, TypeTuple);
|
|
4777
|
+
var TypePrimary$3 = $S($Q(_), FunctionType);
|
|
4778
|
+
var TypePrimary$4 = $S($Q(_), TypeLiteral);
|
|
4779
|
+
var TypePrimary$5 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
4694
4780
|
function TypePrimary(state) {
|
|
4695
4781
|
if (state.tokenize) {
|
|
4696
|
-
return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state));
|
|
4782
|
+
return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state));
|
|
4783
|
+
} else {
|
|
4784
|
+
return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state);
|
|
4785
|
+
}
|
|
4786
|
+
}
|
|
4787
|
+
var TypeTuple$0 = $S(OpenBracket, NestedTypeList, __, CloseBracket);
|
|
4788
|
+
var TypeTuple$1 = $S(OpenBracket, $E(TypeList), __, CloseBracket);
|
|
4789
|
+
function TypeTuple(state) {
|
|
4790
|
+
if (state.tokenize) {
|
|
4791
|
+
return $TOKEN("TypeTuple", state, TypeTuple$0(state) || TypeTuple$1(state));
|
|
4792
|
+
} else {
|
|
4793
|
+
return TypeTuple$0(state) || TypeTuple$1(state);
|
|
4794
|
+
}
|
|
4795
|
+
}
|
|
4796
|
+
var TypeList$0 = $S(Type, $Q($S(__, Comma, Type)));
|
|
4797
|
+
function TypeList(state) {
|
|
4798
|
+
if (state.verbose)
|
|
4799
|
+
console.log("ENTER:", "TypeList");
|
|
4800
|
+
if (state.tokenize) {
|
|
4801
|
+
return $TOKEN("TypeList", state, TypeList$0(state));
|
|
4697
4802
|
} else {
|
|
4698
|
-
return
|
|
4803
|
+
return TypeList$0(state);
|
|
4804
|
+
}
|
|
4805
|
+
}
|
|
4806
|
+
var NestedTypeList$0 = $TS($S(PushIndent, $Q(NestedType), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
4807
|
+
var types = $2;
|
|
4808
|
+
if (types.length)
|
|
4809
|
+
return types;
|
|
4810
|
+
return $skip;
|
|
4811
|
+
});
|
|
4812
|
+
function NestedTypeList(state) {
|
|
4813
|
+
if (state.verbose)
|
|
4814
|
+
console.log("ENTER:", "NestedTypeList");
|
|
4815
|
+
if (state.tokenize) {
|
|
4816
|
+
return $TOKEN("NestedTypeList", state, NestedTypeList$0(state));
|
|
4817
|
+
} else {
|
|
4818
|
+
return NestedTypeList$0(state);
|
|
4819
|
+
}
|
|
4820
|
+
}
|
|
4821
|
+
var NestedType$0 = $S(Nested, Type, ArrayElementDelimiter);
|
|
4822
|
+
function NestedType(state) {
|
|
4823
|
+
if (state.verbose)
|
|
4824
|
+
console.log("ENTER:", "NestedType");
|
|
4825
|
+
if (state.tokenize) {
|
|
4826
|
+
return $TOKEN("NestedType", state, NestedType$0(state));
|
|
4827
|
+
} else {
|
|
4828
|
+
return NestedType$0(state);
|
|
4699
4829
|
}
|
|
4700
4830
|
}
|
|
4701
4831
|
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 +4843,10 @@ var Civet = (() => {
|
|
|
4713
4843
|
}
|
|
4714
4844
|
}
|
|
4715
4845
|
var TypeLiteral$0 = Literal;
|
|
4716
|
-
var TypeLiteral$1 = $TV($EXPECT($
|
|
4846
|
+
var TypeLiteral$1 = $TV($EXPECT($L73, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
|
|
4717
4847
|
return { $loc, token: "void" };
|
|
4718
4848
|
});
|
|
4719
|
-
var TypeLiteral$2 = $TV($EXPECT($
|
|
4849
|
+
var TypeLiteral$2 = $TV($EXPECT($L144, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
4720
4850
|
return { $loc, token: "[]" };
|
|
4721
4851
|
});
|
|
4722
4852
|
function TypeLiteral(state) {
|
|
@@ -4726,10 +4856,10 @@ var Civet = (() => {
|
|
|
4726
4856
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
4727
4857
|
}
|
|
4728
4858
|
}
|
|
4729
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
4859
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L71, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
4730
4860
|
return { $loc, token: "|" };
|
|
4731
4861
|
});
|
|
4732
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
4862
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L69, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
4733
4863
|
return { $loc, token: "&" };
|
|
4734
4864
|
});
|
|
4735
4865
|
function TypeBinaryOp(state) {
|
|
@@ -4749,7 +4879,7 @@ var Civet = (() => {
|
|
|
4749
4879
|
return FunctionType$0(state);
|
|
4750
4880
|
}
|
|
4751
4881
|
}
|
|
4752
|
-
var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
4882
|
+
var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L56, fail, 'TypeArguments ">"'));
|
|
4753
4883
|
function TypeArguments(state) {
|
|
4754
4884
|
if (state.verbose)
|
|
4755
4885
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -4759,7 +4889,7 @@ var Civet = (() => {
|
|
|
4759
4889
|
return TypeArguments$0(state);
|
|
4760
4890
|
}
|
|
4761
4891
|
}
|
|
4762
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
4892
|
+
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
4893
|
return { ts: true, children: $0 };
|
|
4764
4894
|
});
|
|
4765
4895
|
function TypeParameters(state) {
|
|
@@ -4792,8 +4922,8 @@ var Civet = (() => {
|
|
|
4792
4922
|
}
|
|
4793
4923
|
}
|
|
4794
4924
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
4795
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
4796
|
-
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($
|
|
4925
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L56, fail, 'TypeParameterDelimiter ">"')));
|
|
4926
|
+
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L56, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
|
|
4797
4927
|
return { $loc, token: "," };
|
|
4798
4928
|
});
|
|
4799
4929
|
var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
@@ -4806,7 +4936,7 @@ var Civet = (() => {
|
|
|
4806
4936
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
4807
4937
|
}
|
|
4808
4938
|
}
|
|
4809
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
4939
|
+
var Shebang$0 = $S($R$0($EXPECT($R38, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
4810
4940
|
function Shebang(state) {
|
|
4811
4941
|
if (state.verbose)
|
|
4812
4942
|
console.log("ENTER:", "Shebang");
|
|
@@ -4816,11 +4946,11 @@ var Civet = (() => {
|
|
|
4816
4946
|
return Shebang$0(state);
|
|
4817
4947
|
}
|
|
4818
4948
|
}
|
|
4819
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
4949
|
+
var CivetPrologue$0 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
4820
4950
|
var content = value[2];
|
|
4821
4951
|
return content;
|
|
4822
4952
|
});
|
|
4823
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
4953
|
+
var CivetPrologue$1 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
4824
4954
|
var content = value[2];
|
|
4825
4955
|
return content;
|
|
4826
4956
|
});
|
|
@@ -4831,7 +4961,7 @@ var Civet = (() => {
|
|
|
4831
4961
|
return CivetPrologue$0(state) || CivetPrologue$1(state);
|
|
4832
4962
|
}
|
|
4833
4963
|
}
|
|
4834
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
4964
|
+
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
4965
|
var options = $2;
|
|
4836
4966
|
return {
|
|
4837
4967
|
type: "CivetPrologue",
|
|
@@ -4848,8 +4978,8 @@ var Civet = (() => {
|
|
|
4848
4978
|
return CivetPrologueContent$0(state);
|
|
4849
4979
|
}
|
|
4850
4980
|
}
|
|
4851
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
4852
|
-
const optionName = $2.
|
|
4981
|
+
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) {
|
|
4982
|
+
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
4853
4983
|
if (l)
|
|
4854
4984
|
return l.toUpperCase();
|
|
4855
4985
|
return "";
|
|
@@ -4866,7 +4996,7 @@ var Civet = (() => {
|
|
|
4866
4996
|
return CivetOption$0(state);
|
|
4867
4997
|
}
|
|
4868
4998
|
}
|
|
4869
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
4999
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R39, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
|
|
4870
5000
|
function UnknownPrologue(state) {
|
|
4871
5001
|
if (state.verbose)
|
|
4872
5002
|
console.log("ENTER:", "UnknownPrologue");
|
|
@@ -4895,7 +5025,7 @@ var Civet = (() => {
|
|
|
4895
5025
|
return EOS$0(state);
|
|
4896
5026
|
}
|
|
4897
5027
|
}
|
|
4898
|
-
var EOL$0 = $R$0($EXPECT($
|
|
5028
|
+
var EOL$0 = $R$0($EXPECT($R42, fail, "EOL /\\r\\n|\\n|\\r|$/"));
|
|
4899
5029
|
function EOL(state) {
|
|
4900
5030
|
if (state.verbose)
|
|
4901
5031
|
console.log("ENTER:", "EOL");
|
|
@@ -4905,7 +5035,7 @@ var Civet = (() => {
|
|
|
4905
5035
|
return EOL$0(state);
|
|
4906
5036
|
}
|
|
4907
5037
|
}
|
|
4908
|
-
var EOF$0 = $R$0($EXPECT($
|
|
5038
|
+
var EOF$0 = $R$0($EXPECT($R43, fail, "EOF /$/"));
|
|
4909
5039
|
function EOF(state) {
|
|
4910
5040
|
if (state.verbose)
|
|
4911
5041
|
console.log("ENTER:", "EOF");
|
|
@@ -5048,7 +5178,7 @@ var Civet = (() => {
|
|
|
5048
5178
|
}
|
|
5049
5179
|
}
|
|
5050
5180
|
var InsertBreak$0 = $TV($EXPECT($L1, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
5051
|
-
return { $loc, token: "break;" };
|
|
5181
|
+
return { $loc, token: ";break;" };
|
|
5052
5182
|
});
|
|
5053
5183
|
function InsertBreak(state) {
|
|
5054
5184
|
if (state.verbose)
|
|
@@ -5073,6 +5203,20 @@ var Civet = (() => {
|
|
|
5073
5203
|
return CoffeeCommentEnabled$0(state);
|
|
5074
5204
|
}
|
|
5075
5205
|
}
|
|
5206
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
5207
|
+
if (module.config.coffeeBooleans)
|
|
5208
|
+
return;
|
|
5209
|
+
return $skip;
|
|
5210
|
+
});
|
|
5211
|
+
function CoffeeBooleansEnabled(state) {
|
|
5212
|
+
if (state.verbose)
|
|
5213
|
+
console.log("ENTER:", "CoffeeBooleansEnabled");
|
|
5214
|
+
if (state.tokenize) {
|
|
5215
|
+
return $TOKEN("CoffeeBooleansEnabled", state, CoffeeBooleansEnabled$0(state));
|
|
5216
|
+
} else {
|
|
5217
|
+
return CoffeeBooleansEnabled$0(state);
|
|
5218
|
+
}
|
|
5219
|
+
}
|
|
5076
5220
|
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
5077
5221
|
if (module.config.coffeeInterpolation)
|
|
5078
5222
|
return;
|
|
@@ -5093,6 +5237,7 @@ var Civet = (() => {
|
|
|
5093
5237
|
module.verbose = false;
|
|
5094
5238
|
module.config = {
|
|
5095
5239
|
autoVar: false,
|
|
5240
|
+
coffeeBooleans: false,
|
|
5096
5241
|
coffeeComment: false,
|
|
5097
5242
|
coffeeEq: false,
|
|
5098
5243
|
coffeeInterpolation: false,
|
|
@@ -5102,12 +5247,14 @@ var Civet = (() => {
|
|
|
5102
5247
|
set(b) {
|
|
5103
5248
|
if (b) {
|
|
5104
5249
|
this.autoVar = true;
|
|
5250
|
+
this.coffeeBooleans = true;
|
|
5105
5251
|
this.coffeeComment = true;
|
|
5106
5252
|
this.coffeeEq = true;
|
|
5107
5253
|
this.coffeeInterpolation = true;
|
|
5108
5254
|
this.implicitReturns = true;
|
|
5109
5255
|
} else {
|
|
5110
5256
|
this.autoVar = false;
|
|
5257
|
+
this.coffeeBooleans = false;
|
|
5111
5258
|
this.coffeeComment = false;
|
|
5112
5259
|
this.coffeeEq = false;
|
|
5113
5260
|
this.coffeeInterpolation = false;
|
|
@@ -5155,6 +5302,9 @@ var Civet = (() => {
|
|
|
5155
5302
|
case "AssignmentExpression":
|
|
5156
5303
|
node.children.unshift("return ");
|
|
5157
5304
|
return;
|
|
5305
|
+
case "Identifier":
|
|
5306
|
+
node.token = "return " + node.token;
|
|
5307
|
+
return;
|
|
5158
5308
|
case "BlockStatement":
|
|
5159
5309
|
insertReturn(node.expressions[node.expressions.length - 1]);
|
|
5160
5310
|
return;
|
|
@@ -5175,7 +5325,7 @@ var Civet = (() => {
|
|
|
5175
5325
|
}
|
|
5176
5326
|
if (!Array.isArray(node))
|
|
5177
5327
|
return;
|
|
5178
|
-
const [, exp] = node;
|
|
5328
|
+
const [indent, exp] = node;
|
|
5179
5329
|
if (!exp)
|
|
5180
5330
|
return;
|
|
5181
5331
|
switch (exp.type) {
|
|
@@ -5194,6 +5344,8 @@ var Civet = (() => {
|
|
|
5194
5344
|
insertReturn(exp.children[2]);
|
|
5195
5345
|
if (exp.children[3])
|
|
5196
5346
|
insertReturn(exp.children[3][2]);
|
|
5347
|
+
else
|
|
5348
|
+
exp.children.push(["\n", indent, "return"]);
|
|
5197
5349
|
return;
|
|
5198
5350
|
case "SwitchStatement":
|
|
5199
5351
|
insertReturn(exp.children[2]);
|
|
@@ -5211,6 +5363,50 @@ var Civet = (() => {
|
|
|
5211
5363
|
insertReturn(block);
|
|
5212
5364
|
return block;
|
|
5213
5365
|
};
|
|
5366
|
+
module.expandChainedComparisons = function([first, binops]) {
|
|
5367
|
+
const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in", "instanceof"];
|
|
5368
|
+
const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
|
|
5369
|
+
let results = [];
|
|
5370
|
+
let i = 0;
|
|
5371
|
+
let l = binops.length;
|
|
5372
|
+
let start = 0;
|
|
5373
|
+
let chains = [];
|
|
5374
|
+
while (i < l) {
|
|
5375
|
+
const [, op] = binops[i];
|
|
5376
|
+
if (relationalOps.includes(op.token)) {
|
|
5377
|
+
chains.push(i);
|
|
5378
|
+
} else if (lowerPrecedenceOps.includes(op.token)) {
|
|
5379
|
+
processChains();
|
|
5380
|
+
first = [];
|
|
5381
|
+
}
|
|
5382
|
+
i++;
|
|
5383
|
+
}
|
|
5384
|
+
processChains();
|
|
5385
|
+
return results;
|
|
5386
|
+
function processChains() {
|
|
5387
|
+
if (chains.length > 1) {
|
|
5388
|
+
chains.forEach((index, k) => {
|
|
5389
|
+
if (k > 0) {
|
|
5390
|
+
results.push(" && ");
|
|
5391
|
+
}
|
|
5392
|
+
const [pre, op, post, exp] = binops[index];
|
|
5393
|
+
let endIndex;
|
|
5394
|
+
if (k < chains.length - 1) {
|
|
5395
|
+
endIndex = chains[k + 1];
|
|
5396
|
+
} else {
|
|
5397
|
+
endIndex = i + 1;
|
|
5398
|
+
}
|
|
5399
|
+
results = results.concat(first, ...binops.slice(start, endIndex));
|
|
5400
|
+
first = [exp].concat(binops.slice(index + 1, endIndex));
|
|
5401
|
+
start = endIndex;
|
|
5402
|
+
});
|
|
5403
|
+
} else {
|
|
5404
|
+
results = results.concat(first, ...binops.slice(start, i + 1));
|
|
5405
|
+
start = i + 1;
|
|
5406
|
+
}
|
|
5407
|
+
chains.length = 0;
|
|
5408
|
+
}
|
|
5409
|
+
};
|
|
5214
5410
|
module.parsePosition = function() {
|
|
5215
5411
|
let s = Error().stack.split(/\n at /);
|
|
5216
5412
|
s.shift();
|
|
@@ -5307,7 +5503,7 @@ var Civet = (() => {
|
|
|
5307
5503
|
return Init$0(state);
|
|
5308
5504
|
}
|
|
5309
5505
|
}
|
|
5310
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
5506
|
+
var Indent$0 = $TV($Q($C($EXPECT($L146, fail, 'Indent " "'), $EXPECT($L147, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
5311
5507
|
const level = $1.length;
|
|
5312
5508
|
return {
|
|
5313
5509
|
$loc,
|