@danielx/civet 0.4.19-pre.1 → 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 +21 -10
- package/dist/browser.js +629 -379
- package/dist/main.js +629 -379
- 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;
|
|
@@ -1227,7 +1273,7 @@ var Civet = (() => {
|
|
|
1227
1273
|
return result;
|
|
1228
1274
|
}
|
|
1229
1275
|
});
|
|
1230
|
-
var UnaryExpression$1 = $TS($S(CoffeeDoEnabled, Do, __, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1276
|
+
var UnaryExpression$1 = $TS($S(CoffeeDoEnabled, Do, __, $C($S(LeftHandSideExpression, $N($S(__, AssignmentOpSymbol))), ArrowFunction, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1231
1277
|
var ws = $3;
|
|
1232
1278
|
var exp = $4;
|
|
1233
1279
|
module.insertTrimmingSpace(ws, "");
|
|
@@ -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) {
|
|
@@ -2568,12 +2645,59 @@ var Civet = (() => {
|
|
|
2568
2645
|
const inclusive = range.token === "..";
|
|
2569
2646
|
range.token = ",";
|
|
2570
2647
|
if (s.type === "Literal" && e.type === "Literal") {
|
|
2571
|
-
|
|
2572
|
-
|
|
2573
|
-
|
|
2574
|
-
|
|
2575
|
-
|
|
2576
|
-
|
|
2648
|
+
let start, end;
|
|
2649
|
+
if (s.raw[0] === "'") {
|
|
2650
|
+
start = s.raw.match(/^'(.*)'$/)[1];
|
|
2651
|
+
} else {
|
|
2652
|
+
start = JSON.parse(s.raw);
|
|
2653
|
+
}
|
|
2654
|
+
if (e.raw[0] === "'") {
|
|
2655
|
+
end = e.raw.match(/^'(.*)'$/)[1];
|
|
2656
|
+
} else {
|
|
2657
|
+
end = JSON.parse(e.raw);
|
|
2658
|
+
}
|
|
2659
|
+
if (typeof start !== typeof end) {
|
|
2660
|
+
throw new Error("Range start and end must be of the same type");
|
|
2661
|
+
}
|
|
2662
|
+
if (typeof start === "string") {
|
|
2663
|
+
if (start.length !== 1 || end.length !== 1) {
|
|
2664
|
+
throw new Error("String range start and end must be a single character");
|
|
2665
|
+
}
|
|
2666
|
+
const startCode = start.charCodeAt(0);
|
|
2667
|
+
const endCode = end.charCodeAt(0);
|
|
2668
|
+
const step = startCode < endCode ? 1 : -1;
|
|
2669
|
+
const length = Math.abs(endCode - startCode) + (inclusive ? 1 : 0);
|
|
2670
|
+
if (length <= 26) {
|
|
2671
|
+
return {
|
|
2672
|
+
type: "RangeExpression",
|
|
2673
|
+
children: ["[", Array.from({ length }, (_2, i) => JSON.stringify(String.fromCharCode(startCode + i * step))).join(", "), "]"],
|
|
2674
|
+
inclusive,
|
|
2675
|
+
start: s,
|
|
2676
|
+
end: e
|
|
2677
|
+
};
|
|
2678
|
+
} else {
|
|
2679
|
+
const inclusiveAdjust2 = inclusive ? " + 1" : "";
|
|
2680
|
+
const children2 = ["((s, e) => {let step = e > s ? 1 : -1; return Array.from({length: Math.abs(e - s)", inclusiveAdjust2, "}, (_, i) => String.fromCharCode(s + i * step))})(", startCode.toString(), ws, range, endCode.toString(), ")"];
|
|
2681
|
+
return {
|
|
2682
|
+
type: "RangeExpression",
|
|
2683
|
+
children: children2,
|
|
2684
|
+
inclusive,
|
|
2685
|
+
start: s,
|
|
2686
|
+
end: e
|
|
2687
|
+
};
|
|
2688
|
+
}
|
|
2689
|
+
} else if (typeof start === "number") {
|
|
2690
|
+
const step = end > start ? 1 : -1;
|
|
2691
|
+
const length = Math.abs(end - start) + (inclusive ? 1 : 0);
|
|
2692
|
+
if (length <= 20) {
|
|
2693
|
+
return {
|
|
2694
|
+
type: "RangeExpression",
|
|
2695
|
+
children: ["[", Array.from({ length }, (_2, i) => start + i * step).join(", "), "]"],
|
|
2696
|
+
inclusive,
|
|
2697
|
+
start: s,
|
|
2698
|
+
end: e
|
|
2699
|
+
};
|
|
2700
|
+
}
|
|
2577
2701
|
}
|
|
2578
2702
|
}
|
|
2579
2703
|
const inclusiveAdjust = inclusive ? " + 1" : "";
|
|
@@ -2627,7 +2751,7 @@ var Civet = (() => {
|
|
|
2627
2751
|
}
|
|
2628
2752
|
}
|
|
2629
2753
|
var ArrayElementDelimiter$0 = $S($Q(_), Comma);
|
|
2630
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2754
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
|
|
2631
2755
|
var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2632
2756
|
return { $loc, token: "," };
|
|
2633
2757
|
});
|
|
@@ -2689,11 +2813,12 @@ var Civet = (() => {
|
|
|
2689
2813
|
}
|
|
2690
2814
|
var ObjectLiteral$0 = BracedObjectLiteral;
|
|
2691
2815
|
var ObjectLiteral$1 = NestedObjectLiteral;
|
|
2816
|
+
var ObjectLiteral$2 = InlineObjectLiteral;
|
|
2692
2817
|
function ObjectLiteral(state) {
|
|
2693
2818
|
if (state.tokenize) {
|
|
2694
|
-
return $TOKEN("ObjectLiteral", state, ObjectLiteral$0(state) || ObjectLiteral$1(state));
|
|
2819
|
+
return $TOKEN("ObjectLiteral", state, ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state));
|
|
2695
2820
|
} else {
|
|
2696
|
-
return ObjectLiteral$0(state) || ObjectLiteral$1(state);
|
|
2821
|
+
return ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state);
|
|
2697
2822
|
}
|
|
2698
2823
|
}
|
|
2699
2824
|
var BracedObjectLiteral$0 = $TS($S(OpenBrace, $E(BracedObjectLiteralContent), __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
@@ -2793,8 +2918,20 @@ var Civet = (() => {
|
|
|
2793
2918
|
return NestedPropertyDefinition$0(state);
|
|
2794
2919
|
}
|
|
2795
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
|
+
}
|
|
2796
2933
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
2797
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2934
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ObjectPropertyDelimiter "}"')));
|
|
2798
2935
|
var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2799
2936
|
return { $loc, token: "," };
|
|
2800
2937
|
});
|
|
@@ -2805,7 +2942,7 @@ var Civet = (() => {
|
|
|
2805
2942
|
return ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state);
|
|
2806
2943
|
}
|
|
2807
2944
|
}
|
|
2808
|
-
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) {
|
|
2809
2946
|
if ($2.length) {
|
|
2810
2947
|
return [].concat($1 || [], ...$2);
|
|
2811
2948
|
}
|
|
@@ -2823,7 +2960,28 @@ var Civet = (() => {
|
|
|
2823
2960
|
return PropertyDefinitionList$0(state);
|
|
2824
2961
|
}
|
|
2825
2962
|
}
|
|
2826
|
-
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) {
|
|
2827
2985
|
var exp = $4;
|
|
2828
2986
|
return {
|
|
2829
2987
|
type: "Property",
|
|
@@ -2831,14 +2989,30 @@ var Civet = (() => {
|
|
|
2831
2989
|
names: exp.names || []
|
|
2832
2990
|
};
|
|
2833
2991
|
});
|
|
2834
|
-
|
|
2835
|
-
|
|
2836
|
-
|
|
2837
|
-
function PropertyDefinition(state) {
|
|
2992
|
+
function NamedProperty(state) {
|
|
2993
|
+
if (state.verbose)
|
|
2994
|
+
console.log("ENTER:", "NamedProperty");
|
|
2838
2995
|
if (state.tokenize) {
|
|
2839
|
-
return $TOKEN("
|
|
2996
|
+
return $TOKEN("NamedProperty", state, NamedProperty$0(state));
|
|
2840
2997
|
} else {
|
|
2841
|
-
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);
|
|
2842
3016
|
}
|
|
2843
3017
|
}
|
|
2844
3018
|
var PropertyName$0 = NumericLiteral;
|
|
@@ -2955,25 +3129,25 @@ var Civet = (() => {
|
|
|
2955
3129
|
return AssignmentOp$0(state);
|
|
2956
3130
|
}
|
|
2957
3131
|
}
|
|
2958
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
2959
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
2960
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
2961
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
2962
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
2963
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
2964
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
2965
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
2966
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
2967
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
2968
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
2969
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
2970
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
2971
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
2972
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
2973
|
-
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) {
|
|
2974
3148
|
return "??=";
|
|
2975
3149
|
});
|
|
2976
|
-
var AssignmentOpSymbol$16 = $EXPECT($
|
|
3150
|
+
var AssignmentOpSymbol$16 = $EXPECT($L43, fail, 'AssignmentOpSymbol "="');
|
|
2977
3151
|
function AssignmentOpSymbol(state) {
|
|
2978
3152
|
if (state.tokenize) {
|
|
2979
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));
|
|
@@ -2995,68 +3169,80 @@ var Civet = (() => {
|
|
|
2995
3169
|
return BinaryOp$0(state);
|
|
2996
3170
|
}
|
|
2997
3171
|
}
|
|
2998
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
2999
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
3000
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
3001
|
-
var BinaryOpSymbol$3 = $EXPECT($
|
|
3002
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
3003
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
3004
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
3005
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
3006
|
-
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 "<<"');
|
|
3007
3181
|
var BinaryOpSymbol$9 = $EXPECT($L4, fail, 'BinaryOpSymbol "<"');
|
|
3008
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
3009
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
3010
|
-
var BinaryOpSymbol$12 = $EXPECT($
|
|
3011
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
3012
|
-
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) {
|
|
3013
3187
|
if (module.config.coffeeEq)
|
|
3014
3188
|
return "!==";
|
|
3015
3189
|
return $1;
|
|
3016
3190
|
});
|
|
3017
|
-
var BinaryOpSymbol$15 = $TS($S($EXPECT($
|
|
3191
|
+
var BinaryOpSymbol$15 = $TS($S($EXPECT($L58, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3018
3192
|
if (module.config.coffeeIsnt)
|
|
3019
3193
|
return "!==";
|
|
3020
3194
|
return $skip;
|
|
3021
3195
|
});
|
|
3022
|
-
var BinaryOpSymbol$16 = $T($S($EXPECT($
|
|
3196
|
+
var BinaryOpSymbol$16 = $T($S($EXPECT($L59, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
3023
3197
|
return "===";
|
|
3024
3198
|
});
|
|
3025
|
-
var BinaryOpSymbol$17 = $EXPECT($
|
|
3026
|
-
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) {
|
|
3027
3201
|
if (module.config.coffeeEq)
|
|
3028
3202
|
return "===";
|
|
3029
3203
|
return $1;
|
|
3030
3204
|
});
|
|
3031
|
-
var BinaryOpSymbol$19 = $T($S($EXPECT($
|
|
3205
|
+
var BinaryOpSymbol$19 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
3032
3206
|
return "&&";
|
|
3033
3207
|
});
|
|
3034
|
-
var BinaryOpSymbol$20 = $EXPECT($
|
|
3035
|
-
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) {
|
|
3036
3210
|
return "in";
|
|
3037
3211
|
});
|
|
3038
|
-
var BinaryOpSymbol$22 = $T($S($EXPECT($
|
|
3212
|
+
var BinaryOpSymbol$22 = $T($S($EXPECT($L65, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
3039
3213
|
return "||";
|
|
3040
3214
|
});
|
|
3041
|
-
var BinaryOpSymbol$23 = $EXPECT($
|
|
3042
|
-
var BinaryOpSymbol$24 = $EXPECT($
|
|
3043
|
-
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) {
|
|
3044
3221
|
return $1;
|
|
3045
3222
|
});
|
|
3046
|
-
var BinaryOpSymbol$
|
|
3047
|
-
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
|
+
};
|
|
3048
3234
|
});
|
|
3049
|
-
var BinaryOpSymbol$
|
|
3235
|
+
var BinaryOpSymbol$29 = $TS($S($EXPECT($L70, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3050
3236
|
return $1;
|
|
3051
3237
|
});
|
|
3052
|
-
var BinaryOpSymbol$
|
|
3053
|
-
var BinaryOpSymbol$
|
|
3054
|
-
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 "|"');
|
|
3055
3241
|
function BinaryOpSymbol(state) {
|
|
3056
3242
|
if (state.tokenize) {
|
|
3057
|
-
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));
|
|
3058
3244
|
} else {
|
|
3059
|
-
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);
|
|
3060
3246
|
}
|
|
3061
3247
|
}
|
|
3062
3248
|
var UnaryOp$0 = $TR($EXPECT($R4, fail, "UnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
@@ -3140,7 +3326,7 @@ var Civet = (() => {
|
|
|
3140
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);
|
|
3141
3327
|
}
|
|
3142
3328
|
}
|
|
3143
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
3329
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L75, fail, 'EmptyStatement ";"'))), function(value) {
|
|
3144
3330
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
3145
3331
|
});
|
|
3146
3332
|
function EmptyStatement(state) {
|
|
@@ -3152,7 +3338,7 @@ var Civet = (() => {
|
|
|
3152
3338
|
return EmptyStatement$0(state);
|
|
3153
3339
|
}
|
|
3154
3340
|
}
|
|
3155
|
-
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) {
|
|
3156
3342
|
var exps = value[3];
|
|
3157
3343
|
return { "type": "BlockStatement", "children": value, "expressions": exps };
|
|
3158
3344
|
});
|
|
@@ -3587,7 +3773,7 @@ var Civet = (() => {
|
|
|
3587
3773
|
return CoffeeForStatementParameters$0(state);
|
|
3588
3774
|
}
|
|
3589
3775
|
}
|
|
3590
|
-
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) {
|
|
3591
3777
|
var own = $1;
|
|
3592
3778
|
var binding = $2;
|
|
3593
3779
|
if (own) {
|
|
@@ -3886,7 +4072,7 @@ var Civet = (() => {
|
|
|
3886
4072
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
3887
4073
|
}
|
|
3888
4074
|
}
|
|
3889
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
4075
|
+
var Finally$0 = $S(__, $EXPECT($L77, fail, 'Finally "finally"'), BracedBlock);
|
|
3890
4076
|
function Finally(state) {
|
|
3891
4077
|
if (state.verbose)
|
|
3892
4078
|
console.log("ENTER:", "Finally");
|
|
@@ -3963,13 +4149,13 @@ var Civet = (() => {
|
|
|
3963
4149
|
return ExpressionStatement$0(state);
|
|
3964
4150
|
}
|
|
3965
4151
|
}
|
|
3966
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
4152
|
+
var KeywordStatement$0 = $T($S($EXPECT($L78, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
3967
4153
|
return { "type": "BreakStatement", "children": value };
|
|
3968
4154
|
});
|
|
3969
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
4155
|
+
var KeywordStatement$1 = $T($S($EXPECT($L79, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
3970
4156
|
return { "type": "ContinueStatement", "children": value };
|
|
3971
4157
|
});
|
|
3972
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
4158
|
+
var KeywordStatement$2 = $T($S($EXPECT($L80, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
3973
4159
|
return { "type": "DebuggerStatement", "children": value };
|
|
3974
4160
|
});
|
|
3975
4161
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -3985,7 +4171,7 @@ var Civet = (() => {
|
|
|
3985
4171
|
return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state);
|
|
3986
4172
|
}
|
|
3987
4173
|
}
|
|
3988
|
-
var DebuggerExpression$0 = $TS($S($EXPECT($
|
|
4174
|
+
var DebuggerExpression$0 = $TS($S($EXPECT($L80, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3989
4175
|
return {
|
|
3990
4176
|
type: "DebuggerExpression",
|
|
3991
4177
|
children: ["($=>{", $1, "})()"]
|
|
@@ -4028,7 +4214,7 @@ var Civet = (() => {
|
|
|
4028
4214
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
4029
4215
|
}
|
|
4030
4216
|
}
|
|
4031
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
4217
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L81, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
4032
4218
|
return { "ts": true, "children": value };
|
|
4033
4219
|
});
|
|
4034
4220
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
@@ -4207,7 +4393,7 @@ var Civet = (() => {
|
|
|
4207
4393
|
return ImportedBinding$0(state);
|
|
4208
4394
|
}
|
|
4209
4395
|
}
|
|
4210
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
4396
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L82, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression));
|
|
4211
4397
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
4212
4398
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
4213
4399
|
function ExportDeclaration(state) {
|
|
@@ -4314,7 +4500,7 @@ var Civet = (() => {
|
|
|
4314
4500
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
4315
4501
|
}
|
|
4316
4502
|
}
|
|
4317
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
4503
|
+
var ConstAssignment$0 = $TV($EXPECT($L83, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
4318
4504
|
return { $loc, token: "=" };
|
|
4319
4505
|
});
|
|
4320
4506
|
function ConstAssignment(state) {
|
|
@@ -4636,7 +4822,7 @@ var Civet = (() => {
|
|
|
4636
4822
|
return CoffeeDoubleQuotedStringCharacters$0(state);
|
|
4637
4823
|
}
|
|
4638
4824
|
}
|
|
4639
|
-
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) {
|
|
4640
4826
|
return { $loc, token: $1 };
|
|
4641
4827
|
});
|
|
4642
4828
|
function RegularExpressionLiteral(state) {
|
|
@@ -4763,7 +4949,7 @@ var Civet = (() => {
|
|
|
4763
4949
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
4764
4950
|
}
|
|
4765
4951
|
}
|
|
4766
|
-
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) {
|
|
4767
4953
|
return { $loc, token: $1 };
|
|
4768
4954
|
});
|
|
4769
4955
|
function JSMultiLineComment(state) {
|
|
@@ -4787,7 +4973,7 @@ var Civet = (() => {
|
|
|
4787
4973
|
return CoffeeSingleLineComment$0(state);
|
|
4788
4974
|
}
|
|
4789
4975
|
}
|
|
4790
|
-
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) {
|
|
4791
4977
|
return { $loc, token: `/*${$2}*/` };
|
|
4792
4978
|
});
|
|
4793
4979
|
function CoffeeMultiLineComment(state) {
|
|
@@ -4799,7 +4985,7 @@ var Civet = (() => {
|
|
|
4799
4985
|
return CoffeeMultiLineComment$0(state);
|
|
4800
4986
|
}
|
|
4801
4987
|
}
|
|
4802
|
-
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) {
|
|
4803
4989
|
return { $loc, token: $1 };
|
|
4804
4990
|
});
|
|
4805
4991
|
function InlineComment(state) {
|
|
@@ -4844,13 +5030,14 @@ var Civet = (() => {
|
|
|
4844
5030
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R33, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4845
5031
|
return { $loc, token: $0 };
|
|
4846
5032
|
});
|
|
5033
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L87, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
5034
|
+
return "";
|
|
5035
|
+
});
|
|
4847
5036
|
function NonNewlineWhitespace(state) {
|
|
4848
|
-
if (state.verbose)
|
|
4849
|
-
console.log("ENTER:", "NonNewlineWhitespace");
|
|
4850
5037
|
if (state.tokenize) {
|
|
4851
|
-
return $TOKEN("NonNewlineWhitespace", state, NonNewlineWhitespace$0(state));
|
|
5038
|
+
return $TOKEN("NonNewlineWhitespace", state, NonNewlineWhitespace$0(state) || NonNewlineWhitespace$1(state));
|
|
4852
5039
|
} else {
|
|
4853
|
-
return NonNewlineWhitespace$0(state);
|
|
5040
|
+
return NonNewlineWhitespace$0(state) || NonNewlineWhitespace$1(state);
|
|
4854
5041
|
}
|
|
4855
5042
|
}
|
|
4856
5043
|
var __$0 = $Q($C(Whitespace, Comment));
|
|
@@ -4920,7 +5107,7 @@ var Civet = (() => {
|
|
|
4920
5107
|
return Loc$0(state);
|
|
4921
5108
|
}
|
|
4922
5109
|
}
|
|
4923
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
5110
|
+
var Ampersand$0 = $TV($EXPECT($L72, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
4924
5111
|
return { $loc, token: $1 };
|
|
4925
5112
|
});
|
|
4926
5113
|
function Ampersand(state) {
|
|
@@ -4932,7 +5119,7 @@ var Civet = (() => {
|
|
|
4932
5119
|
return Ampersand$0(state);
|
|
4933
5120
|
}
|
|
4934
5121
|
}
|
|
4935
|
-
var As$0 = $TS($S($EXPECT($
|
|
5122
|
+
var As$0 = $TS($S($EXPECT($L88, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4936
5123
|
return { $loc, token: $1 };
|
|
4937
5124
|
});
|
|
4938
5125
|
function As(state) {
|
|
@@ -4944,7 +5131,19 @@ var Civet = (() => {
|
|
|
4944
5131
|
return As$0(state);
|
|
4945
5132
|
}
|
|
4946
5133
|
}
|
|
4947
|
-
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) {
|
|
4948
5147
|
return { $loc, token: $1 };
|
|
4949
5148
|
});
|
|
4950
5149
|
function Async(state) {
|
|
@@ -4956,7 +5155,7 @@ var Civet = (() => {
|
|
|
4956
5155
|
return Async$0(state);
|
|
4957
5156
|
}
|
|
4958
5157
|
}
|
|
4959
|
-
var Await$0 = $TS($S($EXPECT($
|
|
5158
|
+
var Await$0 = $TS($S($EXPECT($L91, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4960
5159
|
return { $loc, token: $1 };
|
|
4961
5160
|
});
|
|
4962
5161
|
function Await(state) {
|
|
@@ -4968,7 +5167,7 @@ var Civet = (() => {
|
|
|
4968
5167
|
return Await$0(state);
|
|
4969
5168
|
}
|
|
4970
5169
|
}
|
|
4971
|
-
var Backtick$0 = $TV($EXPECT($
|
|
5170
|
+
var Backtick$0 = $TV($EXPECT($L92, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
4972
5171
|
return { $loc, token: $1 };
|
|
4973
5172
|
});
|
|
4974
5173
|
function Backtick(state) {
|
|
@@ -4980,7 +5179,7 @@ var Civet = (() => {
|
|
|
4980
5179
|
return Backtick$0(state);
|
|
4981
5180
|
}
|
|
4982
5181
|
}
|
|
4983
|
-
var By$0 = $TS($S($EXPECT($
|
|
5182
|
+
var By$0 = $TS($S($EXPECT($L93, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4984
5183
|
return { $loc, token: $1 };
|
|
4985
5184
|
});
|
|
4986
5185
|
function By(state) {
|
|
@@ -4992,7 +5191,7 @@ var Civet = (() => {
|
|
|
4992
5191
|
return By$0(state);
|
|
4993
5192
|
}
|
|
4994
5193
|
}
|
|
4995
|
-
var Case$0 = $TS($S($EXPECT($
|
|
5194
|
+
var Case$0 = $TS($S($EXPECT($L94, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4996
5195
|
return { $loc, token: $1 };
|
|
4997
5196
|
});
|
|
4998
5197
|
function Case(state) {
|
|
@@ -5004,7 +5203,7 @@ var Civet = (() => {
|
|
|
5004
5203
|
return Case$0(state);
|
|
5005
5204
|
}
|
|
5006
5205
|
}
|
|
5007
|
-
var Catch$0 = $TV($EXPECT($
|
|
5206
|
+
var Catch$0 = $TV($EXPECT($L95, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
5008
5207
|
return { $loc, token: $1 };
|
|
5009
5208
|
});
|
|
5010
5209
|
function Catch(state) {
|
|
@@ -5016,7 +5215,7 @@ var Civet = (() => {
|
|
|
5016
5215
|
return Catch$0(state);
|
|
5017
5216
|
}
|
|
5018
5217
|
}
|
|
5019
|
-
var Class$0 = $TV($EXPECT($
|
|
5218
|
+
var Class$0 = $TV($EXPECT($L96, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
5020
5219
|
return { $loc, token: $1 };
|
|
5021
5220
|
});
|
|
5022
5221
|
function Class(state) {
|
|
@@ -5028,7 +5227,7 @@ var Civet = (() => {
|
|
|
5028
5227
|
return Class$0(state);
|
|
5029
5228
|
}
|
|
5030
5229
|
}
|
|
5031
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
5230
|
+
var CloseBrace$0 = $TV($EXPECT($L26, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
5032
5231
|
return { $loc, token: $1 };
|
|
5033
5232
|
});
|
|
5034
5233
|
function CloseBrace(state) {
|
|
@@ -5040,7 +5239,7 @@ var Civet = (() => {
|
|
|
5040
5239
|
return CloseBrace$0(state);
|
|
5041
5240
|
}
|
|
5042
5241
|
}
|
|
5043
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
5242
|
+
var CloseBracket$0 = $TV($EXPECT($L25, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
5044
5243
|
return { $loc, token: $1 };
|
|
5045
5244
|
});
|
|
5046
5245
|
function CloseBracket(state) {
|
|
@@ -5052,7 +5251,7 @@ var Civet = (() => {
|
|
|
5052
5251
|
return CloseBracket$0(state);
|
|
5053
5252
|
}
|
|
5054
5253
|
}
|
|
5055
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
5254
|
+
var CloseParen$0 = $TV($EXPECT($L15, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
5056
5255
|
return { $loc, token: $1 };
|
|
5057
5256
|
});
|
|
5058
5257
|
function CloseParen(state) {
|
|
@@ -5064,7 +5263,7 @@ var Civet = (() => {
|
|
|
5064
5263
|
return CloseParen$0(state);
|
|
5065
5264
|
}
|
|
5066
5265
|
}
|
|
5067
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
5266
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L97, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
5068
5267
|
return { $loc, token: "${" };
|
|
5069
5268
|
});
|
|
5070
5269
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -5076,7 +5275,7 @@ var Civet = (() => {
|
|
|
5076
5275
|
return CoffeeSubstitutionStart$0(state);
|
|
5077
5276
|
}
|
|
5078
5277
|
}
|
|
5079
|
-
var Colon$0 = $TV($EXPECT($
|
|
5278
|
+
var Colon$0 = $TV($EXPECT($L98, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
5080
5279
|
return { $loc, token: $1 };
|
|
5081
5280
|
});
|
|
5082
5281
|
function Colon(state) {
|
|
@@ -5088,7 +5287,7 @@ var Civet = (() => {
|
|
|
5088
5287
|
return Colon$0(state);
|
|
5089
5288
|
}
|
|
5090
5289
|
}
|
|
5091
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
5290
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L89, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
5092
5291
|
return { $loc, token: "constructor" };
|
|
5093
5292
|
});
|
|
5094
5293
|
function ConstructorShorthand(state) {
|
|
@@ -5100,7 +5299,7 @@ var Civet = (() => {
|
|
|
5100
5299
|
return ConstructorShorthand$0(state);
|
|
5101
5300
|
}
|
|
5102
5301
|
}
|
|
5103
|
-
var Default$0 = $TS($S($EXPECT($
|
|
5302
|
+
var Default$0 = $TS($S($EXPECT($L82, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5104
5303
|
return { $loc, token: $1 };
|
|
5105
5304
|
});
|
|
5106
5305
|
function Default(state) {
|
|
@@ -5112,7 +5311,7 @@ var Civet = (() => {
|
|
|
5112
5311
|
return Default$0(state);
|
|
5113
5312
|
}
|
|
5114
5313
|
}
|
|
5115
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
5314
|
+
var Delete$0 = $TS($S($EXPECT($L99, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5116
5315
|
return { $loc, token: $1 };
|
|
5117
5316
|
});
|
|
5118
5317
|
function Delete(state) {
|
|
@@ -5124,7 +5323,7 @@ var Civet = (() => {
|
|
|
5124
5323
|
return Delete$0(state);
|
|
5125
5324
|
}
|
|
5126
5325
|
}
|
|
5127
|
-
var Do$0 = $TS($S($EXPECT($
|
|
5326
|
+
var Do$0 = $TS($S($EXPECT($L100, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5128
5327
|
return { $loc, token: $1 };
|
|
5129
5328
|
});
|
|
5130
5329
|
function Do(state) {
|
|
@@ -5136,7 +5335,7 @@ var Civet = (() => {
|
|
|
5136
5335
|
return Do$0(state);
|
|
5137
5336
|
}
|
|
5138
5337
|
}
|
|
5139
|
-
var Dot$0 = $TV($EXPECT($
|
|
5338
|
+
var Dot$0 = $TV($EXPECT($L8, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
5140
5339
|
return { $loc, token: $1 };
|
|
5141
5340
|
});
|
|
5142
5341
|
function Dot(state) {
|
|
@@ -5148,7 +5347,7 @@ var Civet = (() => {
|
|
|
5148
5347
|
return Dot$0(state);
|
|
5149
5348
|
}
|
|
5150
5349
|
}
|
|
5151
|
-
var DotDot$0 = $TV($EXPECT($
|
|
5350
|
+
var DotDot$0 = $TV($EXPECT($L101, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
5152
5351
|
return { $loc, token: $1 };
|
|
5153
5352
|
});
|
|
5154
5353
|
function DotDot(state) {
|
|
@@ -5160,7 +5359,7 @@ var Civet = (() => {
|
|
|
5160
5359
|
return DotDot$0(state);
|
|
5161
5360
|
}
|
|
5162
5361
|
}
|
|
5163
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
5362
|
+
var DotDotDot$0 = $TV($EXPECT($L102, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
5164
5363
|
return { $loc, token: $1 };
|
|
5165
5364
|
});
|
|
5166
5365
|
function DotDotDot(state) {
|
|
@@ -5172,7 +5371,7 @@ var Civet = (() => {
|
|
|
5172
5371
|
return DotDotDot$0(state);
|
|
5173
5372
|
}
|
|
5174
5373
|
}
|
|
5175
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
5374
|
+
var DoubleQuote$0 = $TV($EXPECT($L103, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
5176
5375
|
return { $loc, token: $1 };
|
|
5177
5376
|
});
|
|
5178
5377
|
function DoubleQuote(state) {
|
|
@@ -5184,7 +5383,7 @@ var Civet = (() => {
|
|
|
5184
5383
|
return DoubleQuote$0(state);
|
|
5185
5384
|
}
|
|
5186
5385
|
}
|
|
5187
|
-
var Else$0 = $TV($EXPECT($
|
|
5386
|
+
var Else$0 = $TV($EXPECT($L104, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
5188
5387
|
return { $loc, token: $1 };
|
|
5189
5388
|
});
|
|
5190
5389
|
function Else(state) {
|
|
@@ -5196,7 +5395,7 @@ var Civet = (() => {
|
|
|
5196
5395
|
return Else$0(state);
|
|
5197
5396
|
}
|
|
5198
5397
|
}
|
|
5199
|
-
var Equals$0 = $TV($EXPECT($
|
|
5398
|
+
var Equals$0 = $TV($EXPECT($L43, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
5200
5399
|
return { $loc, token: $1 };
|
|
5201
5400
|
});
|
|
5202
5401
|
function Equals(state) {
|
|
@@ -5208,7 +5407,7 @@ var Civet = (() => {
|
|
|
5208
5407
|
return Equals$0(state);
|
|
5209
5408
|
}
|
|
5210
5409
|
}
|
|
5211
|
-
var Export$0 = $TS($S($EXPECT($
|
|
5410
|
+
var Export$0 = $TS($S($EXPECT($L105, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5212
5411
|
return { $loc, token: $1 };
|
|
5213
5412
|
});
|
|
5214
5413
|
function Export(state) {
|
|
@@ -5220,7 +5419,7 @@ var Civet = (() => {
|
|
|
5220
5419
|
return Export$0(state);
|
|
5221
5420
|
}
|
|
5222
5421
|
}
|
|
5223
|
-
var For$0 = $TS($S($EXPECT($
|
|
5422
|
+
var For$0 = $TS($S($EXPECT($L106, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5224
5423
|
return { $loc, token: $1 };
|
|
5225
5424
|
});
|
|
5226
5425
|
function For(state) {
|
|
@@ -5232,7 +5431,7 @@ var Civet = (() => {
|
|
|
5232
5431
|
return For$0(state);
|
|
5233
5432
|
}
|
|
5234
5433
|
}
|
|
5235
|
-
var From$0 = $TS($S($EXPECT($
|
|
5434
|
+
var From$0 = $TS($S($EXPECT($L107, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5236
5435
|
return { $loc, token: $1 };
|
|
5237
5436
|
});
|
|
5238
5437
|
function From(state) {
|
|
@@ -5244,7 +5443,7 @@ var Civet = (() => {
|
|
|
5244
5443
|
return From$0(state);
|
|
5245
5444
|
}
|
|
5246
5445
|
}
|
|
5247
|
-
var Function$0 = $TV($EXPECT($
|
|
5446
|
+
var Function$0 = $TV($EXPECT($L108, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
5248
5447
|
return { $loc, token: $1 };
|
|
5249
5448
|
});
|
|
5250
5449
|
function Function(state) {
|
|
@@ -5256,7 +5455,7 @@ var Civet = (() => {
|
|
|
5256
5455
|
return Function$0(state);
|
|
5257
5456
|
}
|
|
5258
5457
|
}
|
|
5259
|
-
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) {
|
|
5260
5459
|
return { $loc, token: $1 };
|
|
5261
5460
|
});
|
|
5262
5461
|
function GetOrSet(state) {
|
|
@@ -5268,7 +5467,7 @@ var Civet = (() => {
|
|
|
5268
5467
|
return GetOrSet$0(state);
|
|
5269
5468
|
}
|
|
5270
5469
|
}
|
|
5271
|
-
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) {
|
|
5272
5471
|
return { $loc, token: $1 };
|
|
5273
5472
|
});
|
|
5274
5473
|
function If(state) {
|
|
@@ -5280,7 +5479,7 @@ var Civet = (() => {
|
|
|
5280
5479
|
return If$0(state);
|
|
5281
5480
|
}
|
|
5282
5481
|
}
|
|
5283
|
-
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) {
|
|
5284
5483
|
return { $loc, token: $1 };
|
|
5285
5484
|
});
|
|
5286
5485
|
function Import(state) {
|
|
@@ -5304,7 +5503,7 @@ var Civet = (() => {
|
|
|
5304
5503
|
return In$0(state);
|
|
5305
5504
|
}
|
|
5306
5505
|
}
|
|
5307
|
-
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) {
|
|
5308
5507
|
return { $loc, token: $1 };
|
|
5309
5508
|
});
|
|
5310
5509
|
function LetOrConst(state) {
|
|
@@ -5316,7 +5515,7 @@ var Civet = (() => {
|
|
|
5316
5515
|
return LetOrConst$0(state);
|
|
5317
5516
|
}
|
|
5318
5517
|
}
|
|
5319
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
5518
|
+
var Loop$0 = $TS($S($EXPECT($L115, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5320
5519
|
return { $loc, token: "while(true)" };
|
|
5321
5520
|
});
|
|
5322
5521
|
function Loop(state) {
|
|
@@ -5328,7 +5527,7 @@ var Civet = (() => {
|
|
|
5328
5527
|
return Loop$0(state);
|
|
5329
5528
|
}
|
|
5330
5529
|
}
|
|
5331
|
-
var New$0 = $TV($EXPECT($
|
|
5530
|
+
var New$0 = $TV($EXPECT($L116, fail, 'New "new"'), function($skip, $loc, $0, $1) {
|
|
5332
5531
|
return { $loc, token: $1 };
|
|
5333
5532
|
});
|
|
5334
5533
|
function New(state) {
|
|
@@ -5340,7 +5539,7 @@ var Civet = (() => {
|
|
|
5340
5539
|
return New$0(state);
|
|
5341
5540
|
}
|
|
5342
5541
|
}
|
|
5343
|
-
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) {
|
|
5344
5543
|
return { $loc, token: "!" };
|
|
5345
5544
|
});
|
|
5346
5545
|
function Not(state) {
|
|
@@ -5352,7 +5551,7 @@ var Civet = (() => {
|
|
|
5352
5551
|
return Not$0(state);
|
|
5353
5552
|
}
|
|
5354
5553
|
}
|
|
5355
|
-
var Of$0 = $TV($EXPECT($
|
|
5554
|
+
var Of$0 = $TV($EXPECT($L64, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
5356
5555
|
return { $loc, token: $1 };
|
|
5357
5556
|
});
|
|
5358
5557
|
function Of(state) {
|
|
@@ -5364,7 +5563,7 @@ var Civet = (() => {
|
|
|
5364
5563
|
return Of$0(state);
|
|
5365
5564
|
}
|
|
5366
5565
|
}
|
|
5367
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
5566
|
+
var OpenBrace$0 = $TV($EXPECT($L117, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
5368
5567
|
return { $loc, token: $1 };
|
|
5369
5568
|
});
|
|
5370
5569
|
function OpenBrace(state) {
|
|
@@ -5376,7 +5575,7 @@ var Civet = (() => {
|
|
|
5376
5575
|
return OpenBrace$0(state);
|
|
5377
5576
|
}
|
|
5378
5577
|
}
|
|
5379
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
5578
|
+
var OpenBracket$0 = $TV($EXPECT($L118, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
5380
5579
|
return { $loc, token: $1 };
|
|
5381
5580
|
});
|
|
5382
5581
|
function OpenBracket(state) {
|
|
@@ -5388,7 +5587,7 @@ var Civet = (() => {
|
|
|
5388
5587
|
return OpenBracket$0(state);
|
|
5389
5588
|
}
|
|
5390
5589
|
}
|
|
5391
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
5590
|
+
var OpenParen$0 = $TV($EXPECT($L119, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
5392
5591
|
return { $loc, token: $1 };
|
|
5393
5592
|
});
|
|
5394
5593
|
function OpenParen(state) {
|
|
@@ -5400,7 +5599,7 @@ var Civet = (() => {
|
|
|
5400
5599
|
return OpenParen$0(state);
|
|
5401
5600
|
}
|
|
5402
5601
|
}
|
|
5403
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
5602
|
+
var QuestionMark$0 = $TV($EXPECT($L68, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
5404
5603
|
return { $loc, token: $1 };
|
|
5405
5604
|
});
|
|
5406
5605
|
function QuestionMark(state) {
|
|
@@ -5412,7 +5611,7 @@ var Civet = (() => {
|
|
|
5412
5611
|
return QuestionMark$0(state);
|
|
5413
5612
|
}
|
|
5414
5613
|
}
|
|
5415
|
-
var Return$0 = $TS($S($EXPECT($
|
|
5614
|
+
var Return$0 = $TS($S($EXPECT($L120, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5416
5615
|
return { $loc, token: $1 };
|
|
5417
5616
|
});
|
|
5418
5617
|
function Return(state) {
|
|
@@ -5424,7 +5623,7 @@ var Civet = (() => {
|
|
|
5424
5623
|
return Return$0(state);
|
|
5425
5624
|
}
|
|
5426
5625
|
}
|
|
5427
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
5626
|
+
var Semicolon$0 = $TV($EXPECT($L75, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
5428
5627
|
return { $loc, token: $1 };
|
|
5429
5628
|
});
|
|
5430
5629
|
function Semicolon(state) {
|
|
@@ -5436,7 +5635,7 @@ var Civet = (() => {
|
|
|
5436
5635
|
return Semicolon$0(state);
|
|
5437
5636
|
}
|
|
5438
5637
|
}
|
|
5439
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
5638
|
+
var SingleQuote$0 = $TV($EXPECT($L121, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
5440
5639
|
return { $loc, token: $1 };
|
|
5441
5640
|
});
|
|
5442
5641
|
function SingleQuote(state) {
|
|
@@ -5448,7 +5647,7 @@ var Civet = (() => {
|
|
|
5448
5647
|
return SingleQuote$0(state);
|
|
5449
5648
|
}
|
|
5450
5649
|
}
|
|
5451
|
-
var Star$0 = $TV($EXPECT($
|
|
5650
|
+
var Star$0 = $TV($EXPECT($L45, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
5452
5651
|
return { $loc, token: $1 };
|
|
5453
5652
|
});
|
|
5454
5653
|
function Star(state) {
|
|
@@ -5460,10 +5659,10 @@ var Civet = (() => {
|
|
|
5460
5659
|
return Star$0(state);
|
|
5461
5660
|
}
|
|
5462
5661
|
}
|
|
5463
|
-
var Static$0 = $TV($EXPECT($
|
|
5662
|
+
var Static$0 = $TV($EXPECT($L122, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
5464
5663
|
return { $loc, token: $1 };
|
|
5465
5664
|
});
|
|
5466
|
-
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) {
|
|
5467
5666
|
return { $loc, token: "static " };
|
|
5468
5667
|
});
|
|
5469
5668
|
function Static(state) {
|
|
@@ -5473,7 +5672,7 @@ var Civet = (() => {
|
|
|
5473
5672
|
return Static$0(state) || Static$1(state);
|
|
5474
5673
|
}
|
|
5475
5674
|
}
|
|
5476
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
5675
|
+
var SubstitutionStart$0 = $TV($EXPECT($L123, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
5477
5676
|
return { $loc, token: $1 };
|
|
5478
5677
|
});
|
|
5479
5678
|
function SubstitutionStart(state) {
|
|
@@ -5485,7 +5684,7 @@ var Civet = (() => {
|
|
|
5485
5684
|
return SubstitutionStart$0(state);
|
|
5486
5685
|
}
|
|
5487
5686
|
}
|
|
5488
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
5687
|
+
var Switch$0 = $TS($S($EXPECT($L124, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5489
5688
|
return { $loc, token: $1 };
|
|
5490
5689
|
});
|
|
5491
5690
|
function Switch(state) {
|
|
@@ -5497,7 +5696,7 @@ var Civet = (() => {
|
|
|
5497
5696
|
return Switch$0(state);
|
|
5498
5697
|
}
|
|
5499
5698
|
}
|
|
5500
|
-
var Target$0 = $TV($EXPECT($
|
|
5699
|
+
var Target$0 = $TV($EXPECT($L125, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
|
|
5501
5700
|
return { $loc, token: $1 };
|
|
5502
5701
|
});
|
|
5503
5702
|
function Target(state) {
|
|
@@ -5509,7 +5708,7 @@ var Civet = (() => {
|
|
|
5509
5708
|
return Target$0(state);
|
|
5510
5709
|
}
|
|
5511
5710
|
}
|
|
5512
|
-
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) {
|
|
5513
5712
|
return { $loc, token: "" };
|
|
5514
5713
|
});
|
|
5515
5714
|
function Then(state) {
|
|
@@ -5521,7 +5720,7 @@ var Civet = (() => {
|
|
|
5521
5720
|
return Then$0(state);
|
|
5522
5721
|
}
|
|
5523
5722
|
}
|
|
5524
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
5723
|
+
var Throw$0 = $TS($S($EXPECT($L127, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5525
5724
|
return { $loc, token: $1 };
|
|
5526
5725
|
});
|
|
5527
5726
|
function Throw(state) {
|
|
@@ -5533,7 +5732,7 @@ var Civet = (() => {
|
|
|
5533
5732
|
return Throw$0(state);
|
|
5534
5733
|
}
|
|
5535
5734
|
}
|
|
5536
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
5735
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L128, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
5537
5736
|
return { $loc, token: "`" };
|
|
5538
5737
|
});
|
|
5539
5738
|
function TripleDoubleQuote(state) {
|
|
@@ -5545,7 +5744,7 @@ var Civet = (() => {
|
|
|
5545
5744
|
return TripleDoubleQuote$0(state);
|
|
5546
5745
|
}
|
|
5547
5746
|
}
|
|
5548
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
5747
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L129, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
5549
5748
|
return { $loc, token: "`" };
|
|
5550
5749
|
});
|
|
5551
5750
|
function TripleSingleQuote(state) {
|
|
@@ -5557,7 +5756,7 @@ var Civet = (() => {
|
|
|
5557
5756
|
return TripleSingleQuote$0(state);
|
|
5558
5757
|
}
|
|
5559
5758
|
}
|
|
5560
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
5759
|
+
var TripleTick$0 = $TV($EXPECT($L130, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
5561
5760
|
return { $loc, token: "`" };
|
|
5562
5761
|
});
|
|
5563
5762
|
function TripleTick(state) {
|
|
@@ -5569,7 +5768,7 @@ var Civet = (() => {
|
|
|
5569
5768
|
return TripleTick$0(state);
|
|
5570
5769
|
}
|
|
5571
5770
|
}
|
|
5572
|
-
var Try$0 = $TV($EXPECT($
|
|
5771
|
+
var Try$0 = $TV($EXPECT($L131, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
5573
5772
|
return { $loc, token: $1 };
|
|
5574
5773
|
});
|
|
5575
5774
|
function Try(state) {
|
|
@@ -5581,7 +5780,7 @@ var Civet = (() => {
|
|
|
5581
5780
|
return Try$0(state);
|
|
5582
5781
|
}
|
|
5583
5782
|
}
|
|
5584
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
5783
|
+
var Typeof$0 = $TS($S($EXPECT($L132, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5585
5784
|
return { $loc, token: $1 };
|
|
5586
5785
|
});
|
|
5587
5786
|
function Typeof(state) {
|
|
@@ -5593,7 +5792,7 @@ var Civet = (() => {
|
|
|
5593
5792
|
return Typeof$0(state);
|
|
5594
5793
|
}
|
|
5595
5794
|
}
|
|
5596
|
-
var Unless$0 = $TV($EXPECT($
|
|
5795
|
+
var Unless$0 = $TV($EXPECT($L133, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
5597
5796
|
return { $loc, token: $1 };
|
|
5598
5797
|
});
|
|
5599
5798
|
function Unless(state) {
|
|
@@ -5605,7 +5804,7 @@ var Civet = (() => {
|
|
|
5605
5804
|
return Unless$0(state);
|
|
5606
5805
|
}
|
|
5607
5806
|
}
|
|
5608
|
-
var Until$0 = $TS($S($EXPECT($
|
|
5807
|
+
var Until$0 = $TS($S($EXPECT($L134, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5609
5808
|
return { $loc, token: $1 };
|
|
5610
5809
|
});
|
|
5611
5810
|
function Until(state) {
|
|
@@ -5617,7 +5816,7 @@ var Civet = (() => {
|
|
|
5617
5816
|
return Until$0(state);
|
|
5618
5817
|
}
|
|
5619
5818
|
}
|
|
5620
|
-
var Var$0 = $TV($EXPECT($
|
|
5819
|
+
var Var$0 = $TV($EXPECT($L135, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
5621
5820
|
return { $loc, token: $1 };
|
|
5622
5821
|
});
|
|
5623
5822
|
function Var(state) {
|
|
@@ -5629,7 +5828,7 @@ var Civet = (() => {
|
|
|
5629
5828
|
return Var$0(state);
|
|
5630
5829
|
}
|
|
5631
5830
|
}
|
|
5632
|
-
var Void$0 = $TS($S($EXPECT($
|
|
5831
|
+
var Void$0 = $TS($S($EXPECT($L136, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5633
5832
|
return { $loc, token: $1 };
|
|
5634
5833
|
});
|
|
5635
5834
|
function Void(state) {
|
|
@@ -5641,7 +5840,7 @@ var Civet = (() => {
|
|
|
5641
5840
|
return Void$0(state);
|
|
5642
5841
|
}
|
|
5643
5842
|
}
|
|
5644
|
-
var When$0 = $TS($S($EXPECT($
|
|
5843
|
+
var When$0 = $TS($S($EXPECT($L137, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5645
5844
|
return { $loc, token: "case" };
|
|
5646
5845
|
});
|
|
5647
5846
|
function When(state) {
|
|
@@ -5653,7 +5852,7 @@ var Civet = (() => {
|
|
|
5653
5852
|
return When$0(state);
|
|
5654
5853
|
}
|
|
5655
5854
|
}
|
|
5656
|
-
var While$0 = $TS($S($EXPECT($
|
|
5855
|
+
var While$0 = $TS($S($EXPECT($L138, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5657
5856
|
return { $loc, token: $1 };
|
|
5658
5857
|
});
|
|
5659
5858
|
function While(state) {
|
|
@@ -5665,7 +5864,7 @@ var Civet = (() => {
|
|
|
5665
5864
|
return While$0(state);
|
|
5666
5865
|
}
|
|
5667
5866
|
}
|
|
5668
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
5867
|
+
var Yield$0 = $TS($S($EXPECT($L139, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5669
5868
|
return { $loc, token: $1 };
|
|
5670
5869
|
});
|
|
5671
5870
|
function Yield(state) {
|
|
@@ -5691,7 +5890,7 @@ var Civet = (() => {
|
|
|
5691
5890
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
5692
5891
|
}
|
|
5693
5892
|
}
|
|
5694
|
-
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 "/>"'));
|
|
5695
5894
|
function JSXSelfClosingElement(state) {
|
|
5696
5895
|
if (state.verbose)
|
|
5697
5896
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -5701,7 +5900,7 @@ var Civet = (() => {
|
|
|
5701
5900
|
return JSXSelfClosingElement$0(state);
|
|
5702
5901
|
}
|
|
5703
5902
|
}
|
|
5704
|
-
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 ">"'));
|
|
5705
5904
|
function JSXOpeningElement(state) {
|
|
5706
5905
|
if (state.verbose)
|
|
5707
5906
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -5711,7 +5910,7 @@ var Civet = (() => {
|
|
|
5711
5910
|
return JSXOpeningElement$0(state);
|
|
5712
5911
|
}
|
|
5713
5912
|
}
|
|
5714
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
5913
|
+
var JSXClosingElement$0 = $S($EXPECT($L141, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L55, fail, 'JSXClosingElement ">"'));
|
|
5715
5914
|
function JSXClosingElement(state) {
|
|
5716
5915
|
if (state.verbose)
|
|
5717
5916
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -5721,7 +5920,7 @@ var Civet = (() => {
|
|
|
5721
5920
|
return JSXClosingElement$0(state);
|
|
5722
5921
|
}
|
|
5723
5922
|
}
|
|
5724
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
5923
|
+
var JSXFragment$0 = $S($EXPECT($L142, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L143, fail, 'JSXFragment "</>"'));
|
|
5725
5924
|
function JSXFragment(state) {
|
|
5726
5925
|
if (state.verbose)
|
|
5727
5926
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -5855,7 +6054,7 @@ var Civet = (() => {
|
|
|
5855
6054
|
return TypeDeclaration$0(state);
|
|
5856
6055
|
}
|
|
5857
6056
|
}
|
|
5858
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
6057
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L144, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
5859
6058
|
var TypeDeclarationModifier$1 = Export;
|
|
5860
6059
|
function TypeDeclarationModifier(state) {
|
|
5861
6060
|
if (state.tokenize) {
|
|
@@ -5875,7 +6074,7 @@ var Civet = (() => {
|
|
|
5875
6074
|
return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state);
|
|
5876
6075
|
}
|
|
5877
6076
|
}
|
|
5878
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
6077
|
+
var TypeKeyword$0 = $S($EXPECT($L145, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
5879
6078
|
function TypeKeyword(state) {
|
|
5880
6079
|
if (state.verbose)
|
|
5881
6080
|
console.log("ENTER:", "TypeKeyword");
|
|
@@ -5885,7 +6084,7 @@ var Civet = (() => {
|
|
|
5885
6084
|
return TypeKeyword$0(state);
|
|
5886
6085
|
}
|
|
5887
6086
|
}
|
|
5888
|
-
var Interface$0 = $S($EXPECT($
|
|
6087
|
+
var Interface$0 = $S($EXPECT($L146, fail, 'Interface "interface"'), NonIdContinue);
|
|
5889
6088
|
function Interface(state) {
|
|
5890
6089
|
if (state.verbose)
|
|
5891
6090
|
console.log("ENTER:", "Interface");
|
|
@@ -5895,7 +6094,7 @@ var Civet = (() => {
|
|
|
5895
6094
|
return Interface$0(state);
|
|
5896
6095
|
}
|
|
5897
6096
|
}
|
|
5898
|
-
var Namespace$0 = $S($EXPECT($
|
|
6097
|
+
var Namespace$0 = $S($EXPECT($L147, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
5899
6098
|
function Namespace(state) {
|
|
5900
6099
|
if (state.verbose)
|
|
5901
6100
|
console.log("ENTER:", "Namespace");
|
|
@@ -5995,7 +6194,7 @@ var Civet = (() => {
|
|
|
5995
6194
|
return NestedTypeDeclaration$0(state);
|
|
5996
6195
|
}
|
|
5997
6196
|
}
|
|
5998
|
-
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)));
|
|
5999
6198
|
function TypeIndexSignature(state) {
|
|
6000
6199
|
if (state.verbose)
|
|
6001
6200
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -6026,7 +6225,7 @@ var Civet = (() => {
|
|
|
6026
6225
|
return TypeSuffix$0(state);
|
|
6027
6226
|
}
|
|
6028
6227
|
}
|
|
6029
|
-
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) {
|
|
6030
6229
|
if (!$3)
|
|
6031
6230
|
$0.splice(2, 1);
|
|
6032
6231
|
if ($1.length === 0)
|
|
@@ -6046,7 +6245,7 @@ var Civet = (() => {
|
|
|
6046
6245
|
return ReturnTypeSuffix$0(state);
|
|
6047
6246
|
}
|
|
6048
6247
|
}
|
|
6049
|
-
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) {
|
|
6050
6249
|
if (!$2)
|
|
6051
6250
|
return $1;
|
|
6052
6251
|
return $0;
|
|
@@ -6109,9 +6308,9 @@ var Civet = (() => {
|
|
|
6109
6308
|
return TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state);
|
|
6110
6309
|
}
|
|
6111
6310
|
}
|
|
6112
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
6113
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
6114
|
-
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"');
|
|
6115
6314
|
function TypeUnaryOp(state) {
|
|
6116
6315
|
if (state.tokenize) {
|
|
6117
6316
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -6201,10 +6400,10 @@ var Civet = (() => {
|
|
|
6201
6400
|
}
|
|
6202
6401
|
}
|
|
6203
6402
|
var TypeLiteral$0 = Literal;
|
|
6204
|
-
var TypeLiteral$1 = $TV($EXPECT($
|
|
6403
|
+
var TypeLiteral$1 = $TV($EXPECT($L136, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
|
|
6205
6404
|
return { $loc, token: "void" };
|
|
6206
6405
|
});
|
|
6207
|
-
var TypeLiteral$2 = $TV($EXPECT($
|
|
6406
|
+
var TypeLiteral$2 = $TV($EXPECT($L152, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
6208
6407
|
return { $loc, token: "[]" };
|
|
6209
6408
|
});
|
|
6210
6409
|
function TypeLiteral(state) {
|
|
@@ -6214,10 +6413,10 @@ var Civet = (() => {
|
|
|
6214
6413
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
6215
6414
|
}
|
|
6216
6415
|
}
|
|
6217
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
6416
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L74, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
6218
6417
|
return { $loc, token: "|" };
|
|
6219
6418
|
});
|
|
6220
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
6419
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L72, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
6221
6420
|
return { $loc, token: "&" };
|
|
6222
6421
|
});
|
|
6223
6422
|
function TypeBinaryOp(state) {
|
|
@@ -6237,7 +6436,7 @@ var Civet = (() => {
|
|
|
6237
6436
|
return FunctionType$0(state);
|
|
6238
6437
|
}
|
|
6239
6438
|
}
|
|
6240
|
-
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 ">"'));
|
|
6241
6440
|
function TypeArguments(state) {
|
|
6242
6441
|
if (state.verbose)
|
|
6243
6442
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -6247,7 +6446,7 @@ var Civet = (() => {
|
|
|
6247
6446
|
return TypeArguments$0(state);
|
|
6248
6447
|
}
|
|
6249
6448
|
}
|
|
6250
|
-
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) {
|
|
6251
6450
|
return { ts: true, children: $0 };
|
|
6252
6451
|
});
|
|
6253
6452
|
function TypeParameters(state) {
|
|
@@ -6280,8 +6479,8 @@ var Civet = (() => {
|
|
|
6280
6479
|
}
|
|
6281
6480
|
}
|
|
6282
6481
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
6283
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
6284
|
-
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) {
|
|
6285
6484
|
return { $loc, token: "," };
|
|
6286
6485
|
});
|
|
6287
6486
|
var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
@@ -6319,7 +6518,7 @@ var Civet = (() => {
|
|
|
6319
6518
|
return CivetPrologue$0(state) || CivetPrologue$1(state);
|
|
6320
6519
|
}
|
|
6321
6520
|
}
|
|
6322
|
-
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) {
|
|
6323
6522
|
var options = $2;
|
|
6324
6523
|
return {
|
|
6325
6524
|
type: "CivetPrologue",
|
|
@@ -6539,6 +6738,20 @@ var Civet = (() => {
|
|
|
6539
6738
|
return InsertBreak$0(state);
|
|
6540
6739
|
}
|
|
6541
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
|
+
}
|
|
6542
6755
|
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6543
6756
|
if (module.config.coffeeBooleans)
|
|
6544
6757
|
return;
|
|
@@ -6553,6 +6766,20 @@ var Civet = (() => {
|
|
|
6553
6766
|
return CoffeeBooleansEnabled$0(state);
|
|
6554
6767
|
}
|
|
6555
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
|
+
}
|
|
6556
6783
|
var CoffeeCommentEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6557
6784
|
if (module.config.coffeeComment)
|
|
6558
6785
|
return;
|
|
@@ -6623,6 +6850,20 @@ var Civet = (() => {
|
|
|
6623
6850
|
return CoffeeIsntEnabled$0(state);
|
|
6624
6851
|
}
|
|
6625
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
|
+
}
|
|
6626
6867
|
var CoffeeNotEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6627
6868
|
if (module.config.coffeeNot)
|
|
6628
6869
|
return;
|
|
@@ -6657,13 +6898,16 @@ var Civet = (() => {
|
|
|
6657
6898
|
module.verbose = false;
|
|
6658
6899
|
module.config = {
|
|
6659
6900
|
autoVar: false,
|
|
6901
|
+
coffeeBinaryExistential: false,
|
|
6660
6902
|
coffeeBooleans: false,
|
|
6903
|
+
coffeeClasses: false,
|
|
6661
6904
|
coffeeComment: false,
|
|
6662
6905
|
coffeeDo: false,
|
|
6663
6906
|
coffeeEq: false,
|
|
6664
6907
|
coffeeForLoops: false,
|
|
6665
6908
|
coffeeInterpolation: false,
|
|
6666
6909
|
coffeeIsnt: false,
|
|
6910
|
+
coffeeLineContinuation: false,
|
|
6667
6911
|
coffeeNot: false,
|
|
6668
6912
|
coffeeOf: false,
|
|
6669
6913
|
implicitReturns: true
|
|
@@ -6710,24 +6954,30 @@ var Civet = (() => {
|
|
|
6710
6954
|
set(b) {
|
|
6711
6955
|
if (b) {
|
|
6712
6956
|
this.autoVar = true;
|
|
6957
|
+
this.coffeeBinaryExistential = true;
|
|
6713
6958
|
this.coffeeBooleans = true;
|
|
6959
|
+
this.coffeeClasses = true;
|
|
6714
6960
|
this.coffeeComment = true;
|
|
6715
6961
|
this.coffeeDo = true;
|
|
6716
6962
|
this.coffeeEq = true;
|
|
6717
6963
|
this.coffeeForLoops = true;
|
|
6718
6964
|
this.coffeeInterpolation = true;
|
|
6719
6965
|
this.coffeeIsnt = true;
|
|
6966
|
+
this.coffeeLineContinuation = true;
|
|
6720
6967
|
this.coffeeNot = true;
|
|
6721
6968
|
this.coffeeOf = true;
|
|
6722
6969
|
} else {
|
|
6723
6970
|
this.autoVar = false;
|
|
6971
|
+
this.coffeeBinaryExistential = false;
|
|
6724
6972
|
this.coffeeBooleans = false;
|
|
6973
|
+
this.coffeeClasses = false;
|
|
6725
6974
|
this.coffeeComment = false;
|
|
6726
6975
|
this.coffeeDo = false;
|
|
6727
6976
|
this.coffeeEq = false;
|
|
6728
6977
|
this.coffeeForLoops = false;
|
|
6729
6978
|
this.coffeeInterpolation = false;
|
|
6730
6979
|
this.coffeeIsnt = false;
|
|
6980
|
+
this.coffeeLineContinuation = false;
|
|
6731
6981
|
this.coffeeNot = false;
|
|
6732
6982
|
this.coffeeOf = false;
|
|
6733
6983
|
}
|
|
@@ -6843,13 +7093,13 @@ var Civet = (() => {
|
|
|
6843
7093
|
let i = 2;
|
|
6844
7094
|
while (i < expandedOps.length) {
|
|
6845
7095
|
const op = expandedOps[i];
|
|
6846
|
-
if (op.
|
|
7096
|
+
if (op.ref) {
|
|
6847
7097
|
const [a, wsOp, op2, wsB, b] = expandedOps.slice(i - 2, i + 3);
|
|
6848
7098
|
module.insertTrimmingSpace(wsOp, "");
|
|
6849
7099
|
module.insertTrimmingSpace(wsB, "");
|
|
6850
7100
|
expandedOps.splice(i - 2, 5, {
|
|
6851
7101
|
type: "Call",
|
|
6852
|
-
children: [wsOp, op2, ".call(", wsB, b, ", ", a, ")
|
|
7102
|
+
children: [wsOp, op2.ref, ".call(", wsB, b, ", ", a, ")", op2.suffix]
|
|
6853
7103
|
});
|
|
6854
7104
|
} else {
|
|
6855
7105
|
i += 4;
|
|
@@ -6867,7 +7117,7 @@ var Civet = (() => {
|
|
|
6867
7117
|
let chains = [];
|
|
6868
7118
|
while (i < l) {
|
|
6869
7119
|
const [, op] = binops[i];
|
|
6870
|
-
if (relationalOps.includes(op.token) || op.
|
|
7120
|
+
if (relationalOps.includes(op.token) || op.ref) {
|
|
6871
7121
|
chains.push(i);
|
|
6872
7122
|
} else if (lowerPrecedenceOps.includes(op.token)) {
|
|
6873
7123
|
processChains();
|
|
@@ -7132,7 +7382,7 @@ var Civet = (() => {
|
|
|
7132
7382
|
return Init$0(state);
|
|
7133
7383
|
}
|
|
7134
7384
|
}
|
|
7135
|
-
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) {
|
|
7136
7386
|
const level = $1.length;
|
|
7137
7387
|
return {
|
|
7138
7388
|
$loc,
|