@danielx/civet 0.4.19-pre.2 → 0.4.19-pre.3
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 +8 -8
- package/dist/browser.js +575 -372
- package/dist/main.js +575 -372
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -416,16 +416,20 @@ var Civet = (() => {
|
|
|
416
416
|
NestedArgumentList,
|
|
417
417
|
NestedArgument,
|
|
418
418
|
InlineArgumentExpressions,
|
|
419
|
+
ArgumentPart,
|
|
419
420
|
ImplicitApplication,
|
|
420
421
|
ApplicationStart,
|
|
421
422
|
IndentedApplicationAllowed,
|
|
422
423
|
BinaryOpExpression,
|
|
424
|
+
BinaryOpRHS,
|
|
425
|
+
ParenthesizedAssignment,
|
|
423
426
|
UnaryExpression,
|
|
424
427
|
UnaryPostfix,
|
|
425
428
|
UpdateExpression,
|
|
426
429
|
UpdateExpressionSymbol,
|
|
427
430
|
AssignmentExpression,
|
|
428
431
|
AssignmentExpressionTail,
|
|
432
|
+
ActualAssignment,
|
|
429
433
|
YieldExpression,
|
|
430
434
|
YieldTail,
|
|
431
435
|
ArrowFunction,
|
|
@@ -433,6 +437,7 @@ var Civet = (() => {
|
|
|
433
437
|
FatArrow,
|
|
434
438
|
FatArrowBody,
|
|
435
439
|
ConditionalExpression,
|
|
440
|
+
TernaryRest,
|
|
436
441
|
ShortCircuitExpression,
|
|
437
442
|
PrimaryExpression,
|
|
438
443
|
ParenthesizedExpression,
|
|
@@ -446,7 +451,6 @@ var Civet = (() => {
|
|
|
446
451
|
ClassElement,
|
|
447
452
|
FieldDefinition,
|
|
448
453
|
This,
|
|
449
|
-
AtAccessor,
|
|
450
454
|
LeftHandSideExpression,
|
|
451
455
|
CallExpression,
|
|
452
456
|
CallExpressionRest,
|
|
@@ -515,9 +519,12 @@ var Civet = (() => {
|
|
|
515
519
|
NestedObjectLiteral,
|
|
516
520
|
NestedPropertyDefinitions,
|
|
517
521
|
NestedPropertyDefinition,
|
|
522
|
+
InlineObjectLiteral,
|
|
518
523
|
ObjectPropertyDelimiter,
|
|
519
524
|
PropertyDefinitionList,
|
|
520
525
|
PropertyDefinition,
|
|
526
|
+
NamedProperty,
|
|
527
|
+
SnugNamedProperty,
|
|
521
528
|
PropertyName,
|
|
522
529
|
MethodDefinition,
|
|
523
530
|
MethodModifier,
|
|
@@ -650,6 +657,7 @@ var Civet = (() => {
|
|
|
650
657
|
Loc,
|
|
651
658
|
Ampersand,
|
|
652
659
|
As,
|
|
660
|
+
At,
|
|
653
661
|
Async,
|
|
654
662
|
Await,
|
|
655
663
|
Backtick,
|
|
@@ -786,12 +794,15 @@ var Civet = (() => {
|
|
|
786
794
|
InsertSpace,
|
|
787
795
|
InsertDot,
|
|
788
796
|
InsertBreak,
|
|
797
|
+
CoffeeBinaryExistentialEnabled,
|
|
789
798
|
CoffeeBooleansEnabled,
|
|
799
|
+
CoffeeClassesEnabled,
|
|
790
800
|
CoffeeCommentEnabled,
|
|
791
801
|
CoffeeDoEnabled,
|
|
792
802
|
CoffeeForLoopsEnabled,
|
|
793
803
|
CoffeeInterpolationEnabled,
|
|
794
804
|
CoffeeIsntEnabled,
|
|
805
|
+
CoffeeLineContinuationEnabled,
|
|
795
806
|
CoffeeNotEnabled,
|
|
796
807
|
CoffeeOfEnabled,
|
|
797
808
|
Reset,
|
|
@@ -812,153 +823,154 @@ var Civet = (() => {
|
|
|
812
823
|
var $L5 = $L("extends");
|
|
813
824
|
var $L6 = $L("this");
|
|
814
825
|
var $L7 = $L("#");
|
|
815
|
-
var $L8 = $L("
|
|
816
|
-
var $L9 = $L("
|
|
817
|
-
var $L10 = $L("
|
|
818
|
-
var $L11 = $L("
|
|
819
|
-
var $L12 = $L("
|
|
820
|
-
var $L13 = $L("
|
|
821
|
-
var $L14 = $L("
|
|
822
|
-
var $L15 = $L("
|
|
823
|
-
var $L16 = $L("
|
|
824
|
-
var $L17 = $L("
|
|
825
|
-
var $L18 = $L("
|
|
826
|
-
var $L19 = $L("
|
|
827
|
-
var $L20 = $L("
|
|
828
|
-
var $L21 = $L("
|
|
829
|
-
var $L22 = $L("
|
|
830
|
-
var $L23 = $L("
|
|
831
|
-
var $L24 = $L("
|
|
832
|
-
var $L25 = $L("
|
|
833
|
-
var $L26 = $L("
|
|
834
|
-
var $L27 = $L("
|
|
835
|
-
var $L28 = $L("
|
|
836
|
-
var $L29 = $L("
|
|
837
|
-
var $L30 = $L("
|
|
838
|
-
var $L31 = $L("
|
|
839
|
-
var $L32 = $L("
|
|
840
|
-
var $L33 = $L("
|
|
841
|
-
var $L34 = $L("
|
|
842
|
-
var $L35 = $L("
|
|
843
|
-
var $L36 = $L("
|
|
844
|
-
var $L37 = $L("
|
|
845
|
-
var $L38 = $L("
|
|
846
|
-
var $L39 = $L("
|
|
847
|
-
var $L40 = $L("
|
|
848
|
-
var $L41 = $L("
|
|
849
|
-
var $L42 = $L("
|
|
850
|
-
var $L43 = $L("
|
|
851
|
-
var $L44 = $L("
|
|
852
|
-
var $L45 = $L("
|
|
853
|
-
var $L46 = $L("
|
|
854
|
-
var $L47 = $L("
|
|
855
|
-
var $L48 = $L("
|
|
856
|
-
var $L49 = $L("
|
|
857
|
-
var $L50 = $L("
|
|
858
|
-
var $L51 = $L("
|
|
859
|
-
var $L52 = $L("
|
|
860
|
-
var $L53 = $L("
|
|
861
|
-
var $L54 = $L("
|
|
862
|
-
var $L55 = $L("
|
|
863
|
-
var $L56 = $L("
|
|
864
|
-
var $L57 = $L("
|
|
865
|
-
var $L58 = $L("
|
|
866
|
-
var $L59 = $L("
|
|
867
|
-
var $L60 = $L("
|
|
868
|
-
var $L61 = $L("
|
|
869
|
-
var $L62 = $L("
|
|
870
|
-
var $L63 = $L("
|
|
871
|
-
var $L64 = $L("
|
|
872
|
-
var $L65 = $L("
|
|
873
|
-
var $L66 = $L("
|
|
874
|
-
var $L67 = $L("
|
|
875
|
-
var $L68 = $L("
|
|
826
|
+
var $L8 = $L(".");
|
|
827
|
+
var $L9 = $L("super");
|
|
828
|
+
var $L10 = $L("import");
|
|
829
|
+
var $L11 = $L("!");
|
|
830
|
+
var $L12 = $L("::");
|
|
831
|
+
var $L13 = $L("super[");
|
|
832
|
+
var $L14 = $L("import.meta");
|
|
833
|
+
var $L15 = $L(")");
|
|
834
|
+
var $L16 = $L("->");
|
|
835
|
+
var $L17 = $L("null");
|
|
836
|
+
var $L18 = $L("true");
|
|
837
|
+
var $L19 = $L("false");
|
|
838
|
+
var $L20 = $L("yes");
|
|
839
|
+
var $L21 = $L("on");
|
|
840
|
+
var $L22 = $L("no");
|
|
841
|
+
var $L23 = $L("off");
|
|
842
|
+
var $L24 = $L(",");
|
|
843
|
+
var $L25 = $L("]");
|
|
844
|
+
var $L26 = $L("}");
|
|
845
|
+
var $L27 = $L("**=");
|
|
846
|
+
var $L28 = $L("*=");
|
|
847
|
+
var $L29 = $L("/=");
|
|
848
|
+
var $L30 = $L("%=");
|
|
849
|
+
var $L31 = $L("+=");
|
|
850
|
+
var $L32 = $L("-=");
|
|
851
|
+
var $L33 = $L("<<=");
|
|
852
|
+
var $L34 = $L(">>>=");
|
|
853
|
+
var $L35 = $L(">>=");
|
|
854
|
+
var $L36 = $L("&&=");
|
|
855
|
+
var $L37 = $L("&=");
|
|
856
|
+
var $L38 = $L("^=");
|
|
857
|
+
var $L39 = $L("||=");
|
|
858
|
+
var $L40 = $L("|=");
|
|
859
|
+
var $L41 = $L("??=");
|
|
860
|
+
var $L42 = $L("?=");
|
|
861
|
+
var $L43 = $L("=");
|
|
862
|
+
var $L44 = $L("**");
|
|
863
|
+
var $L45 = $L("*");
|
|
864
|
+
var $L46 = $L("/");
|
|
865
|
+
var $L47 = $L("%");
|
|
866
|
+
var $L48 = $L("+");
|
|
867
|
+
var $L49 = $L("-");
|
|
868
|
+
var $L50 = $L("<=");
|
|
869
|
+
var $L51 = $L(">=");
|
|
870
|
+
var $L52 = $L("<<");
|
|
871
|
+
var $L53 = $L(">>>");
|
|
872
|
+
var $L54 = $L(">>");
|
|
873
|
+
var $L55 = $L(">");
|
|
874
|
+
var $L56 = $L("!==");
|
|
875
|
+
var $L57 = $L("!=");
|
|
876
|
+
var $L58 = $L("isnt");
|
|
877
|
+
var $L59 = $L("is");
|
|
878
|
+
var $L60 = $L("===");
|
|
879
|
+
var $L61 = $L("==");
|
|
880
|
+
var $L62 = $L("and");
|
|
881
|
+
var $L63 = $L("&&");
|
|
882
|
+
var $L64 = $L("of");
|
|
883
|
+
var $L65 = $L("or");
|
|
884
|
+
var $L66 = $L("||");
|
|
885
|
+
var $L67 = $L("??");
|
|
886
|
+
var $L68 = $L("?");
|
|
876
887
|
var $L69 = $L("instanceof");
|
|
877
888
|
var $L70 = $L("in");
|
|
878
|
-
var $L71 = $L("
|
|
879
|
-
var $L72 = $L("
|
|
880
|
-
var $L73 = $L("
|
|
881
|
-
var $L74 = $L("
|
|
882
|
-
var $L75 = $L("
|
|
883
|
-
var $L76 = $L("
|
|
884
|
-
var $L77 = $L("
|
|
885
|
-
var $L78 = $L("
|
|
886
|
-
var $L79 = $L("
|
|
887
|
-
var $L80 = $L("
|
|
888
|
-
var $L81 = $L("
|
|
889
|
-
var $L82 = $L("
|
|
890
|
-
var $L83 = $L("
|
|
891
|
-
var $L84 = $L("
|
|
892
|
-
var $L85 = $L("
|
|
893
|
-
var $L86 = $L("
|
|
894
|
-
var $L87 = $L("
|
|
895
|
-
var $L88 = $L("
|
|
896
|
-
var $L89 = $L("
|
|
897
|
-
var $L90 = $L("
|
|
898
|
-
var $L91 = $L("
|
|
899
|
-
var $L92 = $L("
|
|
900
|
-
var $L93 = $L("
|
|
901
|
-
var $L94 = $L("
|
|
902
|
-
var $L95 = $L("
|
|
903
|
-
var $L96 = $L("
|
|
904
|
-
var $L97 = $L("
|
|
905
|
-
var $L98 = $L("
|
|
906
|
-
var $L99 = $L("
|
|
907
|
-
var $L100 = $L(
|
|
908
|
-
var $L101 = $L("
|
|
909
|
-
var $L102 = $L("
|
|
910
|
-
var $L103 = $L("
|
|
911
|
-
var $L104 = $L("
|
|
912
|
-
var $L105 = $L("
|
|
913
|
-
var $L106 = $L("
|
|
914
|
-
var $L107 = $L("
|
|
915
|
-
var $L108 = $L("
|
|
916
|
-
var $L109 = $L("
|
|
917
|
-
var $L110 = $L("
|
|
918
|
-
var $L111 = $L("
|
|
919
|
-
var $L112 = $L("
|
|
920
|
-
var $L113 = $L("
|
|
921
|
-
var $L114 = $L("
|
|
922
|
-
var $L115 = $L("
|
|
923
|
-
var $L116 = $L("
|
|
924
|
-
var $L117 = $L("
|
|
925
|
-
var $L118 = $L("
|
|
926
|
-
var $L119 = $L("
|
|
927
|
-
var $L120 = $L("
|
|
928
|
-
var $L121 = $L("
|
|
929
|
-
var $L122 = $L("
|
|
930
|
-
var $L123 = $L("
|
|
931
|
-
var $L124 = $L("
|
|
932
|
-
var $L125 = $L("
|
|
933
|
-
var $L126 = $L("
|
|
934
|
-
var $L127 = $L(
|
|
935
|
-
var $L128 = $L("'
|
|
936
|
-
var $L129 = $L("
|
|
937
|
-
var $L130 = $L("
|
|
938
|
-
var $L131 = $L("
|
|
939
|
-
var $L132 = $L("
|
|
940
|
-
var $L133 = $L("
|
|
941
|
-
var $L134 = $L("
|
|
942
|
-
var $L135 = $L("
|
|
943
|
-
var $L136 = $L("
|
|
944
|
-
var $L137 = $L("
|
|
945
|
-
var $L138 = $L("
|
|
946
|
-
var $L139 = $L("
|
|
947
|
-
var $L140 = $L("
|
|
948
|
-
var $L141 = $L("
|
|
949
|
-
var $L142 = $L("
|
|
950
|
-
var $L143 = $L("
|
|
951
|
-
var $L144 = $L("
|
|
952
|
-
var $L145 = $L("
|
|
953
|
-
var $L146 = $L("
|
|
954
|
-
var $L147 = $L("
|
|
955
|
-
var $L148 = $L("
|
|
956
|
-
var $L149 = $L("
|
|
957
|
-
var $L150 = $L("
|
|
958
|
-
var $L151 = $L("
|
|
959
|
-
var $L152 = $L("
|
|
960
|
-
var $L153 = $L("
|
|
961
|
-
var $L154 = $L("
|
|
889
|
+
var $L71 = $L("not");
|
|
890
|
+
var $L72 = $L("&");
|
|
891
|
+
var $L73 = $L("^");
|
|
892
|
+
var $L74 = $L("|");
|
|
893
|
+
var $L75 = $L(";");
|
|
894
|
+
var $L76 = $L("own");
|
|
895
|
+
var $L77 = $L("finally");
|
|
896
|
+
var $L78 = $L("break");
|
|
897
|
+
var $L79 = $L("continue");
|
|
898
|
+
var $L80 = $L("debugger");
|
|
899
|
+
var $L81 = $L("import type");
|
|
900
|
+
var $L82 = $L("default");
|
|
901
|
+
var $L83 = $L(":=");
|
|
902
|
+
var $L84 = $L("/*");
|
|
903
|
+
var $L85 = $L("*/");
|
|
904
|
+
var $L86 = $L("###");
|
|
905
|
+
var $L87 = $L("\\");
|
|
906
|
+
var $L88 = $L("as");
|
|
907
|
+
var $L89 = $L("@");
|
|
908
|
+
var $L90 = $L("async");
|
|
909
|
+
var $L91 = $L("await");
|
|
910
|
+
var $L92 = $L("`");
|
|
911
|
+
var $L93 = $L("by");
|
|
912
|
+
var $L94 = $L("case");
|
|
913
|
+
var $L95 = $L("catch");
|
|
914
|
+
var $L96 = $L("class");
|
|
915
|
+
var $L97 = $L("#{");
|
|
916
|
+
var $L98 = $L(":");
|
|
917
|
+
var $L99 = $L("delete");
|
|
918
|
+
var $L100 = $L("do");
|
|
919
|
+
var $L101 = $L("..");
|
|
920
|
+
var $L102 = $L("...");
|
|
921
|
+
var $L103 = $L('"');
|
|
922
|
+
var $L104 = $L("else");
|
|
923
|
+
var $L105 = $L("export");
|
|
924
|
+
var $L106 = $L("for");
|
|
925
|
+
var $L107 = $L("from");
|
|
926
|
+
var $L108 = $L("function");
|
|
927
|
+
var $L109 = $L("get");
|
|
928
|
+
var $L110 = $L("set");
|
|
929
|
+
var $L111 = $L("if");
|
|
930
|
+
var $L112 = $L(" ");
|
|
931
|
+
var $L113 = $L("let");
|
|
932
|
+
var $L114 = $L("const");
|
|
933
|
+
var $L115 = $L("loop");
|
|
934
|
+
var $L116 = $L("new");
|
|
935
|
+
var $L117 = $L("{");
|
|
936
|
+
var $L118 = $L("[");
|
|
937
|
+
var $L119 = $L("(");
|
|
938
|
+
var $L120 = $L("return");
|
|
939
|
+
var $L121 = $L("'");
|
|
940
|
+
var $L122 = $L("static");
|
|
941
|
+
var $L123 = $L("${");
|
|
942
|
+
var $L124 = $L("switch");
|
|
943
|
+
var $L125 = $L("target");
|
|
944
|
+
var $L126 = $L("then");
|
|
945
|
+
var $L127 = $L("throw");
|
|
946
|
+
var $L128 = $L('"""');
|
|
947
|
+
var $L129 = $L("'''");
|
|
948
|
+
var $L130 = $L("```");
|
|
949
|
+
var $L131 = $L("try");
|
|
950
|
+
var $L132 = $L("typeof");
|
|
951
|
+
var $L133 = $L("unless");
|
|
952
|
+
var $L134 = $L("until");
|
|
953
|
+
var $L135 = $L("var");
|
|
954
|
+
var $L136 = $L("void");
|
|
955
|
+
var $L137 = $L("when");
|
|
956
|
+
var $L138 = $L("while");
|
|
957
|
+
var $L139 = $L("yield");
|
|
958
|
+
var $L140 = $L("/>");
|
|
959
|
+
var $L141 = $L("</");
|
|
960
|
+
var $L142 = $L("<>");
|
|
961
|
+
var $L143 = $L("</>");
|
|
962
|
+
var $L144 = $L("declare");
|
|
963
|
+
var $L145 = $L("type");
|
|
964
|
+
var $L146 = $L("interface");
|
|
965
|
+
var $L147 = $L("namespace");
|
|
966
|
+
var $L148 = $L("readonly");
|
|
967
|
+
var $L149 = $L("asserts");
|
|
968
|
+
var $L150 = $L("keyof");
|
|
969
|
+
var $L151 = $L("infer");
|
|
970
|
+
var $L152 = $L("[]");
|
|
971
|
+
var $L153 = $L("civet");
|
|
972
|
+
var $L154 = $L(" ");
|
|
973
|
+
var $L155 = $L(" ");
|
|
962
974
|
var $R0 = $R(new RegExp("(of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
963
975
|
var $R1 = $R(new RegExp("[&]", "suy"));
|
|
964
976
|
var $R2 = $R(new RegExp("[!~+-]+", "suy"));
|
|
@@ -1093,7 +1105,9 @@ var Civet = (() => {
|
|
|
1093
1105
|
return ArgumentsWithTrailingCallExpressions$0(state);
|
|
1094
1106
|
}
|
|
1095
1107
|
}
|
|
1096
|
-
var ArgumentList$0 = $S($Y(EOS), NestedArgumentList)
|
|
1108
|
+
var ArgumentList$0 = $T($S($Y(EOS), NestedArgumentList), function(value) {
|
|
1109
|
+
return value[1];
|
|
1110
|
+
});
|
|
1097
1111
|
var ArgumentList$1 = InlineArgumentExpressions;
|
|
1098
1112
|
function ArgumentList(state) {
|
|
1099
1113
|
if (state.tokenize) {
|
|
@@ -1127,7 +1141,7 @@ var Civet = (() => {
|
|
|
1127
1141
|
return NestedArgument$0(state);
|
|
1128
1142
|
}
|
|
1129
1143
|
}
|
|
1130
|
-
var InlineArgumentExpressions$0 = $TS($S(
|
|
1144
|
+
var InlineArgumentExpressions$0 = $TS($S(ArgumentPart, $Q($S(__, Comma, $Q(TrailingComment), ArgumentPart))), function($skip, $loc, $0, $1, $2) {
|
|
1131
1145
|
if ($2.length == 0)
|
|
1132
1146
|
return $1;
|
|
1133
1147
|
return $0;
|
|
@@ -1141,6 +1155,20 @@ var Civet = (() => {
|
|
|
1141
1155
|
return InlineArgumentExpressions$0(state);
|
|
1142
1156
|
}
|
|
1143
1157
|
}
|
|
1158
|
+
var ArgumentPart$0 = $S(DotDotDot, ExtendedExpression);
|
|
1159
|
+
var ArgumentPart$1 = $TS($S(ExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
|
|
1160
|
+
if ($2) {
|
|
1161
|
+
return [$2, $1];
|
|
1162
|
+
}
|
|
1163
|
+
return $1;
|
|
1164
|
+
});
|
|
1165
|
+
function ArgumentPart(state) {
|
|
1166
|
+
if (state.tokenize) {
|
|
1167
|
+
return $TOKEN("ArgumentPart", state, ArgumentPart$0(state) || ArgumentPart$1(state));
|
|
1168
|
+
} else {
|
|
1169
|
+
return ArgumentPart$0(state) || ArgumentPart$1(state);
|
|
1170
|
+
}
|
|
1171
|
+
}
|
|
1144
1172
|
var ImplicitApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen);
|
|
1145
1173
|
function ImplicitApplication(state) {
|
|
1146
1174
|
if (state.verbose)
|
|
@@ -1155,9 +1183,7 @@ var Civet = (() => {
|
|
|
1155
1183
|
var spacing = $2;
|
|
1156
1184
|
return module.insertTrimmingSpace(spacing, "(");
|
|
1157
1185
|
});
|
|
1158
|
-
var ApplicationStart$1 = $
|
|
1159
|
-
return value[2];
|
|
1160
|
-
});
|
|
1186
|
+
var ApplicationStart$1 = $S(IndentedApplicationAllowed, $Y($S(EOS, NestedPropertyDefinitions)), InsertOpenParen);
|
|
1161
1187
|
function ApplicationStart(state) {
|
|
1162
1188
|
if (state.tokenize) {
|
|
1163
1189
|
return $TOKEN("ApplicationStart", state, ApplicationStart$0(state) || ApplicationStart$1(state));
|
|
@@ -1179,7 +1205,7 @@ var Civet = (() => {
|
|
|
1179
1205
|
return IndentedApplicationAllowed$0(state);
|
|
1180
1206
|
}
|
|
1181
1207
|
}
|
|
1182
|
-
var BinaryOpExpression$0 = $TS($S(UnaryExpression, $Q(
|
|
1208
|
+
var BinaryOpExpression$0 = $TS($S(UnaryExpression, $Q(BinaryOpRHS)), function($skip, $loc, $0, $1, $2) {
|
|
1183
1209
|
if ($2.length) {
|
|
1184
1210
|
return module.processBinaryOpExpression($0);
|
|
1185
1211
|
}
|
|
@@ -1194,6 +1220,26 @@ var Civet = (() => {
|
|
|
1194
1220
|
return BinaryOpExpression$0(state);
|
|
1195
1221
|
}
|
|
1196
1222
|
}
|
|
1223
|
+
var BinaryOpRHS$0 = $S(__, BinaryOp, __, $C(ParenthesizedAssignment, UnaryExpression, ExpressionizedStatement));
|
|
1224
|
+
function BinaryOpRHS(state) {
|
|
1225
|
+
if (state.verbose)
|
|
1226
|
+
console.log("ENTER:", "BinaryOpRHS");
|
|
1227
|
+
if (state.tokenize) {
|
|
1228
|
+
return $TOKEN("BinaryOpRHS", state, BinaryOpRHS$0(state));
|
|
1229
|
+
} else {
|
|
1230
|
+
return BinaryOpRHS$0(state);
|
|
1231
|
+
}
|
|
1232
|
+
}
|
|
1233
|
+
var ParenthesizedAssignment$0 = $S(InsertOpenParen, ActualAssignment, InsertCloseParen);
|
|
1234
|
+
function ParenthesizedAssignment(state) {
|
|
1235
|
+
if (state.verbose)
|
|
1236
|
+
console.log("ENTER:", "ParenthesizedAssignment");
|
|
1237
|
+
if (state.tokenize) {
|
|
1238
|
+
return $TOKEN("ParenthesizedAssignment", state, ParenthesizedAssignment$0(state));
|
|
1239
|
+
} else {
|
|
1240
|
+
return ParenthesizedAssignment$0(state);
|
|
1241
|
+
}
|
|
1242
|
+
}
|
|
1197
1243
|
var UnaryExpression$0 = $TS($S($Q(UnaryOp), UpdateExpression, $E(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1198
1244
|
var pre = $1;
|
|
1199
1245
|
var exp = $2;
|
|
@@ -1296,7 +1342,16 @@ var Civet = (() => {
|
|
|
1296
1342
|
}
|
|
1297
1343
|
var AssignmentExpressionTail$0 = YieldExpression;
|
|
1298
1344
|
var AssignmentExpressionTail$1 = ArrowFunction;
|
|
1299
|
-
var AssignmentExpressionTail$2 =
|
|
1345
|
+
var AssignmentExpressionTail$2 = ActualAssignment;
|
|
1346
|
+
var AssignmentExpressionTail$3 = ConditionalExpression;
|
|
1347
|
+
function AssignmentExpressionTail(state) {
|
|
1348
|
+
if (state.tokenize) {
|
|
1349
|
+
return $TOKEN("AssignmentExpressionTail", state, AssignmentExpressionTail$0(state) || AssignmentExpressionTail$1(state) || AssignmentExpressionTail$2(state) || AssignmentExpressionTail$3(state));
|
|
1350
|
+
} else {
|
|
1351
|
+
return AssignmentExpressionTail$0(state) || AssignmentExpressionTail$1(state) || AssignmentExpressionTail$2(state) || AssignmentExpressionTail$3(state);
|
|
1352
|
+
}
|
|
1353
|
+
}
|
|
1354
|
+
var ActualAssignment$0 = $TS($S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), ExtendedExpression), function($skip, $loc, $0, $1, $2) {
|
|
1300
1355
|
let tail = [], i = 0, len = $1.length;
|
|
1301
1356
|
while (i < len) {
|
|
1302
1357
|
const lastAssignment = $1[i++];
|
|
@@ -1349,12 +1404,13 @@ var Civet = (() => {
|
|
|
1349
1404
|
names
|
|
1350
1405
|
};
|
|
1351
1406
|
});
|
|
1352
|
-
|
|
1353
|
-
|
|
1407
|
+
function ActualAssignment(state) {
|
|
1408
|
+
if (state.verbose)
|
|
1409
|
+
console.log("ENTER:", "ActualAssignment");
|
|
1354
1410
|
if (state.tokenize) {
|
|
1355
|
-
return $TOKEN("
|
|
1411
|
+
return $TOKEN("ActualAssignment", state, ActualAssignment$0(state));
|
|
1356
1412
|
} else {
|
|
1357
|
-
return
|
|
1413
|
+
return ActualAssignment$0(state);
|
|
1358
1414
|
}
|
|
1359
1415
|
}
|
|
1360
1416
|
var YieldExpression$0 = $S(Yield, YieldTail);
|
|
@@ -1448,9 +1504,11 @@ var Civet = (() => {
|
|
|
1448
1504
|
return FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state);
|
|
1449
1505
|
}
|
|
1450
1506
|
}
|
|
1451
|
-
var ConditionalExpression$0 = $TS($S(ShortCircuitExpression, $E(
|
|
1452
|
-
if ($2)
|
|
1453
|
-
|
|
1507
|
+
var ConditionalExpression$0 = $TS($S(ShortCircuitExpression, $E(TernaryRest)), function($skip, $loc, $0, $1, $2) {
|
|
1508
|
+
if ($2) {
|
|
1509
|
+
$2.unshift($1);
|
|
1510
|
+
return $2;
|
|
1511
|
+
}
|
|
1454
1512
|
return $1;
|
|
1455
1513
|
});
|
|
1456
1514
|
function ConditionalExpression(state) {
|
|
@@ -1462,6 +1520,19 @@ var Civet = (() => {
|
|
|
1462
1520
|
return ConditionalExpression$0(state);
|
|
1463
1521
|
}
|
|
1464
1522
|
}
|
|
1523
|
+
var TernaryRest$0 = $TS($S($N(CoffeeBinaryExistentialEnabled), __, QuestionMark, ExtendedExpression, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
1524
|
+
$0.shift();
|
|
1525
|
+
return $0;
|
|
1526
|
+
});
|
|
1527
|
+
function TernaryRest(state) {
|
|
1528
|
+
if (state.verbose)
|
|
1529
|
+
console.log("ENTER:", "TernaryRest");
|
|
1530
|
+
if (state.tokenize) {
|
|
1531
|
+
return $TOKEN("TernaryRest", state, TernaryRest$0(state));
|
|
1532
|
+
} else {
|
|
1533
|
+
return TernaryRest$0(state);
|
|
1534
|
+
}
|
|
1535
|
+
}
|
|
1465
1536
|
var ShortCircuitExpression$0 = BinaryOpExpression;
|
|
1466
1537
|
function ShortCircuitExpression(state) {
|
|
1467
1538
|
if (state.verbose)
|
|
@@ -1473,10 +1544,10 @@ var Civet = (() => {
|
|
|
1473
1544
|
}
|
|
1474
1545
|
}
|
|
1475
1546
|
var PrimaryExpression$0 = This;
|
|
1476
|
-
var PrimaryExpression$1 =
|
|
1477
|
-
var PrimaryExpression$2 =
|
|
1478
|
-
var PrimaryExpression$3 =
|
|
1479
|
-
var PrimaryExpression$4 =
|
|
1547
|
+
var PrimaryExpression$1 = Literal;
|
|
1548
|
+
var PrimaryExpression$2 = ArrayLiteral;
|
|
1549
|
+
var PrimaryExpression$3 = ObjectLiteral;
|
|
1550
|
+
var PrimaryExpression$4 = IdentifierReference;
|
|
1480
1551
|
var PrimaryExpression$5 = FunctionExpression;
|
|
1481
1552
|
var PrimaryExpression$6 = ClassExpression;
|
|
1482
1553
|
var PrimaryExpression$7 = RegularExpressionLiteral;
|
|
@@ -1594,7 +1665,19 @@ var Civet = (() => {
|
|
|
1594
1665
|
return ClassElement$0(state) || ClassElement$1(state);
|
|
1595
1666
|
}
|
|
1596
1667
|
}
|
|
1597
|
-
var FieldDefinition$0 = $TS($S(
|
|
1668
|
+
var FieldDefinition$0 = $TS($S(CoffeeClassesEnabled, ClassElementName, __, Colon, __, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
1669
|
+
var id = $2;
|
|
1670
|
+
var exp = $6;
|
|
1671
|
+
switch (exp.type) {
|
|
1672
|
+
case "FunctionExpression":
|
|
1673
|
+
exp.children.shift();
|
|
1674
|
+
exp.id.push(id);
|
|
1675
|
+
return exp;
|
|
1676
|
+
default:
|
|
1677
|
+
return [id, " = ", exp];
|
|
1678
|
+
}
|
|
1679
|
+
});
|
|
1680
|
+
var FieldDefinition$1 = $TS($S(InsertReadonly, ClassElementName, $E(TypeSuffix), __, ConstAssignment, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
1598
1681
|
var r = $1;
|
|
1599
1682
|
var ca = $5;
|
|
1600
1683
|
r.children[0].$loc = {
|
|
@@ -1603,20 +1686,24 @@ var Civet = (() => {
|
|
|
1603
1686
|
};
|
|
1604
1687
|
return $0;
|
|
1605
1688
|
});
|
|
1606
|
-
var FieldDefinition$
|
|
1689
|
+
var FieldDefinition$2 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
|
|
1607
1690
|
function FieldDefinition(state) {
|
|
1608
1691
|
if (state.tokenize) {
|
|
1609
|
-
return $TOKEN("FieldDefinition", state, FieldDefinition$0(state) || FieldDefinition$1(state));
|
|
1692
|
+
return $TOKEN("FieldDefinition", state, FieldDefinition$0(state) || FieldDefinition$1(state) || FieldDefinition$2(state));
|
|
1610
1693
|
} else {
|
|
1611
|
-
return FieldDefinition$0(state) || FieldDefinition$1(state);
|
|
1694
|
+
return FieldDefinition$0(state) || FieldDefinition$1(state) || FieldDefinition$2(state);
|
|
1612
1695
|
}
|
|
1613
1696
|
}
|
|
1614
1697
|
var This$0 = $TV($EXPECT($L6, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
1615
1698
|
return { $loc, token: $1 };
|
|
1616
1699
|
});
|
|
1617
|
-
var This$1 = $S(
|
|
1618
|
-
|
|
1619
|
-
return
|
|
1700
|
+
var This$1 = $TS($S(At, $S($E($EXPECT($L7, fail, 'This "#"')), IdentifierName)), function($skip, $loc, $0, $1, $2) {
|
|
1701
|
+
$1.token = "this.";
|
|
1702
|
+
return $0;
|
|
1703
|
+
});
|
|
1704
|
+
var This$2 = $TS($S(At), function($skip, $loc, $0, $1) {
|
|
1705
|
+
$1.token = "this";
|
|
1706
|
+
return $1;
|
|
1620
1707
|
});
|
|
1621
1708
|
function This(state) {
|
|
1622
1709
|
if (state.tokenize) {
|
|
@@ -1625,19 +1712,7 @@ var Civet = (() => {
|
|
|
1625
1712
|
return This$0(state) || This$1(state) || This$2(state);
|
|
1626
1713
|
}
|
|
1627
1714
|
}
|
|
1628
|
-
var
|
|
1629
|
-
return { $loc, token: "this." };
|
|
1630
|
-
});
|
|
1631
|
-
function AtAccessor(state) {
|
|
1632
|
-
if (state.verbose)
|
|
1633
|
-
console.log("ENTER:", "AtAccessor");
|
|
1634
|
-
if (state.tokenize) {
|
|
1635
|
-
return $TOKEN("AtAccessor", state, AtAccessor$0(state));
|
|
1636
|
-
} else {
|
|
1637
|
-
return AtAccessor$0(state);
|
|
1638
|
-
}
|
|
1639
|
-
}
|
|
1640
|
-
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($L9, fail, 'LeftHandSideExpression "."')), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
1715
|
+
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($L8, fail, 'LeftHandSideExpression "."')), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
1641
1716
|
if ($1.length)
|
|
1642
1717
|
return $0;
|
|
1643
1718
|
return $2;
|
|
@@ -1651,8 +1726,8 @@ var Civet = (() => {
|
|
|
1651
1726
|
return LeftHandSideExpression$0(state);
|
|
1652
1727
|
}
|
|
1653
1728
|
}
|
|
1654
|
-
var CallExpression$0 = $S($EXPECT($
|
|
1655
|
-
var CallExpression$1 = $S($EXPECT($
|
|
1729
|
+
var CallExpression$0 = $S($EXPECT($L9, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
|
|
1730
|
+
var CallExpression$1 = $S($EXPECT($L10, fail, 'CallExpression "import"'), __, OpenParen, ExtendedExpression, __, CloseParen);
|
|
1656
1731
|
var CallExpression$2 = $TS($S(MemberExpression, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
1657
1732
|
if ($2.length)
|
|
1658
1733
|
return $0;
|
|
@@ -1685,7 +1760,7 @@ var Civet = (() => {
|
|
|
1685
1760
|
return OptionalShorthand$0(state);
|
|
1686
1761
|
}
|
|
1687
1762
|
}
|
|
1688
|
-
var NonNullAssertion$0 = $T($EXPECT($
|
|
1763
|
+
var NonNullAssertion$0 = $T($EXPECT($L11, fail, 'NonNullAssertion "!"'), function(value) {
|
|
1689
1764
|
return { "ts": true, "children": value };
|
|
1690
1765
|
});
|
|
1691
1766
|
function NonNullAssertion(state) {
|
|
@@ -1735,7 +1810,7 @@ var Civet = (() => {
|
|
|
1735
1810
|
$2.children.unshift($1[1]);
|
|
1736
1811
|
return $2;
|
|
1737
1812
|
});
|
|
1738
|
-
var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($
|
|
1813
|
+
var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L12, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1739
1814
|
var id = $3;
|
|
1740
1815
|
if (id)
|
|
1741
1816
|
return [".prototype.", id];
|
|
@@ -1809,7 +1884,7 @@ var Civet = (() => {
|
|
|
1809
1884
|
return PropertyAccess$0(state);
|
|
1810
1885
|
}
|
|
1811
1886
|
}
|
|
1812
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
1887
|
+
var SuperProperty$0 = $S($EXPECT($L13, fail, 'SuperProperty "super["'), ExtendedExpression, __, CloseBracket);
|
|
1813
1888
|
function SuperProperty(state) {
|
|
1814
1889
|
if (state.verbose)
|
|
1815
1890
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1820,7 +1895,7 @@ var Civet = (() => {
|
|
|
1820
1895
|
}
|
|
1821
1896
|
}
|
|
1822
1897
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
1823
|
-
var MetaProperty$1 = $TV($EXPECT($
|
|
1898
|
+
var MetaProperty$1 = $TV($EXPECT($L14, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
|
|
1824
1899
|
return { $loc, token: $1 };
|
|
1825
1900
|
});
|
|
1826
1901
|
function MetaProperty(state) {
|
|
@@ -1888,7 +1963,7 @@ var Civet = (() => {
|
|
|
1888
1963
|
}
|
|
1889
1964
|
}
|
|
1890
1965
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
1891
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
1966
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L15, fail, 'ParameterElementDelimiter ")"')));
|
|
1892
1967
|
var ParameterElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1893
1968
|
return { $loc, token: "," };
|
|
1894
1969
|
});
|
|
@@ -2229,7 +2304,7 @@ var Civet = (() => {
|
|
|
2229
2304
|
var FunctionExpression$1 = $TS($S(Ampersand, $N(_), $P(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
2230
2305
|
$1.token = "$ => $";
|
|
2231
2306
|
return {
|
|
2232
|
-
type: "
|
|
2307
|
+
type: "ArrowFunction",
|
|
2233
2308
|
children: [$1, $3]
|
|
2234
2309
|
};
|
|
2235
2310
|
});
|
|
@@ -2238,13 +2313,13 @@ var Civet = (() => {
|
|
|
2238
2313
|
$1.token = "$ => $";
|
|
2239
2314
|
const exp = module.processBinaryOpExpression($0);
|
|
2240
2315
|
return {
|
|
2241
|
-
type: "
|
|
2316
|
+
type: "ArrowFunction",
|
|
2242
2317
|
children: exp
|
|
2243
2318
|
};
|
|
2244
2319
|
});
|
|
2245
2320
|
var FunctionExpression$3 = $TS($S($EXPECT($R2, fail, "FunctionExpression /[!~+-]+/"), Ampersand), function($skip, $loc, $0, $1, $2) {
|
|
2246
2321
|
return {
|
|
2247
|
-
type: "
|
|
2322
|
+
type: "ArrowFunction",
|
|
2248
2323
|
children: ["$ => ", $1, "$"]
|
|
2249
2324
|
};
|
|
2250
2325
|
});
|
|
@@ -2290,7 +2365,7 @@ var Civet = (() => {
|
|
|
2290
2365
|
return ThinArrowFunction$0(state);
|
|
2291
2366
|
}
|
|
2292
2367
|
}
|
|
2293
|
-
var Arrow$0 = $TV($EXPECT($
|
|
2368
|
+
var Arrow$0 = $TV($EXPECT($L16, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
2294
2369
|
return { $loc, token: $1 };
|
|
2295
2370
|
});
|
|
2296
2371
|
function Arrow(state) {
|
|
@@ -2440,7 +2515,7 @@ var Civet = (() => {
|
|
|
2440
2515
|
return LiteralContent$0(state) || LiteralContent$1(state) || LiteralContent$2(state) || LiteralContent$3(state);
|
|
2441
2516
|
}
|
|
2442
2517
|
}
|
|
2443
|
-
var NullLiteral$0 = $TV($EXPECT($
|
|
2518
|
+
var NullLiteral$0 = $TV($EXPECT($L17, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
2444
2519
|
return { $loc, token: $1 };
|
|
2445
2520
|
});
|
|
2446
2521
|
function NullLiteral(state) {
|
|
@@ -2452,8 +2527,10 @@ var Civet = (() => {
|
|
|
2452
2527
|
return NullLiteral$0(state);
|
|
2453
2528
|
}
|
|
2454
2529
|
}
|
|
2455
|
-
var BooleanLiteral$0 = CoffeeScriptBooleanLiteral
|
|
2456
|
-
|
|
2530
|
+
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
2531
|
+
return value[1];
|
|
2532
|
+
});
|
|
2533
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L18, fail, 'BooleanLiteral "true"'), $EXPECT($L19, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2457
2534
|
return { $loc, token: $1 };
|
|
2458
2535
|
});
|
|
2459
2536
|
function BooleanLiteral(state) {
|
|
@@ -2463,10 +2540,10 @@ var Civet = (() => {
|
|
|
2463
2540
|
return BooleanLiteral$0(state) || BooleanLiteral$1(state);
|
|
2464
2541
|
}
|
|
2465
2542
|
}
|
|
2466
|
-
var CoffeeScriptBooleanLiteral$0 = $
|
|
2543
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L20, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2467
2544
|
return { $loc, token: "true" };
|
|
2468
2545
|
});
|
|
2469
|
-
var CoffeeScriptBooleanLiteral$1 = $
|
|
2546
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2470
2547
|
return { $loc, token: "false" };
|
|
2471
2548
|
});
|
|
2472
2549
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -2476,7 +2553,7 @@ var Civet = (() => {
|
|
|
2476
2553
|
return CoffeeScriptBooleanLiteral$0(state) || CoffeeScriptBooleanLiteral$1(state);
|
|
2477
2554
|
}
|
|
2478
2555
|
}
|
|
2479
|
-
var Comma$0 = $TV($EXPECT($
|
|
2556
|
+
var Comma$0 = $TV($EXPECT($L24, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
2480
2557
|
return { $loc, token: $1 };
|
|
2481
2558
|
});
|
|
2482
2559
|
function Comma(state) {
|
|
@@ -2674,7 +2751,7 @@ var Civet = (() => {
|
|
|
2674
2751
|
}
|
|
2675
2752
|
}
|
|
2676
2753
|
var ArrayElementDelimiter$0 = $S($Q(_), Comma);
|
|
2677
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2754
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
|
|
2678
2755
|
var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2679
2756
|
return { $loc, token: "," };
|
|
2680
2757
|
});
|
|
@@ -2736,11 +2813,12 @@ var Civet = (() => {
|
|
|
2736
2813
|
}
|
|
2737
2814
|
var ObjectLiteral$0 = BracedObjectLiteral;
|
|
2738
2815
|
var ObjectLiteral$1 = NestedObjectLiteral;
|
|
2816
|
+
var ObjectLiteral$2 = InlineObjectLiteral;
|
|
2739
2817
|
function ObjectLiteral(state) {
|
|
2740
2818
|
if (state.tokenize) {
|
|
2741
|
-
return $TOKEN("ObjectLiteral", state, ObjectLiteral$0(state) || ObjectLiteral$1(state));
|
|
2819
|
+
return $TOKEN("ObjectLiteral", state, ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state));
|
|
2742
2820
|
} else {
|
|
2743
|
-
return ObjectLiteral$0(state) || ObjectLiteral$1(state);
|
|
2821
|
+
return ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state);
|
|
2744
2822
|
}
|
|
2745
2823
|
}
|
|
2746
2824
|
var BracedObjectLiteral$0 = $TS($S(OpenBrace, $E(BracedObjectLiteralContent), __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
@@ -2840,8 +2918,20 @@ var Civet = (() => {
|
|
|
2840
2918
|
return NestedPropertyDefinition$0(state);
|
|
2841
2919
|
}
|
|
2842
2920
|
}
|
|
2921
|
+
var InlineObjectLiteral$0 = $TS($S(InsertOpenBrace, SnugNamedProperty, $Q($S($Q(TrailingComment), Comma, __, NamedProperty)), InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2922
|
+
return [$1[1], $2, ...$3.flat(), $4];
|
|
2923
|
+
});
|
|
2924
|
+
function InlineObjectLiteral(state) {
|
|
2925
|
+
if (state.verbose)
|
|
2926
|
+
console.log("ENTER:", "InlineObjectLiteral");
|
|
2927
|
+
if (state.tokenize) {
|
|
2928
|
+
return $TOKEN("InlineObjectLiteral", state, InlineObjectLiteral$0(state));
|
|
2929
|
+
} else {
|
|
2930
|
+
return InlineObjectLiteral$0(state);
|
|
2931
|
+
}
|
|
2932
|
+
}
|
|
2843
2933
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
2844
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2934
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ObjectPropertyDelimiter "}"')));
|
|
2845
2935
|
var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2846
2936
|
return { $loc, token: "," };
|
|
2847
2937
|
});
|
|
@@ -2852,7 +2942,7 @@ var Civet = (() => {
|
|
|
2852
2942
|
return ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state);
|
|
2853
2943
|
}
|
|
2854
2944
|
}
|
|
2855
|
-
var PropertyDefinitionList$0 = $TS($S(PropertyDefinition, $Q($S(
|
|
2945
|
+
var PropertyDefinitionList$0 = $TS($S(PropertyDefinition, $Q($S(ObjectPropertyDelimiter, __, PropertyDefinition))), function($skip, $loc, $0, $1, $2) {
|
|
2856
2946
|
if ($2.length) {
|
|
2857
2947
|
return [].concat($1 || [], ...$2);
|
|
2858
2948
|
}
|
|
@@ -2870,7 +2960,28 @@ var Civet = (() => {
|
|
|
2870
2960
|
return PropertyDefinitionList$0(state);
|
|
2871
2961
|
}
|
|
2872
2962
|
}
|
|
2873
|
-
var PropertyDefinition$0 = $TS($S(
|
|
2963
|
+
var PropertyDefinition$0 = $TS($S(At, IdentifierReference, $Y(ObjectPropertyDelimiter)), function($skip, $loc, $0, $1, $2, $3) {
|
|
2964
|
+
var at = $1;
|
|
2965
|
+
var id = $2;
|
|
2966
|
+
at.token = "this.";
|
|
2967
|
+
return {
|
|
2968
|
+
type: "Property",
|
|
2969
|
+
children: [id, ": ", at, id],
|
|
2970
|
+
names: id.names
|
|
2971
|
+
};
|
|
2972
|
+
});
|
|
2973
|
+
var PropertyDefinition$1 = NamedProperty;
|
|
2974
|
+
var PropertyDefinition$2 = MethodDefinition;
|
|
2975
|
+
var PropertyDefinition$3 = $S(DotDotDot, ExtendedExpression);
|
|
2976
|
+
var PropertyDefinition$4 = IdentifierReference;
|
|
2977
|
+
function PropertyDefinition(state) {
|
|
2978
|
+
if (state.tokenize) {
|
|
2979
|
+
return $TOKEN("PropertyDefinition", state, PropertyDefinition$0(state) || PropertyDefinition$1(state) || PropertyDefinition$2(state) || PropertyDefinition$3(state) || PropertyDefinition$4(state));
|
|
2980
|
+
} else {
|
|
2981
|
+
return PropertyDefinition$0(state) || PropertyDefinition$1(state) || PropertyDefinition$2(state) || PropertyDefinition$3(state) || PropertyDefinition$4(state);
|
|
2982
|
+
}
|
|
2983
|
+
}
|
|
2984
|
+
var NamedProperty$0 = $TS($S(PropertyName, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2874
2985
|
var exp = $4;
|
|
2875
2986
|
return {
|
|
2876
2987
|
type: "Property",
|
|
@@ -2878,14 +2989,30 @@ var Civet = (() => {
|
|
|
2878
2989
|
names: exp.names || []
|
|
2879
2990
|
};
|
|
2880
2991
|
});
|
|
2881
|
-
|
|
2882
|
-
|
|
2883
|
-
|
|
2884
|
-
function PropertyDefinition(state) {
|
|
2992
|
+
function NamedProperty(state) {
|
|
2993
|
+
if (state.verbose)
|
|
2994
|
+
console.log("ENTER:", "NamedProperty");
|
|
2885
2995
|
if (state.tokenize) {
|
|
2886
|
-
return $TOKEN("
|
|
2996
|
+
return $TOKEN("NamedProperty", state, NamedProperty$0(state));
|
|
2887
2997
|
} else {
|
|
2888
|
-
return
|
|
2998
|
+
return NamedProperty$0(state);
|
|
2999
|
+
}
|
|
3000
|
+
}
|
|
3001
|
+
var SnugNamedProperty$0 = $TS($S(PropertyName, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
3002
|
+
var exp = $3;
|
|
3003
|
+
return {
|
|
3004
|
+
type: "Property",
|
|
3005
|
+
children: $0,
|
|
3006
|
+
names: exp.names || []
|
|
3007
|
+
};
|
|
3008
|
+
});
|
|
3009
|
+
function SnugNamedProperty(state) {
|
|
3010
|
+
if (state.verbose)
|
|
3011
|
+
console.log("ENTER:", "SnugNamedProperty");
|
|
3012
|
+
if (state.tokenize) {
|
|
3013
|
+
return $TOKEN("SnugNamedProperty", state, SnugNamedProperty$0(state));
|
|
3014
|
+
} else {
|
|
3015
|
+
return SnugNamedProperty$0(state);
|
|
2889
3016
|
}
|
|
2890
3017
|
}
|
|
2891
3018
|
var PropertyName$0 = NumericLiteral;
|
|
@@ -3002,25 +3129,25 @@ var Civet = (() => {
|
|
|
3002
3129
|
return AssignmentOp$0(state);
|
|
3003
3130
|
}
|
|
3004
3131
|
}
|
|
3005
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
3006
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
3007
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
3008
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
3009
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
3010
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
3011
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
3012
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
3013
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
3014
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
3015
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
3016
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
3017
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
3018
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
3019
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
3020
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
3132
|
+
var AssignmentOpSymbol$0 = $EXPECT($L27, fail, 'AssignmentOpSymbol "**="');
|
|
3133
|
+
var AssignmentOpSymbol$1 = $EXPECT($L28, fail, 'AssignmentOpSymbol "*="');
|
|
3134
|
+
var AssignmentOpSymbol$2 = $EXPECT($L29, fail, 'AssignmentOpSymbol "/="');
|
|
3135
|
+
var AssignmentOpSymbol$3 = $EXPECT($L30, fail, 'AssignmentOpSymbol "%="');
|
|
3136
|
+
var AssignmentOpSymbol$4 = $EXPECT($L31, fail, 'AssignmentOpSymbol "+="');
|
|
3137
|
+
var AssignmentOpSymbol$5 = $EXPECT($L32, fail, 'AssignmentOpSymbol "-="');
|
|
3138
|
+
var AssignmentOpSymbol$6 = $EXPECT($L33, fail, 'AssignmentOpSymbol "<<="');
|
|
3139
|
+
var AssignmentOpSymbol$7 = $EXPECT($L34, fail, 'AssignmentOpSymbol ">>>="');
|
|
3140
|
+
var AssignmentOpSymbol$8 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>="');
|
|
3141
|
+
var AssignmentOpSymbol$9 = $EXPECT($L36, fail, 'AssignmentOpSymbol "&&="');
|
|
3142
|
+
var AssignmentOpSymbol$10 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&="');
|
|
3143
|
+
var AssignmentOpSymbol$11 = $EXPECT($L38, fail, 'AssignmentOpSymbol "^="');
|
|
3144
|
+
var AssignmentOpSymbol$12 = $EXPECT($L39, fail, 'AssignmentOpSymbol "||="');
|
|
3145
|
+
var AssignmentOpSymbol$13 = $EXPECT($L40, fail, 'AssignmentOpSymbol "|="');
|
|
3146
|
+
var AssignmentOpSymbol$14 = $EXPECT($L41, fail, 'AssignmentOpSymbol "??="');
|
|
3147
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L42, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
3021
3148
|
return "??=";
|
|
3022
3149
|
});
|
|
3023
|
-
var AssignmentOpSymbol$16 = $EXPECT($
|
|
3150
|
+
var AssignmentOpSymbol$16 = $EXPECT($L43, fail, 'AssignmentOpSymbol "="');
|
|
3024
3151
|
function AssignmentOpSymbol(state) {
|
|
3025
3152
|
if (state.tokenize) {
|
|
3026
3153
|
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));
|
|
@@ -3042,68 +3169,80 @@ var Civet = (() => {
|
|
|
3042
3169
|
return BinaryOp$0(state);
|
|
3043
3170
|
}
|
|
3044
3171
|
}
|
|
3045
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
3046
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
3047
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
3048
|
-
var BinaryOpSymbol$3 = $EXPECT($
|
|
3049
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
3050
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
3051
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
3052
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
3053
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
3172
|
+
var BinaryOpSymbol$0 = $EXPECT($L44, fail, 'BinaryOpSymbol "**"');
|
|
3173
|
+
var BinaryOpSymbol$1 = $EXPECT($L45, fail, 'BinaryOpSymbol "*"');
|
|
3174
|
+
var BinaryOpSymbol$2 = $EXPECT($L46, fail, 'BinaryOpSymbol "/"');
|
|
3175
|
+
var BinaryOpSymbol$3 = $EXPECT($L47, fail, 'BinaryOpSymbol "%"');
|
|
3176
|
+
var BinaryOpSymbol$4 = $EXPECT($L48, fail, 'BinaryOpSymbol "+"');
|
|
3177
|
+
var BinaryOpSymbol$5 = $EXPECT($L49, fail, 'BinaryOpSymbol "-"');
|
|
3178
|
+
var BinaryOpSymbol$6 = $EXPECT($L50, fail, 'BinaryOpSymbol "<="');
|
|
3179
|
+
var BinaryOpSymbol$7 = $EXPECT($L51, fail, 'BinaryOpSymbol ">="');
|
|
3180
|
+
var BinaryOpSymbol$8 = $EXPECT($L52, fail, 'BinaryOpSymbol "<<"');
|
|
3054
3181
|
var BinaryOpSymbol$9 = $EXPECT($L4, fail, 'BinaryOpSymbol "<"');
|
|
3055
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
3056
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
3057
|
-
var BinaryOpSymbol$12 = $EXPECT($
|
|
3058
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
3059
|
-
var BinaryOpSymbol$14 = $TV($EXPECT($
|
|
3182
|
+
var BinaryOpSymbol$10 = $EXPECT($L53, fail, 'BinaryOpSymbol ">>>"');
|
|
3183
|
+
var BinaryOpSymbol$11 = $EXPECT($L54, fail, 'BinaryOpSymbol ">>"');
|
|
3184
|
+
var BinaryOpSymbol$12 = $EXPECT($L55, fail, 'BinaryOpSymbol ">"');
|
|
3185
|
+
var BinaryOpSymbol$13 = $EXPECT($L56, fail, 'BinaryOpSymbol "!=="');
|
|
3186
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L57, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
3060
3187
|
if (module.config.coffeeEq)
|
|
3061
3188
|
return "!==";
|
|
3062
3189
|
return $1;
|
|
3063
3190
|
});
|
|
3064
|
-
var BinaryOpSymbol$15 = $TS($S($EXPECT($
|
|
3191
|
+
var BinaryOpSymbol$15 = $TS($S($EXPECT($L58, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3065
3192
|
if (module.config.coffeeIsnt)
|
|
3066
3193
|
return "!==";
|
|
3067
3194
|
return $skip;
|
|
3068
3195
|
});
|
|
3069
|
-
var BinaryOpSymbol$16 = $T($S($EXPECT($
|
|
3196
|
+
var BinaryOpSymbol$16 = $T($S($EXPECT($L59, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
3070
3197
|
return "===";
|
|
3071
3198
|
});
|
|
3072
|
-
var BinaryOpSymbol$17 = $EXPECT($
|
|
3073
|
-
var BinaryOpSymbol$18 = $TV($EXPECT($
|
|
3199
|
+
var BinaryOpSymbol$17 = $EXPECT($L60, fail, 'BinaryOpSymbol "==="');
|
|
3200
|
+
var BinaryOpSymbol$18 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
3074
3201
|
if (module.config.coffeeEq)
|
|
3075
3202
|
return "===";
|
|
3076
3203
|
return $1;
|
|
3077
3204
|
});
|
|
3078
|
-
var BinaryOpSymbol$19 = $T($S($EXPECT($
|
|
3205
|
+
var BinaryOpSymbol$19 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
3079
3206
|
return "&&";
|
|
3080
3207
|
});
|
|
3081
|
-
var BinaryOpSymbol$20 = $EXPECT($
|
|
3082
|
-
var BinaryOpSymbol$21 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
3208
|
+
var BinaryOpSymbol$20 = $EXPECT($L63, fail, 'BinaryOpSymbol "&&"');
|
|
3209
|
+
var BinaryOpSymbol$21 = $T($S(CoffeeOfEnabled, $EXPECT($L64, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
3083
3210
|
return "in";
|
|
3084
3211
|
});
|
|
3085
|
-
var BinaryOpSymbol$22 = $T($S($EXPECT($
|
|
3212
|
+
var BinaryOpSymbol$22 = $T($S($EXPECT($L65, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
3086
3213
|
return "||";
|
|
3087
3214
|
});
|
|
3088
|
-
var BinaryOpSymbol$23 = $EXPECT($
|
|
3089
|
-
var BinaryOpSymbol$24 = $EXPECT($
|
|
3090
|
-
var BinaryOpSymbol$25 = $
|
|
3215
|
+
var BinaryOpSymbol$23 = $EXPECT($L66, fail, 'BinaryOpSymbol "||"');
|
|
3216
|
+
var BinaryOpSymbol$24 = $EXPECT($L67, fail, 'BinaryOpSymbol "??"');
|
|
3217
|
+
var BinaryOpSymbol$25 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L68, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
3218
|
+
return "??";
|
|
3219
|
+
});
|
|
3220
|
+
var BinaryOpSymbol$26 = $TS($S($EXPECT($L69, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3091
3221
|
return $1;
|
|
3092
3222
|
});
|
|
3093
|
-
var BinaryOpSymbol$
|
|
3094
|
-
return
|
|
3223
|
+
var BinaryOpSymbol$27 = $TS($S(CoffeeOfEnabled, $EXPECT($L70, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
3224
|
+
return {
|
|
3225
|
+
ref: module.getIndexOfRef(),
|
|
3226
|
+
suffix: " >= 0"
|
|
3227
|
+
};
|
|
3228
|
+
});
|
|
3229
|
+
var BinaryOpSymbol$28 = $TS($S(CoffeeOfEnabled, $EXPECT($L71, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L70, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
3230
|
+
return {
|
|
3231
|
+
ref: module.getIndexOfRef(),
|
|
3232
|
+
suffix: " < 0"
|
|
3233
|
+
};
|
|
3095
3234
|
});
|
|
3096
|
-
var BinaryOpSymbol$
|
|
3235
|
+
var BinaryOpSymbol$29 = $TS($S($EXPECT($L70, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3097
3236
|
return $1;
|
|
3098
3237
|
});
|
|
3099
|
-
var BinaryOpSymbol$
|
|
3100
|
-
var BinaryOpSymbol$
|
|
3101
|
-
var BinaryOpSymbol$
|
|
3238
|
+
var BinaryOpSymbol$30 = $EXPECT($L72, fail, 'BinaryOpSymbol "&"');
|
|
3239
|
+
var BinaryOpSymbol$31 = $EXPECT($L73, fail, 'BinaryOpSymbol "^"');
|
|
3240
|
+
var BinaryOpSymbol$32 = $EXPECT($L74, fail, 'BinaryOpSymbol "|"');
|
|
3102
3241
|
function BinaryOpSymbol(state) {
|
|
3103
3242
|
if (state.tokenize) {
|
|
3104
|
-
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) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state));
|
|
3243
|
+
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) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state));
|
|
3105
3244
|
} else {
|
|
3106
|
-
return BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state);
|
|
3245
|
+
return BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state);
|
|
3107
3246
|
}
|
|
3108
3247
|
}
|
|
3109
3248
|
var UnaryOp$0 = $TR($EXPECT($R4, fail, "UnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
@@ -3187,7 +3326,7 @@ var Civet = (() => {
|
|
|
3187
3326
|
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);
|
|
3188
3327
|
}
|
|
3189
3328
|
}
|
|
3190
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
3329
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L75, fail, 'EmptyStatement ";"'))), function(value) {
|
|
3191
3330
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
3192
3331
|
});
|
|
3193
3332
|
function EmptyStatement(state) {
|
|
@@ -3199,7 +3338,7 @@ var Civet = (() => {
|
|
|
3199
3338
|
return EmptyStatement$0(state);
|
|
3200
3339
|
}
|
|
3201
3340
|
}
|
|
3202
|
-
var BlockStatement$0 = $T($S(__, OpenBrace, EOS, NestedBlockStatements, __, CloseBrace, $N($S(__, $EXPECT($
|
|
3341
|
+
var BlockStatement$0 = $T($S(__, OpenBrace, EOS, NestedBlockStatements, __, CloseBrace, $N($S(__, $EXPECT($L43, fail, 'BlockStatement "="')))), function(value) {
|
|
3203
3342
|
var exps = value[3];
|
|
3204
3343
|
return { "type": "BlockStatement", "children": value, "expressions": exps };
|
|
3205
3344
|
});
|
|
@@ -3634,7 +3773,7 @@ var Civet = (() => {
|
|
|
3634
3773
|
return CoffeeForStatementParameters$0(state);
|
|
3635
3774
|
}
|
|
3636
3775
|
}
|
|
3637
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
3776
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L76, fail, 'CoffeeForDeclaration "own"'))), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
3638
3777
|
var own = $1;
|
|
3639
3778
|
var binding = $2;
|
|
3640
3779
|
if (own) {
|
|
@@ -3933,7 +4072,7 @@ var Civet = (() => {
|
|
|
3933
4072
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
3934
4073
|
}
|
|
3935
4074
|
}
|
|
3936
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
4075
|
+
var Finally$0 = $S(__, $EXPECT($L77, fail, 'Finally "finally"'), BracedBlock);
|
|
3937
4076
|
function Finally(state) {
|
|
3938
4077
|
if (state.verbose)
|
|
3939
4078
|
console.log("ENTER:", "Finally");
|
|
@@ -4010,13 +4149,13 @@ var Civet = (() => {
|
|
|
4010
4149
|
return ExpressionStatement$0(state);
|
|
4011
4150
|
}
|
|
4012
4151
|
}
|
|
4013
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
4152
|
+
var KeywordStatement$0 = $T($S($EXPECT($L78, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
4014
4153
|
return { "type": "BreakStatement", "children": value };
|
|
4015
4154
|
});
|
|
4016
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
4155
|
+
var KeywordStatement$1 = $T($S($EXPECT($L79, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
4017
4156
|
return { "type": "ContinueStatement", "children": value };
|
|
4018
4157
|
});
|
|
4019
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
4158
|
+
var KeywordStatement$2 = $T($S($EXPECT($L80, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
4020
4159
|
return { "type": "DebuggerStatement", "children": value };
|
|
4021
4160
|
});
|
|
4022
4161
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -4032,7 +4171,7 @@ var Civet = (() => {
|
|
|
4032
4171
|
return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state);
|
|
4033
4172
|
}
|
|
4034
4173
|
}
|
|
4035
|
-
var DebuggerExpression$0 = $TS($S($EXPECT($
|
|
4174
|
+
var DebuggerExpression$0 = $TS($S($EXPECT($L80, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4036
4175
|
return {
|
|
4037
4176
|
type: "DebuggerExpression",
|
|
4038
4177
|
children: ["($=>{", $1, "})()"]
|
|
@@ -4075,7 +4214,7 @@ var Civet = (() => {
|
|
|
4075
4214
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
4076
4215
|
}
|
|
4077
4216
|
}
|
|
4078
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
4217
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L81, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
4079
4218
|
return { "ts": true, "children": value };
|
|
4080
4219
|
});
|
|
4081
4220
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
@@ -4254,7 +4393,7 @@ var Civet = (() => {
|
|
|
4254
4393
|
return ImportedBinding$0(state);
|
|
4255
4394
|
}
|
|
4256
4395
|
}
|
|
4257
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
4396
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L82, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression));
|
|
4258
4397
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
4259
4398
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
4260
4399
|
function ExportDeclaration(state) {
|
|
@@ -4361,7 +4500,7 @@ var Civet = (() => {
|
|
|
4361
4500
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
4362
4501
|
}
|
|
4363
4502
|
}
|
|
4364
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
4503
|
+
var ConstAssignment$0 = $TV($EXPECT($L83, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
4365
4504
|
return { $loc, token: "=" };
|
|
4366
4505
|
});
|
|
4367
4506
|
function ConstAssignment(state) {
|
|
@@ -4683,7 +4822,7 @@ var Civet = (() => {
|
|
|
4683
4822
|
return CoffeeDoubleQuotedStringCharacters$0(state);
|
|
4684
4823
|
}
|
|
4685
4824
|
}
|
|
4686
|
-
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($
|
|
4825
|
+
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L46, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L46, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
4687
4826
|
return { $loc, token: $1 };
|
|
4688
4827
|
});
|
|
4689
4828
|
function RegularExpressionLiteral(state) {
|
|
@@ -4810,7 +4949,7 @@ var Civet = (() => {
|
|
|
4810
4949
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
4811
4950
|
}
|
|
4812
4951
|
}
|
|
4813
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
4952
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L85, fail, 'JSMultiLineComment "*/"')), $EXPECT($R30, fail, "JSMultiLineComment /./"))), $EXPECT($L85, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
4814
4953
|
return { $loc, token: $1 };
|
|
4815
4954
|
});
|
|
4816
4955
|
function JSMultiLineComment(state) {
|
|
@@ -4834,7 +4973,7 @@ var Civet = (() => {
|
|
|
4834
4973
|
return CoffeeSingleLineComment$0(state);
|
|
4835
4974
|
}
|
|
4836
4975
|
}
|
|
4837
|
-
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($
|
|
4976
|
+
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L85, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R30, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L86, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
4838
4977
|
return { $loc, token: `/*${$2}*/` };
|
|
4839
4978
|
});
|
|
4840
4979
|
function CoffeeMultiLineComment(state) {
|
|
@@ -4846,7 +4985,7 @@ var Civet = (() => {
|
|
|
4846
4985
|
return CoffeeMultiLineComment$0(state);
|
|
4847
4986
|
}
|
|
4848
4987
|
}
|
|
4849
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
4988
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L85, fail, 'InlineComment "*/"')), $EXPECT($R32, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L85, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
4850
4989
|
return { $loc, token: $1 };
|
|
4851
4990
|
});
|
|
4852
4991
|
function InlineComment(state) {
|
|
@@ -4891,13 +5030,14 @@ var Civet = (() => {
|
|
|
4891
5030
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R33, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4892
5031
|
return { $loc, token: $0 };
|
|
4893
5032
|
});
|
|
5033
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L87, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
5034
|
+
return "";
|
|
5035
|
+
});
|
|
4894
5036
|
function NonNewlineWhitespace(state) {
|
|
4895
|
-
if (state.verbose)
|
|
4896
|
-
console.log("ENTER:", "NonNewlineWhitespace");
|
|
4897
5037
|
if (state.tokenize) {
|
|
4898
|
-
return $TOKEN("NonNewlineWhitespace", state, NonNewlineWhitespace$0(state));
|
|
5038
|
+
return $TOKEN("NonNewlineWhitespace", state, NonNewlineWhitespace$0(state) || NonNewlineWhitespace$1(state));
|
|
4899
5039
|
} else {
|
|
4900
|
-
return NonNewlineWhitespace$0(state);
|
|
5040
|
+
return NonNewlineWhitespace$0(state) || NonNewlineWhitespace$1(state);
|
|
4901
5041
|
}
|
|
4902
5042
|
}
|
|
4903
5043
|
var __$0 = $Q($C(Whitespace, Comment));
|
|
@@ -4967,7 +5107,7 @@ var Civet = (() => {
|
|
|
4967
5107
|
return Loc$0(state);
|
|
4968
5108
|
}
|
|
4969
5109
|
}
|
|
4970
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
5110
|
+
var Ampersand$0 = $TV($EXPECT($L72, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
4971
5111
|
return { $loc, token: $1 };
|
|
4972
5112
|
});
|
|
4973
5113
|
function Ampersand(state) {
|
|
@@ -4979,7 +5119,7 @@ var Civet = (() => {
|
|
|
4979
5119
|
return Ampersand$0(state);
|
|
4980
5120
|
}
|
|
4981
5121
|
}
|
|
4982
|
-
var As$0 = $TS($S($EXPECT($
|
|
5122
|
+
var As$0 = $TS($S($EXPECT($L88, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4983
5123
|
return { $loc, token: $1 };
|
|
4984
5124
|
});
|
|
4985
5125
|
function As(state) {
|
|
@@ -4991,7 +5131,19 @@ var Civet = (() => {
|
|
|
4991
5131
|
return As$0(state);
|
|
4992
5132
|
}
|
|
4993
5133
|
}
|
|
4994
|
-
var
|
|
5134
|
+
var At$0 = $TV($EXPECT($L89, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
5135
|
+
return { $loc, token: $1 };
|
|
5136
|
+
});
|
|
5137
|
+
function At(state) {
|
|
5138
|
+
if (state.verbose)
|
|
5139
|
+
console.log("ENTER:", "At");
|
|
5140
|
+
if (state.tokenize) {
|
|
5141
|
+
return $TOKEN("At", state, At$0(state));
|
|
5142
|
+
} else {
|
|
5143
|
+
return At$0(state);
|
|
5144
|
+
}
|
|
5145
|
+
}
|
|
5146
|
+
var Async$0 = $TV($EXPECT($L90, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
|
|
4995
5147
|
return { $loc, token: $1 };
|
|
4996
5148
|
});
|
|
4997
5149
|
function Async(state) {
|
|
@@ -5003,7 +5155,7 @@ var Civet = (() => {
|
|
|
5003
5155
|
return Async$0(state);
|
|
5004
5156
|
}
|
|
5005
5157
|
}
|
|
5006
|
-
var Await$0 = $TS($S($EXPECT($
|
|
5158
|
+
var Await$0 = $TS($S($EXPECT($L91, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5007
5159
|
return { $loc, token: $1 };
|
|
5008
5160
|
});
|
|
5009
5161
|
function Await(state) {
|
|
@@ -5015,7 +5167,7 @@ var Civet = (() => {
|
|
|
5015
5167
|
return Await$0(state);
|
|
5016
5168
|
}
|
|
5017
5169
|
}
|
|
5018
|
-
var Backtick$0 = $TV($EXPECT($
|
|
5170
|
+
var Backtick$0 = $TV($EXPECT($L92, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
5019
5171
|
return { $loc, token: $1 };
|
|
5020
5172
|
});
|
|
5021
5173
|
function Backtick(state) {
|
|
@@ -5027,7 +5179,7 @@ var Civet = (() => {
|
|
|
5027
5179
|
return Backtick$0(state);
|
|
5028
5180
|
}
|
|
5029
5181
|
}
|
|
5030
|
-
var By$0 = $TS($S($EXPECT($
|
|
5182
|
+
var By$0 = $TS($S($EXPECT($L93, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5031
5183
|
return { $loc, token: $1 };
|
|
5032
5184
|
});
|
|
5033
5185
|
function By(state) {
|
|
@@ -5039,7 +5191,7 @@ var Civet = (() => {
|
|
|
5039
5191
|
return By$0(state);
|
|
5040
5192
|
}
|
|
5041
5193
|
}
|
|
5042
|
-
var Case$0 = $TS($S($EXPECT($
|
|
5194
|
+
var Case$0 = $TS($S($EXPECT($L94, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5043
5195
|
return { $loc, token: $1 };
|
|
5044
5196
|
});
|
|
5045
5197
|
function Case(state) {
|
|
@@ -5051,7 +5203,7 @@ var Civet = (() => {
|
|
|
5051
5203
|
return Case$0(state);
|
|
5052
5204
|
}
|
|
5053
5205
|
}
|
|
5054
|
-
var Catch$0 = $TV($EXPECT($
|
|
5206
|
+
var Catch$0 = $TV($EXPECT($L95, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
5055
5207
|
return { $loc, token: $1 };
|
|
5056
5208
|
});
|
|
5057
5209
|
function Catch(state) {
|
|
@@ -5063,7 +5215,7 @@ var Civet = (() => {
|
|
|
5063
5215
|
return Catch$0(state);
|
|
5064
5216
|
}
|
|
5065
5217
|
}
|
|
5066
|
-
var Class$0 = $TV($EXPECT($
|
|
5218
|
+
var Class$0 = $TV($EXPECT($L96, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
5067
5219
|
return { $loc, token: $1 };
|
|
5068
5220
|
});
|
|
5069
5221
|
function Class(state) {
|
|
@@ -5075,7 +5227,7 @@ var Civet = (() => {
|
|
|
5075
5227
|
return Class$0(state);
|
|
5076
5228
|
}
|
|
5077
5229
|
}
|
|
5078
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
5230
|
+
var CloseBrace$0 = $TV($EXPECT($L26, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
5079
5231
|
return { $loc, token: $1 };
|
|
5080
5232
|
});
|
|
5081
5233
|
function CloseBrace(state) {
|
|
@@ -5087,7 +5239,7 @@ var Civet = (() => {
|
|
|
5087
5239
|
return CloseBrace$0(state);
|
|
5088
5240
|
}
|
|
5089
5241
|
}
|
|
5090
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
5242
|
+
var CloseBracket$0 = $TV($EXPECT($L25, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
5091
5243
|
return { $loc, token: $1 };
|
|
5092
5244
|
});
|
|
5093
5245
|
function CloseBracket(state) {
|
|
@@ -5099,7 +5251,7 @@ var Civet = (() => {
|
|
|
5099
5251
|
return CloseBracket$0(state);
|
|
5100
5252
|
}
|
|
5101
5253
|
}
|
|
5102
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
5254
|
+
var CloseParen$0 = $TV($EXPECT($L15, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
5103
5255
|
return { $loc, token: $1 };
|
|
5104
5256
|
});
|
|
5105
5257
|
function CloseParen(state) {
|
|
@@ -5111,7 +5263,7 @@ var Civet = (() => {
|
|
|
5111
5263
|
return CloseParen$0(state);
|
|
5112
5264
|
}
|
|
5113
5265
|
}
|
|
5114
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
5266
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L97, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
5115
5267
|
return { $loc, token: "${" };
|
|
5116
5268
|
});
|
|
5117
5269
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -5123,7 +5275,7 @@ var Civet = (() => {
|
|
|
5123
5275
|
return CoffeeSubstitutionStart$0(state);
|
|
5124
5276
|
}
|
|
5125
5277
|
}
|
|
5126
|
-
var Colon$0 = $TV($EXPECT($
|
|
5278
|
+
var Colon$0 = $TV($EXPECT($L98, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
5127
5279
|
return { $loc, token: $1 };
|
|
5128
5280
|
});
|
|
5129
5281
|
function Colon(state) {
|
|
@@ -5135,7 +5287,7 @@ var Civet = (() => {
|
|
|
5135
5287
|
return Colon$0(state);
|
|
5136
5288
|
}
|
|
5137
5289
|
}
|
|
5138
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
5290
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L89, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
5139
5291
|
return { $loc, token: "constructor" };
|
|
5140
5292
|
});
|
|
5141
5293
|
function ConstructorShorthand(state) {
|
|
@@ -5147,7 +5299,7 @@ var Civet = (() => {
|
|
|
5147
5299
|
return ConstructorShorthand$0(state);
|
|
5148
5300
|
}
|
|
5149
5301
|
}
|
|
5150
|
-
var Default$0 = $TS($S($EXPECT($
|
|
5302
|
+
var Default$0 = $TS($S($EXPECT($L82, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5151
5303
|
return { $loc, token: $1 };
|
|
5152
5304
|
});
|
|
5153
5305
|
function Default(state) {
|
|
@@ -5159,7 +5311,7 @@ var Civet = (() => {
|
|
|
5159
5311
|
return Default$0(state);
|
|
5160
5312
|
}
|
|
5161
5313
|
}
|
|
5162
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
5314
|
+
var Delete$0 = $TS($S($EXPECT($L99, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5163
5315
|
return { $loc, token: $1 };
|
|
5164
5316
|
});
|
|
5165
5317
|
function Delete(state) {
|
|
@@ -5171,7 +5323,7 @@ var Civet = (() => {
|
|
|
5171
5323
|
return Delete$0(state);
|
|
5172
5324
|
}
|
|
5173
5325
|
}
|
|
5174
|
-
var Do$0 = $TS($S($EXPECT($
|
|
5326
|
+
var Do$0 = $TS($S($EXPECT($L100, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5175
5327
|
return { $loc, token: $1 };
|
|
5176
5328
|
});
|
|
5177
5329
|
function Do(state) {
|
|
@@ -5183,7 +5335,7 @@ var Civet = (() => {
|
|
|
5183
5335
|
return Do$0(state);
|
|
5184
5336
|
}
|
|
5185
5337
|
}
|
|
5186
|
-
var Dot$0 = $TV($EXPECT($
|
|
5338
|
+
var Dot$0 = $TV($EXPECT($L8, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
5187
5339
|
return { $loc, token: $1 };
|
|
5188
5340
|
});
|
|
5189
5341
|
function Dot(state) {
|
|
@@ -5195,7 +5347,7 @@ var Civet = (() => {
|
|
|
5195
5347
|
return Dot$0(state);
|
|
5196
5348
|
}
|
|
5197
5349
|
}
|
|
5198
|
-
var DotDot$0 = $TV($EXPECT($
|
|
5350
|
+
var DotDot$0 = $TV($EXPECT($L101, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
5199
5351
|
return { $loc, token: $1 };
|
|
5200
5352
|
});
|
|
5201
5353
|
function DotDot(state) {
|
|
@@ -5207,7 +5359,7 @@ var Civet = (() => {
|
|
|
5207
5359
|
return DotDot$0(state);
|
|
5208
5360
|
}
|
|
5209
5361
|
}
|
|
5210
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
5362
|
+
var DotDotDot$0 = $TV($EXPECT($L102, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
5211
5363
|
return { $loc, token: $1 };
|
|
5212
5364
|
});
|
|
5213
5365
|
function DotDotDot(state) {
|
|
@@ -5219,7 +5371,7 @@ var Civet = (() => {
|
|
|
5219
5371
|
return DotDotDot$0(state);
|
|
5220
5372
|
}
|
|
5221
5373
|
}
|
|
5222
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
5374
|
+
var DoubleQuote$0 = $TV($EXPECT($L103, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
5223
5375
|
return { $loc, token: $1 };
|
|
5224
5376
|
});
|
|
5225
5377
|
function DoubleQuote(state) {
|
|
@@ -5231,7 +5383,7 @@ var Civet = (() => {
|
|
|
5231
5383
|
return DoubleQuote$0(state);
|
|
5232
5384
|
}
|
|
5233
5385
|
}
|
|
5234
|
-
var Else$0 = $TV($EXPECT($
|
|
5386
|
+
var Else$0 = $TV($EXPECT($L104, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
5235
5387
|
return { $loc, token: $1 };
|
|
5236
5388
|
});
|
|
5237
5389
|
function Else(state) {
|
|
@@ -5243,7 +5395,7 @@ var Civet = (() => {
|
|
|
5243
5395
|
return Else$0(state);
|
|
5244
5396
|
}
|
|
5245
5397
|
}
|
|
5246
|
-
var Equals$0 = $TV($EXPECT($
|
|
5398
|
+
var Equals$0 = $TV($EXPECT($L43, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
5247
5399
|
return { $loc, token: $1 };
|
|
5248
5400
|
});
|
|
5249
5401
|
function Equals(state) {
|
|
@@ -5255,7 +5407,7 @@ var Civet = (() => {
|
|
|
5255
5407
|
return Equals$0(state);
|
|
5256
5408
|
}
|
|
5257
5409
|
}
|
|
5258
|
-
var Export$0 = $TS($S($EXPECT($
|
|
5410
|
+
var Export$0 = $TS($S($EXPECT($L105, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5259
5411
|
return { $loc, token: $1 };
|
|
5260
5412
|
});
|
|
5261
5413
|
function Export(state) {
|
|
@@ -5267,7 +5419,7 @@ var Civet = (() => {
|
|
|
5267
5419
|
return Export$0(state);
|
|
5268
5420
|
}
|
|
5269
5421
|
}
|
|
5270
|
-
var For$0 = $TS($S($EXPECT($
|
|
5422
|
+
var For$0 = $TS($S($EXPECT($L106, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5271
5423
|
return { $loc, token: $1 };
|
|
5272
5424
|
});
|
|
5273
5425
|
function For(state) {
|
|
@@ -5279,7 +5431,7 @@ var Civet = (() => {
|
|
|
5279
5431
|
return For$0(state);
|
|
5280
5432
|
}
|
|
5281
5433
|
}
|
|
5282
|
-
var From$0 = $TS($S($EXPECT($
|
|
5434
|
+
var From$0 = $TS($S($EXPECT($L107, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5283
5435
|
return { $loc, token: $1 };
|
|
5284
5436
|
});
|
|
5285
5437
|
function From(state) {
|
|
@@ -5291,7 +5443,7 @@ var Civet = (() => {
|
|
|
5291
5443
|
return From$0(state);
|
|
5292
5444
|
}
|
|
5293
5445
|
}
|
|
5294
|
-
var Function$0 = $TV($EXPECT($
|
|
5446
|
+
var Function$0 = $TV($EXPECT($L108, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
5295
5447
|
return { $loc, token: $1 };
|
|
5296
5448
|
});
|
|
5297
5449
|
function Function(state) {
|
|
@@ -5303,7 +5455,7 @@ var Civet = (() => {
|
|
|
5303
5455
|
return Function$0(state);
|
|
5304
5456
|
}
|
|
5305
5457
|
}
|
|
5306
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
5458
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L109, fail, 'GetOrSet "get"'), $EXPECT($L110, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5307
5459
|
return { $loc, token: $1 };
|
|
5308
5460
|
});
|
|
5309
5461
|
function GetOrSet(state) {
|
|
@@ -5315,7 +5467,7 @@ var Civet = (() => {
|
|
|
5315
5467
|
return GetOrSet$0(state);
|
|
5316
5468
|
}
|
|
5317
5469
|
}
|
|
5318
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
5470
|
+
var If$0 = $TV($TEXT($S($EXPECT($L111, fail, 'If "if"'), $E($EXPECT($L112, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
5319
5471
|
return { $loc, token: $1 };
|
|
5320
5472
|
});
|
|
5321
5473
|
function If(state) {
|
|
@@ -5327,7 +5479,7 @@ var Civet = (() => {
|
|
|
5327
5479
|
return If$0(state);
|
|
5328
5480
|
}
|
|
5329
5481
|
}
|
|
5330
|
-
var Import$0 = $TS($S($EXPECT($
|
|
5482
|
+
var Import$0 = $TS($S($EXPECT($L10, fail, 'Import "import"'), $Y($EXPECT($R36, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
5331
5483
|
return { $loc, token: $1 };
|
|
5332
5484
|
});
|
|
5333
5485
|
function Import(state) {
|
|
@@ -5351,7 +5503,7 @@ var Civet = (() => {
|
|
|
5351
5503
|
return In$0(state);
|
|
5352
5504
|
}
|
|
5353
5505
|
}
|
|
5354
|
-
var LetOrConst$0 = $TV($C($EXPECT($
|
|
5506
|
+
var LetOrConst$0 = $TV($C($EXPECT($L113, fail, 'LetOrConst "let"'), $EXPECT($L114, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
5355
5507
|
return { $loc, token: $1 };
|
|
5356
5508
|
});
|
|
5357
5509
|
function LetOrConst(state) {
|
|
@@ -5363,7 +5515,7 @@ var Civet = (() => {
|
|
|
5363
5515
|
return LetOrConst$0(state);
|
|
5364
5516
|
}
|
|
5365
5517
|
}
|
|
5366
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
5518
|
+
var Loop$0 = $TS($S($EXPECT($L115, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5367
5519
|
return { $loc, token: "while(true)" };
|
|
5368
5520
|
});
|
|
5369
5521
|
function Loop(state) {
|
|
@@ -5375,7 +5527,7 @@ var Civet = (() => {
|
|
|
5375
5527
|
return Loop$0(state);
|
|
5376
5528
|
}
|
|
5377
5529
|
}
|
|
5378
|
-
var New$0 = $TV($EXPECT($
|
|
5530
|
+
var New$0 = $TV($EXPECT($L116, fail, 'New "new"'), function($skip, $loc, $0, $1) {
|
|
5379
5531
|
return { $loc, token: $1 };
|
|
5380
5532
|
});
|
|
5381
5533
|
function New(state) {
|
|
@@ -5387,7 +5539,7 @@ var Civet = (() => {
|
|
|
5387
5539
|
return New$0(state);
|
|
5388
5540
|
}
|
|
5389
5541
|
}
|
|
5390
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
5542
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L71, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L112, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5391
5543
|
return { $loc, token: "!" };
|
|
5392
5544
|
});
|
|
5393
5545
|
function Not(state) {
|
|
@@ -5399,7 +5551,7 @@ var Civet = (() => {
|
|
|
5399
5551
|
return Not$0(state);
|
|
5400
5552
|
}
|
|
5401
5553
|
}
|
|
5402
|
-
var Of$0 = $TV($EXPECT($
|
|
5554
|
+
var Of$0 = $TV($EXPECT($L64, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
5403
5555
|
return { $loc, token: $1 };
|
|
5404
5556
|
});
|
|
5405
5557
|
function Of(state) {
|
|
@@ -5411,7 +5563,7 @@ var Civet = (() => {
|
|
|
5411
5563
|
return Of$0(state);
|
|
5412
5564
|
}
|
|
5413
5565
|
}
|
|
5414
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
5566
|
+
var OpenBrace$0 = $TV($EXPECT($L117, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
5415
5567
|
return { $loc, token: $1 };
|
|
5416
5568
|
});
|
|
5417
5569
|
function OpenBrace(state) {
|
|
@@ -5423,7 +5575,7 @@ var Civet = (() => {
|
|
|
5423
5575
|
return OpenBrace$0(state);
|
|
5424
5576
|
}
|
|
5425
5577
|
}
|
|
5426
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
5578
|
+
var OpenBracket$0 = $TV($EXPECT($L118, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
5427
5579
|
return { $loc, token: $1 };
|
|
5428
5580
|
});
|
|
5429
5581
|
function OpenBracket(state) {
|
|
@@ -5435,7 +5587,7 @@ var Civet = (() => {
|
|
|
5435
5587
|
return OpenBracket$0(state);
|
|
5436
5588
|
}
|
|
5437
5589
|
}
|
|
5438
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
5590
|
+
var OpenParen$0 = $TV($EXPECT($L119, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
5439
5591
|
return { $loc, token: $1 };
|
|
5440
5592
|
});
|
|
5441
5593
|
function OpenParen(state) {
|
|
@@ -5447,7 +5599,7 @@ var Civet = (() => {
|
|
|
5447
5599
|
return OpenParen$0(state);
|
|
5448
5600
|
}
|
|
5449
5601
|
}
|
|
5450
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
5602
|
+
var QuestionMark$0 = $TV($EXPECT($L68, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
5451
5603
|
return { $loc, token: $1 };
|
|
5452
5604
|
});
|
|
5453
5605
|
function QuestionMark(state) {
|
|
@@ -5459,7 +5611,7 @@ var Civet = (() => {
|
|
|
5459
5611
|
return QuestionMark$0(state);
|
|
5460
5612
|
}
|
|
5461
5613
|
}
|
|
5462
|
-
var Return$0 = $TS($S($EXPECT($
|
|
5614
|
+
var Return$0 = $TS($S($EXPECT($L120, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5463
5615
|
return { $loc, token: $1 };
|
|
5464
5616
|
});
|
|
5465
5617
|
function Return(state) {
|
|
@@ -5471,7 +5623,7 @@ var Civet = (() => {
|
|
|
5471
5623
|
return Return$0(state);
|
|
5472
5624
|
}
|
|
5473
5625
|
}
|
|
5474
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
5626
|
+
var Semicolon$0 = $TV($EXPECT($L75, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
5475
5627
|
return { $loc, token: $1 };
|
|
5476
5628
|
});
|
|
5477
5629
|
function Semicolon(state) {
|
|
@@ -5483,7 +5635,7 @@ var Civet = (() => {
|
|
|
5483
5635
|
return Semicolon$0(state);
|
|
5484
5636
|
}
|
|
5485
5637
|
}
|
|
5486
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
5638
|
+
var SingleQuote$0 = $TV($EXPECT($L121, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
5487
5639
|
return { $loc, token: $1 };
|
|
5488
5640
|
});
|
|
5489
5641
|
function SingleQuote(state) {
|
|
@@ -5495,7 +5647,7 @@ var Civet = (() => {
|
|
|
5495
5647
|
return SingleQuote$0(state);
|
|
5496
5648
|
}
|
|
5497
5649
|
}
|
|
5498
|
-
var Star$0 = $TV($EXPECT($
|
|
5650
|
+
var Star$0 = $TV($EXPECT($L45, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
5499
5651
|
return { $loc, token: $1 };
|
|
5500
5652
|
});
|
|
5501
5653
|
function Star(state) {
|
|
@@ -5507,10 +5659,10 @@ var Civet = (() => {
|
|
|
5507
5659
|
return Star$0(state);
|
|
5508
5660
|
}
|
|
5509
5661
|
}
|
|
5510
|
-
var Static$0 = $TV($EXPECT($
|
|
5662
|
+
var Static$0 = $TV($EXPECT($L122, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
5511
5663
|
return { $loc, token: $1 };
|
|
5512
5664
|
});
|
|
5513
|
-
var Static$1 = $TS($S($EXPECT($
|
|
5665
|
+
var Static$1 = $TS($S($EXPECT($L89, fail, 'Static "@"'), $N($EXPECT($L119, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
|
|
5514
5666
|
return { $loc, token: "static " };
|
|
5515
5667
|
});
|
|
5516
5668
|
function Static(state) {
|
|
@@ -5520,7 +5672,7 @@ var Civet = (() => {
|
|
|
5520
5672
|
return Static$0(state) || Static$1(state);
|
|
5521
5673
|
}
|
|
5522
5674
|
}
|
|
5523
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
5675
|
+
var SubstitutionStart$0 = $TV($EXPECT($L123, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
5524
5676
|
return { $loc, token: $1 };
|
|
5525
5677
|
});
|
|
5526
5678
|
function SubstitutionStart(state) {
|
|
@@ -5532,7 +5684,7 @@ var Civet = (() => {
|
|
|
5532
5684
|
return SubstitutionStart$0(state);
|
|
5533
5685
|
}
|
|
5534
5686
|
}
|
|
5535
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
5687
|
+
var Switch$0 = $TS($S($EXPECT($L124, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5536
5688
|
return { $loc, token: $1 };
|
|
5537
5689
|
});
|
|
5538
5690
|
function Switch(state) {
|
|
@@ -5544,7 +5696,7 @@ var Civet = (() => {
|
|
|
5544
5696
|
return Switch$0(state);
|
|
5545
5697
|
}
|
|
5546
5698
|
}
|
|
5547
|
-
var Target$0 = $TV($EXPECT($
|
|
5699
|
+
var Target$0 = $TV($EXPECT($L125, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
|
|
5548
5700
|
return { $loc, token: $1 };
|
|
5549
5701
|
});
|
|
5550
5702
|
function Target(state) {
|
|
@@ -5556,7 +5708,7 @@ var Civet = (() => {
|
|
|
5556
5708
|
return Target$0(state);
|
|
5557
5709
|
}
|
|
5558
5710
|
}
|
|
5559
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
5711
|
+
var Then$0 = $TS($S(__, $EXPECT($L126, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
5560
5712
|
return { $loc, token: "" };
|
|
5561
5713
|
});
|
|
5562
5714
|
function Then(state) {
|
|
@@ -5568,7 +5720,7 @@ var Civet = (() => {
|
|
|
5568
5720
|
return Then$0(state);
|
|
5569
5721
|
}
|
|
5570
5722
|
}
|
|
5571
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
5723
|
+
var Throw$0 = $TS($S($EXPECT($L127, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5572
5724
|
return { $loc, token: $1 };
|
|
5573
5725
|
});
|
|
5574
5726
|
function Throw(state) {
|
|
@@ -5580,7 +5732,7 @@ var Civet = (() => {
|
|
|
5580
5732
|
return Throw$0(state);
|
|
5581
5733
|
}
|
|
5582
5734
|
}
|
|
5583
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
5735
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L128, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
5584
5736
|
return { $loc, token: "`" };
|
|
5585
5737
|
});
|
|
5586
5738
|
function TripleDoubleQuote(state) {
|
|
@@ -5592,7 +5744,7 @@ var Civet = (() => {
|
|
|
5592
5744
|
return TripleDoubleQuote$0(state);
|
|
5593
5745
|
}
|
|
5594
5746
|
}
|
|
5595
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
5747
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L129, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
5596
5748
|
return { $loc, token: "`" };
|
|
5597
5749
|
});
|
|
5598
5750
|
function TripleSingleQuote(state) {
|
|
@@ -5604,7 +5756,7 @@ var Civet = (() => {
|
|
|
5604
5756
|
return TripleSingleQuote$0(state);
|
|
5605
5757
|
}
|
|
5606
5758
|
}
|
|
5607
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
5759
|
+
var TripleTick$0 = $TV($EXPECT($L130, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
5608
5760
|
return { $loc, token: "`" };
|
|
5609
5761
|
});
|
|
5610
5762
|
function TripleTick(state) {
|
|
@@ -5616,7 +5768,7 @@ var Civet = (() => {
|
|
|
5616
5768
|
return TripleTick$0(state);
|
|
5617
5769
|
}
|
|
5618
5770
|
}
|
|
5619
|
-
var Try$0 = $TV($EXPECT($
|
|
5771
|
+
var Try$0 = $TV($EXPECT($L131, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
5620
5772
|
return { $loc, token: $1 };
|
|
5621
5773
|
});
|
|
5622
5774
|
function Try(state) {
|
|
@@ -5628,7 +5780,7 @@ var Civet = (() => {
|
|
|
5628
5780
|
return Try$0(state);
|
|
5629
5781
|
}
|
|
5630
5782
|
}
|
|
5631
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
5783
|
+
var Typeof$0 = $TS($S($EXPECT($L132, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5632
5784
|
return { $loc, token: $1 };
|
|
5633
5785
|
});
|
|
5634
5786
|
function Typeof(state) {
|
|
@@ -5640,7 +5792,7 @@ var Civet = (() => {
|
|
|
5640
5792
|
return Typeof$0(state);
|
|
5641
5793
|
}
|
|
5642
5794
|
}
|
|
5643
|
-
var Unless$0 = $TV($EXPECT($
|
|
5795
|
+
var Unless$0 = $TV($EXPECT($L133, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
5644
5796
|
return { $loc, token: $1 };
|
|
5645
5797
|
});
|
|
5646
5798
|
function Unless(state) {
|
|
@@ -5652,7 +5804,7 @@ var Civet = (() => {
|
|
|
5652
5804
|
return Unless$0(state);
|
|
5653
5805
|
}
|
|
5654
5806
|
}
|
|
5655
|
-
var Until$0 = $TS($S($EXPECT($
|
|
5807
|
+
var Until$0 = $TS($S($EXPECT($L134, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5656
5808
|
return { $loc, token: $1 };
|
|
5657
5809
|
});
|
|
5658
5810
|
function Until(state) {
|
|
@@ -5664,7 +5816,7 @@ var Civet = (() => {
|
|
|
5664
5816
|
return Until$0(state);
|
|
5665
5817
|
}
|
|
5666
5818
|
}
|
|
5667
|
-
var Var$0 = $TV($EXPECT($
|
|
5819
|
+
var Var$0 = $TV($EXPECT($L135, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
5668
5820
|
return { $loc, token: $1 };
|
|
5669
5821
|
});
|
|
5670
5822
|
function Var(state) {
|
|
@@ -5676,7 +5828,7 @@ var Civet = (() => {
|
|
|
5676
5828
|
return Var$0(state);
|
|
5677
5829
|
}
|
|
5678
5830
|
}
|
|
5679
|
-
var Void$0 = $TS($S($EXPECT($
|
|
5831
|
+
var Void$0 = $TS($S($EXPECT($L136, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5680
5832
|
return { $loc, token: $1 };
|
|
5681
5833
|
});
|
|
5682
5834
|
function Void(state) {
|
|
@@ -5688,7 +5840,7 @@ var Civet = (() => {
|
|
|
5688
5840
|
return Void$0(state);
|
|
5689
5841
|
}
|
|
5690
5842
|
}
|
|
5691
|
-
var When$0 = $TS($S($EXPECT($
|
|
5843
|
+
var When$0 = $TS($S($EXPECT($L137, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5692
5844
|
return { $loc, token: "case" };
|
|
5693
5845
|
});
|
|
5694
5846
|
function When(state) {
|
|
@@ -5700,7 +5852,7 @@ var Civet = (() => {
|
|
|
5700
5852
|
return When$0(state);
|
|
5701
5853
|
}
|
|
5702
5854
|
}
|
|
5703
|
-
var While$0 = $TS($S($EXPECT($
|
|
5855
|
+
var While$0 = $TS($S($EXPECT($L138, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5704
5856
|
return { $loc, token: $1 };
|
|
5705
5857
|
});
|
|
5706
5858
|
function While(state) {
|
|
@@ -5712,7 +5864,7 @@ var Civet = (() => {
|
|
|
5712
5864
|
return While$0(state);
|
|
5713
5865
|
}
|
|
5714
5866
|
}
|
|
5715
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
5867
|
+
var Yield$0 = $TS($S($EXPECT($L139, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5716
5868
|
return { $loc, token: $1 };
|
|
5717
5869
|
});
|
|
5718
5870
|
function Yield(state) {
|
|
@@ -5738,7 +5890,7 @@ var Civet = (() => {
|
|
|
5738
5890
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
5739
5891
|
}
|
|
5740
5892
|
}
|
|
5741
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
5893
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L140, fail, 'JSXSelfClosingElement "/>"'));
|
|
5742
5894
|
function JSXSelfClosingElement(state) {
|
|
5743
5895
|
if (state.verbose)
|
|
5744
5896
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -5748,7 +5900,7 @@ var Civet = (() => {
|
|
|
5748
5900
|
return JSXSelfClosingElement$0(state);
|
|
5749
5901
|
}
|
|
5750
5902
|
}
|
|
5751
|
-
var JSXOpeningElement$0 = $S($EXPECT($L4, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
5903
|
+
var JSXOpeningElement$0 = $S($EXPECT($L4, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L55, fail, 'JSXOpeningElement ">"'));
|
|
5752
5904
|
function JSXOpeningElement(state) {
|
|
5753
5905
|
if (state.verbose)
|
|
5754
5906
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -5758,7 +5910,7 @@ var Civet = (() => {
|
|
|
5758
5910
|
return JSXOpeningElement$0(state);
|
|
5759
5911
|
}
|
|
5760
5912
|
}
|
|
5761
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
5913
|
+
var JSXClosingElement$0 = $S($EXPECT($L141, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L55, fail, 'JSXClosingElement ">"'));
|
|
5762
5914
|
function JSXClosingElement(state) {
|
|
5763
5915
|
if (state.verbose)
|
|
5764
5916
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -5768,7 +5920,7 @@ var Civet = (() => {
|
|
|
5768
5920
|
return JSXClosingElement$0(state);
|
|
5769
5921
|
}
|
|
5770
5922
|
}
|
|
5771
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
5923
|
+
var JSXFragment$0 = $S($EXPECT($L142, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L143, fail, 'JSXFragment "</>"'));
|
|
5772
5924
|
function JSXFragment(state) {
|
|
5773
5925
|
if (state.verbose)
|
|
5774
5926
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -5902,7 +6054,7 @@ var Civet = (() => {
|
|
|
5902
6054
|
return TypeDeclaration$0(state);
|
|
5903
6055
|
}
|
|
5904
6056
|
}
|
|
5905
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
6057
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L144, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
5906
6058
|
var TypeDeclarationModifier$1 = Export;
|
|
5907
6059
|
function TypeDeclarationModifier(state) {
|
|
5908
6060
|
if (state.tokenize) {
|
|
@@ -5922,7 +6074,7 @@ var Civet = (() => {
|
|
|
5922
6074
|
return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state);
|
|
5923
6075
|
}
|
|
5924
6076
|
}
|
|
5925
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
6077
|
+
var TypeKeyword$0 = $S($EXPECT($L145, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
5926
6078
|
function TypeKeyword(state) {
|
|
5927
6079
|
if (state.verbose)
|
|
5928
6080
|
console.log("ENTER:", "TypeKeyword");
|
|
@@ -5932,7 +6084,7 @@ var Civet = (() => {
|
|
|
5932
6084
|
return TypeKeyword$0(state);
|
|
5933
6085
|
}
|
|
5934
6086
|
}
|
|
5935
|
-
var Interface$0 = $S($EXPECT($
|
|
6087
|
+
var Interface$0 = $S($EXPECT($L146, fail, 'Interface "interface"'), NonIdContinue);
|
|
5936
6088
|
function Interface(state) {
|
|
5937
6089
|
if (state.verbose)
|
|
5938
6090
|
console.log("ENTER:", "Interface");
|
|
@@ -5942,7 +6094,7 @@ var Civet = (() => {
|
|
|
5942
6094
|
return Interface$0(state);
|
|
5943
6095
|
}
|
|
5944
6096
|
}
|
|
5945
|
-
var Namespace$0 = $S($EXPECT($
|
|
6097
|
+
var Namespace$0 = $S($EXPECT($L147, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
5946
6098
|
function Namespace(state) {
|
|
5947
6099
|
if (state.verbose)
|
|
5948
6100
|
console.log("ENTER:", "Namespace");
|
|
@@ -6042,7 +6194,7 @@ var Civet = (() => {
|
|
|
6042
6194
|
return NestedTypeDeclaration$0(state);
|
|
6043
6195
|
}
|
|
6044
6196
|
}
|
|
6045
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R41, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($
|
|
6197
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R41, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L148, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R42, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
6046
6198
|
function TypeIndexSignature(state) {
|
|
6047
6199
|
if (state.verbose)
|
|
6048
6200
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -6073,7 +6225,7 @@ var Civet = (() => {
|
|
|
6073
6225
|
return TypeSuffix$0(state);
|
|
6074
6226
|
}
|
|
6075
6227
|
}
|
|
6076
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
6228
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L149, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6077
6229
|
if (!$3)
|
|
6078
6230
|
$0.splice(2, 1);
|
|
6079
6231
|
if ($1.length === 0)
|
|
@@ -6093,7 +6245,7 @@ var Civet = (() => {
|
|
|
6093
6245
|
return ReturnTypeSuffix$0(state);
|
|
6094
6246
|
}
|
|
6095
6247
|
}
|
|
6096
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
6248
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L59, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
6097
6249
|
if (!$2)
|
|
6098
6250
|
return $1;
|
|
6099
6251
|
return $0;
|
|
@@ -6156,9 +6308,9 @@ var Civet = (() => {
|
|
|
6156
6308
|
return TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state);
|
|
6157
6309
|
}
|
|
6158
6310
|
}
|
|
6159
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
6160
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
6161
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
6311
|
+
var TypeUnaryOp$0 = $EXPECT($L150, fail, 'TypeUnaryOp "keyof"');
|
|
6312
|
+
var TypeUnaryOp$1 = $EXPECT($L132, fail, 'TypeUnaryOp "typeof"');
|
|
6313
|
+
var TypeUnaryOp$2 = $EXPECT($L151, fail, 'TypeUnaryOp "infer"');
|
|
6162
6314
|
function TypeUnaryOp(state) {
|
|
6163
6315
|
if (state.tokenize) {
|
|
6164
6316
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -6248,10 +6400,10 @@ var Civet = (() => {
|
|
|
6248
6400
|
}
|
|
6249
6401
|
}
|
|
6250
6402
|
var TypeLiteral$0 = Literal;
|
|
6251
|
-
var TypeLiteral$1 = $TV($EXPECT($
|
|
6403
|
+
var TypeLiteral$1 = $TV($EXPECT($L136, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
|
|
6252
6404
|
return { $loc, token: "void" };
|
|
6253
6405
|
});
|
|
6254
|
-
var TypeLiteral$2 = $TV($EXPECT($
|
|
6406
|
+
var TypeLiteral$2 = $TV($EXPECT($L152, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
6255
6407
|
return { $loc, token: "[]" };
|
|
6256
6408
|
});
|
|
6257
6409
|
function TypeLiteral(state) {
|
|
@@ -6261,10 +6413,10 @@ var Civet = (() => {
|
|
|
6261
6413
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
6262
6414
|
}
|
|
6263
6415
|
}
|
|
6264
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
6416
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L74, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
6265
6417
|
return { $loc, token: "|" };
|
|
6266
6418
|
});
|
|
6267
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
6419
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L72, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
6268
6420
|
return { $loc, token: "&" };
|
|
6269
6421
|
});
|
|
6270
6422
|
function TypeBinaryOp(state) {
|
|
@@ -6284,7 +6436,7 @@ var Civet = (() => {
|
|
|
6284
6436
|
return FunctionType$0(state);
|
|
6285
6437
|
}
|
|
6286
6438
|
}
|
|
6287
|
-
var TypeArguments$0 = $S(__, $EXPECT($L4, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
6439
|
+
var TypeArguments$0 = $S(__, $EXPECT($L4, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L55, fail, 'TypeArguments ">"'));
|
|
6288
6440
|
function TypeArguments(state) {
|
|
6289
6441
|
if (state.verbose)
|
|
6290
6442
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -6294,7 +6446,7 @@ var Civet = (() => {
|
|
|
6294
6446
|
return TypeArguments$0(state);
|
|
6295
6447
|
}
|
|
6296
6448
|
}
|
|
6297
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($L4, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
6449
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L4, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L55, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
6298
6450
|
return { ts: true, children: $0 };
|
|
6299
6451
|
});
|
|
6300
6452
|
function TypeParameters(state) {
|
|
@@ -6327,8 +6479,8 @@ var Civet = (() => {
|
|
|
6327
6479
|
}
|
|
6328
6480
|
}
|
|
6329
6481
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
6330
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
6331
|
-
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($
|
|
6482
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L55, fail, 'TypeParameterDelimiter ">"')));
|
|
6483
|
+
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L55, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
|
|
6332
6484
|
return { $loc, token: "," };
|
|
6333
6485
|
});
|
|
6334
6486
|
var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
@@ -6366,7 +6518,7 @@ var Civet = (() => {
|
|
|
6366
6518
|
return CivetPrologue$0(state) || CivetPrologue$1(state);
|
|
6367
6519
|
}
|
|
6368
6520
|
}
|
|
6369
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
6521
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L153, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R45, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
6370
6522
|
var options = $2;
|
|
6371
6523
|
return {
|
|
6372
6524
|
type: "CivetPrologue",
|
|
@@ -6586,6 +6738,20 @@ var Civet = (() => {
|
|
|
6586
6738
|
return InsertBreak$0(state);
|
|
6587
6739
|
}
|
|
6588
6740
|
}
|
|
6741
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6742
|
+
if (module.config.coffeeBinaryExistential)
|
|
6743
|
+
return;
|
|
6744
|
+
return $skip;
|
|
6745
|
+
});
|
|
6746
|
+
function CoffeeBinaryExistentialEnabled(state) {
|
|
6747
|
+
if (state.verbose)
|
|
6748
|
+
console.log("ENTER:", "CoffeeBinaryExistentialEnabled");
|
|
6749
|
+
if (state.tokenize) {
|
|
6750
|
+
return $TOKEN("CoffeeBinaryExistentialEnabled", state, CoffeeBinaryExistentialEnabled$0(state));
|
|
6751
|
+
} else {
|
|
6752
|
+
return CoffeeBinaryExistentialEnabled$0(state);
|
|
6753
|
+
}
|
|
6754
|
+
}
|
|
6589
6755
|
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6590
6756
|
if (module.config.coffeeBooleans)
|
|
6591
6757
|
return;
|
|
@@ -6600,6 +6766,20 @@ var Civet = (() => {
|
|
|
6600
6766
|
return CoffeeBooleansEnabled$0(state);
|
|
6601
6767
|
}
|
|
6602
6768
|
}
|
|
6769
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6770
|
+
if (module.config.coffeeClasses)
|
|
6771
|
+
return;
|
|
6772
|
+
return $skip;
|
|
6773
|
+
});
|
|
6774
|
+
function CoffeeClassesEnabled(state) {
|
|
6775
|
+
if (state.verbose)
|
|
6776
|
+
console.log("ENTER:", "CoffeeClassesEnabled");
|
|
6777
|
+
if (state.tokenize) {
|
|
6778
|
+
return $TOKEN("CoffeeClassesEnabled", state, CoffeeClassesEnabled$0(state));
|
|
6779
|
+
} else {
|
|
6780
|
+
return CoffeeClassesEnabled$0(state);
|
|
6781
|
+
}
|
|
6782
|
+
}
|
|
6603
6783
|
var CoffeeCommentEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6604
6784
|
if (module.config.coffeeComment)
|
|
6605
6785
|
return;
|
|
@@ -6670,6 +6850,20 @@ var Civet = (() => {
|
|
|
6670
6850
|
return CoffeeIsntEnabled$0(state);
|
|
6671
6851
|
}
|
|
6672
6852
|
}
|
|
6853
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6854
|
+
if (module.config.coffeeLineContinuation)
|
|
6855
|
+
return;
|
|
6856
|
+
return $skip;
|
|
6857
|
+
});
|
|
6858
|
+
function CoffeeLineContinuationEnabled(state) {
|
|
6859
|
+
if (state.verbose)
|
|
6860
|
+
console.log("ENTER:", "CoffeeLineContinuationEnabled");
|
|
6861
|
+
if (state.tokenize) {
|
|
6862
|
+
return $TOKEN("CoffeeLineContinuationEnabled", state, CoffeeLineContinuationEnabled$0(state));
|
|
6863
|
+
} else {
|
|
6864
|
+
return CoffeeLineContinuationEnabled$0(state);
|
|
6865
|
+
}
|
|
6866
|
+
}
|
|
6673
6867
|
var CoffeeNotEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6674
6868
|
if (module.config.coffeeNot)
|
|
6675
6869
|
return;
|
|
@@ -6704,13 +6898,16 @@ var Civet = (() => {
|
|
|
6704
6898
|
module.verbose = false;
|
|
6705
6899
|
module.config = {
|
|
6706
6900
|
autoVar: false,
|
|
6901
|
+
coffeeBinaryExistential: false,
|
|
6707
6902
|
coffeeBooleans: false,
|
|
6903
|
+
coffeeClasses: false,
|
|
6708
6904
|
coffeeComment: false,
|
|
6709
6905
|
coffeeDo: false,
|
|
6710
6906
|
coffeeEq: false,
|
|
6711
6907
|
coffeeForLoops: false,
|
|
6712
6908
|
coffeeInterpolation: false,
|
|
6713
6909
|
coffeeIsnt: false,
|
|
6910
|
+
coffeeLineContinuation: false,
|
|
6714
6911
|
coffeeNot: false,
|
|
6715
6912
|
coffeeOf: false,
|
|
6716
6913
|
implicitReturns: true
|
|
@@ -6757,24 +6954,30 @@ var Civet = (() => {
|
|
|
6757
6954
|
set(b) {
|
|
6758
6955
|
if (b) {
|
|
6759
6956
|
this.autoVar = true;
|
|
6957
|
+
this.coffeeBinaryExistential = true;
|
|
6760
6958
|
this.coffeeBooleans = true;
|
|
6959
|
+
this.coffeeClasses = true;
|
|
6761
6960
|
this.coffeeComment = true;
|
|
6762
6961
|
this.coffeeDo = true;
|
|
6763
6962
|
this.coffeeEq = true;
|
|
6764
6963
|
this.coffeeForLoops = true;
|
|
6765
6964
|
this.coffeeInterpolation = true;
|
|
6766
6965
|
this.coffeeIsnt = true;
|
|
6966
|
+
this.coffeeLineContinuation = true;
|
|
6767
6967
|
this.coffeeNot = true;
|
|
6768
6968
|
this.coffeeOf = true;
|
|
6769
6969
|
} else {
|
|
6770
6970
|
this.autoVar = false;
|
|
6971
|
+
this.coffeeBinaryExistential = false;
|
|
6771
6972
|
this.coffeeBooleans = false;
|
|
6973
|
+
this.coffeeClasses = false;
|
|
6772
6974
|
this.coffeeComment = false;
|
|
6773
6975
|
this.coffeeDo = false;
|
|
6774
6976
|
this.coffeeEq = false;
|
|
6775
6977
|
this.coffeeForLoops = false;
|
|
6776
6978
|
this.coffeeInterpolation = false;
|
|
6777
6979
|
this.coffeeIsnt = false;
|
|
6980
|
+
this.coffeeLineContinuation = false;
|
|
6778
6981
|
this.coffeeNot = false;
|
|
6779
6982
|
this.coffeeOf = false;
|
|
6780
6983
|
}
|
|
@@ -6890,13 +7093,13 @@ var Civet = (() => {
|
|
|
6890
7093
|
let i = 2;
|
|
6891
7094
|
while (i < expandedOps.length) {
|
|
6892
7095
|
const op = expandedOps[i];
|
|
6893
|
-
if (op.
|
|
7096
|
+
if (op.ref) {
|
|
6894
7097
|
const [a, wsOp, op2, wsB, b] = expandedOps.slice(i - 2, i + 3);
|
|
6895
7098
|
module.insertTrimmingSpace(wsOp, "");
|
|
6896
7099
|
module.insertTrimmingSpace(wsB, "");
|
|
6897
7100
|
expandedOps.splice(i - 2, 5, {
|
|
6898
7101
|
type: "Call",
|
|
6899
|
-
children: [wsOp, op2, ".call(", wsB, b, ", ", a, ")
|
|
7102
|
+
children: [wsOp, op2.ref, ".call(", wsB, b, ", ", a, ")", op2.suffix]
|
|
6900
7103
|
});
|
|
6901
7104
|
} else {
|
|
6902
7105
|
i += 4;
|
|
@@ -6914,7 +7117,7 @@ var Civet = (() => {
|
|
|
6914
7117
|
let chains = [];
|
|
6915
7118
|
while (i < l) {
|
|
6916
7119
|
const [, op] = binops[i];
|
|
6917
|
-
if (relationalOps.includes(op.token) || op.
|
|
7120
|
+
if (relationalOps.includes(op.token) || op.ref) {
|
|
6918
7121
|
chains.push(i);
|
|
6919
7122
|
} else if (lowerPrecedenceOps.includes(op.token)) {
|
|
6920
7123
|
processChains();
|
|
@@ -7179,7 +7382,7 @@ var Civet = (() => {
|
|
|
7179
7382
|
return Init$0(state);
|
|
7180
7383
|
}
|
|
7181
7384
|
}
|
|
7182
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
7385
|
+
var Indent$0 = $TV($Q($C($EXPECT($L154, fail, 'Indent " "'), $EXPECT($L155, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
7183
7386
|
const level = $1.length;
|
|
7184
7387
|
return {
|
|
7185
7388
|
$loc,
|