@danielx/civet 0.4.8 → 0.4.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +26 -6
- package/dist/browser.js +756 -448
- package/dist/main.js +756 -448
- 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,
|
|
@@ -589,9 +593,8 @@ var Civet = (() => {
|
|
|
589
593
|
TripleDoubleStringCharacters,
|
|
590
594
|
TripleSingleStringCharacters,
|
|
591
595
|
CoffeeStringSubstitution,
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
CoffeeCompatDoubleQuotedStringCharacters,
|
|
596
|
+
CoffeeInterpolatedDoubleQuotedString,
|
|
597
|
+
CoffeeDoubleQuotedStringCharacters,
|
|
595
598
|
RegularExpressionLiteral,
|
|
596
599
|
RegularExpressionBody,
|
|
597
600
|
RegExpCharacter,
|
|
@@ -631,6 +634,7 @@ var Civet = (() => {
|
|
|
631
634
|
ConstructorShorthand,
|
|
632
635
|
Default,
|
|
633
636
|
Dot,
|
|
637
|
+
DotDotDot,
|
|
634
638
|
DoubleQuote,
|
|
635
639
|
Else,
|
|
636
640
|
Equals,
|
|
@@ -709,6 +713,10 @@ var Civet = (() => {
|
|
|
709
713
|
TypeUnaryOp,
|
|
710
714
|
TypeIndexedAccess,
|
|
711
715
|
TypePrimary,
|
|
716
|
+
TypeTuple,
|
|
717
|
+
TypeList,
|
|
718
|
+
NestedTypeList,
|
|
719
|
+
NestedType,
|
|
712
720
|
TypeConditional,
|
|
713
721
|
TypeLiteral,
|
|
714
722
|
TypeBinaryOp,
|
|
@@ -719,6 +727,10 @@ var Civet = (() => {
|
|
|
719
727
|
TypeConstraint,
|
|
720
728
|
TypeParameterDelimiter,
|
|
721
729
|
Shebang,
|
|
730
|
+
CivetPrologue,
|
|
731
|
+
CivetPrologueContent,
|
|
732
|
+
CivetOption,
|
|
733
|
+
UnknownPrologue,
|
|
722
734
|
DirectivePrologue,
|
|
723
735
|
EOS,
|
|
724
736
|
EOL,
|
|
@@ -735,6 +747,9 @@ var Civet = (() => {
|
|
|
735
747
|
InsertSpace,
|
|
736
748
|
InsertDot,
|
|
737
749
|
InsertBreak,
|
|
750
|
+
CoffeeCommentEnabled,
|
|
751
|
+
CoffeeBooleansEnabled,
|
|
752
|
+
CoffeeInterpolationEnabled,
|
|
738
753
|
Reset,
|
|
739
754
|
Init,
|
|
740
755
|
Indent,
|
|
@@ -762,170 +777,181 @@ var Civet = (() => {
|
|
|
762
777
|
var $L14 = $L("super[");
|
|
763
778
|
var $L15 = $L("import.meta");
|
|
764
779
|
var $L16 = $L(")");
|
|
765
|
-
var $L17 = $L("
|
|
766
|
-
var $L18 = $L("
|
|
767
|
-
var $L19 = $L("
|
|
768
|
-
var $L20 = $L("
|
|
769
|
-
var $L21 = $L("
|
|
770
|
-
var $L22 = $L("
|
|
771
|
-
var $L23 = $L("
|
|
772
|
-
var $L24 = $L("
|
|
773
|
-
var $L25 = $L("
|
|
774
|
-
var $L26 = $L("
|
|
775
|
-
var $L27 = $L("
|
|
776
|
-
var $L28 = $L("
|
|
777
|
-
var $L29 = $L("
|
|
778
|
-
var $L30 = $L("
|
|
779
|
-
var $L31 = $L("
|
|
780
|
-
var $L32 = $L("
|
|
781
|
-
var $L33 = $L("
|
|
782
|
-
var $L34 = $L("
|
|
783
|
-
var $L35 = $L("
|
|
784
|
-
var $L36 = $L("
|
|
785
|
-
var $L37 = $L("
|
|
786
|
-
var $L38 = $L("
|
|
787
|
-
var $L39 = $L("
|
|
788
|
-
var $L40 = $L("
|
|
789
|
-
var $L41 = $L("
|
|
790
|
-
var $L42 = $L("
|
|
791
|
-
var $L43 = $L("
|
|
792
|
-
var $L44 = $L("
|
|
793
|
-
var $L45 = $L("
|
|
794
|
-
var $L46 = $L("
|
|
795
|
-
var $L47 = $L("
|
|
796
|
-
var $L48 = $L("
|
|
797
|
-
var $L49 = $L("
|
|
798
|
-
var $L50 = $L("
|
|
799
|
-
var $L51 = $L("
|
|
800
|
-
var $L52 = $L("
|
|
801
|
-
var $L53 = $L("
|
|
802
|
-
var $L54 = $L("
|
|
803
|
-
var $L55 = $L("
|
|
804
|
-
var $L56 = $L("
|
|
805
|
-
var $L57 = $L("
|
|
806
|
-
var $L58 = $L("
|
|
807
|
-
var $L59 = $L("
|
|
808
|
-
var $L60 = $L("
|
|
809
|
-
var $L61 = $L("
|
|
810
|
-
var $L62 = $L("
|
|
811
|
-
var $L63 = $L("
|
|
812
|
-
var $L64 = $L("
|
|
813
|
-
var $L65 = $L("
|
|
814
|
-
var $L66 = $L("
|
|
815
|
-
var $L67 = $L("
|
|
816
|
-
var $L68 = $L("
|
|
817
|
-
var $L69 = $L("
|
|
818
|
-
var $L70 = $L("
|
|
819
|
-
var $L71 = $L("
|
|
820
|
-
var $L72 = $L("
|
|
821
|
-
var $L73 = $L("
|
|
822
|
-
var $L74 = $L("
|
|
823
|
-
var $L75 = $L("
|
|
824
|
-
var $L76 = $L("
|
|
825
|
-
var $L77 = $L("
|
|
826
|
-
var $L78 = $L("
|
|
827
|
-
var $L79 = $L("
|
|
828
|
-
var $L80 = $L("
|
|
829
|
-
var $L81 = $L("
|
|
830
|
-
var $L82 = $L("
|
|
831
|
-
var $L83 = $L("
|
|
832
|
-
var $L84 = $L("
|
|
833
|
-
var $L85 = $L("
|
|
834
|
-
var $L86 = $L("
|
|
835
|
-
var $L87 = $L("
|
|
836
|
-
var $L88 = $L("
|
|
837
|
-
var $L89 = $L("
|
|
838
|
-
var $L90 = $L("
|
|
839
|
-
var $L91 = $L("
|
|
840
|
-
var $L92 = $L("
|
|
841
|
-
var $L93 = $L("
|
|
842
|
-
var $L94 = $L("
|
|
843
|
-
var $L95 = $L(
|
|
844
|
-
var $L96 = $L("
|
|
845
|
-
var $L97 = $L("
|
|
846
|
-
var $L98 = $L("
|
|
847
|
-
var $L99 = $L("
|
|
848
|
-
var $L100 = $L("
|
|
849
|
-
var $L101 = $L("
|
|
850
|
-
var $L102 = $L("
|
|
851
|
-
var $L103 = $L("
|
|
852
|
-
var $L104 = $L("
|
|
853
|
-
var $L105 = $L("
|
|
854
|
-
var $L106 = $L("
|
|
855
|
-
var $L107 = $L("
|
|
856
|
-
var $L108 = $L("
|
|
857
|
-
var $L109 = $L("
|
|
858
|
-
var $L110 = $L("
|
|
859
|
-
var $L111 = $L("
|
|
860
|
-
var $L112 = $L("
|
|
861
|
-
var $L113 = $L("
|
|
862
|
-
var $L114 = $L("
|
|
863
|
-
var $L115 = $L("
|
|
864
|
-
var $L116 = $L("
|
|
865
|
-
var $L117 = $L("
|
|
866
|
-
var $L118 = $L("
|
|
867
|
-
var $L119 = $L("
|
|
868
|
-
var $L120 = $L(
|
|
869
|
-
var $L121 = $L("
|
|
870
|
-
var $L122 = $L("
|
|
871
|
-
var $L123 = $L("
|
|
872
|
-
var $L124 = $L("
|
|
873
|
-
var $L125 = $L("
|
|
874
|
-
var $L126 = $L("
|
|
875
|
-
var $L127 = $L("
|
|
876
|
-
var $L128 = $L("
|
|
877
|
-
var $L129 = $L("
|
|
878
|
-
var $L130 = $L("
|
|
879
|
-
var $L131 = $L("
|
|
880
|
-
var $L132 = $L("
|
|
881
|
-
var $L133 = $L("
|
|
882
|
-
var $L134 = $L("
|
|
883
|
-
var $L135 = $L("
|
|
884
|
-
var $L136 = $L("
|
|
885
|
-
var $L137 = $L("
|
|
886
|
-
var $L138 = $L("
|
|
887
|
-
var $L139 = $L("
|
|
888
|
-
var $L140 = $L("
|
|
889
|
-
var $L141 = $L("
|
|
890
|
-
var $L142 = $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(" ");
|
|
891
911
|
var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
892
912
|
var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
893
913
|
var $R2 = $R(new RegExp("[!~+-]", "suy"));
|
|
894
914
|
var $R3 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
895
915
|
var $R4 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
896
|
-
var $R5 = $R(new RegExp("
|
|
897
|
-
var $R6 = $R(new RegExp("0[
|
|
898
|
-
var $R7 = $R(new RegExp("
|
|
899
|
-
var $R8 = $R(new RegExp("
|
|
900
|
-
var $R9 = $R(new RegExp(
|
|
901
|
-
var $R10 = $R(new RegExp("(
|
|
902
|
-
var $R11 = $R(new RegExp(
|
|
903
|
-
var $R12 = $R(new RegExp(
|
|
904
|
-
var $R13 = $R(new RegExp(
|
|
905
|
-
var $R14 = $R(new RegExp("[
|
|
906
|
-
var $R15 = $R(new RegExp("(
|
|
907
|
-
var $R16 = $R(new RegExp(
|
|
908
|
-
var $R17 = $R(new RegExp("
|
|
909
|
-
var $R18 = $R(new RegExp("(
|
|
910
|
-
var $R19 = $R(new RegExp("(
|
|
911
|
-
var $R20 = $R(new RegExp("
|
|
912
|
-
var $R21 = $R(new RegExp("
|
|
913
|
-
var $R22 = $R(new RegExp("
|
|
914
|
-
var $R23 = $R(new RegExp("
|
|
915
|
-
var $R24 = $R(new RegExp("[
|
|
916
|
-
var $R25 = $R(new RegExp("
|
|
917
|
-
var $R26 = $R(new RegExp("(
|
|
918
|
-
var $R27 = $R(new RegExp("\\
|
|
919
|
-
var $R28 = $R(new RegExp("
|
|
920
|
-
var $R29 = $R(new RegExp(
|
|
921
|
-
var $R30 = $R(new RegExp("
|
|
922
|
-
var $R31 = $R(new RegExp("
|
|
923
|
-
var $R32 = $R(new RegExp("[
|
|
924
|
-
var $R33 = $R(new RegExp("[
|
|
925
|
-
var $R34 = $R(new RegExp("
|
|
926
|
-
var $R35 = $R(new RegExp("[
|
|
927
|
-
var $R36 = $R(new RegExp("
|
|
928
|
-
var $R37 = $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"));
|
|
929
955
|
var Program$0 = $S(Reset, Init, __, $Q(TopLevelStatement), __);
|
|
930
956
|
function Program(state) {
|
|
931
957
|
if (state.verbose)
|
|
@@ -984,7 +1010,7 @@ var Civet = (() => {
|
|
|
984
1010
|
}
|
|
985
1011
|
}
|
|
986
1012
|
var ArgumentList$0 = $S($Y(EOS), NestedArgumentList);
|
|
987
|
-
var ArgumentList$1 =
|
|
1013
|
+
var ArgumentList$1 = InlineArgumentExpressions;
|
|
988
1014
|
function ArgumentList(state) {
|
|
989
1015
|
if (state.tokenize) {
|
|
990
1016
|
return $TOKEN("ArgumentList", state, ArgumentList$0(state) || ArgumentList$1(state));
|
|
@@ -1007,7 +1033,7 @@ var Civet = (() => {
|
|
|
1007
1033
|
return NestedArgumentList$0(state);
|
|
1008
1034
|
}
|
|
1009
1035
|
}
|
|
1010
|
-
var NestedArgument$0 = $S(Nested,
|
|
1036
|
+
var NestedArgument$0 = $S(Nested, InlineArgumentExpressions, ParameterElementDelimiter);
|
|
1011
1037
|
function NestedArgument(state) {
|
|
1012
1038
|
if (state.verbose)
|
|
1013
1039
|
console.log("ENTER:", "NestedArgument");
|
|
@@ -1017,6 +1043,20 @@ var Civet = (() => {
|
|
|
1017
1043
|
return NestedArgument$0(state);
|
|
1018
1044
|
}
|
|
1019
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
|
+
}
|
|
1020
1060
|
var ImplicitApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen);
|
|
1021
1061
|
function ImplicitApplication(state) {
|
|
1022
1062
|
if (state.verbose)
|
|
@@ -1055,19 +1095,10 @@ var Civet = (() => {
|
|
|
1055
1095
|
return IndentedApplicationAllowed$0(state);
|
|
1056
1096
|
}
|
|
1057
1097
|
}
|
|
1058
|
-
var CommaExpression$0 = $S(__, Comma, Expression);
|
|
1059
|
-
function CommaExpression(state) {
|
|
1060
|
-
if (state.verbose)
|
|
1061
|
-
console.log("ENTER:", "CommaExpression");
|
|
1062
|
-
if (state.tokenize) {
|
|
1063
|
-
return $TOKEN("CommaExpression", state, CommaExpression$0(state));
|
|
1064
|
-
} else {
|
|
1065
|
-
return CommaExpression$0(state);
|
|
1066
|
-
}
|
|
1067
|
-
}
|
|
1068
1098
|
var BinaryOpExpression$0 = $TS($S(UnaryExpression, $Q($S(__, BinaryOp, __, UnaryExpression))), function($skip, $loc, $0, $1, $2) {
|
|
1069
|
-
if ($2.length)
|
|
1070
|
-
return $0;
|
|
1099
|
+
if ($2.length) {
|
|
1100
|
+
return module.expandChainedComparisons($0);
|
|
1101
|
+
}
|
|
1071
1102
|
return $1;
|
|
1072
1103
|
});
|
|
1073
1104
|
function BinaryOpExpression(state) {
|
|
@@ -1084,9 +1115,16 @@ var Civet = (() => {
|
|
|
1084
1115
|
var exp = $2;
|
|
1085
1116
|
var post = $3;
|
|
1086
1117
|
if (post?.token === "?") {
|
|
1087
|
-
return ["(", pre,
|
|
1088
|
-
}
|
|
1089
|
-
|
|
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;
|
|
1090
1128
|
});
|
|
1091
1129
|
function UnaryExpression(state) {
|
|
1092
1130
|
if (state.verbose)
|
|
@@ -1098,7 +1136,7 @@ var Civet = (() => {
|
|
|
1098
1136
|
}
|
|
1099
1137
|
}
|
|
1100
1138
|
var UnaryPostfix$0 = QuestionMark;
|
|
1101
|
-
var UnaryPostfix$1 = $T($S(__, As,
|
|
1139
|
+
var UnaryPostfix$1 = $T($P($S(__, As, Type)), function(value) {
|
|
1102
1140
|
return { "ts": true, "children": value };
|
|
1103
1141
|
});
|
|
1104
1142
|
function UnaryPostfix(state) {
|
|
@@ -1186,7 +1224,7 @@ var Civet = (() => {
|
|
|
1186
1224
|
var expOrBlock = $4;
|
|
1187
1225
|
const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
|
|
1188
1226
|
const isBlock = expOrBlock.type === "BlockStatement";
|
|
1189
|
-
if (module.implicitReturns && !isVoid && isBlock) {
|
|
1227
|
+
if (module.config.implicitReturns && !isVoid && isBlock) {
|
|
1190
1228
|
module.addImplicitReturns(expOrBlock);
|
|
1191
1229
|
}
|
|
1192
1230
|
return {
|
|
@@ -1553,7 +1591,7 @@ var Civet = (() => {
|
|
|
1553
1591
|
return Parameters$0(state) || Parameters$1(state);
|
|
1554
1592
|
}
|
|
1555
1593
|
}
|
|
1556
|
-
var NonEmptyParameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), __, CloseParen);
|
|
1594
|
+
var NonEmptyParameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), $E(FunctionRestParameter), __, CloseParen);
|
|
1557
1595
|
function NonEmptyParameters(state) {
|
|
1558
1596
|
if (state.verbose)
|
|
1559
1597
|
console.log("ENTER:", "NonEmptyParameters");
|
|
@@ -1563,6 +1601,16 @@ var Civet = (() => {
|
|
|
1563
1601
|
return NonEmptyParameters$0(state);
|
|
1564
1602
|
}
|
|
1565
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
|
+
}
|
|
1566
1614
|
var ParameterElement$0 = $S(__, $C(BindingIdentifier, BindingPattern), $E(TypeSuffix), $E(Initializer), ParameterElementDelimiter);
|
|
1567
1615
|
function ParameterElement(state) {
|
|
1568
1616
|
if (state.verbose)
|
|
@@ -1574,18 +1622,15 @@ var Civet = (() => {
|
|
|
1574
1622
|
}
|
|
1575
1623
|
}
|
|
1576
1624
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
1577
|
-
var ParameterElementDelimiter$1 = $Y($S(
|
|
1578
|
-
var ParameterElementDelimiter$2 = $TV($Y(
|
|
1579
|
-
return { $loc, token: "," };
|
|
1580
|
-
});
|
|
1581
|
-
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) {
|
|
1582
1627
|
return { $loc, token: "," };
|
|
1583
1628
|
});
|
|
1584
1629
|
function ParameterElementDelimiter(state) {
|
|
1585
1630
|
if (state.tokenize) {
|
|
1586
|
-
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));
|
|
1587
1632
|
} else {
|
|
1588
|
-
return ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state)
|
|
1633
|
+
return ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state);
|
|
1589
1634
|
}
|
|
1590
1635
|
}
|
|
1591
1636
|
var BindingIdentifier$0 = $S(__, Identifier);
|
|
@@ -1662,7 +1707,7 @@ var Civet = (() => {
|
|
|
1662
1707
|
return BindingProperty$0(state) || BindingProperty$1(state);
|
|
1663
1708
|
}
|
|
1664
1709
|
}
|
|
1665
|
-
var BindingRestProperty$0 = $S(
|
|
1710
|
+
var BindingRestProperty$0 = $S(DotDotDot, BindingIdentifier);
|
|
1666
1711
|
function BindingRestProperty(state) {
|
|
1667
1712
|
if (state.verbose)
|
|
1668
1713
|
console.log("ENTER:", "BindingRestProperty");
|
|
@@ -1710,7 +1755,7 @@ var Civet = (() => {
|
|
|
1710
1755
|
return BindingElement$0(state);
|
|
1711
1756
|
}
|
|
1712
1757
|
}
|
|
1713
|
-
var BindingRestElement$0 = $S(
|
|
1758
|
+
var BindingRestElement$0 = $S(DotDotDot, __, $C(BindingIdentifier, BindingPattern));
|
|
1714
1759
|
function BindingRestElement(state) {
|
|
1715
1760
|
if (state.verbose)
|
|
1716
1761
|
console.log("ENTER:", "BindingRestElement");
|
|
@@ -1730,17 +1775,35 @@ var Civet = (() => {
|
|
|
1730
1775
|
return FunctionDeclaration$0(state);
|
|
1731
1776
|
}
|
|
1732
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
|
+
}
|
|
1733
1788
|
var FunctionExpression$0 = ThinArrowFunction;
|
|
1734
|
-
var FunctionExpression$1 = $TS($S(
|
|
1735
|
-
var
|
|
1736
|
-
|
|
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];
|
|
1737
1799
|
const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
|
|
1738
|
-
if (module.implicitReturns && !isVoid) {
|
|
1800
|
+
if (module.config.implicitReturns && !isVoid) {
|
|
1739
1801
|
module.addImplicitReturns(block);
|
|
1740
1802
|
}
|
|
1803
|
+
$1.push(block);
|
|
1741
1804
|
return {
|
|
1742
1805
|
type: "FunctionExpression",
|
|
1743
|
-
children: $
|
|
1806
|
+
children: $1
|
|
1744
1807
|
};
|
|
1745
1808
|
});
|
|
1746
1809
|
function FunctionExpression(state) {
|
|
@@ -1756,7 +1819,7 @@ var Civet = (() => {
|
|
|
1756
1819
|
var arrow = $4;
|
|
1757
1820
|
var block = $5;
|
|
1758
1821
|
const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
|
|
1759
|
-
if (module.implicitReturns && !isVoid) {
|
|
1822
|
+
if (module.config.implicitReturns && !isVoid) {
|
|
1760
1823
|
block = module.addImplicitReturns(block);
|
|
1761
1824
|
}
|
|
1762
1825
|
return {
|
|
@@ -1778,7 +1841,7 @@ var Civet = (() => {
|
|
|
1778
1841
|
return ThinArrowFunction$0(state);
|
|
1779
1842
|
}
|
|
1780
1843
|
}
|
|
1781
|
-
var Arrow$0 = $TV($EXPECT($
|
|
1844
|
+
var Arrow$0 = $TV($EXPECT($L17, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
1782
1845
|
return { $loc, token: $1 };
|
|
1783
1846
|
});
|
|
1784
1847
|
function Arrow(state) {
|
|
@@ -1902,7 +1965,7 @@ var Civet = (() => {
|
|
|
1902
1965
|
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
|
|
1903
1966
|
}
|
|
1904
1967
|
}
|
|
1905
|
-
var NullLiteral$0 = $TV($EXPECT($
|
|
1968
|
+
var NullLiteral$0 = $TV($EXPECT($L18, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
1906
1969
|
return { $loc, token: $1 };
|
|
1907
1970
|
});
|
|
1908
1971
|
function NullLiteral(state) {
|
|
@@ -1914,19 +1977,31 @@ var Civet = (() => {
|
|
|
1914
1977
|
return NullLiteral$0(state);
|
|
1915
1978
|
}
|
|
1916
1979
|
}
|
|
1917
|
-
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) {
|
|
1918
1982
|
return { $loc, token: $1 };
|
|
1919
1983
|
});
|
|
1920
1984
|
function BooleanLiteral(state) {
|
|
1921
|
-
if (state.verbose)
|
|
1922
|
-
console.log("ENTER:", "BooleanLiteral");
|
|
1923
1985
|
if (state.tokenize) {
|
|
1924
|
-
return $TOKEN("BooleanLiteral", state, BooleanLiteral$0(state));
|
|
1986
|
+
return $TOKEN("BooleanLiteral", state, BooleanLiteral$0(state) || BooleanLiteral$1(state));
|
|
1925
1987
|
} else {
|
|
1926
|
-
return BooleanLiteral$0(state);
|
|
1988
|
+
return BooleanLiteral$0(state) || BooleanLiteral$1(state);
|
|
1927
1989
|
}
|
|
1928
1990
|
}
|
|
1929
|
-
var
|
|
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));
|
|
2000
|
+
} else {
|
|
2001
|
+
return CoffeeScriptBooleanLiteral$0(state) || CoffeeScriptBooleanLiteral$1(state);
|
|
2002
|
+
}
|
|
2003
|
+
}
|
|
2004
|
+
var Comma$0 = $TV($EXPECT($L25, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
1930
2005
|
return { $loc, token: $1 };
|
|
1931
2006
|
});
|
|
1932
2007
|
function Comma(state) {
|
|
@@ -1952,6 +2027,7 @@ var Civet = (() => {
|
|
|
1952
2027
|
}
|
|
1953
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) {
|
|
1954
2029
|
return {
|
|
2030
|
+
type: "Identifier",
|
|
1955
2031
|
$loc,
|
|
1956
2032
|
token: $0
|
|
1957
2033
|
};
|
|
@@ -2010,7 +2086,7 @@ var Civet = (() => {
|
|
|
2010
2086
|
}
|
|
2011
2087
|
}
|
|
2012
2088
|
var ArrayElementDelimiter$0 = $S($Q(_), Comma);
|
|
2013
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2089
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
|
|
2014
2090
|
var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2015
2091
|
return { $loc, token: "," };
|
|
2016
2092
|
});
|
|
@@ -2041,7 +2117,7 @@ var Civet = (() => {
|
|
|
2041
2117
|
return InlineElementList$0(state);
|
|
2042
2118
|
}
|
|
2043
2119
|
}
|
|
2044
|
-
var ArrayElementExpression$0 = $E($S($E($S(
|
|
2120
|
+
var ArrayElementExpression$0 = $E($S($E($S(DotDotDot, __)), AssignmentExpression));
|
|
2045
2121
|
function ArrayElementExpression(state) {
|
|
2046
2122
|
if (state.verbose)
|
|
2047
2123
|
console.log("ENTER:", "ArrayElementExpression");
|
|
@@ -2108,7 +2184,7 @@ var Civet = (() => {
|
|
|
2108
2184
|
}
|
|
2109
2185
|
}
|
|
2110
2186
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
2111
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2187
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L27, fail, 'ObjectPropertyDelimiter "}"')));
|
|
2112
2188
|
var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2113
2189
|
return { $loc, token: "," };
|
|
2114
2190
|
});
|
|
@@ -2131,7 +2207,7 @@ var Civet = (() => {
|
|
|
2131
2207
|
}
|
|
2132
2208
|
var PropertyDefinition$0 = $S(PropertyName, __, Colon, AssignmentExpression);
|
|
2133
2209
|
var PropertyDefinition$1 = MethodDefinition;
|
|
2134
|
-
var PropertyDefinition$2 = $S(
|
|
2210
|
+
var PropertyDefinition$2 = $S(DotDotDot, AssignmentExpression);
|
|
2135
2211
|
var PropertyDefinition$3 = IdentifierReference;
|
|
2136
2212
|
function PropertyDefinition(state) {
|
|
2137
2213
|
if (state.tokenize) {
|
|
@@ -2143,7 +2219,7 @@ var Civet = (() => {
|
|
|
2143
2219
|
var PropertyName$0 = NumericLiteral;
|
|
2144
2220
|
var PropertyName$1 = StringLiteral;
|
|
2145
2221
|
var PropertyName$2 = IdentifierName;
|
|
2146
|
-
var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($
|
|
2222
|
+
var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L26, fail, 'PropertyName "]"'));
|
|
2147
2223
|
function PropertyName(state) {
|
|
2148
2224
|
if (state.tokenize) {
|
|
2149
2225
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -2157,7 +2233,7 @@ var Civet = (() => {
|
|
|
2157
2233
|
const isConstructor = sig.name === "constructor";
|
|
2158
2234
|
const isVoid = sig.returnType === "void";
|
|
2159
2235
|
const isSet = sig.modifier === "set";
|
|
2160
|
-
if (module.implicitReturns && !isConstructor && !isSet && !isVoid) {
|
|
2236
|
+
if (module.config.implicitReturns && !isConstructor && !isSet && !isVoid) {
|
|
2161
2237
|
block = module.addImplicitReturns(block);
|
|
2162
2238
|
}
|
|
2163
2239
|
return $0;
|
|
@@ -2245,25 +2321,25 @@ var Civet = (() => {
|
|
|
2245
2321
|
return AssignmentOp$0(state);
|
|
2246
2322
|
}
|
|
2247
2323
|
}
|
|
2248
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
2249
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
2250
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
2251
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
2252
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
2253
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
2254
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
2255
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
2256
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
2257
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
2258
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
2259
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
2260
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
2261
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
2262
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
2263
|
-
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) {
|
|
2264
2340
|
return "??=";
|
|
2265
2341
|
});
|
|
2266
|
-
var AssignmentOpSymbol$16 = $EXPECT($
|
|
2342
|
+
var AssignmentOpSymbol$16 = $EXPECT($L44, fail, 'AssignmentOpSymbol "="');
|
|
2267
2343
|
function AssignmentOpSymbol(state) {
|
|
2268
2344
|
if (state.tokenize) {
|
|
2269
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));
|
|
@@ -2283,52 +2359,52 @@ var Civet = (() => {
|
|
|
2283
2359
|
return BinaryOp$0(state);
|
|
2284
2360
|
}
|
|
2285
2361
|
}
|
|
2286
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
2287
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
2288
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
2289
|
-
var BinaryOpSymbol$3 = $EXPECT($
|
|
2290
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
2291
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
2292
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
2293
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
2294
|
-
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 "<<"');
|
|
2295
2371
|
var BinaryOpSymbol$9 = $EXPECT($L5, fail, 'BinaryOpSymbol "<"');
|
|
2296
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
2297
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
2298
|
-
var BinaryOpSymbol$12 = $EXPECT($
|
|
2299
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
2300
|
-
var BinaryOpSymbol$14 = $TV($EXPECT($
|
|
2301
|
-
if (module.
|
|
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) {
|
|
2377
|
+
if (module.config.coffeeEq)
|
|
2302
2378
|
return "!==";
|
|
2303
2379
|
return $1;
|
|
2304
2380
|
});
|
|
2305
|
-
var BinaryOpSymbol$15 = $T($S($EXPECT($
|
|
2381
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L59, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
2306
2382
|
return "===";
|
|
2307
2383
|
});
|
|
2308
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
2309
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
2310
|
-
if (module.
|
|
2384
|
+
var BinaryOpSymbol$16 = $EXPECT($L60, fail, 'BinaryOpSymbol "==="');
|
|
2385
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
2386
|
+
if (module.config.coffeeEq)
|
|
2311
2387
|
return "===";
|
|
2312
2388
|
return $1;
|
|
2313
2389
|
});
|
|
2314
|
-
var BinaryOpSymbol$18 = $T($S($EXPECT($
|
|
2390
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
2315
2391
|
return "&&";
|
|
2316
2392
|
});
|
|
2317
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
2318
|
-
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) {
|
|
2319
2395
|
return "||";
|
|
2320
2396
|
});
|
|
2321
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
2322
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
2323
|
-
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) {
|
|
2324
2400
|
return $1;
|
|
2325
2401
|
});
|
|
2326
|
-
var BinaryOpSymbol$24 = $TS($S($EXPECT($
|
|
2402
|
+
var BinaryOpSymbol$24 = $TS($S($EXPECT($L68, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2327
2403
|
return $1;
|
|
2328
2404
|
});
|
|
2329
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
2330
|
-
var BinaryOpSymbol$26 = $EXPECT($
|
|
2331
|
-
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 "|"');
|
|
2332
2408
|
function BinaryOpSymbol(state) {
|
|
2333
2409
|
if (state.tokenize) {
|
|
2334
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));
|
|
@@ -2337,7 +2413,7 @@ var Civet = (() => {
|
|
|
2337
2413
|
}
|
|
2338
2414
|
}
|
|
2339
2415
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
2340
|
-
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, __);
|
|
2341
2417
|
function UnaryOp(state) {
|
|
2342
2418
|
if (state.tokenize) {
|
|
2343
2419
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -2416,7 +2492,7 @@ var Civet = (() => {
|
|
|
2416
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);
|
|
2417
2493
|
}
|
|
2418
2494
|
}
|
|
2419
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
2495
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L75, fail, 'EmptyStatement ";"'))), function(value) {
|
|
2420
2496
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
2421
2497
|
});
|
|
2422
2498
|
function EmptyStatement(state) {
|
|
@@ -2428,7 +2504,10 @@ var Civet = (() => {
|
|
|
2428
2504
|
return EmptyStatement$0(state);
|
|
2429
2505
|
}
|
|
2430
2506
|
}
|
|
2431
|
-
var BlockStatement$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace)
|
|
2507
|
+
var BlockStatement$0 = $T($S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace), function(value) {
|
|
2508
|
+
var exps = value[3];
|
|
2509
|
+
return { "type": "BlockStatement", "children": value, "expressions": exps };
|
|
2510
|
+
});
|
|
2432
2511
|
function BlockStatement(state) {
|
|
2433
2512
|
if (state.verbose)
|
|
2434
2513
|
console.log("ENTER:", "BlockStatement");
|
|
@@ -2494,7 +2573,7 @@ var Civet = (() => {
|
|
|
2494
2573
|
return LoopStatement$0(state);
|
|
2495
2574
|
}
|
|
2496
2575
|
}
|
|
2497
|
-
var DoWhileStatement$0 = $T($S($EXPECT($
|
|
2576
|
+
var DoWhileStatement$0 = $T($S($EXPECT($L76, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause), function(value) {
|
|
2498
2577
|
return { "type": "IterationStatement", "children": value };
|
|
2499
2578
|
});
|
|
2500
2579
|
function DoWhileStatement(state) {
|
|
@@ -2518,7 +2597,7 @@ var Civet = (() => {
|
|
|
2518
2597
|
return WhileStatement$0(state);
|
|
2519
2598
|
}
|
|
2520
2599
|
}
|
|
2521
|
-
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) {
|
|
2522
2601
|
var kind = $1;
|
|
2523
2602
|
var cond = $3;
|
|
2524
2603
|
if (kind === "until") {
|
|
@@ -2756,7 +2835,7 @@ var Civet = (() => {
|
|
|
2756
2835
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2757
2836
|
}
|
|
2758
2837
|
}
|
|
2759
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2838
|
+
var Finally$0 = $S(__, $EXPECT($L79, fail, 'Finally "finally"'), BracedBlock);
|
|
2760
2839
|
function Finally(state) {
|
|
2761
2840
|
if (state.verbose)
|
|
2762
2841
|
console.log("ENTER:", "Finally");
|
|
@@ -2822,13 +2901,13 @@ var Civet = (() => {
|
|
|
2822
2901
|
return ExpressionStatement$0(state);
|
|
2823
2902
|
}
|
|
2824
2903
|
}
|
|
2825
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
2904
|
+
var KeywordStatement$0 = $T($S($EXPECT($L80, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
2826
2905
|
return { "type": "BreakStatement", "children": value };
|
|
2827
2906
|
});
|
|
2828
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
2907
|
+
var KeywordStatement$1 = $T($S($EXPECT($L81, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
2829
2908
|
return { "type": "ContinueStatement", "children": value };
|
|
2830
2909
|
});
|
|
2831
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
2910
|
+
var KeywordStatement$2 = $T($S($EXPECT($L82, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
2832
2911
|
return { "type": "DebuggerStatement", "children": value };
|
|
2833
2912
|
});
|
|
2834
2913
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -2853,7 +2932,7 @@ var Civet = (() => {
|
|
|
2853
2932
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2854
2933
|
}
|
|
2855
2934
|
}
|
|
2856
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2935
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L83, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2857
2936
|
return { "ts": true, "children": value };
|
|
2858
2937
|
});
|
|
2859
2938
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
@@ -2991,7 +3070,7 @@ var Civet = (() => {
|
|
|
2991
3070
|
return ImportedBinding$0(state);
|
|
2992
3071
|
}
|
|
2993
3072
|
}
|
|
2994
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
3073
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L84, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2995
3074
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
2996
3075
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
2997
3076
|
function ExportDeclaration(state) {
|
|
@@ -3073,7 +3152,7 @@ var Civet = (() => {
|
|
|
3073
3152
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
3074
3153
|
}
|
|
3075
3154
|
}
|
|
3076
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
3155
|
+
var ConstAssignment$0 = $TV($EXPECT($L85, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
3077
3156
|
return { $loc, token: "=" };
|
|
3078
3157
|
});
|
|
3079
3158
|
function ConstAssignment(state) {
|
|
@@ -3169,17 +3248,29 @@ var Civet = (() => {
|
|
|
3169
3248
|
return DecimalBigIntegerLiteral$0(state);
|
|
3170
3249
|
}
|
|
3171
3250
|
}
|
|
3172
|
-
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)));
|
|
3173
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) {
|
|
3174
3265
|
if (state.verbose)
|
|
3175
|
-
console.log("ENTER:", "
|
|
3266
|
+
console.log("ENTER:", "ExponentPart");
|
|
3176
3267
|
if (state.tokenize) {
|
|
3177
|
-
return $TOKEN("
|
|
3268
|
+
return $TOKEN("ExponentPart", state, ExponentPart$0(state));
|
|
3178
3269
|
} else {
|
|
3179
|
-
return
|
|
3270
|
+
return ExponentPart$0(state);
|
|
3180
3271
|
}
|
|
3181
3272
|
}
|
|
3182
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
3273
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R9, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
3183
3274
|
function BinaryIntegerLiteral(state) {
|
|
3184
3275
|
if (state.verbose)
|
|
3185
3276
|
console.log("ENTER:", "BinaryIntegerLiteral");
|
|
@@ -3189,7 +3280,7 @@ var Civet = (() => {
|
|
|
3189
3280
|
return BinaryIntegerLiteral$0(state);
|
|
3190
3281
|
}
|
|
3191
3282
|
}
|
|
3192
|
-
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?/"));
|
|
3193
3284
|
function OctalIntegerLiteral(state) {
|
|
3194
3285
|
if (state.verbose)
|
|
3195
3286
|
console.log("ENTER:", "OctalIntegerLiteral");
|
|
@@ -3199,7 +3290,7 @@ var Civet = (() => {
|
|
|
3199
3290
|
return OctalIntegerLiteral$0(state);
|
|
3200
3291
|
}
|
|
3201
3292
|
}
|
|
3202
|
-
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?/"));
|
|
3203
3294
|
function HexLiteral(state) {
|
|
3204
3295
|
if (state.verbose)
|
|
3205
3296
|
console.log("ENTER:", "HexLiteral");
|
|
@@ -3218,7 +3309,7 @@ var Civet = (() => {
|
|
|
3218
3309
|
var e = $3;
|
|
3219
3310
|
return [s, module.dedentBlockString(str), e];
|
|
3220
3311
|
});
|
|
3221
|
-
var StringLiteral$2 =
|
|
3312
|
+
var StringLiteral$2 = CoffeeInterpolatedDoubleQuotedString;
|
|
3222
3313
|
var StringLiteral$3 = BasicStringLiteral;
|
|
3223
3314
|
function StringLiteral(state) {
|
|
3224
3315
|
if (state.tokenize) {
|
|
@@ -3248,7 +3339,7 @@ var Civet = (() => {
|
|
|
3248
3339
|
return BasicStringLiteral$0(state) || BasicStringLiteral$1(state);
|
|
3249
3340
|
}
|
|
3250
3341
|
}
|
|
3251
|
-
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) {
|
|
3252
3343
|
return { $loc, token: $0 };
|
|
3253
3344
|
});
|
|
3254
3345
|
function DoubleStringCharacters(state) {
|
|
@@ -3260,7 +3351,7 @@ var Civet = (() => {
|
|
|
3260
3351
|
return DoubleStringCharacters$0(state);
|
|
3261
3352
|
}
|
|
3262
3353
|
}
|
|
3263
|
-
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) {
|
|
3264
3355
|
return { $loc, token: $0 };
|
|
3265
3356
|
});
|
|
3266
3357
|
function SingleStringCharacters(state) {
|
|
@@ -3272,7 +3363,7 @@ var Civet = (() => {
|
|
|
3272
3363
|
return SingleStringCharacters$0(state);
|
|
3273
3364
|
}
|
|
3274
3365
|
}
|
|
3275
|
-
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) {
|
|
3276
3367
|
return { $loc, token: $0 };
|
|
3277
3368
|
});
|
|
3278
3369
|
function TripleDoubleStringCharacters(state) {
|
|
@@ -3284,7 +3375,7 @@ var Civet = (() => {
|
|
|
3284
3375
|
return TripleDoubleStringCharacters$0(state);
|
|
3285
3376
|
}
|
|
3286
3377
|
}
|
|
3287
|
-
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) {
|
|
3288
3379
|
return { $loc, token: $0 };
|
|
3289
3380
|
});
|
|
3290
3381
|
function TripleSingleStringCharacters(state) {
|
|
@@ -3306,21 +3397,7 @@ var Civet = (() => {
|
|
|
3306
3397
|
return CoffeeStringSubstitution$0(state);
|
|
3307
3398
|
}
|
|
3308
3399
|
}
|
|
3309
|
-
var
|
|
3310
|
-
if (module.coffeeCompat)
|
|
3311
|
-
return;
|
|
3312
|
-
return $skip;
|
|
3313
|
-
});
|
|
3314
|
-
function CoffeeCompat(state) {
|
|
3315
|
-
if (state.verbose)
|
|
3316
|
-
console.log("ENTER:", "CoffeeCompat");
|
|
3317
|
-
if (state.tokenize) {
|
|
3318
|
-
return $TOKEN("CoffeeCompat", state, CoffeeCompat$0(state));
|
|
3319
|
-
} else {
|
|
3320
|
-
return CoffeeCompat$0(state);
|
|
3321
|
-
}
|
|
3322
|
-
}
|
|
3323
|
-
var CoffeeCompatDoubleQuotedString$0 = $TS($S(CoffeeCompat, DoubleQuote, $Q($C(CoffeeCompatDoubleQuotedStringCharacters, CoffeeStringSubstitution)), DoubleQuote), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
3400
|
+
var CoffeeInterpolatedDoubleQuotedString$0 = $TS($S(CoffeeInterpolationEnabled, DoubleQuote, $Q($C(CoffeeDoubleQuotedStringCharacters, CoffeeStringSubstitution)), DoubleQuote), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
3324
3401
|
var s = $2;
|
|
3325
3402
|
var parts = $3;
|
|
3326
3403
|
var e = $4;
|
|
@@ -3340,28 +3417,28 @@ var Civet = (() => {
|
|
|
3340
3417
|
s.token = e.token = "`";
|
|
3341
3418
|
return [s, parts, e];
|
|
3342
3419
|
});
|
|
3343
|
-
function
|
|
3420
|
+
function CoffeeInterpolatedDoubleQuotedString(state) {
|
|
3344
3421
|
if (state.verbose)
|
|
3345
|
-
console.log("ENTER:", "
|
|
3422
|
+
console.log("ENTER:", "CoffeeInterpolatedDoubleQuotedString");
|
|
3346
3423
|
if (state.tokenize) {
|
|
3347
|
-
return $TOKEN("
|
|
3424
|
+
return $TOKEN("CoffeeInterpolatedDoubleQuotedString", state, CoffeeInterpolatedDoubleQuotedString$0(state));
|
|
3348
3425
|
} else {
|
|
3349
|
-
return
|
|
3426
|
+
return CoffeeInterpolatedDoubleQuotedString$0(state);
|
|
3350
3427
|
}
|
|
3351
3428
|
}
|
|
3352
|
-
var
|
|
3429
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R16, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3353
3430
|
return { $loc, token: $0 };
|
|
3354
3431
|
});
|
|
3355
|
-
function
|
|
3432
|
+
function CoffeeDoubleQuotedStringCharacters(state) {
|
|
3356
3433
|
if (state.verbose)
|
|
3357
|
-
console.log("ENTER:", "
|
|
3434
|
+
console.log("ENTER:", "CoffeeDoubleQuotedStringCharacters");
|
|
3358
3435
|
if (state.tokenize) {
|
|
3359
|
-
return $TOKEN("
|
|
3436
|
+
return $TOKEN("CoffeeDoubleQuotedStringCharacters", state, CoffeeDoubleQuotedStringCharacters$0(state));
|
|
3360
3437
|
} else {
|
|
3361
|
-
return
|
|
3438
|
+
return CoffeeDoubleQuotedStringCharacters$0(state);
|
|
3362
3439
|
}
|
|
3363
3440
|
}
|
|
3364
|
-
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) {
|
|
3365
3442
|
return { $loc, token: $1 };
|
|
3366
3443
|
});
|
|
3367
3444
|
function RegularExpressionLiteral(state) {
|
|
@@ -3373,7 +3450,7 @@ var Civet = (() => {
|
|
|
3373
3450
|
return RegularExpressionLiteral$0(state);
|
|
3374
3451
|
}
|
|
3375
3452
|
}
|
|
3376
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
3453
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R17, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
|
|
3377
3454
|
function RegularExpressionBody(state) {
|
|
3378
3455
|
if (state.verbose)
|
|
3379
3456
|
console.log("ENTER:", "RegularExpressionBody");
|
|
@@ -3383,7 +3460,7 @@ var Civet = (() => {
|
|
|
3383
3460
|
return RegularExpressionBody$0(state);
|
|
3384
3461
|
}
|
|
3385
3462
|
}
|
|
3386
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
3463
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R18, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
3387
3464
|
function RegExpCharacter(state) {
|
|
3388
3465
|
if (state.verbose)
|
|
3389
3466
|
console.log("ENTER:", "RegExpCharacter");
|
|
@@ -3393,7 +3470,7 @@ var Civet = (() => {
|
|
|
3393
3470
|
return RegExpCharacter$0(state);
|
|
3394
3471
|
}
|
|
3395
3472
|
}
|
|
3396
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
3473
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R19, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
3397
3474
|
function RegularExpressionFlags(state) {
|
|
3398
3475
|
if (state.verbose)
|
|
3399
3476
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -3424,7 +3501,7 @@ var Civet = (() => {
|
|
|
3424
3501
|
return TemplateSubstitution$0(state);
|
|
3425
3502
|
}
|
|
3426
3503
|
}
|
|
3427
|
-
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) {
|
|
3428
3505
|
return { $loc, token: $0 };
|
|
3429
3506
|
});
|
|
3430
3507
|
function TemplateCharacters(state) {
|
|
@@ -3436,7 +3513,7 @@ var Civet = (() => {
|
|
|
3436
3513
|
return TemplateCharacters$0(state);
|
|
3437
3514
|
}
|
|
3438
3515
|
}
|
|
3439
|
-
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) {
|
|
3440
3517
|
return { $loc, token: $0 };
|
|
3441
3518
|
});
|
|
3442
3519
|
function TemplateBlockCharacters(state) {
|
|
@@ -3448,14 +3525,13 @@ var Civet = (() => {
|
|
|
3448
3525
|
return TemplateBlockCharacters$0(state);
|
|
3449
3526
|
}
|
|
3450
3527
|
}
|
|
3451
|
-
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})/"));
|
|
3452
3530
|
function ReservedWord(state) {
|
|
3453
|
-
if (state.verbose)
|
|
3454
|
-
console.log("ENTER:", "ReservedWord");
|
|
3455
3531
|
if (state.tokenize) {
|
|
3456
|
-
return $TOKEN("ReservedWord", state, ReservedWord$0(state));
|
|
3532
|
+
return $TOKEN("ReservedWord", state, ReservedWord$0(state) || ReservedWord$1(state));
|
|
3457
3533
|
} else {
|
|
3458
|
-
return ReservedWord$0(state);
|
|
3534
|
+
return ReservedWord$0(state) || ReservedWord$1(state);
|
|
3459
3535
|
}
|
|
3460
3536
|
}
|
|
3461
3537
|
var Comment$0 = MultiLineComment;
|
|
@@ -3467,10 +3543,10 @@ var Civet = (() => {
|
|
|
3467
3543
|
return Comment$0(state) || Comment$1(state);
|
|
3468
3544
|
}
|
|
3469
3545
|
}
|
|
3470
|
-
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) {
|
|
3471
3547
|
return { $loc, token: $0 };
|
|
3472
3548
|
});
|
|
3473
|
-
var SingleLineComment$1 = $S(
|
|
3549
|
+
var SingleLineComment$1 = $S(CoffeeCommentEnabled, CoffeeSingleLineComment);
|
|
3474
3550
|
function SingleLineComment(state) {
|
|
3475
3551
|
if (state.tokenize) {
|
|
3476
3552
|
return $TOKEN("SingleLineComment", state, SingleLineComment$0(state) || SingleLineComment$1(state));
|
|
@@ -3487,7 +3563,7 @@ var Civet = (() => {
|
|
|
3487
3563
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
3488
3564
|
}
|
|
3489
3565
|
}
|
|
3490
|
-
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) {
|
|
3491
3567
|
return { $loc, token: $1 };
|
|
3492
3568
|
});
|
|
3493
3569
|
function JSMultiLineComment(state) {
|
|
@@ -3499,7 +3575,7 @@ var Civet = (() => {
|
|
|
3499
3575
|
return JSMultiLineComment$0(state);
|
|
3500
3576
|
}
|
|
3501
3577
|
}
|
|
3502
|
-
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) {
|
|
3503
3579
|
return { $loc, token: `//${$1}` };
|
|
3504
3580
|
});
|
|
3505
3581
|
function CoffeeSingleLineComment(state) {
|
|
@@ -3511,7 +3587,7 @@ var Civet = (() => {
|
|
|
3511
3587
|
return CoffeeSingleLineComment$0(state);
|
|
3512
3588
|
}
|
|
3513
3589
|
}
|
|
3514
|
-
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) {
|
|
3515
3591
|
return { $loc, token: `/*${$2}*/` };
|
|
3516
3592
|
});
|
|
3517
3593
|
function CoffeeMultiLineComment(state) {
|
|
@@ -3523,7 +3599,7 @@ var Civet = (() => {
|
|
|
3523
3599
|
return CoffeeMultiLineComment$0(state);
|
|
3524
3600
|
}
|
|
3525
3601
|
}
|
|
3526
|
-
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) {
|
|
3527
3603
|
return { $loc, token: $1 };
|
|
3528
3604
|
});
|
|
3529
3605
|
function InlineComment(state) {
|
|
@@ -3565,7 +3641,7 @@ var Civet = (() => {
|
|
|
3565
3641
|
return _$0(state);
|
|
3566
3642
|
}
|
|
3567
3643
|
}
|
|
3568
|
-
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) {
|
|
3569
3645
|
return { $loc, token: $0 };
|
|
3570
3646
|
});
|
|
3571
3647
|
function NonNewlineWhitespace(state) {
|
|
@@ -3587,7 +3663,7 @@ var Civet = (() => {
|
|
|
3587
3663
|
return __$0(state);
|
|
3588
3664
|
}
|
|
3589
3665
|
}
|
|
3590
|
-
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) {
|
|
3591
3667
|
return { $loc, token: $0 };
|
|
3592
3668
|
});
|
|
3593
3669
|
function Whitespace(state) {
|
|
@@ -3610,7 +3686,7 @@ var Civet = (() => {
|
|
|
3610
3686
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
3611
3687
|
}
|
|
3612
3688
|
}
|
|
3613
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3689
|
+
var NonIdContinue$0 = $R$0($EXPECT($R30, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
3614
3690
|
function NonIdContinue(state) {
|
|
3615
3691
|
if (state.verbose)
|
|
3616
3692
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -3632,7 +3708,7 @@ var Civet = (() => {
|
|
|
3632
3708
|
return Loc$0(state);
|
|
3633
3709
|
}
|
|
3634
3710
|
}
|
|
3635
|
-
var As$0 = $TS($S($EXPECT($
|
|
3711
|
+
var As$0 = $TS($S($EXPECT($L89, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3636
3712
|
return { $loc, token: $1 };
|
|
3637
3713
|
});
|
|
3638
3714
|
function As(state) {
|
|
@@ -3644,7 +3720,7 @@ var Civet = (() => {
|
|
|
3644
3720
|
return As$0(state);
|
|
3645
3721
|
}
|
|
3646
3722
|
}
|
|
3647
|
-
var Async$0 = $TV($EXPECT($
|
|
3723
|
+
var Async$0 = $TV($EXPECT($L90, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
|
|
3648
3724
|
return { $loc, token: $1 };
|
|
3649
3725
|
});
|
|
3650
3726
|
function Async(state) {
|
|
@@ -3656,7 +3732,7 @@ var Civet = (() => {
|
|
|
3656
3732
|
return Async$0(state);
|
|
3657
3733
|
}
|
|
3658
3734
|
}
|
|
3659
|
-
var Await$0 = $TS($S($EXPECT($
|
|
3735
|
+
var Await$0 = $TS($S($EXPECT($L91, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3660
3736
|
return { $loc, token: $1 };
|
|
3661
3737
|
});
|
|
3662
3738
|
function Await(state) {
|
|
@@ -3668,7 +3744,7 @@ var Civet = (() => {
|
|
|
3668
3744
|
return Await$0(state);
|
|
3669
3745
|
}
|
|
3670
3746
|
}
|
|
3671
|
-
var Case$0 = $TS($S($EXPECT($
|
|
3747
|
+
var Case$0 = $TS($S($EXPECT($L92, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3672
3748
|
return { $loc, token: $1 };
|
|
3673
3749
|
});
|
|
3674
3750
|
function Case(state) {
|
|
@@ -3680,7 +3756,7 @@ var Civet = (() => {
|
|
|
3680
3756
|
return Case$0(state);
|
|
3681
3757
|
}
|
|
3682
3758
|
}
|
|
3683
|
-
var Catch$0 = $TV($EXPECT($
|
|
3759
|
+
var Catch$0 = $TV($EXPECT($L93, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
3684
3760
|
return { $loc, token: $1 };
|
|
3685
3761
|
});
|
|
3686
3762
|
function Catch(state) {
|
|
@@ -3692,7 +3768,7 @@ var Civet = (() => {
|
|
|
3692
3768
|
return Catch$0(state);
|
|
3693
3769
|
}
|
|
3694
3770
|
}
|
|
3695
|
-
var Class$0 = $TV($EXPECT($
|
|
3771
|
+
var Class$0 = $TV($EXPECT($L94, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
3696
3772
|
return { $loc, token: $1 };
|
|
3697
3773
|
});
|
|
3698
3774
|
function Class(state) {
|
|
@@ -3704,7 +3780,7 @@ var Civet = (() => {
|
|
|
3704
3780
|
return Class$0(state);
|
|
3705
3781
|
}
|
|
3706
3782
|
}
|
|
3707
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
3783
|
+
var CloseBrace$0 = $TV($EXPECT($L27, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
3708
3784
|
return { $loc, token: $1 };
|
|
3709
3785
|
});
|
|
3710
3786
|
function CloseBrace(state) {
|
|
@@ -3716,7 +3792,7 @@ var Civet = (() => {
|
|
|
3716
3792
|
return CloseBrace$0(state);
|
|
3717
3793
|
}
|
|
3718
3794
|
}
|
|
3719
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
3795
|
+
var CloseBracket$0 = $TV($EXPECT($L26, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
3720
3796
|
return { $loc, token: $1 };
|
|
3721
3797
|
});
|
|
3722
3798
|
function CloseBracket(state) {
|
|
@@ -3740,7 +3816,7 @@ var Civet = (() => {
|
|
|
3740
3816
|
return CloseParen$0(state);
|
|
3741
3817
|
}
|
|
3742
3818
|
}
|
|
3743
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
3819
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L95, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
3744
3820
|
return { $loc, token: "${" };
|
|
3745
3821
|
});
|
|
3746
3822
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -3752,7 +3828,7 @@ var Civet = (() => {
|
|
|
3752
3828
|
return CoffeeSubstitutionStart$0(state);
|
|
3753
3829
|
}
|
|
3754
3830
|
}
|
|
3755
|
-
var Colon$0 = $TV($EXPECT($
|
|
3831
|
+
var Colon$0 = $TV($EXPECT($L96, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
3756
3832
|
return { $loc, token: $1 };
|
|
3757
3833
|
});
|
|
3758
3834
|
function Colon(state) {
|
|
@@ -3776,7 +3852,7 @@ var Civet = (() => {
|
|
|
3776
3852
|
return ConstructorShorthand$0(state);
|
|
3777
3853
|
}
|
|
3778
3854
|
}
|
|
3779
|
-
var Default$0 = $TS($S($EXPECT($
|
|
3855
|
+
var Default$0 = $TS($S($EXPECT($L84, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3780
3856
|
return { $loc, token: $1 };
|
|
3781
3857
|
});
|
|
3782
3858
|
function Default(state) {
|
|
@@ -3788,7 +3864,7 @@ var Civet = (() => {
|
|
|
3788
3864
|
return Default$0(state);
|
|
3789
3865
|
}
|
|
3790
3866
|
}
|
|
3791
|
-
var Dot$0 = $TV($EXPECT($
|
|
3867
|
+
var Dot$0 = $TV($EXPECT($L97, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
3792
3868
|
return { $loc, token: $1 };
|
|
3793
3869
|
});
|
|
3794
3870
|
function Dot(state) {
|
|
@@ -3800,7 +3876,19 @@ var Civet = (() => {
|
|
|
3800
3876
|
return Dot$0(state);
|
|
3801
3877
|
}
|
|
3802
3878
|
}
|
|
3803
|
-
var
|
|
3879
|
+
var DotDotDot$0 = $TV($EXPECT($L98, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
3880
|
+
return { $loc, token: $1 };
|
|
3881
|
+
});
|
|
3882
|
+
function DotDotDot(state) {
|
|
3883
|
+
if (state.verbose)
|
|
3884
|
+
console.log("ENTER:", "DotDotDot");
|
|
3885
|
+
if (state.tokenize) {
|
|
3886
|
+
return $TOKEN("DotDotDot", state, DotDotDot$0(state));
|
|
3887
|
+
} else {
|
|
3888
|
+
return DotDotDot$0(state);
|
|
3889
|
+
}
|
|
3890
|
+
}
|
|
3891
|
+
var DoubleQuote$0 = $TV($EXPECT($L99, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
3804
3892
|
return { $loc, token: $1 };
|
|
3805
3893
|
});
|
|
3806
3894
|
function DoubleQuote(state) {
|
|
@@ -3812,7 +3900,7 @@ var Civet = (() => {
|
|
|
3812
3900
|
return DoubleQuote$0(state);
|
|
3813
3901
|
}
|
|
3814
3902
|
}
|
|
3815
|
-
var Else$0 = $TV($EXPECT($
|
|
3903
|
+
var Else$0 = $TV($EXPECT($L100, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
3816
3904
|
return { $loc, token: $1 };
|
|
3817
3905
|
});
|
|
3818
3906
|
function Else(state) {
|
|
@@ -3824,7 +3912,7 @@ var Civet = (() => {
|
|
|
3824
3912
|
return Else$0(state);
|
|
3825
3913
|
}
|
|
3826
3914
|
}
|
|
3827
|
-
var Equals$0 = $TV($EXPECT($
|
|
3915
|
+
var Equals$0 = $TV($EXPECT($L44, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
3828
3916
|
return { $loc, token: $1 };
|
|
3829
3917
|
});
|
|
3830
3918
|
function Equals(state) {
|
|
@@ -3836,7 +3924,7 @@ var Civet = (() => {
|
|
|
3836
3924
|
return Equals$0(state);
|
|
3837
3925
|
}
|
|
3838
3926
|
}
|
|
3839
|
-
var Export$0 = $TS($S($EXPECT($
|
|
3927
|
+
var Export$0 = $TS($S($EXPECT($L101, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3840
3928
|
return { $loc, token: $1 };
|
|
3841
3929
|
});
|
|
3842
3930
|
function Export(state) {
|
|
@@ -3848,7 +3936,7 @@ var Civet = (() => {
|
|
|
3848
3936
|
return Export$0(state);
|
|
3849
3937
|
}
|
|
3850
3938
|
}
|
|
3851
|
-
var For$0 = $TS($S($EXPECT($
|
|
3939
|
+
var For$0 = $TS($S($EXPECT($L102, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3852
3940
|
return { $loc, token: $1 };
|
|
3853
3941
|
});
|
|
3854
3942
|
function For(state) {
|
|
@@ -3860,7 +3948,7 @@ var Civet = (() => {
|
|
|
3860
3948
|
return For$0(state);
|
|
3861
3949
|
}
|
|
3862
3950
|
}
|
|
3863
|
-
var From$0 = $TS($S($EXPECT($
|
|
3951
|
+
var From$0 = $TS($S($EXPECT($L103, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3864
3952
|
return { $loc, token: $1 };
|
|
3865
3953
|
});
|
|
3866
3954
|
function From(state) {
|
|
@@ -3872,7 +3960,7 @@ var Civet = (() => {
|
|
|
3872
3960
|
return From$0(state);
|
|
3873
3961
|
}
|
|
3874
3962
|
}
|
|
3875
|
-
var Function$0 = $TV($EXPECT($
|
|
3963
|
+
var Function$0 = $TV($EXPECT($L104, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
3876
3964
|
return { $loc, token: $1 };
|
|
3877
3965
|
});
|
|
3878
3966
|
function Function(state) {
|
|
@@ -3884,7 +3972,7 @@ var Civet = (() => {
|
|
|
3884
3972
|
return Function$0(state);
|
|
3885
3973
|
}
|
|
3886
3974
|
}
|
|
3887
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
3975
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L105, fail, 'GetOrSet "get"'), $EXPECT($L106, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3888
3976
|
return { $loc, token: $1 };
|
|
3889
3977
|
});
|
|
3890
3978
|
function GetOrSet(state) {
|
|
@@ -3896,7 +3984,7 @@ var Civet = (() => {
|
|
|
3896
3984
|
return GetOrSet$0(state);
|
|
3897
3985
|
}
|
|
3898
3986
|
}
|
|
3899
|
-
var If$0 = $TV($EXPECT($
|
|
3987
|
+
var If$0 = $TV($EXPECT($L107, fail, 'If "if"'), function($skip, $loc, $0, $1) {
|
|
3900
3988
|
return { $loc, token: $1 };
|
|
3901
3989
|
});
|
|
3902
3990
|
function If(state) {
|
|
@@ -3908,7 +3996,7 @@ var Civet = (() => {
|
|
|
3908
3996
|
return If$0(state);
|
|
3909
3997
|
}
|
|
3910
3998
|
}
|
|
3911
|
-
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($
|
|
3999
|
+
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R31, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
3912
4000
|
return { $loc, token: $1 };
|
|
3913
4001
|
});
|
|
3914
4002
|
function Import(state) {
|
|
@@ -3920,7 +4008,7 @@ var Civet = (() => {
|
|
|
3920
4008
|
return Import$0(state);
|
|
3921
4009
|
}
|
|
3922
4010
|
}
|
|
3923
|
-
var In$0 = $TV($EXPECT($
|
|
4011
|
+
var In$0 = $TV($EXPECT($L68, fail, 'In "in"'), function($skip, $loc, $0, $1) {
|
|
3924
4012
|
return { $loc, token: $1 };
|
|
3925
4013
|
});
|
|
3926
4014
|
function In(state) {
|
|
@@ -3932,7 +4020,7 @@ var Civet = (() => {
|
|
|
3932
4020
|
return In$0(state);
|
|
3933
4021
|
}
|
|
3934
4022
|
}
|
|
3935
|
-
var LetOrConst$0 = $TV($C($EXPECT($
|
|
4023
|
+
var LetOrConst$0 = $TV($C($EXPECT($L108, fail, 'LetOrConst "let"'), $EXPECT($L109, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
3936
4024
|
return { $loc, token: $1 };
|
|
3937
4025
|
});
|
|
3938
4026
|
function LetOrConst(state) {
|
|
@@ -3944,7 +4032,7 @@ var Civet = (() => {
|
|
|
3944
4032
|
return LetOrConst$0(state);
|
|
3945
4033
|
}
|
|
3946
4034
|
}
|
|
3947
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
4035
|
+
var Loop$0 = $TS($S($EXPECT($L110, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3948
4036
|
return { $loc, token: "while(true)" };
|
|
3949
4037
|
});
|
|
3950
4038
|
function Loop(state) {
|
|
@@ -3956,7 +4044,7 @@ var Civet = (() => {
|
|
|
3956
4044
|
return Loop$0(state);
|
|
3957
4045
|
}
|
|
3958
4046
|
}
|
|
3959
|
-
var New$0 = $TV($EXPECT($
|
|
4047
|
+
var New$0 = $TV($EXPECT($L111, fail, 'New "new"'), function($skip, $loc, $0, $1) {
|
|
3960
4048
|
return { $loc, token: $1 };
|
|
3961
4049
|
});
|
|
3962
4050
|
function New(state) {
|
|
@@ -3968,7 +4056,7 @@ var Civet = (() => {
|
|
|
3968
4056
|
return New$0(state);
|
|
3969
4057
|
}
|
|
3970
4058
|
}
|
|
3971
|
-
var Of$0 = $TV($EXPECT($
|
|
4059
|
+
var Of$0 = $TV($EXPECT($L112, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
3972
4060
|
return { $loc, token: $1 };
|
|
3973
4061
|
});
|
|
3974
4062
|
function Of(state) {
|
|
@@ -3980,7 +4068,7 @@ var Civet = (() => {
|
|
|
3980
4068
|
return Of$0(state);
|
|
3981
4069
|
}
|
|
3982
4070
|
}
|
|
3983
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
4071
|
+
var OpenBrace$0 = $TV($EXPECT($L113, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
3984
4072
|
return { $loc, token: $1 };
|
|
3985
4073
|
});
|
|
3986
4074
|
function OpenBrace(state) {
|
|
@@ -3992,7 +4080,7 @@ var Civet = (() => {
|
|
|
3992
4080
|
return OpenBrace$0(state);
|
|
3993
4081
|
}
|
|
3994
4082
|
}
|
|
3995
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
4083
|
+
var OpenBracket$0 = $TV($EXPECT($L114, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
3996
4084
|
return { $loc, token: $1 };
|
|
3997
4085
|
});
|
|
3998
4086
|
function OpenBracket(state) {
|
|
@@ -4004,7 +4092,7 @@ var Civet = (() => {
|
|
|
4004
4092
|
return OpenBracket$0(state);
|
|
4005
4093
|
}
|
|
4006
4094
|
}
|
|
4007
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
4095
|
+
var OpenParen$0 = $TV($EXPECT($L115, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
4008
4096
|
return { $loc, token: $1 };
|
|
4009
4097
|
});
|
|
4010
4098
|
function OpenParen(state) {
|
|
@@ -4016,7 +4104,7 @@ var Civet = (() => {
|
|
|
4016
4104
|
return OpenParen$0(state);
|
|
4017
4105
|
}
|
|
4018
4106
|
}
|
|
4019
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
4107
|
+
var QuestionMark$0 = $TV($EXPECT($L116, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
4020
4108
|
return { $loc, token: $1 };
|
|
4021
4109
|
});
|
|
4022
4110
|
function QuestionMark(state) {
|
|
@@ -4028,7 +4116,7 @@ var Civet = (() => {
|
|
|
4028
4116
|
return QuestionMark$0(state);
|
|
4029
4117
|
}
|
|
4030
4118
|
}
|
|
4031
|
-
var Return$0 = $TS($S($EXPECT($
|
|
4119
|
+
var Return$0 = $TS($S($EXPECT($L117, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4032
4120
|
return { $loc, token: $1 };
|
|
4033
4121
|
});
|
|
4034
4122
|
function Return(state) {
|
|
@@ -4040,7 +4128,7 @@ var Civet = (() => {
|
|
|
4040
4128
|
return Return$0(state);
|
|
4041
4129
|
}
|
|
4042
4130
|
}
|
|
4043
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
4131
|
+
var Semicolon$0 = $TV($EXPECT($L75, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
4044
4132
|
return { $loc, token: $1 };
|
|
4045
4133
|
});
|
|
4046
4134
|
function Semicolon(state) {
|
|
@@ -4052,7 +4140,7 @@ var Civet = (() => {
|
|
|
4052
4140
|
return Semicolon$0(state);
|
|
4053
4141
|
}
|
|
4054
4142
|
}
|
|
4055
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
4143
|
+
var SingleQuote$0 = $TV($EXPECT($L118, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
4056
4144
|
return { $loc, token: $1 };
|
|
4057
4145
|
});
|
|
4058
4146
|
function SingleQuote(state) {
|
|
@@ -4064,7 +4152,7 @@ var Civet = (() => {
|
|
|
4064
4152
|
return SingleQuote$0(state);
|
|
4065
4153
|
}
|
|
4066
4154
|
}
|
|
4067
|
-
var Star$0 = $TV($EXPECT($
|
|
4155
|
+
var Star$0 = $TV($EXPECT($L46, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
4068
4156
|
return { $loc, token: $1 };
|
|
4069
4157
|
});
|
|
4070
4158
|
function Star(state) {
|
|
@@ -4076,10 +4164,10 @@ var Civet = (() => {
|
|
|
4076
4164
|
return Star$0(state);
|
|
4077
4165
|
}
|
|
4078
4166
|
}
|
|
4079
|
-
var Static$0 = $TV($EXPECT($
|
|
4167
|
+
var Static$0 = $TV($EXPECT($L119, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
4080
4168
|
return { $loc, token: $1 };
|
|
4081
4169
|
});
|
|
4082
|
-
var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($
|
|
4170
|
+
var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L115, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
|
|
4083
4171
|
return { $loc, token: "static " };
|
|
4084
4172
|
});
|
|
4085
4173
|
function Static(state) {
|
|
@@ -4089,7 +4177,7 @@ var Civet = (() => {
|
|
|
4089
4177
|
return Static$0(state) || Static$1(state);
|
|
4090
4178
|
}
|
|
4091
4179
|
}
|
|
4092
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
4180
|
+
var SubstitutionStart$0 = $TV($EXPECT($L120, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
4093
4181
|
return { $loc, token: $1 };
|
|
4094
4182
|
});
|
|
4095
4183
|
function SubstitutionStart(state) {
|
|
@@ -4101,7 +4189,7 @@ var Civet = (() => {
|
|
|
4101
4189
|
return SubstitutionStart$0(state);
|
|
4102
4190
|
}
|
|
4103
4191
|
}
|
|
4104
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
4192
|
+
var Switch$0 = $TS($S($EXPECT($L121, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4105
4193
|
return { $loc, token: $1 };
|
|
4106
4194
|
});
|
|
4107
4195
|
function Switch(state) {
|
|
@@ -4113,7 +4201,7 @@ var Civet = (() => {
|
|
|
4113
4201
|
return Switch$0(state);
|
|
4114
4202
|
}
|
|
4115
4203
|
}
|
|
4116
|
-
var Target$0 = $TV($EXPECT($
|
|
4204
|
+
var Target$0 = $TV($EXPECT($L122, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
|
|
4117
4205
|
return { $loc, token: $1 };
|
|
4118
4206
|
});
|
|
4119
4207
|
function Target(state) {
|
|
@@ -4125,7 +4213,7 @@ var Civet = (() => {
|
|
|
4125
4213
|
return Target$0(state);
|
|
4126
4214
|
}
|
|
4127
4215
|
}
|
|
4128
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
4216
|
+
var Throw$0 = $TS($S($EXPECT($L123, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4129
4217
|
return { $loc, token: $1 };
|
|
4130
4218
|
});
|
|
4131
4219
|
function Throw(state) {
|
|
@@ -4137,7 +4225,7 @@ var Civet = (() => {
|
|
|
4137
4225
|
return Throw$0(state);
|
|
4138
4226
|
}
|
|
4139
4227
|
}
|
|
4140
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
4228
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L124, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
4141
4229
|
return { $loc, token: "`" };
|
|
4142
4230
|
});
|
|
4143
4231
|
function TripleDoubleQuote(state) {
|
|
@@ -4149,7 +4237,7 @@ var Civet = (() => {
|
|
|
4149
4237
|
return TripleDoubleQuote$0(state);
|
|
4150
4238
|
}
|
|
4151
4239
|
}
|
|
4152
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
4240
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L125, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
4153
4241
|
return { $loc, token: "`" };
|
|
4154
4242
|
});
|
|
4155
4243
|
function TripleSingleQuote(state) {
|
|
@@ -4161,7 +4249,7 @@ var Civet = (() => {
|
|
|
4161
4249
|
return TripleSingleQuote$0(state);
|
|
4162
4250
|
}
|
|
4163
4251
|
}
|
|
4164
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
4252
|
+
var TripleTick$0 = $TV($EXPECT($L126, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
4165
4253
|
return { $loc, token: "`" };
|
|
4166
4254
|
});
|
|
4167
4255
|
function TripleTick(state) {
|
|
@@ -4173,7 +4261,7 @@ var Civet = (() => {
|
|
|
4173
4261
|
return TripleTick$0(state);
|
|
4174
4262
|
}
|
|
4175
4263
|
}
|
|
4176
|
-
var Try$0 = $TV($EXPECT($
|
|
4264
|
+
var Try$0 = $TV($EXPECT($L127, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
4177
4265
|
return { $loc, token: $1 };
|
|
4178
4266
|
});
|
|
4179
4267
|
function Try(state) {
|
|
@@ -4185,7 +4273,7 @@ var Civet = (() => {
|
|
|
4185
4273
|
return Try$0(state);
|
|
4186
4274
|
}
|
|
4187
4275
|
}
|
|
4188
|
-
var Unless$0 = $TV($EXPECT($
|
|
4276
|
+
var Unless$0 = $TV($EXPECT($L128, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
4189
4277
|
return { $loc, token: $1 };
|
|
4190
4278
|
});
|
|
4191
4279
|
function Unless(state) {
|
|
@@ -4197,7 +4285,7 @@ var Civet = (() => {
|
|
|
4197
4285
|
return Unless$0(state);
|
|
4198
4286
|
}
|
|
4199
4287
|
}
|
|
4200
|
-
var Var$0 = $TV($EXPECT($
|
|
4288
|
+
var Var$0 = $TV($EXPECT($L129, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
4201
4289
|
return { $loc, token: $1 };
|
|
4202
4290
|
});
|
|
4203
4291
|
function Var(state) {
|
|
@@ -4209,7 +4297,7 @@ var Civet = (() => {
|
|
|
4209
4297
|
return Var$0(state);
|
|
4210
4298
|
}
|
|
4211
4299
|
}
|
|
4212
|
-
var When$0 = $TS($S($EXPECT($
|
|
4300
|
+
var When$0 = $TS($S($EXPECT($L130, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4213
4301
|
return { $loc, token: "case" };
|
|
4214
4302
|
});
|
|
4215
4303
|
function When(state) {
|
|
@@ -4221,7 +4309,7 @@ var Civet = (() => {
|
|
|
4221
4309
|
return When$0(state);
|
|
4222
4310
|
}
|
|
4223
4311
|
}
|
|
4224
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
4312
|
+
var Yield$0 = $TS($S($EXPECT($L131, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4225
4313
|
return { $loc, token: $1 };
|
|
4226
4314
|
});
|
|
4227
4315
|
function Yield(state) {
|
|
@@ -4247,7 +4335,7 @@ var Civet = (() => {
|
|
|
4247
4335
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
4248
4336
|
}
|
|
4249
4337
|
}
|
|
4250
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
4338
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L132, fail, 'JSXSelfClosingElement "/>"'));
|
|
4251
4339
|
function JSXSelfClosingElement(state) {
|
|
4252
4340
|
if (state.verbose)
|
|
4253
4341
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -4257,7 +4345,7 @@ var Civet = (() => {
|
|
|
4257
4345
|
return JSXSelfClosingElement$0(state);
|
|
4258
4346
|
}
|
|
4259
4347
|
}
|
|
4260
|
-
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
4348
|
+
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L56, fail, 'JSXOpeningElement ">"'));
|
|
4261
4349
|
function JSXOpeningElement(state) {
|
|
4262
4350
|
if (state.verbose)
|
|
4263
4351
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -4267,7 +4355,7 @@ var Civet = (() => {
|
|
|
4267
4355
|
return JSXOpeningElement$0(state);
|
|
4268
4356
|
}
|
|
4269
4357
|
}
|
|
4270
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
4358
|
+
var JSXClosingElement$0 = $S($EXPECT($L133, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L56, fail, 'JSXClosingElement ">"'));
|
|
4271
4359
|
function JSXClosingElement(state) {
|
|
4272
4360
|
if (state.verbose)
|
|
4273
4361
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -4277,7 +4365,7 @@ var Civet = (() => {
|
|
|
4277
4365
|
return JSXClosingElement$0(state);
|
|
4278
4366
|
}
|
|
4279
4367
|
}
|
|
4280
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
4368
|
+
var JSXFragment$0 = $S($EXPECT($L134, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L135, fail, 'JSXFragment "</>"'));
|
|
4281
4369
|
function JSXFragment(state) {
|
|
4282
4370
|
if (state.verbose)
|
|
4283
4371
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -4297,7 +4385,7 @@ var Civet = (() => {
|
|
|
4297
4385
|
return JSXElementName$0(state);
|
|
4298
4386
|
}
|
|
4299
4387
|
}
|
|
4300
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
4388
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R32, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
4301
4389
|
function JSXIdentifierName(state) {
|
|
4302
4390
|
if (state.verbose)
|
|
4303
4391
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -4317,7 +4405,7 @@ var Civet = (() => {
|
|
|
4317
4405
|
return JSXAttributes$0(state);
|
|
4318
4406
|
}
|
|
4319
4407
|
}
|
|
4320
|
-
var JSXAttribute$0 = $S(OpenBrace, __,
|
|
4408
|
+
var JSXAttribute$0 = $S(OpenBrace, __, DotDotDot, __, AssignmentExpression, __, CloseBrace);
|
|
4321
4409
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
4322
4410
|
function JSXAttribute(state) {
|
|
4323
4411
|
if (state.tokenize) {
|
|
@@ -4346,8 +4434,8 @@ var Civet = (() => {
|
|
|
4346
4434
|
return JSXAttributeInitializer$0(state);
|
|
4347
4435
|
}
|
|
4348
4436
|
}
|
|
4349
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
4350
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
4437
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R33, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
4438
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R34, fail, "JSXAttributeValue /'[^']*'/"));
|
|
4351
4439
|
var JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
|
|
4352
4440
|
var JSXAttributeValue$3 = JSXElement;
|
|
4353
4441
|
var JSXAttributeValue$4 = JSXFragment;
|
|
@@ -4379,7 +4467,7 @@ var Civet = (() => {
|
|
|
4379
4467
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
4380
4468
|
}
|
|
4381
4469
|
}
|
|
4382
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
4470
|
+
var JSXText$0 = $R$0($EXPECT($R35, fail, "JSXText /[^{}<>]+/"));
|
|
4383
4471
|
function JSXText(state) {
|
|
4384
4472
|
if (state.verbose)
|
|
4385
4473
|
console.log("ENTER:", "JSXText");
|
|
@@ -4389,7 +4477,7 @@ var Civet = (() => {
|
|
|
4389
4477
|
return JSXText$0(state);
|
|
4390
4478
|
}
|
|
4391
4479
|
}
|
|
4392
|
-
var JSXChildExpression$0 = $S(__, $E($S(
|
|
4480
|
+
var JSXChildExpression$0 = $S(__, $E($S(DotDotDot, __)), AssignmentExpression);
|
|
4393
4481
|
function JSXChildExpression(state) {
|
|
4394
4482
|
if (state.verbose)
|
|
4395
4483
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -4411,7 +4499,7 @@ var Civet = (() => {
|
|
|
4411
4499
|
return TypeDeclaration$0(state);
|
|
4412
4500
|
}
|
|
4413
4501
|
}
|
|
4414
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
4502
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L136, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
4415
4503
|
var TypeDeclarationModifier$1 = Export;
|
|
4416
4504
|
function TypeDeclarationModifier(state) {
|
|
4417
4505
|
if (state.tokenize) {
|
|
@@ -4421,16 +4509,17 @@ var Civet = (() => {
|
|
|
4421
4509
|
}
|
|
4422
4510
|
}
|
|
4423
4511
|
var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, Equals, __, Type);
|
|
4424
|
-
var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, InterfaceBlock);
|
|
4512
|
+
var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, $E(TypeParameters), InterfaceBlock);
|
|
4425
4513
|
var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
|
|
4514
|
+
var TypeDeclarationRest$3 = FunctionSignature;
|
|
4426
4515
|
function TypeDeclarationRest(state) {
|
|
4427
4516
|
if (state.tokenize) {
|
|
4428
|
-
return $TOKEN("TypeDeclarationRest", state, TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state));
|
|
4517
|
+
return $TOKEN("TypeDeclarationRest", state, TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state));
|
|
4429
4518
|
} else {
|
|
4430
|
-
return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state);
|
|
4519
|
+
return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state);
|
|
4431
4520
|
}
|
|
4432
4521
|
}
|
|
4433
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
4522
|
+
var TypeKeyword$0 = $S($EXPECT($L137, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
4434
4523
|
function TypeKeyword(state) {
|
|
4435
4524
|
if (state.verbose)
|
|
4436
4525
|
console.log("ENTER:", "TypeKeyword");
|
|
@@ -4440,7 +4529,7 @@ var Civet = (() => {
|
|
|
4440
4529
|
return TypeKeyword$0(state);
|
|
4441
4530
|
}
|
|
4442
4531
|
}
|
|
4443
|
-
var Interface$0 = $S($EXPECT($
|
|
4532
|
+
var Interface$0 = $S($EXPECT($L138, fail, 'Interface "interface"'), NonIdContinue);
|
|
4444
4533
|
function Interface(state) {
|
|
4445
4534
|
if (state.verbose)
|
|
4446
4535
|
console.log("ENTER:", "Interface");
|
|
@@ -4450,7 +4539,7 @@ var Civet = (() => {
|
|
|
4450
4539
|
return Interface$0(state);
|
|
4451
4540
|
}
|
|
4452
4541
|
}
|
|
4453
|
-
var Namespace$0 = $S($EXPECT($
|
|
4542
|
+
var Namespace$0 = $S($EXPECT($L139, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
4454
4543
|
function Namespace(state) {
|
|
4455
4544
|
if (state.verbose)
|
|
4456
4545
|
console.log("ENTER:", "Namespace");
|
|
@@ -4496,27 +4585,23 @@ var Civet = (() => {
|
|
|
4496
4585
|
}
|
|
4497
4586
|
}
|
|
4498
4587
|
var InterfaceProperty$0 = $S($C(TypeIndexSignature, PropertyName), TypeSuffix, InterfacePropertyDelimiter);
|
|
4499
|
-
var InterfaceProperty$1 =
|
|
4588
|
+
var InterfaceProperty$1 = $S(NonEmptyParameters, TypeSuffix, InterfacePropertyDelimiter);
|
|
4589
|
+
var InterfaceProperty$2 = $S(MethodSignature, InterfacePropertyDelimiter);
|
|
4500
4590
|
function InterfaceProperty(state) {
|
|
4501
4591
|
if (state.tokenize) {
|
|
4502
|
-
return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state));
|
|
4592
|
+
return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state) || InterfaceProperty$2(state));
|
|
4503
4593
|
} else {
|
|
4504
|
-
return InterfaceProperty$0(state) || InterfaceProperty$1(state);
|
|
4594
|
+
return InterfaceProperty$0(state) || InterfaceProperty$1(state) || InterfaceProperty$2(state);
|
|
4505
4595
|
}
|
|
4506
4596
|
}
|
|
4507
|
-
var InterfacePropertyDelimiter$0 = $S($Q(_), Semicolon);
|
|
4508
|
-
var InterfacePropertyDelimiter$1 = $Y($S(
|
|
4509
|
-
var InterfacePropertyDelimiter$2 = $
|
|
4510
|
-
return { $loc, token: ";" };
|
|
4511
|
-
});
|
|
4512
|
-
var InterfacePropertyDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
4513
|
-
return { $loc, token: ";" };
|
|
4514
|
-
});
|
|
4597
|
+
var InterfacePropertyDelimiter$0 = $S($Q(_), $C(Semicolon, Comma));
|
|
4598
|
+
var InterfacePropertyDelimiter$1 = $Y($S(__, CloseBrace));
|
|
4599
|
+
var InterfacePropertyDelimiter$2 = $Y(EOS);
|
|
4515
4600
|
function InterfacePropertyDelimiter(state) {
|
|
4516
4601
|
if (state.tokenize) {
|
|
4517
|
-
return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state)
|
|
4602
|
+
return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state));
|
|
4518
4603
|
} else {
|
|
4519
|
-
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state)
|
|
4604
|
+
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state);
|
|
4520
4605
|
}
|
|
4521
4606
|
}
|
|
4522
4607
|
var NamespaceBlock$0 = $S(__, OpenBrace, EOS, NestedTypeDeclarations, __, CloseBrace);
|
|
@@ -4554,7 +4639,7 @@ var Civet = (() => {
|
|
|
4554
4639
|
return NestedTypeDeclaration$0(state);
|
|
4555
4640
|
}
|
|
4556
4641
|
}
|
|
4557
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
4642
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R36, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L140, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R37, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
4558
4643
|
function TypeIndexSignature(state) {
|
|
4559
4644
|
if (state.verbose)
|
|
4560
4645
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -4585,7 +4670,7 @@ var Civet = (() => {
|
|
|
4585
4670
|
return TypeSuffix$0(state);
|
|
4586
4671
|
}
|
|
4587
4672
|
}
|
|
4588
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
4673
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L141, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
4589
4674
|
if (!$3)
|
|
4590
4675
|
$0.splice(2, 1);
|
|
4591
4676
|
if ($1.length === 0)
|
|
@@ -4605,7 +4690,7 @@ var Civet = (() => {
|
|
|
4605
4690
|
return ReturnTypeSuffix$0(state);
|
|
4606
4691
|
}
|
|
4607
4692
|
}
|
|
4608
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
4693
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L59, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
4609
4694
|
if (!$2)
|
|
4610
4695
|
return $1;
|
|
4611
4696
|
return $0;
|
|
@@ -4660,18 +4745,17 @@ var Civet = (() => {
|
|
|
4660
4745
|
}
|
|
4661
4746
|
}
|
|
4662
4747
|
var TypeUnarySuffix$0 = TypeIndexedAccess;
|
|
4748
|
+
var TypeUnarySuffix$1 = QuestionMark;
|
|
4663
4749
|
function TypeUnarySuffix(state) {
|
|
4664
|
-
if (state.verbose)
|
|
4665
|
-
console.log("ENTER:", "TypeUnarySuffix");
|
|
4666
4750
|
if (state.tokenize) {
|
|
4667
|
-
return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state));
|
|
4751
|
+
return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state));
|
|
4668
4752
|
} else {
|
|
4669
|
-
return TypeUnarySuffix$0(state);
|
|
4753
|
+
return TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state);
|
|
4670
4754
|
}
|
|
4671
4755
|
}
|
|
4672
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
4673
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
4674
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
4756
|
+
var TypeUnaryOp$0 = $EXPECT($L142, fail, 'TypeUnaryOp "keyof"');
|
|
4757
|
+
var TypeUnaryOp$1 = $EXPECT($L74, fail, 'TypeUnaryOp "typeof"');
|
|
4758
|
+
var TypeUnaryOp$2 = $EXPECT($L143, fail, 'TypeUnaryOp "infer"');
|
|
4675
4759
|
function TypeUnaryOp(state) {
|
|
4676
4760
|
if (state.tokenize) {
|
|
4677
4761
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -4691,14 +4775,59 @@ var Civet = (() => {
|
|
|
4691
4775
|
}
|
|
4692
4776
|
var TypePrimary$0 = InterfaceBlock;
|
|
4693
4777
|
var TypePrimary$1 = $S(__, OpenParen, Type, __, CloseParen);
|
|
4694
|
-
var TypePrimary$2 = $S(
|
|
4695
|
-
var TypePrimary$3 = $S($Q(_),
|
|
4696
|
-
var TypePrimary$4 = $S($Q(_),
|
|
4778
|
+
var TypePrimary$2 = $S(__, TypeTuple);
|
|
4779
|
+
var TypePrimary$3 = $S($Q(_), FunctionType);
|
|
4780
|
+
var TypePrimary$4 = $S($Q(_), TypeLiteral);
|
|
4781
|
+
var TypePrimary$5 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
4697
4782
|
function TypePrimary(state) {
|
|
4698
4783
|
if (state.tokenize) {
|
|
4699
|
-
return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state));
|
|
4784
|
+
return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state));
|
|
4785
|
+
} else {
|
|
4786
|
+
return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state);
|
|
4787
|
+
}
|
|
4788
|
+
}
|
|
4789
|
+
var TypeTuple$0 = $S(OpenBracket, NestedTypeList, __, CloseBracket);
|
|
4790
|
+
var TypeTuple$1 = $S(OpenBracket, $E(TypeList), __, CloseBracket);
|
|
4791
|
+
function TypeTuple(state) {
|
|
4792
|
+
if (state.tokenize) {
|
|
4793
|
+
return $TOKEN("TypeTuple", state, TypeTuple$0(state) || TypeTuple$1(state));
|
|
4794
|
+
} else {
|
|
4795
|
+
return TypeTuple$0(state) || TypeTuple$1(state);
|
|
4796
|
+
}
|
|
4797
|
+
}
|
|
4798
|
+
var TypeList$0 = $S(Type, $Q($S(__, Comma, Type)));
|
|
4799
|
+
function TypeList(state) {
|
|
4800
|
+
if (state.verbose)
|
|
4801
|
+
console.log("ENTER:", "TypeList");
|
|
4802
|
+
if (state.tokenize) {
|
|
4803
|
+
return $TOKEN("TypeList", state, TypeList$0(state));
|
|
4804
|
+
} else {
|
|
4805
|
+
return TypeList$0(state);
|
|
4806
|
+
}
|
|
4807
|
+
}
|
|
4808
|
+
var NestedTypeList$0 = $TS($S(PushIndent, $Q(NestedType), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
4809
|
+
var types = $2;
|
|
4810
|
+
if (types.length)
|
|
4811
|
+
return types;
|
|
4812
|
+
return $skip;
|
|
4813
|
+
});
|
|
4814
|
+
function NestedTypeList(state) {
|
|
4815
|
+
if (state.verbose)
|
|
4816
|
+
console.log("ENTER:", "NestedTypeList");
|
|
4817
|
+
if (state.tokenize) {
|
|
4818
|
+
return $TOKEN("NestedTypeList", state, NestedTypeList$0(state));
|
|
4700
4819
|
} else {
|
|
4701
|
-
return
|
|
4820
|
+
return NestedTypeList$0(state);
|
|
4821
|
+
}
|
|
4822
|
+
}
|
|
4823
|
+
var NestedType$0 = $S(Nested, Type, ArrayElementDelimiter);
|
|
4824
|
+
function NestedType(state) {
|
|
4825
|
+
if (state.verbose)
|
|
4826
|
+
console.log("ENTER:", "NestedType");
|
|
4827
|
+
if (state.tokenize) {
|
|
4828
|
+
return $TOKEN("NestedType", state, NestedType$0(state));
|
|
4829
|
+
} else {
|
|
4830
|
+
return NestedType$0(state);
|
|
4702
4831
|
}
|
|
4703
4832
|
}
|
|
4704
4833
|
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
@@ -4716,10 +4845,10 @@ var Civet = (() => {
|
|
|
4716
4845
|
}
|
|
4717
4846
|
}
|
|
4718
4847
|
var TypeLiteral$0 = Literal;
|
|
4719
|
-
var TypeLiteral$1 = $TV($EXPECT($
|
|
4848
|
+
var TypeLiteral$1 = $TV($EXPECT($L73, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
|
|
4720
4849
|
return { $loc, token: "void" };
|
|
4721
4850
|
});
|
|
4722
|
-
var TypeLiteral$2 = $TV($EXPECT($
|
|
4851
|
+
var TypeLiteral$2 = $TV($EXPECT($L144, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
4723
4852
|
return { $loc, token: "[]" };
|
|
4724
4853
|
});
|
|
4725
4854
|
function TypeLiteral(state) {
|
|
@@ -4729,10 +4858,10 @@ var Civet = (() => {
|
|
|
4729
4858
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
4730
4859
|
}
|
|
4731
4860
|
}
|
|
4732
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
4861
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L71, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
4733
4862
|
return { $loc, token: "|" };
|
|
4734
4863
|
});
|
|
4735
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
4864
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L69, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
4736
4865
|
return { $loc, token: "&" };
|
|
4737
4866
|
});
|
|
4738
4867
|
function TypeBinaryOp(state) {
|
|
@@ -4752,7 +4881,7 @@ var Civet = (() => {
|
|
|
4752
4881
|
return FunctionType$0(state);
|
|
4753
4882
|
}
|
|
4754
4883
|
}
|
|
4755
|
-
var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
4884
|
+
var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L56, fail, 'TypeArguments ">"'));
|
|
4756
4885
|
function TypeArguments(state) {
|
|
4757
4886
|
if (state.verbose)
|
|
4758
4887
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -4762,7 +4891,7 @@ var Civet = (() => {
|
|
|
4762
4891
|
return TypeArguments$0(state);
|
|
4763
4892
|
}
|
|
4764
4893
|
}
|
|
4765
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
4894
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L56, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
4766
4895
|
return { ts: true, children: $0 };
|
|
4767
4896
|
});
|
|
4768
4897
|
function TypeParameters(state) {
|
|
@@ -4795,8 +4924,8 @@ var Civet = (() => {
|
|
|
4795
4924
|
}
|
|
4796
4925
|
}
|
|
4797
4926
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
4798
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
4799
|
-
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($
|
|
4927
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L56, fail, 'TypeParameterDelimiter ">"')));
|
|
4928
|
+
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L56, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
|
|
4800
4929
|
return { $loc, token: "," };
|
|
4801
4930
|
});
|
|
4802
4931
|
var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
@@ -4809,7 +4938,7 @@ var Civet = (() => {
|
|
|
4809
4938
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
4810
4939
|
}
|
|
4811
4940
|
}
|
|
4812
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
4941
|
+
var Shebang$0 = $S($R$0($EXPECT($R38, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
4813
4942
|
function Shebang(state) {
|
|
4814
4943
|
if (state.verbose)
|
|
4815
4944
|
console.log("ENTER:", "Shebang");
|
|
@@ -4819,14 +4948,73 @@ var Civet = (() => {
|
|
|
4819
4948
|
return Shebang$0(state);
|
|
4820
4949
|
}
|
|
4821
4950
|
}
|
|
4822
|
-
var
|
|
4823
|
-
|
|
4951
|
+
var CivetPrologue$0 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
4952
|
+
var content = value[2];
|
|
4953
|
+
return content;
|
|
4954
|
+
});
|
|
4955
|
+
var CivetPrologue$1 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
4956
|
+
var content = value[2];
|
|
4957
|
+
return content;
|
|
4958
|
+
});
|
|
4959
|
+
function CivetPrologue(state) {
|
|
4960
|
+
if (state.tokenize) {
|
|
4961
|
+
return $TOKEN("CivetPrologue", state, CivetPrologue$0(state) || CivetPrologue$1(state));
|
|
4962
|
+
} else {
|
|
4963
|
+
return CivetPrologue$0(state) || CivetPrologue$1(state);
|
|
4964
|
+
}
|
|
4965
|
+
}
|
|
4966
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L145, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R40, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
4967
|
+
var options = $2;
|
|
4968
|
+
return {
|
|
4969
|
+
type: "CivetPrologue",
|
|
4970
|
+
children: [],
|
|
4971
|
+
config: Object.fromEntries(options)
|
|
4972
|
+
};
|
|
4973
|
+
});
|
|
4974
|
+
function CivetPrologueContent(state) {
|
|
4975
|
+
if (state.verbose)
|
|
4976
|
+
console.log("ENTER:", "CivetPrologueContent");
|
|
4977
|
+
if (state.tokenize) {
|
|
4978
|
+
return $TOKEN("CivetPrologueContent", state, CivetPrologueContent$0(state));
|
|
4979
|
+
} else {
|
|
4980
|
+
return CivetPrologueContent$0(state);
|
|
4981
|
+
}
|
|
4982
|
+
}
|
|
4983
|
+
var CivetOption$0 = $TR($EXPECT($R41, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4984
|
+
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
4985
|
+
if (l)
|
|
4986
|
+
return l.toUpperCase();
|
|
4987
|
+
return "";
|
|
4988
|
+
});
|
|
4989
|
+
const value = $1 === "-" ? false : true;
|
|
4990
|
+
return [optionName, value];
|
|
4991
|
+
});
|
|
4992
|
+
function CivetOption(state) {
|
|
4993
|
+
if (state.verbose)
|
|
4994
|
+
console.log("ENTER:", "CivetOption");
|
|
4995
|
+
if (state.tokenize) {
|
|
4996
|
+
return $TOKEN("CivetOption", state, CivetOption$0(state));
|
|
4997
|
+
} else {
|
|
4998
|
+
return CivetOption$0(state);
|
|
4999
|
+
}
|
|
5000
|
+
}
|
|
5001
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R39, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
|
|
5002
|
+
function UnknownPrologue(state) {
|
|
4824
5003
|
if (state.verbose)
|
|
4825
|
-
console.log("ENTER:", "
|
|
5004
|
+
console.log("ENTER:", "UnknownPrologue");
|
|
5005
|
+
if (state.tokenize) {
|
|
5006
|
+
return $TOKEN("UnknownPrologue", state, UnknownPrologue$0(state));
|
|
5007
|
+
} else {
|
|
5008
|
+
return UnknownPrologue$0(state);
|
|
5009
|
+
}
|
|
5010
|
+
}
|
|
5011
|
+
var DirectivePrologue$0 = CivetPrologue;
|
|
5012
|
+
var DirectivePrologue$1 = UnknownPrologue;
|
|
5013
|
+
function DirectivePrologue(state) {
|
|
4826
5014
|
if (state.tokenize) {
|
|
4827
|
-
return $TOKEN("DirectivePrologue", state, DirectivePrologue$0(state));
|
|
5015
|
+
return $TOKEN("DirectivePrologue", state, DirectivePrologue$0(state) || DirectivePrologue$1(state));
|
|
4828
5016
|
} else {
|
|
4829
|
-
return DirectivePrologue$0(state);
|
|
5017
|
+
return DirectivePrologue$0(state) || DirectivePrologue$1(state);
|
|
4830
5018
|
}
|
|
4831
5019
|
}
|
|
4832
5020
|
var EOS$0 = $P(RestOfLine);
|
|
@@ -4839,7 +5027,7 @@ var Civet = (() => {
|
|
|
4839
5027
|
return EOS$0(state);
|
|
4840
5028
|
}
|
|
4841
5029
|
}
|
|
4842
|
-
var EOL$0 = $R$0($EXPECT($
|
|
5030
|
+
var EOL$0 = $R$0($EXPECT($R42, fail, "EOL /\\r\\n|\\n|\\r|$/"));
|
|
4843
5031
|
function EOL(state) {
|
|
4844
5032
|
if (state.verbose)
|
|
4845
5033
|
console.log("ENTER:", "EOL");
|
|
@@ -4849,7 +5037,7 @@ var Civet = (() => {
|
|
|
4849
5037
|
return EOL$0(state);
|
|
4850
5038
|
}
|
|
4851
5039
|
}
|
|
4852
|
-
var EOF$0 = $R$0($EXPECT($
|
|
5040
|
+
var EOF$0 = $R$0($EXPECT($R43, fail, "EOF /$/"));
|
|
4853
5041
|
function EOF(state) {
|
|
4854
5042
|
if (state.verbose)
|
|
4855
5043
|
console.log("ENTER:", "EOF");
|
|
@@ -5003,12 +5191,82 @@ var Civet = (() => {
|
|
|
5003
5191
|
return InsertBreak$0(state);
|
|
5004
5192
|
}
|
|
5005
5193
|
}
|
|
5194
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
5195
|
+
if (module.config.coffeeComment)
|
|
5196
|
+
return;
|
|
5197
|
+
return $skip;
|
|
5198
|
+
});
|
|
5199
|
+
function CoffeeCommentEnabled(state) {
|
|
5200
|
+
if (state.verbose)
|
|
5201
|
+
console.log("ENTER:", "CoffeeCommentEnabled");
|
|
5202
|
+
if (state.tokenize) {
|
|
5203
|
+
return $TOKEN("CoffeeCommentEnabled", state, CoffeeCommentEnabled$0(state));
|
|
5204
|
+
} else {
|
|
5205
|
+
return CoffeeCommentEnabled$0(state);
|
|
5206
|
+
}
|
|
5207
|
+
}
|
|
5208
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
5209
|
+
if (module.config.coffeeBooleans)
|
|
5210
|
+
return;
|
|
5211
|
+
return $skip;
|
|
5212
|
+
});
|
|
5213
|
+
function CoffeeBooleansEnabled(state) {
|
|
5214
|
+
if (state.verbose)
|
|
5215
|
+
console.log("ENTER:", "CoffeeBooleansEnabled");
|
|
5216
|
+
if (state.tokenize) {
|
|
5217
|
+
return $TOKEN("CoffeeBooleansEnabled", state, CoffeeBooleansEnabled$0(state));
|
|
5218
|
+
} else {
|
|
5219
|
+
return CoffeeBooleansEnabled$0(state);
|
|
5220
|
+
}
|
|
5221
|
+
}
|
|
5222
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
5223
|
+
if (module.config.coffeeInterpolation)
|
|
5224
|
+
return;
|
|
5225
|
+
return $skip;
|
|
5226
|
+
});
|
|
5227
|
+
function CoffeeInterpolationEnabled(state) {
|
|
5228
|
+
if (state.verbose)
|
|
5229
|
+
console.log("ENTER:", "CoffeeInterpolationEnabled");
|
|
5230
|
+
if (state.tokenize) {
|
|
5231
|
+
return $TOKEN("CoffeeInterpolationEnabled", state, CoffeeInterpolationEnabled$0(state));
|
|
5232
|
+
} else {
|
|
5233
|
+
return CoffeeInterpolationEnabled$0(state);
|
|
5234
|
+
}
|
|
5235
|
+
}
|
|
5006
5236
|
var Reset$0 = $TV($EXPECT($L1, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
5007
5237
|
module.currentIndent = 0;
|
|
5008
5238
|
module.indentLevels = [0];
|
|
5009
5239
|
module.verbose = false;
|
|
5010
|
-
module.
|
|
5011
|
-
|
|
5240
|
+
module.config = {
|
|
5241
|
+
autoVar: false,
|
|
5242
|
+
coffeeBooleans: false,
|
|
5243
|
+
coffeeComment: false,
|
|
5244
|
+
coffeeEq: false,
|
|
5245
|
+
coffeeInterpolation: false,
|
|
5246
|
+
implicitReturns: true
|
|
5247
|
+
};
|
|
5248
|
+
Object.defineProperty(module.config, "coffeeCompat", {
|
|
5249
|
+
set(b) {
|
|
5250
|
+
if (b) {
|
|
5251
|
+
this.autoVar = true;
|
|
5252
|
+
this.coffeeBooleans = true;
|
|
5253
|
+
this.coffeeComment = true;
|
|
5254
|
+
this.coffeeEq = true;
|
|
5255
|
+
this.coffeeInterpolation = true;
|
|
5256
|
+
this.implicitReturns = true;
|
|
5257
|
+
} else {
|
|
5258
|
+
this.autoVar = false;
|
|
5259
|
+
this.coffeeBooleans = false;
|
|
5260
|
+
this.coffeeComment = false;
|
|
5261
|
+
this.coffeeEq = false;
|
|
5262
|
+
this.coffeeInterpolation = false;
|
|
5263
|
+
this.implicitReturns = false;
|
|
5264
|
+
}
|
|
5265
|
+
}
|
|
5266
|
+
});
|
|
5267
|
+
module.modifyString = function(str) {
|
|
5268
|
+
return str.replace(/(?<!\\)(\\\\)*\n/g, "$1\\n");
|
|
5269
|
+
};
|
|
5012
5270
|
});
|
|
5013
5271
|
function Reset(state) {
|
|
5014
5272
|
if (state.verbose)
|
|
@@ -5019,12 +5277,13 @@ var Civet = (() => {
|
|
|
5019
5277
|
return Reset$0(state);
|
|
5020
5278
|
}
|
|
5021
5279
|
}
|
|
5022
|
-
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
5280
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
5023
5281
|
var directives = $2;
|
|
5024
|
-
|
|
5025
|
-
|
|
5026
|
-
|
|
5027
|
-
|
|
5282
|
+
directives.forEach((directive) => {
|
|
5283
|
+
if (directive.type === "CivetPrologue") {
|
|
5284
|
+
Object.assign(module.config, directive.config);
|
|
5285
|
+
}
|
|
5286
|
+
});
|
|
5028
5287
|
function hasReturnStatement(node) {
|
|
5029
5288
|
if (!node)
|
|
5030
5289
|
return false;
|
|
@@ -5045,6 +5304,9 @@ var Civet = (() => {
|
|
|
5045
5304
|
case "AssignmentExpression":
|
|
5046
5305
|
node.children.unshift("return ");
|
|
5047
5306
|
return;
|
|
5307
|
+
case "Identifier":
|
|
5308
|
+
node.token = "return " + node.token;
|
|
5309
|
+
return;
|
|
5048
5310
|
case "BlockStatement":
|
|
5049
5311
|
insertReturn(node.expressions[node.expressions.length - 1]);
|
|
5050
5312
|
return;
|
|
@@ -5065,7 +5327,7 @@ var Civet = (() => {
|
|
|
5065
5327
|
}
|
|
5066
5328
|
if (!Array.isArray(node))
|
|
5067
5329
|
return;
|
|
5068
|
-
const [, exp] = node;
|
|
5330
|
+
const [indent, exp] = node;
|
|
5069
5331
|
if (!exp)
|
|
5070
5332
|
return;
|
|
5071
5333
|
switch (exp.type) {
|
|
@@ -5077,10 +5339,15 @@ var Civet = (() => {
|
|
|
5077
5339
|
case "ThrowStatement":
|
|
5078
5340
|
case "VariableDeclaration":
|
|
5079
5341
|
return;
|
|
5342
|
+
case "BlockStatement":
|
|
5343
|
+
insertReturn(exp.expressions[exp.expressions.length - 1]);
|
|
5344
|
+
return;
|
|
5080
5345
|
case "IfStatement":
|
|
5081
5346
|
insertReturn(exp.children[2]);
|
|
5082
5347
|
if (exp.children[3])
|
|
5083
5348
|
insertReturn(exp.children[3][2]);
|
|
5349
|
+
else
|
|
5350
|
+
exp.children.push(["\n", indent, "return"]);
|
|
5084
5351
|
return;
|
|
5085
5352
|
case "SwitchStatement":
|
|
5086
5353
|
insertReturn(exp.children[2]);
|
|
@@ -5098,6 +5365,50 @@ var Civet = (() => {
|
|
|
5098
5365
|
insertReturn(block);
|
|
5099
5366
|
return block;
|
|
5100
5367
|
};
|
|
5368
|
+
module.expandChainedComparisons = function([first, binops]) {
|
|
5369
|
+
const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in", "instanceof"];
|
|
5370
|
+
const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
|
|
5371
|
+
let results = [];
|
|
5372
|
+
let i = 0;
|
|
5373
|
+
let l = binops.length;
|
|
5374
|
+
let start = 0;
|
|
5375
|
+
let chains = [];
|
|
5376
|
+
while (i < l) {
|
|
5377
|
+
const [, op] = binops[i];
|
|
5378
|
+
if (relationalOps.includes(op.token)) {
|
|
5379
|
+
chains.push(i);
|
|
5380
|
+
} else if (lowerPrecedenceOps.includes(op.token)) {
|
|
5381
|
+
processChains();
|
|
5382
|
+
first = [];
|
|
5383
|
+
}
|
|
5384
|
+
i++;
|
|
5385
|
+
}
|
|
5386
|
+
processChains();
|
|
5387
|
+
return results;
|
|
5388
|
+
function processChains() {
|
|
5389
|
+
if (chains.length > 1) {
|
|
5390
|
+
chains.forEach((index, k) => {
|
|
5391
|
+
if (k > 0) {
|
|
5392
|
+
results.push(" && ");
|
|
5393
|
+
}
|
|
5394
|
+
const [pre, op, post, exp] = binops[index];
|
|
5395
|
+
let endIndex;
|
|
5396
|
+
if (k < chains.length - 1) {
|
|
5397
|
+
endIndex = chains[k + 1];
|
|
5398
|
+
} else {
|
|
5399
|
+
endIndex = i + 1;
|
|
5400
|
+
}
|
|
5401
|
+
results = results.concat(first, ...binops.slice(start, endIndex));
|
|
5402
|
+
first = [exp].concat(binops.slice(index + 1, endIndex));
|
|
5403
|
+
start = endIndex;
|
|
5404
|
+
});
|
|
5405
|
+
} else {
|
|
5406
|
+
results = results.concat(first, ...binops.slice(start, i + 1));
|
|
5407
|
+
start = i + 1;
|
|
5408
|
+
}
|
|
5409
|
+
chains.length = 0;
|
|
5410
|
+
}
|
|
5411
|
+
};
|
|
5101
5412
|
module.parsePosition = function() {
|
|
5102
5413
|
let s = Error().stack.split(/\n at /);
|
|
5103
5414
|
s.shift();
|
|
@@ -5134,9 +5445,6 @@ var Civet = (() => {
|
|
|
5134
5445
|
}
|
|
5135
5446
|
return spacing;
|
|
5136
5447
|
};
|
|
5137
|
-
module.modifyString = function(str) {
|
|
5138
|
-
return str.replace(/(?<!\\)(\\\\)*\n/g, "$1\\n");
|
|
5139
|
-
};
|
|
5140
5448
|
module.dedentBlockSubstitutions = function($02) {
|
|
5141
5449
|
const [s, strWithSubstitutions, e] = $02;
|
|
5142
5450
|
if (strWithSubstitutions.length === 0) {
|
|
@@ -5197,7 +5505,7 @@ var Civet = (() => {
|
|
|
5197
5505
|
return Init$0(state);
|
|
5198
5506
|
}
|
|
5199
5507
|
}
|
|
5200
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
5508
|
+
var Indent$0 = $TV($Q($C($EXPECT($L146, fail, 'Indent " "'), $EXPECT($L147, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
5201
5509
|
const level = $1.length;
|
|
5202
5510
|
return {
|
|
5203
5511
|
$loc,
|