@danielx/civet 0.4.19-pre.2 → 0.4.19-pre.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +8 -8
- package/dist/browser.js +641 -386
- package/dist/main.js +641 -386
- 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,
|
|
@@ -486,6 +490,7 @@ var Civet = (() => {
|
|
|
486
490
|
ThinArrowFunction,
|
|
487
491
|
Arrow,
|
|
488
492
|
Block,
|
|
493
|
+
ThenClause,
|
|
489
494
|
BracedOrEmptyBlock,
|
|
490
495
|
EmptyBlock,
|
|
491
496
|
BracedBlock,
|
|
@@ -515,9 +520,12 @@ var Civet = (() => {
|
|
|
515
520
|
NestedObjectLiteral,
|
|
516
521
|
NestedPropertyDefinitions,
|
|
517
522
|
NestedPropertyDefinition,
|
|
523
|
+
InlineObjectLiteral,
|
|
518
524
|
ObjectPropertyDelimiter,
|
|
519
525
|
PropertyDefinitionList,
|
|
520
526
|
PropertyDefinition,
|
|
527
|
+
NamedProperty,
|
|
528
|
+
SnugNamedProperty,
|
|
521
529
|
PropertyName,
|
|
522
530
|
MethodDefinition,
|
|
523
531
|
MethodModifier,
|
|
@@ -559,6 +567,7 @@ var Civet = (() => {
|
|
|
559
567
|
ForDeclaration,
|
|
560
568
|
ForBinding,
|
|
561
569
|
SwitchStatement,
|
|
570
|
+
EmptyCondition,
|
|
562
571
|
SwitchExpression,
|
|
563
572
|
CaseBlock,
|
|
564
573
|
NestedCaseClauses,
|
|
@@ -650,6 +659,7 @@ var Civet = (() => {
|
|
|
650
659
|
Loc,
|
|
651
660
|
Ampersand,
|
|
652
661
|
As,
|
|
662
|
+
At,
|
|
653
663
|
Async,
|
|
654
664
|
Await,
|
|
655
665
|
Backtick,
|
|
@@ -786,12 +796,15 @@ var Civet = (() => {
|
|
|
786
796
|
InsertSpace,
|
|
787
797
|
InsertDot,
|
|
788
798
|
InsertBreak,
|
|
799
|
+
CoffeeBinaryExistentialEnabled,
|
|
789
800
|
CoffeeBooleansEnabled,
|
|
801
|
+
CoffeeClassesEnabled,
|
|
790
802
|
CoffeeCommentEnabled,
|
|
791
803
|
CoffeeDoEnabled,
|
|
792
804
|
CoffeeForLoopsEnabled,
|
|
793
805
|
CoffeeInterpolationEnabled,
|
|
794
806
|
CoffeeIsntEnabled,
|
|
807
|
+
CoffeeLineContinuationEnabled,
|
|
795
808
|
CoffeeNotEnabled,
|
|
796
809
|
CoffeeOfEnabled,
|
|
797
810
|
Reset,
|
|
@@ -812,153 +825,154 @@ var Civet = (() => {
|
|
|
812
825
|
var $L5 = $L("extends");
|
|
813
826
|
var $L6 = $L("this");
|
|
814
827
|
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("
|
|
828
|
+
var $L8 = $L(".");
|
|
829
|
+
var $L9 = $L("super");
|
|
830
|
+
var $L10 = $L("import");
|
|
831
|
+
var $L11 = $L("!");
|
|
832
|
+
var $L12 = $L("::");
|
|
833
|
+
var $L13 = $L("super[");
|
|
834
|
+
var $L14 = $L("import.meta");
|
|
835
|
+
var $L15 = $L(")");
|
|
836
|
+
var $L16 = $L("->");
|
|
837
|
+
var $L17 = $L("null");
|
|
838
|
+
var $L18 = $L("true");
|
|
839
|
+
var $L19 = $L("false");
|
|
840
|
+
var $L20 = $L("yes");
|
|
841
|
+
var $L21 = $L("on");
|
|
842
|
+
var $L22 = $L("no");
|
|
843
|
+
var $L23 = $L("off");
|
|
844
|
+
var $L24 = $L(",");
|
|
845
|
+
var $L25 = $L("]");
|
|
846
|
+
var $L26 = $L("}");
|
|
847
|
+
var $L27 = $L("**=");
|
|
848
|
+
var $L28 = $L("*=");
|
|
849
|
+
var $L29 = $L("/=");
|
|
850
|
+
var $L30 = $L("%=");
|
|
851
|
+
var $L31 = $L("+=");
|
|
852
|
+
var $L32 = $L("-=");
|
|
853
|
+
var $L33 = $L("<<=");
|
|
854
|
+
var $L34 = $L(">>>=");
|
|
855
|
+
var $L35 = $L(">>=");
|
|
856
|
+
var $L36 = $L("&&=");
|
|
857
|
+
var $L37 = $L("&=");
|
|
858
|
+
var $L38 = $L("^=");
|
|
859
|
+
var $L39 = $L("||=");
|
|
860
|
+
var $L40 = $L("|=");
|
|
861
|
+
var $L41 = $L("??=");
|
|
862
|
+
var $L42 = $L("?=");
|
|
863
|
+
var $L43 = $L("=");
|
|
864
|
+
var $L44 = $L("**");
|
|
865
|
+
var $L45 = $L("*");
|
|
866
|
+
var $L46 = $L("/");
|
|
867
|
+
var $L47 = $L("%");
|
|
868
|
+
var $L48 = $L("+");
|
|
869
|
+
var $L49 = $L("-");
|
|
870
|
+
var $L50 = $L("<=");
|
|
871
|
+
var $L51 = $L(">=");
|
|
872
|
+
var $L52 = $L("<<");
|
|
873
|
+
var $L53 = $L(">>>");
|
|
874
|
+
var $L54 = $L(">>");
|
|
875
|
+
var $L55 = $L(">");
|
|
876
|
+
var $L56 = $L("!==");
|
|
877
|
+
var $L57 = $L("!=");
|
|
878
|
+
var $L58 = $L("isnt");
|
|
879
|
+
var $L59 = $L("is");
|
|
880
|
+
var $L60 = $L("===");
|
|
881
|
+
var $L61 = $L("==");
|
|
882
|
+
var $L62 = $L("and");
|
|
883
|
+
var $L63 = $L("&&");
|
|
884
|
+
var $L64 = $L("of");
|
|
885
|
+
var $L65 = $L("or");
|
|
886
|
+
var $L66 = $L("||");
|
|
887
|
+
var $L67 = $L("??");
|
|
888
|
+
var $L68 = $L("?");
|
|
876
889
|
var $L69 = $L("instanceof");
|
|
877
890
|
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("
|
|
891
|
+
var $L71 = $L("not");
|
|
892
|
+
var $L72 = $L("&");
|
|
893
|
+
var $L73 = $L("^");
|
|
894
|
+
var $L74 = $L("|");
|
|
895
|
+
var $L75 = $L(";");
|
|
896
|
+
var $L76 = $L("own");
|
|
897
|
+
var $L77 = $L("finally");
|
|
898
|
+
var $L78 = $L("break");
|
|
899
|
+
var $L79 = $L("continue");
|
|
900
|
+
var $L80 = $L("debugger");
|
|
901
|
+
var $L81 = $L("import type");
|
|
902
|
+
var $L82 = $L("default");
|
|
903
|
+
var $L83 = $L(":=");
|
|
904
|
+
var $L84 = $L("/*");
|
|
905
|
+
var $L85 = $L("*/");
|
|
906
|
+
var $L86 = $L("###");
|
|
907
|
+
var $L87 = $L("\\");
|
|
908
|
+
var $L88 = $L("as");
|
|
909
|
+
var $L89 = $L("@");
|
|
910
|
+
var $L90 = $L("async");
|
|
911
|
+
var $L91 = $L("await");
|
|
912
|
+
var $L92 = $L("`");
|
|
913
|
+
var $L93 = $L("by");
|
|
914
|
+
var $L94 = $L("case");
|
|
915
|
+
var $L95 = $L("catch");
|
|
916
|
+
var $L96 = $L("class");
|
|
917
|
+
var $L97 = $L("#{");
|
|
918
|
+
var $L98 = $L(":");
|
|
919
|
+
var $L99 = $L("delete");
|
|
920
|
+
var $L100 = $L("do");
|
|
921
|
+
var $L101 = $L("..");
|
|
922
|
+
var $L102 = $L("...");
|
|
923
|
+
var $L103 = $L('"');
|
|
924
|
+
var $L104 = $L("else");
|
|
925
|
+
var $L105 = $L("export");
|
|
926
|
+
var $L106 = $L("for");
|
|
927
|
+
var $L107 = $L("from");
|
|
928
|
+
var $L108 = $L("function");
|
|
929
|
+
var $L109 = $L("get");
|
|
930
|
+
var $L110 = $L("set");
|
|
931
|
+
var $L111 = $L("if");
|
|
932
|
+
var $L112 = $L(" ");
|
|
933
|
+
var $L113 = $L("let");
|
|
934
|
+
var $L114 = $L("const");
|
|
935
|
+
var $L115 = $L("loop");
|
|
936
|
+
var $L116 = $L("new");
|
|
937
|
+
var $L117 = $L("{");
|
|
938
|
+
var $L118 = $L("[");
|
|
939
|
+
var $L119 = $L("(");
|
|
940
|
+
var $L120 = $L("return");
|
|
941
|
+
var $L121 = $L("'");
|
|
942
|
+
var $L122 = $L("static");
|
|
943
|
+
var $L123 = $L("${");
|
|
944
|
+
var $L124 = $L("switch");
|
|
945
|
+
var $L125 = $L("target");
|
|
946
|
+
var $L126 = $L("then");
|
|
947
|
+
var $L127 = $L("throw");
|
|
948
|
+
var $L128 = $L('"""');
|
|
949
|
+
var $L129 = $L("'''");
|
|
950
|
+
var $L130 = $L("```");
|
|
951
|
+
var $L131 = $L("try");
|
|
952
|
+
var $L132 = $L("typeof");
|
|
953
|
+
var $L133 = $L("unless");
|
|
954
|
+
var $L134 = $L("until");
|
|
955
|
+
var $L135 = $L("var");
|
|
956
|
+
var $L136 = $L("void");
|
|
957
|
+
var $L137 = $L("when");
|
|
958
|
+
var $L138 = $L("while");
|
|
959
|
+
var $L139 = $L("yield");
|
|
960
|
+
var $L140 = $L("/>");
|
|
961
|
+
var $L141 = $L("</");
|
|
962
|
+
var $L142 = $L("<>");
|
|
963
|
+
var $L143 = $L("</>");
|
|
964
|
+
var $L144 = $L("declare");
|
|
965
|
+
var $L145 = $L("type");
|
|
966
|
+
var $L146 = $L("interface");
|
|
967
|
+
var $L147 = $L("namespace");
|
|
968
|
+
var $L148 = $L("readonly");
|
|
969
|
+
var $L149 = $L("asserts");
|
|
970
|
+
var $L150 = $L("keyof");
|
|
971
|
+
var $L151 = $L("infer");
|
|
972
|
+
var $L152 = $L("[]");
|
|
973
|
+
var $L153 = $L("civet");
|
|
974
|
+
var $L154 = $L(" ");
|
|
975
|
+
var $L155 = $L(" ");
|
|
962
976
|
var $R0 = $R(new RegExp("(of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
963
977
|
var $R1 = $R(new RegExp("[&]", "suy"));
|
|
964
978
|
var $R2 = $R(new RegExp("[!~+-]+", "suy"));
|
|
@@ -1093,7 +1107,9 @@ var Civet = (() => {
|
|
|
1093
1107
|
return ArgumentsWithTrailingCallExpressions$0(state);
|
|
1094
1108
|
}
|
|
1095
1109
|
}
|
|
1096
|
-
var ArgumentList$0 = $S($Y(EOS), NestedArgumentList)
|
|
1110
|
+
var ArgumentList$0 = $T($S($Y(EOS), NestedArgumentList), function(value) {
|
|
1111
|
+
return value[1];
|
|
1112
|
+
});
|
|
1097
1113
|
var ArgumentList$1 = InlineArgumentExpressions;
|
|
1098
1114
|
function ArgumentList(state) {
|
|
1099
1115
|
if (state.tokenize) {
|
|
@@ -1127,7 +1143,7 @@ var Civet = (() => {
|
|
|
1127
1143
|
return NestedArgument$0(state);
|
|
1128
1144
|
}
|
|
1129
1145
|
}
|
|
1130
|
-
var InlineArgumentExpressions$0 = $TS($S(
|
|
1146
|
+
var InlineArgumentExpressions$0 = $TS($S(ArgumentPart, $Q($S(__, Comma, $Q(TrailingComment), ArgumentPart))), function($skip, $loc, $0, $1, $2) {
|
|
1131
1147
|
if ($2.length == 0)
|
|
1132
1148
|
return $1;
|
|
1133
1149
|
return $0;
|
|
@@ -1141,6 +1157,20 @@ var Civet = (() => {
|
|
|
1141
1157
|
return InlineArgumentExpressions$0(state);
|
|
1142
1158
|
}
|
|
1143
1159
|
}
|
|
1160
|
+
var ArgumentPart$0 = $S(DotDotDot, ExtendedExpression);
|
|
1161
|
+
var ArgumentPart$1 = $TS($S(ExtendedExpression, $E(DotDotDot)), function($skip, $loc, $0, $1, $2) {
|
|
1162
|
+
if ($2) {
|
|
1163
|
+
return [$2, $1];
|
|
1164
|
+
}
|
|
1165
|
+
return $1;
|
|
1166
|
+
});
|
|
1167
|
+
function ArgumentPart(state) {
|
|
1168
|
+
if (state.tokenize) {
|
|
1169
|
+
return $TOKEN("ArgumentPart", state, ArgumentPart$0(state) || ArgumentPart$1(state));
|
|
1170
|
+
} else {
|
|
1171
|
+
return ArgumentPart$0(state) || ArgumentPart$1(state);
|
|
1172
|
+
}
|
|
1173
|
+
}
|
|
1144
1174
|
var ImplicitApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen);
|
|
1145
1175
|
function ImplicitApplication(state) {
|
|
1146
1176
|
if (state.verbose)
|
|
@@ -1155,9 +1185,7 @@ var Civet = (() => {
|
|
|
1155
1185
|
var spacing = $2;
|
|
1156
1186
|
return module.insertTrimmingSpace(spacing, "(");
|
|
1157
1187
|
});
|
|
1158
|
-
var ApplicationStart$1 = $
|
|
1159
|
-
return value[2];
|
|
1160
|
-
});
|
|
1188
|
+
var ApplicationStart$1 = $S(IndentedApplicationAllowed, $Y($S(EOS, NestedPropertyDefinitions)), InsertOpenParen);
|
|
1161
1189
|
function ApplicationStart(state) {
|
|
1162
1190
|
if (state.tokenize) {
|
|
1163
1191
|
return $TOKEN("ApplicationStart", state, ApplicationStart$0(state) || ApplicationStart$1(state));
|
|
@@ -1179,7 +1207,7 @@ var Civet = (() => {
|
|
|
1179
1207
|
return IndentedApplicationAllowed$0(state);
|
|
1180
1208
|
}
|
|
1181
1209
|
}
|
|
1182
|
-
var BinaryOpExpression$0 = $TS($S(UnaryExpression, $Q(
|
|
1210
|
+
var BinaryOpExpression$0 = $TS($S(UnaryExpression, $Q(BinaryOpRHS)), function($skip, $loc, $0, $1, $2) {
|
|
1183
1211
|
if ($2.length) {
|
|
1184
1212
|
return module.processBinaryOpExpression($0);
|
|
1185
1213
|
}
|
|
@@ -1194,6 +1222,26 @@ var Civet = (() => {
|
|
|
1194
1222
|
return BinaryOpExpression$0(state);
|
|
1195
1223
|
}
|
|
1196
1224
|
}
|
|
1225
|
+
var BinaryOpRHS$0 = $S(__, BinaryOp, __, $C(ParenthesizedAssignment, UnaryExpression, ExpressionizedStatement));
|
|
1226
|
+
function BinaryOpRHS(state) {
|
|
1227
|
+
if (state.verbose)
|
|
1228
|
+
console.log("ENTER:", "BinaryOpRHS");
|
|
1229
|
+
if (state.tokenize) {
|
|
1230
|
+
return $TOKEN("BinaryOpRHS", state, BinaryOpRHS$0(state));
|
|
1231
|
+
} else {
|
|
1232
|
+
return BinaryOpRHS$0(state);
|
|
1233
|
+
}
|
|
1234
|
+
}
|
|
1235
|
+
var ParenthesizedAssignment$0 = $S(InsertOpenParen, ActualAssignment, InsertCloseParen);
|
|
1236
|
+
function ParenthesizedAssignment(state) {
|
|
1237
|
+
if (state.verbose)
|
|
1238
|
+
console.log("ENTER:", "ParenthesizedAssignment");
|
|
1239
|
+
if (state.tokenize) {
|
|
1240
|
+
return $TOKEN("ParenthesizedAssignment", state, ParenthesizedAssignment$0(state));
|
|
1241
|
+
} else {
|
|
1242
|
+
return ParenthesizedAssignment$0(state);
|
|
1243
|
+
}
|
|
1244
|
+
}
|
|
1197
1245
|
var UnaryExpression$0 = $TS($S($Q(UnaryOp), UpdateExpression, $E(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1198
1246
|
var pre = $1;
|
|
1199
1247
|
var exp = $2;
|
|
@@ -1296,7 +1344,16 @@ var Civet = (() => {
|
|
|
1296
1344
|
}
|
|
1297
1345
|
var AssignmentExpressionTail$0 = YieldExpression;
|
|
1298
1346
|
var AssignmentExpressionTail$1 = ArrowFunction;
|
|
1299
|
-
var AssignmentExpressionTail$2 =
|
|
1347
|
+
var AssignmentExpressionTail$2 = ActualAssignment;
|
|
1348
|
+
var AssignmentExpressionTail$3 = ConditionalExpression;
|
|
1349
|
+
function AssignmentExpressionTail(state) {
|
|
1350
|
+
if (state.tokenize) {
|
|
1351
|
+
return $TOKEN("AssignmentExpressionTail", state, AssignmentExpressionTail$0(state) || AssignmentExpressionTail$1(state) || AssignmentExpressionTail$2(state) || AssignmentExpressionTail$3(state));
|
|
1352
|
+
} else {
|
|
1353
|
+
return AssignmentExpressionTail$0(state) || AssignmentExpressionTail$1(state) || AssignmentExpressionTail$2(state) || AssignmentExpressionTail$3(state);
|
|
1354
|
+
}
|
|
1355
|
+
}
|
|
1356
|
+
var ActualAssignment$0 = $TS($S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), ExtendedExpression), function($skip, $loc, $0, $1, $2) {
|
|
1300
1357
|
let tail = [], i = 0, len = $1.length;
|
|
1301
1358
|
while (i < len) {
|
|
1302
1359
|
const lastAssignment = $1[i++];
|
|
@@ -1349,12 +1406,13 @@ var Civet = (() => {
|
|
|
1349
1406
|
names
|
|
1350
1407
|
};
|
|
1351
1408
|
});
|
|
1352
|
-
|
|
1353
|
-
|
|
1409
|
+
function ActualAssignment(state) {
|
|
1410
|
+
if (state.verbose)
|
|
1411
|
+
console.log("ENTER:", "ActualAssignment");
|
|
1354
1412
|
if (state.tokenize) {
|
|
1355
|
-
return $TOKEN("
|
|
1413
|
+
return $TOKEN("ActualAssignment", state, ActualAssignment$0(state));
|
|
1356
1414
|
} else {
|
|
1357
|
-
return
|
|
1415
|
+
return ActualAssignment$0(state);
|
|
1358
1416
|
}
|
|
1359
1417
|
}
|
|
1360
1418
|
var YieldExpression$0 = $S(Yield, YieldTail);
|
|
@@ -1448,9 +1506,11 @@ var Civet = (() => {
|
|
|
1448
1506
|
return FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state);
|
|
1449
1507
|
}
|
|
1450
1508
|
}
|
|
1451
|
-
var ConditionalExpression$0 = $TS($S(ShortCircuitExpression, $E(
|
|
1452
|
-
if ($2)
|
|
1453
|
-
|
|
1509
|
+
var ConditionalExpression$0 = $TS($S(ShortCircuitExpression, $E(TernaryRest)), function($skip, $loc, $0, $1, $2) {
|
|
1510
|
+
if ($2) {
|
|
1511
|
+
$2.unshift($1);
|
|
1512
|
+
return $2;
|
|
1513
|
+
}
|
|
1454
1514
|
return $1;
|
|
1455
1515
|
});
|
|
1456
1516
|
function ConditionalExpression(state) {
|
|
@@ -1462,6 +1522,19 @@ var Civet = (() => {
|
|
|
1462
1522
|
return ConditionalExpression$0(state);
|
|
1463
1523
|
}
|
|
1464
1524
|
}
|
|
1525
|
+
var TernaryRest$0 = $TS($S($N(CoffeeBinaryExistentialEnabled), __, QuestionMark, ExtendedExpression, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
1526
|
+
$0.shift();
|
|
1527
|
+
return $0;
|
|
1528
|
+
});
|
|
1529
|
+
function TernaryRest(state) {
|
|
1530
|
+
if (state.verbose)
|
|
1531
|
+
console.log("ENTER:", "TernaryRest");
|
|
1532
|
+
if (state.tokenize) {
|
|
1533
|
+
return $TOKEN("TernaryRest", state, TernaryRest$0(state));
|
|
1534
|
+
} else {
|
|
1535
|
+
return TernaryRest$0(state);
|
|
1536
|
+
}
|
|
1537
|
+
}
|
|
1465
1538
|
var ShortCircuitExpression$0 = BinaryOpExpression;
|
|
1466
1539
|
function ShortCircuitExpression(state) {
|
|
1467
1540
|
if (state.verbose)
|
|
@@ -1473,10 +1546,10 @@ var Civet = (() => {
|
|
|
1473
1546
|
}
|
|
1474
1547
|
}
|
|
1475
1548
|
var PrimaryExpression$0 = This;
|
|
1476
|
-
var PrimaryExpression$1 =
|
|
1477
|
-
var PrimaryExpression$2 =
|
|
1478
|
-
var PrimaryExpression$3 =
|
|
1479
|
-
var PrimaryExpression$4 =
|
|
1549
|
+
var PrimaryExpression$1 = Literal;
|
|
1550
|
+
var PrimaryExpression$2 = ArrayLiteral;
|
|
1551
|
+
var PrimaryExpression$3 = ObjectLiteral;
|
|
1552
|
+
var PrimaryExpression$4 = IdentifierReference;
|
|
1480
1553
|
var PrimaryExpression$5 = FunctionExpression;
|
|
1481
1554
|
var PrimaryExpression$6 = ClassExpression;
|
|
1482
1555
|
var PrimaryExpression$7 = RegularExpressionLiteral;
|
|
@@ -1594,7 +1667,19 @@ var Civet = (() => {
|
|
|
1594
1667
|
return ClassElement$0(state) || ClassElement$1(state);
|
|
1595
1668
|
}
|
|
1596
1669
|
}
|
|
1597
|
-
var FieldDefinition$0 = $TS($S(
|
|
1670
|
+
var FieldDefinition$0 = $TS($S(CoffeeClassesEnabled, ClassElementName, __, Colon, __, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
1671
|
+
var id = $2;
|
|
1672
|
+
var exp = $6;
|
|
1673
|
+
switch (exp.type) {
|
|
1674
|
+
case "FunctionExpression":
|
|
1675
|
+
exp.children.shift();
|
|
1676
|
+
exp.id.push(id);
|
|
1677
|
+
return exp;
|
|
1678
|
+
default:
|
|
1679
|
+
return [id, " = ", exp];
|
|
1680
|
+
}
|
|
1681
|
+
});
|
|
1682
|
+
var FieldDefinition$1 = $TS($S(InsertReadonly, ClassElementName, $E(TypeSuffix), __, ConstAssignment, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
1598
1683
|
var r = $1;
|
|
1599
1684
|
var ca = $5;
|
|
1600
1685
|
r.children[0].$loc = {
|
|
@@ -1603,20 +1688,24 @@ var Civet = (() => {
|
|
|
1603
1688
|
};
|
|
1604
1689
|
return $0;
|
|
1605
1690
|
});
|
|
1606
|
-
var FieldDefinition$
|
|
1691
|
+
var FieldDefinition$2 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
|
|
1607
1692
|
function FieldDefinition(state) {
|
|
1608
1693
|
if (state.tokenize) {
|
|
1609
|
-
return $TOKEN("FieldDefinition", state, FieldDefinition$0(state) || FieldDefinition$1(state));
|
|
1694
|
+
return $TOKEN("FieldDefinition", state, FieldDefinition$0(state) || FieldDefinition$1(state) || FieldDefinition$2(state));
|
|
1610
1695
|
} else {
|
|
1611
|
-
return FieldDefinition$0(state) || FieldDefinition$1(state);
|
|
1696
|
+
return FieldDefinition$0(state) || FieldDefinition$1(state) || FieldDefinition$2(state);
|
|
1612
1697
|
}
|
|
1613
1698
|
}
|
|
1614
1699
|
var This$0 = $TV($EXPECT($L6, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
1615
1700
|
return { $loc, token: $1 };
|
|
1616
1701
|
});
|
|
1617
|
-
var This$1 = $S(
|
|
1618
|
-
|
|
1619
|
-
return
|
|
1702
|
+
var This$1 = $TS($S(At, $S($E($EXPECT($L7, fail, 'This "#"')), IdentifierName)), function($skip, $loc, $0, $1, $2) {
|
|
1703
|
+
$1.token = "this.";
|
|
1704
|
+
return $0;
|
|
1705
|
+
});
|
|
1706
|
+
var This$2 = $TS($S(At), function($skip, $loc, $0, $1) {
|
|
1707
|
+
$1.token = "this";
|
|
1708
|
+
return $1;
|
|
1620
1709
|
});
|
|
1621
1710
|
function This(state) {
|
|
1622
1711
|
if (state.tokenize) {
|
|
@@ -1625,19 +1714,7 @@ var Civet = (() => {
|
|
|
1625
1714
|
return This$0(state) || This$1(state) || This$2(state);
|
|
1626
1715
|
}
|
|
1627
1716
|
}
|
|
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) {
|
|
1717
|
+
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($L8, fail, 'LeftHandSideExpression "."')), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
1641
1718
|
if ($1.length)
|
|
1642
1719
|
return $0;
|
|
1643
1720
|
return $2;
|
|
@@ -1651,8 +1728,8 @@ var Civet = (() => {
|
|
|
1651
1728
|
return LeftHandSideExpression$0(state);
|
|
1652
1729
|
}
|
|
1653
1730
|
}
|
|
1654
|
-
var CallExpression$0 = $S($EXPECT($
|
|
1655
|
-
var CallExpression$1 = $S($EXPECT($
|
|
1731
|
+
var CallExpression$0 = $S($EXPECT($L9, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
|
|
1732
|
+
var CallExpression$1 = $S($EXPECT($L10, fail, 'CallExpression "import"'), __, OpenParen, ExtendedExpression, __, CloseParen);
|
|
1656
1733
|
var CallExpression$2 = $TS($S(MemberExpression, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
1657
1734
|
if ($2.length)
|
|
1658
1735
|
return $0;
|
|
@@ -1685,7 +1762,7 @@ var Civet = (() => {
|
|
|
1685
1762
|
return OptionalShorthand$0(state);
|
|
1686
1763
|
}
|
|
1687
1764
|
}
|
|
1688
|
-
var NonNullAssertion$0 = $T($EXPECT($
|
|
1765
|
+
var NonNullAssertion$0 = $T($EXPECT($L11, fail, 'NonNullAssertion "!"'), function(value) {
|
|
1689
1766
|
return { "ts": true, "children": value };
|
|
1690
1767
|
});
|
|
1691
1768
|
function NonNullAssertion(state) {
|
|
@@ -1735,7 +1812,7 @@ var Civet = (() => {
|
|
|
1735
1812
|
$2.children.unshift($1[1]);
|
|
1736
1813
|
return $2;
|
|
1737
1814
|
});
|
|
1738
|
-
var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($
|
|
1815
|
+
var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L12, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1739
1816
|
var id = $3;
|
|
1740
1817
|
if (id)
|
|
1741
1818
|
return [".prototype.", id];
|
|
@@ -1809,7 +1886,7 @@ var Civet = (() => {
|
|
|
1809
1886
|
return PropertyAccess$0(state);
|
|
1810
1887
|
}
|
|
1811
1888
|
}
|
|
1812
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
1889
|
+
var SuperProperty$0 = $S($EXPECT($L13, fail, 'SuperProperty "super["'), ExtendedExpression, __, CloseBracket);
|
|
1813
1890
|
function SuperProperty(state) {
|
|
1814
1891
|
if (state.verbose)
|
|
1815
1892
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1820,7 +1897,7 @@ var Civet = (() => {
|
|
|
1820
1897
|
}
|
|
1821
1898
|
}
|
|
1822
1899
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
1823
|
-
var MetaProperty$1 = $TV($EXPECT($
|
|
1900
|
+
var MetaProperty$1 = $TV($EXPECT($L14, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
|
|
1824
1901
|
return { $loc, token: $1 };
|
|
1825
1902
|
});
|
|
1826
1903
|
function MetaProperty(state) {
|
|
@@ -1888,7 +1965,7 @@ var Civet = (() => {
|
|
|
1888
1965
|
}
|
|
1889
1966
|
}
|
|
1890
1967
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
1891
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
1968
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L15, fail, 'ParameterElementDelimiter ")"')));
|
|
1892
1969
|
var ParameterElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1893
1970
|
return { $loc, token: "," };
|
|
1894
1971
|
});
|
|
@@ -2229,7 +2306,7 @@ var Civet = (() => {
|
|
|
2229
2306
|
var FunctionExpression$1 = $TS($S(Ampersand, $N(_), $P(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
|
|
2230
2307
|
$1.token = "$ => $";
|
|
2231
2308
|
return {
|
|
2232
|
-
type: "
|
|
2309
|
+
type: "ArrowFunction",
|
|
2233
2310
|
children: [$1, $3]
|
|
2234
2311
|
};
|
|
2235
2312
|
});
|
|
@@ -2238,13 +2315,13 @@ var Civet = (() => {
|
|
|
2238
2315
|
$1.token = "$ => $";
|
|
2239
2316
|
const exp = module.processBinaryOpExpression($0);
|
|
2240
2317
|
return {
|
|
2241
|
-
type: "
|
|
2318
|
+
type: "ArrowFunction",
|
|
2242
2319
|
children: exp
|
|
2243
2320
|
};
|
|
2244
2321
|
});
|
|
2245
2322
|
var FunctionExpression$3 = $TS($S($EXPECT($R2, fail, "FunctionExpression /[!~+-]+/"), Ampersand), function($skip, $loc, $0, $1, $2) {
|
|
2246
2323
|
return {
|
|
2247
|
-
type: "
|
|
2324
|
+
type: "ArrowFunction",
|
|
2248
2325
|
children: ["$ => ", $1, "$"]
|
|
2249
2326
|
};
|
|
2250
2327
|
});
|
|
@@ -2290,7 +2367,7 @@ var Civet = (() => {
|
|
|
2290
2367
|
return ThinArrowFunction$0(state);
|
|
2291
2368
|
}
|
|
2292
2369
|
}
|
|
2293
|
-
var Arrow$0 = $TV($EXPECT($
|
|
2370
|
+
var Arrow$0 = $TV($EXPECT($L16, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
2294
2371
|
return { $loc, token: $1 };
|
|
2295
2372
|
});
|
|
2296
2373
|
function Arrow(state) {
|
|
@@ -2310,12 +2387,8 @@ var Civet = (() => {
|
|
|
2310
2387
|
var exps = value[2];
|
|
2311
2388
|
return { "type": "BlockStatement", "expressions": exps, "children": value };
|
|
2312
2389
|
});
|
|
2313
|
-
var Block$2 =
|
|
2314
|
-
|
|
2315
|
-
});
|
|
2316
|
-
var Block$3 = $T($S($E(Then), __, Statement), function(value) {
|
|
2317
|
-
return [value[1], value[2]];
|
|
2318
|
-
});
|
|
2390
|
+
var Block$2 = ThenClause;
|
|
2391
|
+
var Block$3 = $S($Q(TrailingComment), Statement);
|
|
2319
2392
|
function Block(state) {
|
|
2320
2393
|
if (state.tokenize) {
|
|
2321
2394
|
return $TOKEN("Block", state, Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state));
|
|
@@ -2323,6 +2396,18 @@ var Civet = (() => {
|
|
|
2323
2396
|
return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
|
|
2324
2397
|
}
|
|
2325
2398
|
}
|
|
2399
|
+
var ThenClause$0 = $T($S(Then, $Q(TrailingComment), Statement), function(value) {
|
|
2400
|
+
return [value[1], value[2]];
|
|
2401
|
+
});
|
|
2402
|
+
function ThenClause(state) {
|
|
2403
|
+
if (state.verbose)
|
|
2404
|
+
console.log("ENTER:", "ThenClause");
|
|
2405
|
+
if (state.tokenize) {
|
|
2406
|
+
return $TOKEN("ThenClause", state, ThenClause$0(state));
|
|
2407
|
+
} else {
|
|
2408
|
+
return ThenClause$0(state);
|
|
2409
|
+
}
|
|
2410
|
+
}
|
|
2326
2411
|
var BracedOrEmptyBlock$0 = BracedBlock;
|
|
2327
2412
|
var BracedOrEmptyBlock$1 = EmptyBlock;
|
|
2328
2413
|
function BracedOrEmptyBlock(state) {
|
|
@@ -2440,7 +2525,7 @@ var Civet = (() => {
|
|
|
2440
2525
|
return LiteralContent$0(state) || LiteralContent$1(state) || LiteralContent$2(state) || LiteralContent$3(state);
|
|
2441
2526
|
}
|
|
2442
2527
|
}
|
|
2443
|
-
var NullLiteral$0 = $TV($EXPECT($
|
|
2528
|
+
var NullLiteral$0 = $TV($EXPECT($L17, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
2444
2529
|
return { $loc, token: $1 };
|
|
2445
2530
|
});
|
|
2446
2531
|
function NullLiteral(state) {
|
|
@@ -2452,8 +2537,10 @@ var Civet = (() => {
|
|
|
2452
2537
|
return NullLiteral$0(state);
|
|
2453
2538
|
}
|
|
2454
2539
|
}
|
|
2455
|
-
var BooleanLiteral$0 = CoffeeScriptBooleanLiteral
|
|
2456
|
-
|
|
2540
|
+
var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
|
|
2541
|
+
return value[1];
|
|
2542
|
+
});
|
|
2543
|
+
var BooleanLiteral$1 = $TS($S($C($EXPECT($L18, fail, 'BooleanLiteral "true"'), $EXPECT($L19, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2457
2544
|
return { $loc, token: $1 };
|
|
2458
2545
|
});
|
|
2459
2546
|
function BooleanLiteral(state) {
|
|
@@ -2463,10 +2550,10 @@ var Civet = (() => {
|
|
|
2463
2550
|
return BooleanLiteral$0(state) || BooleanLiteral$1(state);
|
|
2464
2551
|
}
|
|
2465
2552
|
}
|
|
2466
|
-
var CoffeeScriptBooleanLiteral$0 = $
|
|
2553
|
+
var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L20, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2467
2554
|
return { $loc, token: "true" };
|
|
2468
2555
|
});
|
|
2469
|
-
var CoffeeScriptBooleanLiteral$1 = $
|
|
2556
|
+
var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2470
2557
|
return { $loc, token: "false" };
|
|
2471
2558
|
});
|
|
2472
2559
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -2476,7 +2563,7 @@ var Civet = (() => {
|
|
|
2476
2563
|
return CoffeeScriptBooleanLiteral$0(state) || CoffeeScriptBooleanLiteral$1(state);
|
|
2477
2564
|
}
|
|
2478
2565
|
}
|
|
2479
|
-
var Comma$0 = $TV($EXPECT($
|
|
2566
|
+
var Comma$0 = $TV($EXPECT($L24, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
2480
2567
|
return { $loc, token: $1 };
|
|
2481
2568
|
});
|
|
2482
2569
|
function Comma(state) {
|
|
@@ -2674,7 +2761,7 @@ var Civet = (() => {
|
|
|
2674
2761
|
}
|
|
2675
2762
|
}
|
|
2676
2763
|
var ArrayElementDelimiter$0 = $S($Q(_), Comma);
|
|
2677
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2764
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
|
|
2678
2765
|
var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2679
2766
|
return { $loc, token: "," };
|
|
2680
2767
|
});
|
|
@@ -2736,11 +2823,12 @@ var Civet = (() => {
|
|
|
2736
2823
|
}
|
|
2737
2824
|
var ObjectLiteral$0 = BracedObjectLiteral;
|
|
2738
2825
|
var ObjectLiteral$1 = NestedObjectLiteral;
|
|
2826
|
+
var ObjectLiteral$2 = InlineObjectLiteral;
|
|
2739
2827
|
function ObjectLiteral(state) {
|
|
2740
2828
|
if (state.tokenize) {
|
|
2741
|
-
return $TOKEN("ObjectLiteral", state, ObjectLiteral$0(state) || ObjectLiteral$1(state));
|
|
2829
|
+
return $TOKEN("ObjectLiteral", state, ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state));
|
|
2742
2830
|
} else {
|
|
2743
|
-
return ObjectLiteral$0(state) || ObjectLiteral$1(state);
|
|
2831
|
+
return ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state);
|
|
2744
2832
|
}
|
|
2745
2833
|
}
|
|
2746
2834
|
var BracedObjectLiteral$0 = $TS($S(OpenBrace, $E(BracedObjectLiteralContent), __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
@@ -2840,8 +2928,20 @@ var Civet = (() => {
|
|
|
2840
2928
|
return NestedPropertyDefinition$0(state);
|
|
2841
2929
|
}
|
|
2842
2930
|
}
|
|
2931
|
+
var InlineObjectLiteral$0 = $TS($S(InsertOpenBrace, SnugNamedProperty, $Q($S($Q(TrailingComment), Comma, __, NamedProperty)), InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2932
|
+
return [$1[1], $2, ...$3.flat(), $4];
|
|
2933
|
+
});
|
|
2934
|
+
function InlineObjectLiteral(state) {
|
|
2935
|
+
if (state.verbose)
|
|
2936
|
+
console.log("ENTER:", "InlineObjectLiteral");
|
|
2937
|
+
if (state.tokenize) {
|
|
2938
|
+
return $TOKEN("InlineObjectLiteral", state, InlineObjectLiteral$0(state));
|
|
2939
|
+
} else {
|
|
2940
|
+
return InlineObjectLiteral$0(state);
|
|
2941
|
+
}
|
|
2942
|
+
}
|
|
2843
2943
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
2844
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2944
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ObjectPropertyDelimiter "}"')));
|
|
2845
2945
|
var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2846
2946
|
return { $loc, token: "," };
|
|
2847
2947
|
});
|
|
@@ -2852,7 +2952,7 @@ var Civet = (() => {
|
|
|
2852
2952
|
return ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state);
|
|
2853
2953
|
}
|
|
2854
2954
|
}
|
|
2855
|
-
var PropertyDefinitionList$0 = $TS($S(PropertyDefinition, $Q($S(
|
|
2955
|
+
var PropertyDefinitionList$0 = $TS($S(PropertyDefinition, $Q($S(ObjectPropertyDelimiter, __, PropertyDefinition))), function($skip, $loc, $0, $1, $2) {
|
|
2856
2956
|
if ($2.length) {
|
|
2857
2957
|
return [].concat($1 || [], ...$2);
|
|
2858
2958
|
}
|
|
@@ -2870,7 +2970,28 @@ var Civet = (() => {
|
|
|
2870
2970
|
return PropertyDefinitionList$0(state);
|
|
2871
2971
|
}
|
|
2872
2972
|
}
|
|
2873
|
-
var PropertyDefinition$0 = $TS($S(
|
|
2973
|
+
var PropertyDefinition$0 = $TS($S(At, IdentifierReference, $Y(ObjectPropertyDelimiter)), function($skip, $loc, $0, $1, $2, $3) {
|
|
2974
|
+
var at = $1;
|
|
2975
|
+
var id = $2;
|
|
2976
|
+
at.token = "this.";
|
|
2977
|
+
return {
|
|
2978
|
+
type: "Property",
|
|
2979
|
+
children: [id, ": ", at, id],
|
|
2980
|
+
names: id.names
|
|
2981
|
+
};
|
|
2982
|
+
});
|
|
2983
|
+
var PropertyDefinition$1 = NamedProperty;
|
|
2984
|
+
var PropertyDefinition$2 = MethodDefinition;
|
|
2985
|
+
var PropertyDefinition$3 = $S(DotDotDot, ExtendedExpression);
|
|
2986
|
+
var PropertyDefinition$4 = IdentifierReference;
|
|
2987
|
+
function PropertyDefinition(state) {
|
|
2988
|
+
if (state.tokenize) {
|
|
2989
|
+
return $TOKEN("PropertyDefinition", state, PropertyDefinition$0(state) || PropertyDefinition$1(state) || PropertyDefinition$2(state) || PropertyDefinition$3(state) || PropertyDefinition$4(state));
|
|
2990
|
+
} else {
|
|
2991
|
+
return PropertyDefinition$0(state) || PropertyDefinition$1(state) || PropertyDefinition$2(state) || PropertyDefinition$3(state) || PropertyDefinition$4(state);
|
|
2992
|
+
}
|
|
2993
|
+
}
|
|
2994
|
+
var NamedProperty$0 = $TS($S(PropertyName, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2874
2995
|
var exp = $4;
|
|
2875
2996
|
return {
|
|
2876
2997
|
type: "Property",
|
|
@@ -2878,14 +2999,30 @@ var Civet = (() => {
|
|
|
2878
2999
|
names: exp.names || []
|
|
2879
3000
|
};
|
|
2880
3001
|
});
|
|
2881
|
-
|
|
2882
|
-
|
|
2883
|
-
|
|
2884
|
-
function PropertyDefinition(state) {
|
|
3002
|
+
function NamedProperty(state) {
|
|
3003
|
+
if (state.verbose)
|
|
3004
|
+
console.log("ENTER:", "NamedProperty");
|
|
2885
3005
|
if (state.tokenize) {
|
|
2886
|
-
return $TOKEN("
|
|
3006
|
+
return $TOKEN("NamedProperty", state, NamedProperty$0(state));
|
|
2887
3007
|
} else {
|
|
2888
|
-
return
|
|
3008
|
+
return NamedProperty$0(state);
|
|
3009
|
+
}
|
|
3010
|
+
}
|
|
3011
|
+
var SnugNamedProperty$0 = $TS($S(PropertyName, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
3012
|
+
var exp = $3;
|
|
3013
|
+
return {
|
|
3014
|
+
type: "Property",
|
|
3015
|
+
children: $0,
|
|
3016
|
+
names: exp.names || []
|
|
3017
|
+
};
|
|
3018
|
+
});
|
|
3019
|
+
function SnugNamedProperty(state) {
|
|
3020
|
+
if (state.verbose)
|
|
3021
|
+
console.log("ENTER:", "SnugNamedProperty");
|
|
3022
|
+
if (state.tokenize) {
|
|
3023
|
+
return $TOKEN("SnugNamedProperty", state, SnugNamedProperty$0(state));
|
|
3024
|
+
} else {
|
|
3025
|
+
return SnugNamedProperty$0(state);
|
|
2889
3026
|
}
|
|
2890
3027
|
}
|
|
2891
3028
|
var PropertyName$0 = NumericLiteral;
|
|
@@ -3002,25 +3139,25 @@ var Civet = (() => {
|
|
|
3002
3139
|
return AssignmentOp$0(state);
|
|
3003
3140
|
}
|
|
3004
3141
|
}
|
|
3005
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
3006
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
3007
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
3008
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
3009
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
3010
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
3011
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
3012
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
3013
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
3014
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
3015
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
3016
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
3017
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
3018
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
3019
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
3020
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
3142
|
+
var AssignmentOpSymbol$0 = $EXPECT($L27, fail, 'AssignmentOpSymbol "**="');
|
|
3143
|
+
var AssignmentOpSymbol$1 = $EXPECT($L28, fail, 'AssignmentOpSymbol "*="');
|
|
3144
|
+
var AssignmentOpSymbol$2 = $EXPECT($L29, fail, 'AssignmentOpSymbol "/="');
|
|
3145
|
+
var AssignmentOpSymbol$3 = $EXPECT($L30, fail, 'AssignmentOpSymbol "%="');
|
|
3146
|
+
var AssignmentOpSymbol$4 = $EXPECT($L31, fail, 'AssignmentOpSymbol "+="');
|
|
3147
|
+
var AssignmentOpSymbol$5 = $EXPECT($L32, fail, 'AssignmentOpSymbol "-="');
|
|
3148
|
+
var AssignmentOpSymbol$6 = $EXPECT($L33, fail, 'AssignmentOpSymbol "<<="');
|
|
3149
|
+
var AssignmentOpSymbol$7 = $EXPECT($L34, fail, 'AssignmentOpSymbol ">>>="');
|
|
3150
|
+
var AssignmentOpSymbol$8 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>="');
|
|
3151
|
+
var AssignmentOpSymbol$9 = $EXPECT($L36, fail, 'AssignmentOpSymbol "&&="');
|
|
3152
|
+
var AssignmentOpSymbol$10 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&="');
|
|
3153
|
+
var AssignmentOpSymbol$11 = $EXPECT($L38, fail, 'AssignmentOpSymbol "^="');
|
|
3154
|
+
var AssignmentOpSymbol$12 = $EXPECT($L39, fail, 'AssignmentOpSymbol "||="');
|
|
3155
|
+
var AssignmentOpSymbol$13 = $EXPECT($L40, fail, 'AssignmentOpSymbol "|="');
|
|
3156
|
+
var AssignmentOpSymbol$14 = $EXPECT($L41, fail, 'AssignmentOpSymbol "??="');
|
|
3157
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L42, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
3021
3158
|
return "??=";
|
|
3022
3159
|
});
|
|
3023
|
-
var AssignmentOpSymbol$16 = $EXPECT($
|
|
3160
|
+
var AssignmentOpSymbol$16 = $EXPECT($L43, fail, 'AssignmentOpSymbol "="');
|
|
3024
3161
|
function AssignmentOpSymbol(state) {
|
|
3025
3162
|
if (state.tokenize) {
|
|
3026
3163
|
return $TOKEN("AssignmentOpSymbol", state, AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state) || AssignmentOpSymbol$16(state));
|
|
@@ -3042,68 +3179,80 @@ var Civet = (() => {
|
|
|
3042
3179
|
return BinaryOp$0(state);
|
|
3043
3180
|
}
|
|
3044
3181
|
}
|
|
3045
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
3046
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
3047
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
3048
|
-
var BinaryOpSymbol$3 = $EXPECT($
|
|
3049
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
3050
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
3051
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
3052
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
3053
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
3182
|
+
var BinaryOpSymbol$0 = $EXPECT($L44, fail, 'BinaryOpSymbol "**"');
|
|
3183
|
+
var BinaryOpSymbol$1 = $EXPECT($L45, fail, 'BinaryOpSymbol "*"');
|
|
3184
|
+
var BinaryOpSymbol$2 = $EXPECT($L46, fail, 'BinaryOpSymbol "/"');
|
|
3185
|
+
var BinaryOpSymbol$3 = $EXPECT($L47, fail, 'BinaryOpSymbol "%"');
|
|
3186
|
+
var BinaryOpSymbol$4 = $EXPECT($L48, fail, 'BinaryOpSymbol "+"');
|
|
3187
|
+
var BinaryOpSymbol$5 = $EXPECT($L49, fail, 'BinaryOpSymbol "-"');
|
|
3188
|
+
var BinaryOpSymbol$6 = $EXPECT($L50, fail, 'BinaryOpSymbol "<="');
|
|
3189
|
+
var BinaryOpSymbol$7 = $EXPECT($L51, fail, 'BinaryOpSymbol ">="');
|
|
3190
|
+
var BinaryOpSymbol$8 = $EXPECT($L52, fail, 'BinaryOpSymbol "<<"');
|
|
3054
3191
|
var BinaryOpSymbol$9 = $EXPECT($L4, fail, 'BinaryOpSymbol "<"');
|
|
3055
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
3056
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
3057
|
-
var BinaryOpSymbol$12 = $EXPECT($
|
|
3058
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
3059
|
-
var BinaryOpSymbol$14 = $TV($EXPECT($
|
|
3192
|
+
var BinaryOpSymbol$10 = $EXPECT($L53, fail, 'BinaryOpSymbol ">>>"');
|
|
3193
|
+
var BinaryOpSymbol$11 = $EXPECT($L54, fail, 'BinaryOpSymbol ">>"');
|
|
3194
|
+
var BinaryOpSymbol$12 = $EXPECT($L55, fail, 'BinaryOpSymbol ">"');
|
|
3195
|
+
var BinaryOpSymbol$13 = $EXPECT($L56, fail, 'BinaryOpSymbol "!=="');
|
|
3196
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L57, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
3060
3197
|
if (module.config.coffeeEq)
|
|
3061
3198
|
return "!==";
|
|
3062
3199
|
return $1;
|
|
3063
3200
|
});
|
|
3064
|
-
var BinaryOpSymbol$15 = $TS($S($EXPECT($
|
|
3201
|
+
var BinaryOpSymbol$15 = $TS($S($EXPECT($L58, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3065
3202
|
if (module.config.coffeeIsnt)
|
|
3066
3203
|
return "!==";
|
|
3067
3204
|
return $skip;
|
|
3068
3205
|
});
|
|
3069
|
-
var BinaryOpSymbol$16 = $T($S($EXPECT($
|
|
3206
|
+
var BinaryOpSymbol$16 = $T($S($EXPECT($L59, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
3070
3207
|
return "===";
|
|
3071
3208
|
});
|
|
3072
|
-
var BinaryOpSymbol$17 = $EXPECT($
|
|
3073
|
-
var BinaryOpSymbol$18 = $TV($EXPECT($
|
|
3209
|
+
var BinaryOpSymbol$17 = $EXPECT($L60, fail, 'BinaryOpSymbol "==="');
|
|
3210
|
+
var BinaryOpSymbol$18 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
3074
3211
|
if (module.config.coffeeEq)
|
|
3075
3212
|
return "===";
|
|
3076
3213
|
return $1;
|
|
3077
3214
|
});
|
|
3078
|
-
var BinaryOpSymbol$19 = $T($S($EXPECT($
|
|
3215
|
+
var BinaryOpSymbol$19 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
3079
3216
|
return "&&";
|
|
3080
3217
|
});
|
|
3081
|
-
var BinaryOpSymbol$20 = $EXPECT($
|
|
3082
|
-
var BinaryOpSymbol$21 = $T($S(CoffeeOfEnabled, $EXPECT($
|
|
3218
|
+
var BinaryOpSymbol$20 = $EXPECT($L63, fail, 'BinaryOpSymbol "&&"');
|
|
3219
|
+
var BinaryOpSymbol$21 = $T($S(CoffeeOfEnabled, $EXPECT($L64, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
|
|
3083
3220
|
return "in";
|
|
3084
3221
|
});
|
|
3085
|
-
var BinaryOpSymbol$22 = $T($S($EXPECT($
|
|
3222
|
+
var BinaryOpSymbol$22 = $T($S($EXPECT($L65, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
3086
3223
|
return "||";
|
|
3087
3224
|
});
|
|
3088
|
-
var BinaryOpSymbol$23 = $EXPECT($
|
|
3089
|
-
var BinaryOpSymbol$24 = $EXPECT($
|
|
3090
|
-
var BinaryOpSymbol$25 = $
|
|
3225
|
+
var BinaryOpSymbol$23 = $EXPECT($L66, fail, 'BinaryOpSymbol "||"');
|
|
3226
|
+
var BinaryOpSymbol$24 = $EXPECT($L67, fail, 'BinaryOpSymbol "??"');
|
|
3227
|
+
var BinaryOpSymbol$25 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L68, fail, 'BinaryOpSymbol "?"')), function(value) {
|
|
3228
|
+
return "??";
|
|
3229
|
+
});
|
|
3230
|
+
var BinaryOpSymbol$26 = $TS($S($EXPECT($L69, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3091
3231
|
return $1;
|
|
3092
3232
|
});
|
|
3093
|
-
var BinaryOpSymbol$
|
|
3094
|
-
return
|
|
3233
|
+
var BinaryOpSymbol$27 = $TS($S(CoffeeOfEnabled, $EXPECT($L70, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
3234
|
+
return {
|
|
3235
|
+
ref: module.getIndexOfRef(),
|
|
3236
|
+
suffix: " >= 0"
|
|
3237
|
+
};
|
|
3095
3238
|
});
|
|
3096
|
-
var BinaryOpSymbol$
|
|
3239
|
+
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) {
|
|
3240
|
+
return {
|
|
3241
|
+
ref: module.getIndexOfRef(),
|
|
3242
|
+
suffix: " < 0"
|
|
3243
|
+
};
|
|
3244
|
+
});
|
|
3245
|
+
var BinaryOpSymbol$29 = $TS($S($EXPECT($L70, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3097
3246
|
return $1;
|
|
3098
3247
|
});
|
|
3099
|
-
var BinaryOpSymbol$
|
|
3100
|
-
var BinaryOpSymbol$
|
|
3101
|
-
var BinaryOpSymbol$
|
|
3248
|
+
var BinaryOpSymbol$30 = $EXPECT($L72, fail, 'BinaryOpSymbol "&"');
|
|
3249
|
+
var BinaryOpSymbol$31 = $EXPECT($L73, fail, 'BinaryOpSymbol "^"');
|
|
3250
|
+
var BinaryOpSymbol$32 = $EXPECT($L74, fail, 'BinaryOpSymbol "|"');
|
|
3102
3251
|
function BinaryOpSymbol(state) {
|
|
3103
3252
|
if (state.tokenize) {
|
|
3104
|
-
return $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state));
|
|
3253
|
+
return $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state));
|
|
3105
3254
|
} else {
|
|
3106
|
-
return BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state);
|
|
3255
|
+
return BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state);
|
|
3107
3256
|
}
|
|
3108
3257
|
}
|
|
3109
3258
|
var UnaryOp$0 = $TR($EXPECT($R4, fail, "UnaryOp /[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
@@ -3187,7 +3336,7 @@ var Civet = (() => {
|
|
|
3187
3336
|
return Statement$0(state) || Statement$1(state) || Statement$2(state) || Statement$3(state) || Statement$4(state) || Statement$5(state) || Statement$6(state) || Statement$7(state) || Statement$8(state);
|
|
3188
3337
|
}
|
|
3189
3338
|
}
|
|
3190
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
3339
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L75, fail, 'EmptyStatement ";"'))), function(value) {
|
|
3191
3340
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
3192
3341
|
});
|
|
3193
3342
|
function EmptyStatement(state) {
|
|
@@ -3199,7 +3348,7 @@ var Civet = (() => {
|
|
|
3199
3348
|
return EmptyStatement$0(state);
|
|
3200
3349
|
}
|
|
3201
3350
|
}
|
|
3202
|
-
var BlockStatement$0 = $T($S(__, OpenBrace, EOS, NestedBlockStatements, __, CloseBrace, $N($S(__, $EXPECT($
|
|
3351
|
+
var BlockStatement$0 = $T($S(__, OpenBrace, EOS, NestedBlockStatements, __, CloseBrace, $N($S(__, $EXPECT($L43, fail, 'BlockStatement "="')))), function(value) {
|
|
3203
3352
|
var exps = value[3];
|
|
3204
3353
|
return { "type": "BlockStatement", "children": value, "expressions": exps };
|
|
3205
3354
|
});
|
|
@@ -3634,7 +3783,7 @@ var Civet = (() => {
|
|
|
3634
3783
|
return CoffeeForStatementParameters$0(state);
|
|
3635
3784
|
}
|
|
3636
3785
|
}
|
|
3637
|
-
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($
|
|
3786
|
+
var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L76, fail, 'CoffeeForDeclaration "own"'))), ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
3638
3787
|
var own = $1;
|
|
3639
3788
|
var binding = $2;
|
|
3640
3789
|
if (own) {
|
|
@@ -3738,8 +3887,30 @@ var Civet = (() => {
|
|
|
3738
3887
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
3739
3888
|
}
|
|
3740
3889
|
}
|
|
3741
|
-
var SwitchStatement$0 = $
|
|
3742
|
-
|
|
3890
|
+
var SwitchStatement$0 = $TS($S(Switch, $C(EmptyCondition, Condition), CaseBlock), function($skip, $loc, $0, $1, $2, $3) {
|
|
3891
|
+
var condition = $2;
|
|
3892
|
+
var caseBlock = $3;
|
|
3893
|
+
if (condition.type === "EmptyCondition") {
|
|
3894
|
+
caseBlock.clauses.forEach(({ cases }) => {
|
|
3895
|
+
if (cases) {
|
|
3896
|
+
cases.forEach((c) => {
|
|
3897
|
+
const exp = c[1];
|
|
3898
|
+
switch (exp.type) {
|
|
3899
|
+
case "Identifier":
|
|
3900
|
+
case "Literal":
|
|
3901
|
+
c.splice(1, 0, "!");
|
|
3902
|
+
break;
|
|
3903
|
+
default:
|
|
3904
|
+
c.splice(1, 1, "!(", exp, ")");
|
|
3905
|
+
}
|
|
3906
|
+
});
|
|
3907
|
+
}
|
|
3908
|
+
});
|
|
3909
|
+
}
|
|
3910
|
+
return {
|
|
3911
|
+
type: "SwitchStatement",
|
|
3912
|
+
children: $0
|
|
3913
|
+
};
|
|
3743
3914
|
});
|
|
3744
3915
|
function SwitchStatement(state) {
|
|
3745
3916
|
if (state.verbose)
|
|
@@ -3750,6 +3921,24 @@ var Civet = (() => {
|
|
|
3750
3921
|
return SwitchStatement$0(state);
|
|
3751
3922
|
}
|
|
3752
3923
|
}
|
|
3924
|
+
var EmptyCondition$0 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
3925
|
+
return {
|
|
3926
|
+
type: "EmptyCondition",
|
|
3927
|
+
children: [{
|
|
3928
|
+
$loc,
|
|
3929
|
+
token: " (false)"
|
|
3930
|
+
}]
|
|
3931
|
+
};
|
|
3932
|
+
});
|
|
3933
|
+
function EmptyCondition(state) {
|
|
3934
|
+
if (state.verbose)
|
|
3935
|
+
console.log("ENTER:", "EmptyCondition");
|
|
3936
|
+
if (state.tokenize) {
|
|
3937
|
+
return $TOKEN("EmptyCondition", state, EmptyCondition$0(state));
|
|
3938
|
+
} else {
|
|
3939
|
+
return EmptyCondition$0(state);
|
|
3940
|
+
}
|
|
3941
|
+
}
|
|
3753
3942
|
var SwitchExpression$0 = $TV(SwitchStatement, function($skip, $loc, $0, $1) {
|
|
3754
3943
|
var e = $0;
|
|
3755
3944
|
module.addImplicitReturns(e.children[2]);
|
|
@@ -3820,18 +4009,20 @@ var Civet = (() => {
|
|
|
3820
4009
|
}
|
|
3821
4010
|
}
|
|
3822
4011
|
var CaseClause$0 = $T($S(Case, CaseExpressionList, $C(NestedBlockStatements, NoExpressions)), function(value) {
|
|
3823
|
-
var
|
|
3824
|
-
|
|
4012
|
+
var cases = value[1];
|
|
4013
|
+
var expressions = value[2];
|
|
4014
|
+
return { "type": "CaseClause", "cases": cases, "expressions": expressions, "children": value };
|
|
3825
4015
|
});
|
|
3826
|
-
var CaseClause$1 = $T($S(When, CaseExpressionList, NestedBlockStatements, InsertBreak), function(value) {
|
|
3827
|
-
var
|
|
3828
|
-
|
|
4016
|
+
var CaseClause$1 = $T($S(When, CaseExpressionList, $C(ThenClause, NestedBlockStatements), InsertBreak), function(value) {
|
|
4017
|
+
var cases = value[1];
|
|
4018
|
+
var expressions = value[2];
|
|
4019
|
+
return { "type": "WhenClause", "cases": cases, "expressions": expressions, "children": value };
|
|
3829
4020
|
});
|
|
3830
4021
|
var CaseClause$2 = $T($S(Default, ImpliedColon, $C(NestedBlockStatements, NoExpressions)), function(value) {
|
|
3831
4022
|
var exps = value[2];
|
|
3832
4023
|
return { "type": "DefaultClause", "expressions": exps, "children": value };
|
|
3833
4024
|
});
|
|
3834
|
-
var CaseClause$3 = $TS($S(Else, ImpliedColon, NestedBlockStatements), function($skip, $loc, $0, $1, $2, $3) {
|
|
4025
|
+
var CaseClause$3 = $TS($S(Else, ImpliedColon, $C(NestedBlockStatements, $S($Q(TrailingComment), Statement))), function($skip, $loc, $0, $1, $2, $3) {
|
|
3835
4026
|
var exps = $3;
|
|
3836
4027
|
$1.token = "default";
|
|
3837
4028
|
return {
|
|
@@ -3933,7 +4124,7 @@ var Civet = (() => {
|
|
|
3933
4124
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
3934
4125
|
}
|
|
3935
4126
|
}
|
|
3936
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
4127
|
+
var Finally$0 = $S(__, $EXPECT($L77, fail, 'Finally "finally"'), BracedBlock);
|
|
3937
4128
|
function Finally(state) {
|
|
3938
4129
|
if (state.verbose)
|
|
3939
4130
|
console.log("ENTER:", "Finally");
|
|
@@ -4010,13 +4201,13 @@ var Civet = (() => {
|
|
|
4010
4201
|
return ExpressionStatement$0(state);
|
|
4011
4202
|
}
|
|
4012
4203
|
}
|
|
4013
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
4204
|
+
var KeywordStatement$0 = $T($S($EXPECT($L78, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
4014
4205
|
return { "type": "BreakStatement", "children": value };
|
|
4015
4206
|
});
|
|
4016
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
4207
|
+
var KeywordStatement$1 = $T($S($EXPECT($L79, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
4017
4208
|
return { "type": "ContinueStatement", "children": value };
|
|
4018
4209
|
});
|
|
4019
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
4210
|
+
var KeywordStatement$2 = $T($S($EXPECT($L80, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
4020
4211
|
return { "type": "DebuggerStatement", "children": value };
|
|
4021
4212
|
});
|
|
4022
4213
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -4032,7 +4223,7 @@ var Civet = (() => {
|
|
|
4032
4223
|
return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state);
|
|
4033
4224
|
}
|
|
4034
4225
|
}
|
|
4035
|
-
var DebuggerExpression$0 = $TS($S($EXPECT($
|
|
4226
|
+
var DebuggerExpression$0 = $TS($S($EXPECT($L80, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4036
4227
|
return {
|
|
4037
4228
|
type: "DebuggerExpression",
|
|
4038
4229
|
children: ["($=>{", $1, "})()"]
|
|
@@ -4075,7 +4266,7 @@ var Civet = (() => {
|
|
|
4075
4266
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
4076
4267
|
}
|
|
4077
4268
|
}
|
|
4078
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
4269
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L81, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
4079
4270
|
return { "ts": true, "children": value };
|
|
4080
4271
|
});
|
|
4081
4272
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
@@ -4254,7 +4445,7 @@ var Civet = (() => {
|
|
|
4254
4445
|
return ImportedBinding$0(state);
|
|
4255
4446
|
}
|
|
4256
4447
|
}
|
|
4257
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
4448
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L82, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression));
|
|
4258
4449
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
4259
4450
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
4260
4451
|
function ExportDeclaration(state) {
|
|
@@ -4361,7 +4552,7 @@ var Civet = (() => {
|
|
|
4361
4552
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
4362
4553
|
}
|
|
4363
4554
|
}
|
|
4364
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
4555
|
+
var ConstAssignment$0 = $TV($EXPECT($L83, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
4365
4556
|
return { $loc, token: "=" };
|
|
4366
4557
|
});
|
|
4367
4558
|
function ConstAssignment(state) {
|
|
@@ -4683,7 +4874,7 @@ var Civet = (() => {
|
|
|
4683
4874
|
return CoffeeDoubleQuotedStringCharacters$0(state);
|
|
4684
4875
|
}
|
|
4685
4876
|
}
|
|
4686
|
-
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($
|
|
4877
|
+
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L46, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L46, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
4687
4878
|
return { $loc, token: $1 };
|
|
4688
4879
|
});
|
|
4689
4880
|
function RegularExpressionLiteral(state) {
|
|
@@ -4810,7 +5001,7 @@ var Civet = (() => {
|
|
|
4810
5001
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
4811
5002
|
}
|
|
4812
5003
|
}
|
|
4813
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
5004
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L85, fail, 'JSMultiLineComment "*/"')), $EXPECT($R30, fail, "JSMultiLineComment /./"))), $EXPECT($L85, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
4814
5005
|
return { $loc, token: $1 };
|
|
4815
5006
|
});
|
|
4816
5007
|
function JSMultiLineComment(state) {
|
|
@@ -4834,7 +5025,7 @@ var Civet = (() => {
|
|
|
4834
5025
|
return CoffeeSingleLineComment$0(state);
|
|
4835
5026
|
}
|
|
4836
5027
|
}
|
|
4837
|
-
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($
|
|
5028
|
+
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L85, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R30, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L86, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
4838
5029
|
return { $loc, token: `/*${$2}*/` };
|
|
4839
5030
|
});
|
|
4840
5031
|
function CoffeeMultiLineComment(state) {
|
|
@@ -4846,7 +5037,7 @@ var Civet = (() => {
|
|
|
4846
5037
|
return CoffeeMultiLineComment$0(state);
|
|
4847
5038
|
}
|
|
4848
5039
|
}
|
|
4849
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
5040
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L85, fail, 'InlineComment "*/"')), $EXPECT($R32, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L85, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
4850
5041
|
return { $loc, token: $1 };
|
|
4851
5042
|
});
|
|
4852
5043
|
function InlineComment(state) {
|
|
@@ -4891,13 +5082,14 @@ var Civet = (() => {
|
|
|
4891
5082
|
var NonNewlineWhitespace$0 = $TR($EXPECT($R33, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4892
5083
|
return { $loc, token: $0 };
|
|
4893
5084
|
});
|
|
5085
|
+
var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L87, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
|
|
5086
|
+
return "";
|
|
5087
|
+
});
|
|
4894
5088
|
function NonNewlineWhitespace(state) {
|
|
4895
|
-
if (state.verbose)
|
|
4896
|
-
console.log("ENTER:", "NonNewlineWhitespace");
|
|
4897
5089
|
if (state.tokenize) {
|
|
4898
|
-
return $TOKEN("NonNewlineWhitespace", state, NonNewlineWhitespace$0(state));
|
|
5090
|
+
return $TOKEN("NonNewlineWhitespace", state, NonNewlineWhitespace$0(state) || NonNewlineWhitespace$1(state));
|
|
4899
5091
|
} else {
|
|
4900
|
-
return NonNewlineWhitespace$0(state);
|
|
5092
|
+
return NonNewlineWhitespace$0(state) || NonNewlineWhitespace$1(state);
|
|
4901
5093
|
}
|
|
4902
5094
|
}
|
|
4903
5095
|
var __$0 = $Q($C(Whitespace, Comment));
|
|
@@ -4967,7 +5159,7 @@ var Civet = (() => {
|
|
|
4967
5159
|
return Loc$0(state);
|
|
4968
5160
|
}
|
|
4969
5161
|
}
|
|
4970
|
-
var Ampersand$0 = $TV($EXPECT($
|
|
5162
|
+
var Ampersand$0 = $TV($EXPECT($L72, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
|
|
4971
5163
|
return { $loc, token: $1 };
|
|
4972
5164
|
});
|
|
4973
5165
|
function Ampersand(state) {
|
|
@@ -4979,7 +5171,7 @@ var Civet = (() => {
|
|
|
4979
5171
|
return Ampersand$0(state);
|
|
4980
5172
|
}
|
|
4981
5173
|
}
|
|
4982
|
-
var As$0 = $TS($S($EXPECT($
|
|
5174
|
+
var As$0 = $TS($S($EXPECT($L88, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4983
5175
|
return { $loc, token: $1 };
|
|
4984
5176
|
});
|
|
4985
5177
|
function As(state) {
|
|
@@ -4991,7 +5183,19 @@ var Civet = (() => {
|
|
|
4991
5183
|
return As$0(state);
|
|
4992
5184
|
}
|
|
4993
5185
|
}
|
|
4994
|
-
var
|
|
5186
|
+
var At$0 = $TV($EXPECT($L89, fail, 'At "@"'), function($skip, $loc, $0, $1) {
|
|
5187
|
+
return { $loc, token: $1 };
|
|
5188
|
+
});
|
|
5189
|
+
function At(state) {
|
|
5190
|
+
if (state.verbose)
|
|
5191
|
+
console.log("ENTER:", "At");
|
|
5192
|
+
if (state.tokenize) {
|
|
5193
|
+
return $TOKEN("At", state, At$0(state));
|
|
5194
|
+
} else {
|
|
5195
|
+
return At$0(state);
|
|
5196
|
+
}
|
|
5197
|
+
}
|
|
5198
|
+
var Async$0 = $TV($EXPECT($L90, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
|
|
4995
5199
|
return { $loc, token: $1 };
|
|
4996
5200
|
});
|
|
4997
5201
|
function Async(state) {
|
|
@@ -5003,7 +5207,7 @@ var Civet = (() => {
|
|
|
5003
5207
|
return Async$0(state);
|
|
5004
5208
|
}
|
|
5005
5209
|
}
|
|
5006
|
-
var Await$0 = $TS($S($EXPECT($
|
|
5210
|
+
var Await$0 = $TS($S($EXPECT($L91, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5007
5211
|
return { $loc, token: $1 };
|
|
5008
5212
|
});
|
|
5009
5213
|
function Await(state) {
|
|
@@ -5015,7 +5219,7 @@ var Civet = (() => {
|
|
|
5015
5219
|
return Await$0(state);
|
|
5016
5220
|
}
|
|
5017
5221
|
}
|
|
5018
|
-
var Backtick$0 = $TV($EXPECT($
|
|
5222
|
+
var Backtick$0 = $TV($EXPECT($L92, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
5019
5223
|
return { $loc, token: $1 };
|
|
5020
5224
|
});
|
|
5021
5225
|
function Backtick(state) {
|
|
@@ -5027,7 +5231,7 @@ var Civet = (() => {
|
|
|
5027
5231
|
return Backtick$0(state);
|
|
5028
5232
|
}
|
|
5029
5233
|
}
|
|
5030
|
-
var By$0 = $TS($S($EXPECT($
|
|
5234
|
+
var By$0 = $TS($S($EXPECT($L93, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5031
5235
|
return { $loc, token: $1 };
|
|
5032
5236
|
});
|
|
5033
5237
|
function By(state) {
|
|
@@ -5039,7 +5243,7 @@ var Civet = (() => {
|
|
|
5039
5243
|
return By$0(state);
|
|
5040
5244
|
}
|
|
5041
5245
|
}
|
|
5042
|
-
var Case$0 = $TS($S($EXPECT($
|
|
5246
|
+
var Case$0 = $TS($S($EXPECT($L94, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5043
5247
|
return { $loc, token: $1 };
|
|
5044
5248
|
});
|
|
5045
5249
|
function Case(state) {
|
|
@@ -5051,7 +5255,7 @@ var Civet = (() => {
|
|
|
5051
5255
|
return Case$0(state);
|
|
5052
5256
|
}
|
|
5053
5257
|
}
|
|
5054
|
-
var Catch$0 = $TV($EXPECT($
|
|
5258
|
+
var Catch$0 = $TV($EXPECT($L95, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
5055
5259
|
return { $loc, token: $1 };
|
|
5056
5260
|
});
|
|
5057
5261
|
function Catch(state) {
|
|
@@ -5063,7 +5267,7 @@ var Civet = (() => {
|
|
|
5063
5267
|
return Catch$0(state);
|
|
5064
5268
|
}
|
|
5065
5269
|
}
|
|
5066
|
-
var Class$0 = $TV($EXPECT($
|
|
5270
|
+
var Class$0 = $TV($EXPECT($L96, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
5067
5271
|
return { $loc, token: $1 };
|
|
5068
5272
|
});
|
|
5069
5273
|
function Class(state) {
|
|
@@ -5075,7 +5279,7 @@ var Civet = (() => {
|
|
|
5075
5279
|
return Class$0(state);
|
|
5076
5280
|
}
|
|
5077
5281
|
}
|
|
5078
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
5282
|
+
var CloseBrace$0 = $TV($EXPECT($L26, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
5079
5283
|
return { $loc, token: $1 };
|
|
5080
5284
|
});
|
|
5081
5285
|
function CloseBrace(state) {
|
|
@@ -5087,7 +5291,7 @@ var Civet = (() => {
|
|
|
5087
5291
|
return CloseBrace$0(state);
|
|
5088
5292
|
}
|
|
5089
5293
|
}
|
|
5090
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
5294
|
+
var CloseBracket$0 = $TV($EXPECT($L25, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
5091
5295
|
return { $loc, token: $1 };
|
|
5092
5296
|
});
|
|
5093
5297
|
function CloseBracket(state) {
|
|
@@ -5099,7 +5303,7 @@ var Civet = (() => {
|
|
|
5099
5303
|
return CloseBracket$0(state);
|
|
5100
5304
|
}
|
|
5101
5305
|
}
|
|
5102
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
5306
|
+
var CloseParen$0 = $TV($EXPECT($L15, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
5103
5307
|
return { $loc, token: $1 };
|
|
5104
5308
|
});
|
|
5105
5309
|
function CloseParen(state) {
|
|
@@ -5111,7 +5315,7 @@ var Civet = (() => {
|
|
|
5111
5315
|
return CloseParen$0(state);
|
|
5112
5316
|
}
|
|
5113
5317
|
}
|
|
5114
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
5318
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L97, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
5115
5319
|
return { $loc, token: "${" };
|
|
5116
5320
|
});
|
|
5117
5321
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -5123,7 +5327,7 @@ var Civet = (() => {
|
|
|
5123
5327
|
return CoffeeSubstitutionStart$0(state);
|
|
5124
5328
|
}
|
|
5125
5329
|
}
|
|
5126
|
-
var Colon$0 = $TV($EXPECT($
|
|
5330
|
+
var Colon$0 = $TV($EXPECT($L98, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
5127
5331
|
return { $loc, token: $1 };
|
|
5128
5332
|
});
|
|
5129
5333
|
function Colon(state) {
|
|
@@ -5135,7 +5339,7 @@ var Civet = (() => {
|
|
|
5135
5339
|
return Colon$0(state);
|
|
5136
5340
|
}
|
|
5137
5341
|
}
|
|
5138
|
-
var ConstructorShorthand$0 = $TV($EXPECT($
|
|
5342
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L89, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
5139
5343
|
return { $loc, token: "constructor" };
|
|
5140
5344
|
});
|
|
5141
5345
|
function ConstructorShorthand(state) {
|
|
@@ -5147,7 +5351,7 @@ var Civet = (() => {
|
|
|
5147
5351
|
return ConstructorShorthand$0(state);
|
|
5148
5352
|
}
|
|
5149
5353
|
}
|
|
5150
|
-
var Default$0 = $TS($S($EXPECT($
|
|
5354
|
+
var Default$0 = $TS($S($EXPECT($L82, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5151
5355
|
return { $loc, token: $1 };
|
|
5152
5356
|
});
|
|
5153
5357
|
function Default(state) {
|
|
@@ -5159,7 +5363,7 @@ var Civet = (() => {
|
|
|
5159
5363
|
return Default$0(state);
|
|
5160
5364
|
}
|
|
5161
5365
|
}
|
|
5162
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
5366
|
+
var Delete$0 = $TS($S($EXPECT($L99, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5163
5367
|
return { $loc, token: $1 };
|
|
5164
5368
|
});
|
|
5165
5369
|
function Delete(state) {
|
|
@@ -5171,7 +5375,7 @@ var Civet = (() => {
|
|
|
5171
5375
|
return Delete$0(state);
|
|
5172
5376
|
}
|
|
5173
5377
|
}
|
|
5174
|
-
var Do$0 = $TS($S($EXPECT($
|
|
5378
|
+
var Do$0 = $TS($S($EXPECT($L100, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5175
5379
|
return { $loc, token: $1 };
|
|
5176
5380
|
});
|
|
5177
5381
|
function Do(state) {
|
|
@@ -5183,7 +5387,7 @@ var Civet = (() => {
|
|
|
5183
5387
|
return Do$0(state);
|
|
5184
5388
|
}
|
|
5185
5389
|
}
|
|
5186
|
-
var Dot$0 = $TV($EXPECT($
|
|
5390
|
+
var Dot$0 = $TV($EXPECT($L8, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
5187
5391
|
return { $loc, token: $1 };
|
|
5188
5392
|
});
|
|
5189
5393
|
function Dot(state) {
|
|
@@ -5195,7 +5399,7 @@ var Civet = (() => {
|
|
|
5195
5399
|
return Dot$0(state);
|
|
5196
5400
|
}
|
|
5197
5401
|
}
|
|
5198
|
-
var DotDot$0 = $TV($EXPECT($
|
|
5402
|
+
var DotDot$0 = $TV($EXPECT($L101, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
5199
5403
|
return { $loc, token: $1 };
|
|
5200
5404
|
});
|
|
5201
5405
|
function DotDot(state) {
|
|
@@ -5207,7 +5411,7 @@ var Civet = (() => {
|
|
|
5207
5411
|
return DotDot$0(state);
|
|
5208
5412
|
}
|
|
5209
5413
|
}
|
|
5210
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
5414
|
+
var DotDotDot$0 = $TV($EXPECT($L102, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
5211
5415
|
return { $loc, token: $1 };
|
|
5212
5416
|
});
|
|
5213
5417
|
function DotDotDot(state) {
|
|
@@ -5219,7 +5423,7 @@ var Civet = (() => {
|
|
|
5219
5423
|
return DotDotDot$0(state);
|
|
5220
5424
|
}
|
|
5221
5425
|
}
|
|
5222
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
5426
|
+
var DoubleQuote$0 = $TV($EXPECT($L103, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
5223
5427
|
return { $loc, token: $1 };
|
|
5224
5428
|
});
|
|
5225
5429
|
function DoubleQuote(state) {
|
|
@@ -5231,7 +5435,7 @@ var Civet = (() => {
|
|
|
5231
5435
|
return DoubleQuote$0(state);
|
|
5232
5436
|
}
|
|
5233
5437
|
}
|
|
5234
|
-
var Else$0 = $TV($EXPECT($
|
|
5438
|
+
var Else$0 = $TV($EXPECT($L104, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
5235
5439
|
return { $loc, token: $1 };
|
|
5236
5440
|
});
|
|
5237
5441
|
function Else(state) {
|
|
@@ -5243,7 +5447,7 @@ var Civet = (() => {
|
|
|
5243
5447
|
return Else$0(state);
|
|
5244
5448
|
}
|
|
5245
5449
|
}
|
|
5246
|
-
var Equals$0 = $TV($EXPECT($
|
|
5450
|
+
var Equals$0 = $TV($EXPECT($L43, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
5247
5451
|
return { $loc, token: $1 };
|
|
5248
5452
|
});
|
|
5249
5453
|
function Equals(state) {
|
|
@@ -5255,7 +5459,7 @@ var Civet = (() => {
|
|
|
5255
5459
|
return Equals$0(state);
|
|
5256
5460
|
}
|
|
5257
5461
|
}
|
|
5258
|
-
var Export$0 = $TS($S($EXPECT($
|
|
5462
|
+
var Export$0 = $TS($S($EXPECT($L105, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5259
5463
|
return { $loc, token: $1 };
|
|
5260
5464
|
});
|
|
5261
5465
|
function Export(state) {
|
|
@@ -5267,7 +5471,7 @@ var Civet = (() => {
|
|
|
5267
5471
|
return Export$0(state);
|
|
5268
5472
|
}
|
|
5269
5473
|
}
|
|
5270
|
-
var For$0 = $TS($S($EXPECT($
|
|
5474
|
+
var For$0 = $TS($S($EXPECT($L106, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5271
5475
|
return { $loc, token: $1 };
|
|
5272
5476
|
});
|
|
5273
5477
|
function For(state) {
|
|
@@ -5279,7 +5483,7 @@ var Civet = (() => {
|
|
|
5279
5483
|
return For$0(state);
|
|
5280
5484
|
}
|
|
5281
5485
|
}
|
|
5282
|
-
var From$0 = $TS($S($EXPECT($
|
|
5486
|
+
var From$0 = $TS($S($EXPECT($L107, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5283
5487
|
return { $loc, token: $1 };
|
|
5284
5488
|
});
|
|
5285
5489
|
function From(state) {
|
|
@@ -5291,7 +5495,7 @@ var Civet = (() => {
|
|
|
5291
5495
|
return From$0(state);
|
|
5292
5496
|
}
|
|
5293
5497
|
}
|
|
5294
|
-
var Function$0 = $TV($EXPECT($
|
|
5498
|
+
var Function$0 = $TV($EXPECT($L108, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
5295
5499
|
return { $loc, token: $1 };
|
|
5296
5500
|
});
|
|
5297
5501
|
function Function(state) {
|
|
@@ -5303,7 +5507,7 @@ var Civet = (() => {
|
|
|
5303
5507
|
return Function$0(state);
|
|
5304
5508
|
}
|
|
5305
5509
|
}
|
|
5306
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
5510
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L109, fail, 'GetOrSet "get"'), $EXPECT($L110, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5307
5511
|
return { $loc, token: $1 };
|
|
5308
5512
|
});
|
|
5309
5513
|
function GetOrSet(state) {
|
|
@@ -5315,7 +5519,7 @@ var Civet = (() => {
|
|
|
5315
5519
|
return GetOrSet$0(state);
|
|
5316
5520
|
}
|
|
5317
5521
|
}
|
|
5318
|
-
var If$0 = $TV($TEXT($S($EXPECT($
|
|
5522
|
+
var If$0 = $TV($TEXT($S($EXPECT($L111, fail, 'If "if"'), $E($EXPECT($L112, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
5319
5523
|
return { $loc, token: $1 };
|
|
5320
5524
|
});
|
|
5321
5525
|
function If(state) {
|
|
@@ -5327,7 +5531,7 @@ var Civet = (() => {
|
|
|
5327
5531
|
return If$0(state);
|
|
5328
5532
|
}
|
|
5329
5533
|
}
|
|
5330
|
-
var Import$0 = $TS($S($EXPECT($
|
|
5534
|
+
var Import$0 = $TS($S($EXPECT($L10, fail, 'Import "import"'), $Y($EXPECT($R36, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
5331
5535
|
return { $loc, token: $1 };
|
|
5332
5536
|
});
|
|
5333
5537
|
function Import(state) {
|
|
@@ -5351,7 +5555,7 @@ var Civet = (() => {
|
|
|
5351
5555
|
return In$0(state);
|
|
5352
5556
|
}
|
|
5353
5557
|
}
|
|
5354
|
-
var LetOrConst$0 = $TV($C($EXPECT($
|
|
5558
|
+
var LetOrConst$0 = $TV($C($EXPECT($L113, fail, 'LetOrConst "let"'), $EXPECT($L114, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
5355
5559
|
return { $loc, token: $1 };
|
|
5356
5560
|
});
|
|
5357
5561
|
function LetOrConst(state) {
|
|
@@ -5363,7 +5567,7 @@ var Civet = (() => {
|
|
|
5363
5567
|
return LetOrConst$0(state);
|
|
5364
5568
|
}
|
|
5365
5569
|
}
|
|
5366
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
5570
|
+
var Loop$0 = $TS($S($EXPECT($L115, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5367
5571
|
return { $loc, token: "while(true)" };
|
|
5368
5572
|
});
|
|
5369
5573
|
function Loop(state) {
|
|
@@ -5375,7 +5579,7 @@ var Civet = (() => {
|
|
|
5375
5579
|
return Loop$0(state);
|
|
5376
5580
|
}
|
|
5377
5581
|
}
|
|
5378
|
-
var New$0 = $TV($EXPECT($
|
|
5582
|
+
var New$0 = $TV($EXPECT($L116, fail, 'New "new"'), function($skip, $loc, $0, $1) {
|
|
5379
5583
|
return { $loc, token: $1 };
|
|
5380
5584
|
});
|
|
5381
5585
|
function New(state) {
|
|
@@ -5387,7 +5591,7 @@ var Civet = (() => {
|
|
|
5387
5591
|
return New$0(state);
|
|
5388
5592
|
}
|
|
5389
5593
|
}
|
|
5390
|
-
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($
|
|
5594
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L71, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L112, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
5391
5595
|
return { $loc, token: "!" };
|
|
5392
5596
|
});
|
|
5393
5597
|
function Not(state) {
|
|
@@ -5399,7 +5603,7 @@ var Civet = (() => {
|
|
|
5399
5603
|
return Not$0(state);
|
|
5400
5604
|
}
|
|
5401
5605
|
}
|
|
5402
|
-
var Of$0 = $TV($EXPECT($
|
|
5606
|
+
var Of$0 = $TV($EXPECT($L64, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
5403
5607
|
return { $loc, token: $1 };
|
|
5404
5608
|
});
|
|
5405
5609
|
function Of(state) {
|
|
@@ -5411,7 +5615,7 @@ var Civet = (() => {
|
|
|
5411
5615
|
return Of$0(state);
|
|
5412
5616
|
}
|
|
5413
5617
|
}
|
|
5414
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
5618
|
+
var OpenBrace$0 = $TV($EXPECT($L117, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
5415
5619
|
return { $loc, token: $1 };
|
|
5416
5620
|
});
|
|
5417
5621
|
function OpenBrace(state) {
|
|
@@ -5423,7 +5627,7 @@ var Civet = (() => {
|
|
|
5423
5627
|
return OpenBrace$0(state);
|
|
5424
5628
|
}
|
|
5425
5629
|
}
|
|
5426
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
5630
|
+
var OpenBracket$0 = $TV($EXPECT($L118, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
5427
5631
|
return { $loc, token: $1 };
|
|
5428
5632
|
});
|
|
5429
5633
|
function OpenBracket(state) {
|
|
@@ -5435,7 +5639,7 @@ var Civet = (() => {
|
|
|
5435
5639
|
return OpenBracket$0(state);
|
|
5436
5640
|
}
|
|
5437
5641
|
}
|
|
5438
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
5642
|
+
var OpenParen$0 = $TV($EXPECT($L119, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
5439
5643
|
return { $loc, token: $1 };
|
|
5440
5644
|
});
|
|
5441
5645
|
function OpenParen(state) {
|
|
@@ -5447,7 +5651,7 @@ var Civet = (() => {
|
|
|
5447
5651
|
return OpenParen$0(state);
|
|
5448
5652
|
}
|
|
5449
5653
|
}
|
|
5450
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
5654
|
+
var QuestionMark$0 = $TV($EXPECT($L68, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
5451
5655
|
return { $loc, token: $1 };
|
|
5452
5656
|
});
|
|
5453
5657
|
function QuestionMark(state) {
|
|
@@ -5459,7 +5663,7 @@ var Civet = (() => {
|
|
|
5459
5663
|
return QuestionMark$0(state);
|
|
5460
5664
|
}
|
|
5461
5665
|
}
|
|
5462
|
-
var Return$0 = $TS($S($EXPECT($
|
|
5666
|
+
var Return$0 = $TS($S($EXPECT($L120, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5463
5667
|
return { $loc, token: $1 };
|
|
5464
5668
|
});
|
|
5465
5669
|
function Return(state) {
|
|
@@ -5471,7 +5675,7 @@ var Civet = (() => {
|
|
|
5471
5675
|
return Return$0(state);
|
|
5472
5676
|
}
|
|
5473
5677
|
}
|
|
5474
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
5678
|
+
var Semicolon$0 = $TV($EXPECT($L75, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
5475
5679
|
return { $loc, token: $1 };
|
|
5476
5680
|
});
|
|
5477
5681
|
function Semicolon(state) {
|
|
@@ -5483,7 +5687,7 @@ var Civet = (() => {
|
|
|
5483
5687
|
return Semicolon$0(state);
|
|
5484
5688
|
}
|
|
5485
5689
|
}
|
|
5486
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
5690
|
+
var SingleQuote$0 = $TV($EXPECT($L121, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
5487
5691
|
return { $loc, token: $1 };
|
|
5488
5692
|
});
|
|
5489
5693
|
function SingleQuote(state) {
|
|
@@ -5495,7 +5699,7 @@ var Civet = (() => {
|
|
|
5495
5699
|
return SingleQuote$0(state);
|
|
5496
5700
|
}
|
|
5497
5701
|
}
|
|
5498
|
-
var Star$0 = $TV($EXPECT($
|
|
5702
|
+
var Star$0 = $TV($EXPECT($L45, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
5499
5703
|
return { $loc, token: $1 };
|
|
5500
5704
|
});
|
|
5501
5705
|
function Star(state) {
|
|
@@ -5507,10 +5711,10 @@ var Civet = (() => {
|
|
|
5507
5711
|
return Star$0(state);
|
|
5508
5712
|
}
|
|
5509
5713
|
}
|
|
5510
|
-
var Static$0 = $TV($EXPECT($
|
|
5714
|
+
var Static$0 = $TV($EXPECT($L122, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
5511
5715
|
return { $loc, token: $1 };
|
|
5512
5716
|
});
|
|
5513
|
-
var Static$1 = $TS($S($EXPECT($
|
|
5717
|
+
var Static$1 = $TS($S($EXPECT($L89, fail, 'Static "@"'), $N($EXPECT($L119, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
|
|
5514
5718
|
return { $loc, token: "static " };
|
|
5515
5719
|
});
|
|
5516
5720
|
function Static(state) {
|
|
@@ -5520,7 +5724,7 @@ var Civet = (() => {
|
|
|
5520
5724
|
return Static$0(state) || Static$1(state);
|
|
5521
5725
|
}
|
|
5522
5726
|
}
|
|
5523
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
5727
|
+
var SubstitutionStart$0 = $TV($EXPECT($L123, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
5524
5728
|
return { $loc, token: $1 };
|
|
5525
5729
|
});
|
|
5526
5730
|
function SubstitutionStart(state) {
|
|
@@ -5532,7 +5736,7 @@ var Civet = (() => {
|
|
|
5532
5736
|
return SubstitutionStart$0(state);
|
|
5533
5737
|
}
|
|
5534
5738
|
}
|
|
5535
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
5739
|
+
var Switch$0 = $TS($S($EXPECT($L124, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5536
5740
|
return { $loc, token: $1 };
|
|
5537
5741
|
});
|
|
5538
5742
|
function Switch(state) {
|
|
@@ -5544,7 +5748,7 @@ var Civet = (() => {
|
|
|
5544
5748
|
return Switch$0(state);
|
|
5545
5749
|
}
|
|
5546
5750
|
}
|
|
5547
|
-
var Target$0 = $TV($EXPECT($
|
|
5751
|
+
var Target$0 = $TV($EXPECT($L125, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
|
|
5548
5752
|
return { $loc, token: $1 };
|
|
5549
5753
|
});
|
|
5550
5754
|
function Target(state) {
|
|
@@ -5556,7 +5760,7 @@ var Civet = (() => {
|
|
|
5556
5760
|
return Target$0(state);
|
|
5557
5761
|
}
|
|
5558
5762
|
}
|
|
5559
|
-
var Then$0 = $TS($S(__, $EXPECT($
|
|
5763
|
+
var Then$0 = $TS($S(__, $EXPECT($L126, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
5560
5764
|
return { $loc, token: "" };
|
|
5561
5765
|
});
|
|
5562
5766
|
function Then(state) {
|
|
@@ -5568,7 +5772,7 @@ var Civet = (() => {
|
|
|
5568
5772
|
return Then$0(state);
|
|
5569
5773
|
}
|
|
5570
5774
|
}
|
|
5571
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
5775
|
+
var Throw$0 = $TS($S($EXPECT($L127, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5572
5776
|
return { $loc, token: $1 };
|
|
5573
5777
|
});
|
|
5574
5778
|
function Throw(state) {
|
|
@@ -5580,7 +5784,7 @@ var Civet = (() => {
|
|
|
5580
5784
|
return Throw$0(state);
|
|
5581
5785
|
}
|
|
5582
5786
|
}
|
|
5583
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
5787
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L128, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
5584
5788
|
return { $loc, token: "`" };
|
|
5585
5789
|
});
|
|
5586
5790
|
function TripleDoubleQuote(state) {
|
|
@@ -5592,7 +5796,7 @@ var Civet = (() => {
|
|
|
5592
5796
|
return TripleDoubleQuote$0(state);
|
|
5593
5797
|
}
|
|
5594
5798
|
}
|
|
5595
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
5799
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L129, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
5596
5800
|
return { $loc, token: "`" };
|
|
5597
5801
|
});
|
|
5598
5802
|
function TripleSingleQuote(state) {
|
|
@@ -5604,7 +5808,7 @@ var Civet = (() => {
|
|
|
5604
5808
|
return TripleSingleQuote$0(state);
|
|
5605
5809
|
}
|
|
5606
5810
|
}
|
|
5607
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
5811
|
+
var TripleTick$0 = $TV($EXPECT($L130, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
5608
5812
|
return { $loc, token: "`" };
|
|
5609
5813
|
});
|
|
5610
5814
|
function TripleTick(state) {
|
|
@@ -5616,7 +5820,7 @@ var Civet = (() => {
|
|
|
5616
5820
|
return TripleTick$0(state);
|
|
5617
5821
|
}
|
|
5618
5822
|
}
|
|
5619
|
-
var Try$0 = $TV($EXPECT($
|
|
5823
|
+
var Try$0 = $TV($EXPECT($L131, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
5620
5824
|
return { $loc, token: $1 };
|
|
5621
5825
|
});
|
|
5622
5826
|
function Try(state) {
|
|
@@ -5628,7 +5832,7 @@ var Civet = (() => {
|
|
|
5628
5832
|
return Try$0(state);
|
|
5629
5833
|
}
|
|
5630
5834
|
}
|
|
5631
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
5835
|
+
var Typeof$0 = $TS($S($EXPECT($L132, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5632
5836
|
return { $loc, token: $1 };
|
|
5633
5837
|
});
|
|
5634
5838
|
function Typeof(state) {
|
|
@@ -5640,7 +5844,7 @@ var Civet = (() => {
|
|
|
5640
5844
|
return Typeof$0(state);
|
|
5641
5845
|
}
|
|
5642
5846
|
}
|
|
5643
|
-
var Unless$0 = $TV($EXPECT($
|
|
5847
|
+
var Unless$0 = $TV($EXPECT($L133, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
5644
5848
|
return { $loc, token: $1 };
|
|
5645
5849
|
});
|
|
5646
5850
|
function Unless(state) {
|
|
@@ -5652,7 +5856,7 @@ var Civet = (() => {
|
|
|
5652
5856
|
return Unless$0(state);
|
|
5653
5857
|
}
|
|
5654
5858
|
}
|
|
5655
|
-
var Until$0 = $TS($S($EXPECT($
|
|
5859
|
+
var Until$0 = $TS($S($EXPECT($L134, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5656
5860
|
return { $loc, token: $1 };
|
|
5657
5861
|
});
|
|
5658
5862
|
function Until(state) {
|
|
@@ -5664,7 +5868,7 @@ var Civet = (() => {
|
|
|
5664
5868
|
return Until$0(state);
|
|
5665
5869
|
}
|
|
5666
5870
|
}
|
|
5667
|
-
var Var$0 = $TV($EXPECT($
|
|
5871
|
+
var Var$0 = $TV($EXPECT($L135, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
5668
5872
|
return { $loc, token: $1 };
|
|
5669
5873
|
});
|
|
5670
5874
|
function Var(state) {
|
|
@@ -5676,7 +5880,7 @@ var Civet = (() => {
|
|
|
5676
5880
|
return Var$0(state);
|
|
5677
5881
|
}
|
|
5678
5882
|
}
|
|
5679
|
-
var Void$0 = $TS($S($EXPECT($
|
|
5883
|
+
var Void$0 = $TS($S($EXPECT($L136, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5680
5884
|
return { $loc, token: $1 };
|
|
5681
5885
|
});
|
|
5682
5886
|
function Void(state) {
|
|
@@ -5688,7 +5892,7 @@ var Civet = (() => {
|
|
|
5688
5892
|
return Void$0(state);
|
|
5689
5893
|
}
|
|
5690
5894
|
}
|
|
5691
|
-
var When$0 = $TS($S($EXPECT($
|
|
5895
|
+
var When$0 = $TS($S($EXPECT($L137, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5692
5896
|
return { $loc, token: "case" };
|
|
5693
5897
|
});
|
|
5694
5898
|
function When(state) {
|
|
@@ -5700,7 +5904,7 @@ var Civet = (() => {
|
|
|
5700
5904
|
return When$0(state);
|
|
5701
5905
|
}
|
|
5702
5906
|
}
|
|
5703
|
-
var While$0 = $TS($S($EXPECT($
|
|
5907
|
+
var While$0 = $TS($S($EXPECT($L138, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5704
5908
|
return { $loc, token: $1 };
|
|
5705
5909
|
});
|
|
5706
5910
|
function While(state) {
|
|
@@ -5712,7 +5916,7 @@ var Civet = (() => {
|
|
|
5712
5916
|
return While$0(state);
|
|
5713
5917
|
}
|
|
5714
5918
|
}
|
|
5715
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
5919
|
+
var Yield$0 = $TS($S($EXPECT($L139, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
5716
5920
|
return { $loc, token: $1 };
|
|
5717
5921
|
});
|
|
5718
5922
|
function Yield(state) {
|
|
@@ -5738,7 +5942,7 @@ var Civet = (() => {
|
|
|
5738
5942
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
5739
5943
|
}
|
|
5740
5944
|
}
|
|
5741
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
5945
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L140, fail, 'JSXSelfClosingElement "/>"'));
|
|
5742
5946
|
function JSXSelfClosingElement(state) {
|
|
5743
5947
|
if (state.verbose)
|
|
5744
5948
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -5748,7 +5952,7 @@ var Civet = (() => {
|
|
|
5748
5952
|
return JSXSelfClosingElement$0(state);
|
|
5749
5953
|
}
|
|
5750
5954
|
}
|
|
5751
|
-
var JSXOpeningElement$0 = $S($EXPECT($L4, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
5955
|
+
var JSXOpeningElement$0 = $S($EXPECT($L4, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L55, fail, 'JSXOpeningElement ">"'));
|
|
5752
5956
|
function JSXOpeningElement(state) {
|
|
5753
5957
|
if (state.verbose)
|
|
5754
5958
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -5758,7 +5962,7 @@ var Civet = (() => {
|
|
|
5758
5962
|
return JSXOpeningElement$0(state);
|
|
5759
5963
|
}
|
|
5760
5964
|
}
|
|
5761
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
5965
|
+
var JSXClosingElement$0 = $S($EXPECT($L141, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L55, fail, 'JSXClosingElement ">"'));
|
|
5762
5966
|
function JSXClosingElement(state) {
|
|
5763
5967
|
if (state.verbose)
|
|
5764
5968
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -5768,7 +5972,7 @@ var Civet = (() => {
|
|
|
5768
5972
|
return JSXClosingElement$0(state);
|
|
5769
5973
|
}
|
|
5770
5974
|
}
|
|
5771
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
5975
|
+
var JSXFragment$0 = $S($EXPECT($L142, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L143, fail, 'JSXFragment "</>"'));
|
|
5772
5976
|
function JSXFragment(state) {
|
|
5773
5977
|
if (state.verbose)
|
|
5774
5978
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -5902,7 +6106,7 @@ var Civet = (() => {
|
|
|
5902
6106
|
return TypeDeclaration$0(state);
|
|
5903
6107
|
}
|
|
5904
6108
|
}
|
|
5905
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
6109
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L144, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
5906
6110
|
var TypeDeclarationModifier$1 = Export;
|
|
5907
6111
|
function TypeDeclarationModifier(state) {
|
|
5908
6112
|
if (state.tokenize) {
|
|
@@ -5922,7 +6126,7 @@ var Civet = (() => {
|
|
|
5922
6126
|
return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state);
|
|
5923
6127
|
}
|
|
5924
6128
|
}
|
|
5925
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
6129
|
+
var TypeKeyword$0 = $S($EXPECT($L145, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
5926
6130
|
function TypeKeyword(state) {
|
|
5927
6131
|
if (state.verbose)
|
|
5928
6132
|
console.log("ENTER:", "TypeKeyword");
|
|
@@ -5932,7 +6136,7 @@ var Civet = (() => {
|
|
|
5932
6136
|
return TypeKeyword$0(state);
|
|
5933
6137
|
}
|
|
5934
6138
|
}
|
|
5935
|
-
var Interface$0 = $S($EXPECT($
|
|
6139
|
+
var Interface$0 = $S($EXPECT($L146, fail, 'Interface "interface"'), NonIdContinue);
|
|
5936
6140
|
function Interface(state) {
|
|
5937
6141
|
if (state.verbose)
|
|
5938
6142
|
console.log("ENTER:", "Interface");
|
|
@@ -5942,7 +6146,7 @@ var Civet = (() => {
|
|
|
5942
6146
|
return Interface$0(state);
|
|
5943
6147
|
}
|
|
5944
6148
|
}
|
|
5945
|
-
var Namespace$0 = $S($EXPECT($
|
|
6149
|
+
var Namespace$0 = $S($EXPECT($L147, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
5946
6150
|
function Namespace(state) {
|
|
5947
6151
|
if (state.verbose)
|
|
5948
6152
|
console.log("ENTER:", "Namespace");
|
|
@@ -6042,7 +6246,7 @@ var Civet = (() => {
|
|
|
6042
6246
|
return NestedTypeDeclaration$0(state);
|
|
6043
6247
|
}
|
|
6044
6248
|
}
|
|
6045
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R41, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($
|
|
6249
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R41, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L148, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R42, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
6046
6250
|
function TypeIndexSignature(state) {
|
|
6047
6251
|
if (state.verbose)
|
|
6048
6252
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -6073,7 +6277,7 @@ var Civet = (() => {
|
|
|
6073
6277
|
return TypeSuffix$0(state);
|
|
6074
6278
|
}
|
|
6075
6279
|
}
|
|
6076
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
6280
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L149, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
6077
6281
|
if (!$3)
|
|
6078
6282
|
$0.splice(2, 1);
|
|
6079
6283
|
if ($1.length === 0)
|
|
@@ -6093,7 +6297,7 @@ var Civet = (() => {
|
|
|
6093
6297
|
return ReturnTypeSuffix$0(state);
|
|
6094
6298
|
}
|
|
6095
6299
|
}
|
|
6096
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
6300
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L59, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
6097
6301
|
if (!$2)
|
|
6098
6302
|
return $1;
|
|
6099
6303
|
return $0;
|
|
@@ -6156,9 +6360,9 @@ var Civet = (() => {
|
|
|
6156
6360
|
return TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state);
|
|
6157
6361
|
}
|
|
6158
6362
|
}
|
|
6159
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
6160
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
6161
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
6363
|
+
var TypeUnaryOp$0 = $EXPECT($L150, fail, 'TypeUnaryOp "keyof"');
|
|
6364
|
+
var TypeUnaryOp$1 = $EXPECT($L132, fail, 'TypeUnaryOp "typeof"');
|
|
6365
|
+
var TypeUnaryOp$2 = $EXPECT($L151, fail, 'TypeUnaryOp "infer"');
|
|
6162
6366
|
function TypeUnaryOp(state) {
|
|
6163
6367
|
if (state.tokenize) {
|
|
6164
6368
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -6248,10 +6452,10 @@ var Civet = (() => {
|
|
|
6248
6452
|
}
|
|
6249
6453
|
}
|
|
6250
6454
|
var TypeLiteral$0 = Literal;
|
|
6251
|
-
var TypeLiteral$1 = $TV($EXPECT($
|
|
6455
|
+
var TypeLiteral$1 = $TV($EXPECT($L136, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
|
|
6252
6456
|
return { $loc, token: "void" };
|
|
6253
6457
|
});
|
|
6254
|
-
var TypeLiteral$2 = $TV($EXPECT($
|
|
6458
|
+
var TypeLiteral$2 = $TV($EXPECT($L152, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
6255
6459
|
return { $loc, token: "[]" };
|
|
6256
6460
|
});
|
|
6257
6461
|
function TypeLiteral(state) {
|
|
@@ -6261,10 +6465,10 @@ var Civet = (() => {
|
|
|
6261
6465
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
6262
6466
|
}
|
|
6263
6467
|
}
|
|
6264
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
6468
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L74, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
6265
6469
|
return { $loc, token: "|" };
|
|
6266
6470
|
});
|
|
6267
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
6471
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L72, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
6268
6472
|
return { $loc, token: "&" };
|
|
6269
6473
|
});
|
|
6270
6474
|
function TypeBinaryOp(state) {
|
|
@@ -6284,7 +6488,7 @@ var Civet = (() => {
|
|
|
6284
6488
|
return FunctionType$0(state);
|
|
6285
6489
|
}
|
|
6286
6490
|
}
|
|
6287
|
-
var TypeArguments$0 = $S(__, $EXPECT($L4, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
6491
|
+
var TypeArguments$0 = $S(__, $EXPECT($L4, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L55, fail, 'TypeArguments ">"'));
|
|
6288
6492
|
function TypeArguments(state) {
|
|
6289
6493
|
if (state.verbose)
|
|
6290
6494
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -6294,7 +6498,7 @@ var Civet = (() => {
|
|
|
6294
6498
|
return TypeArguments$0(state);
|
|
6295
6499
|
}
|
|
6296
6500
|
}
|
|
6297
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($L4, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
6501
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L4, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L55, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
6298
6502
|
return { ts: true, children: $0 };
|
|
6299
6503
|
});
|
|
6300
6504
|
function TypeParameters(state) {
|
|
@@ -6327,8 +6531,8 @@ var Civet = (() => {
|
|
|
6327
6531
|
}
|
|
6328
6532
|
}
|
|
6329
6533
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
6330
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
6331
|
-
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($
|
|
6534
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L55, fail, 'TypeParameterDelimiter ">"')));
|
|
6535
|
+
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L55, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
|
|
6332
6536
|
return { $loc, token: "," };
|
|
6333
6537
|
});
|
|
6334
6538
|
var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
@@ -6366,7 +6570,7 @@ var Civet = (() => {
|
|
|
6366
6570
|
return CivetPrologue$0(state) || CivetPrologue$1(state);
|
|
6367
6571
|
}
|
|
6368
6572
|
}
|
|
6369
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
6573
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L153, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R45, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
6370
6574
|
var options = $2;
|
|
6371
6575
|
return {
|
|
6372
6576
|
type: "CivetPrologue",
|
|
@@ -6586,6 +6790,20 @@ var Civet = (() => {
|
|
|
6586
6790
|
return InsertBreak$0(state);
|
|
6587
6791
|
}
|
|
6588
6792
|
}
|
|
6793
|
+
var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6794
|
+
if (module.config.coffeeBinaryExistential)
|
|
6795
|
+
return;
|
|
6796
|
+
return $skip;
|
|
6797
|
+
});
|
|
6798
|
+
function CoffeeBinaryExistentialEnabled(state) {
|
|
6799
|
+
if (state.verbose)
|
|
6800
|
+
console.log("ENTER:", "CoffeeBinaryExistentialEnabled");
|
|
6801
|
+
if (state.tokenize) {
|
|
6802
|
+
return $TOKEN("CoffeeBinaryExistentialEnabled", state, CoffeeBinaryExistentialEnabled$0(state));
|
|
6803
|
+
} else {
|
|
6804
|
+
return CoffeeBinaryExistentialEnabled$0(state);
|
|
6805
|
+
}
|
|
6806
|
+
}
|
|
6589
6807
|
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6590
6808
|
if (module.config.coffeeBooleans)
|
|
6591
6809
|
return;
|
|
@@ -6600,6 +6818,20 @@ var Civet = (() => {
|
|
|
6600
6818
|
return CoffeeBooleansEnabled$0(state);
|
|
6601
6819
|
}
|
|
6602
6820
|
}
|
|
6821
|
+
var CoffeeClassesEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6822
|
+
if (module.config.coffeeClasses)
|
|
6823
|
+
return;
|
|
6824
|
+
return $skip;
|
|
6825
|
+
});
|
|
6826
|
+
function CoffeeClassesEnabled(state) {
|
|
6827
|
+
if (state.verbose)
|
|
6828
|
+
console.log("ENTER:", "CoffeeClassesEnabled");
|
|
6829
|
+
if (state.tokenize) {
|
|
6830
|
+
return $TOKEN("CoffeeClassesEnabled", state, CoffeeClassesEnabled$0(state));
|
|
6831
|
+
} else {
|
|
6832
|
+
return CoffeeClassesEnabled$0(state);
|
|
6833
|
+
}
|
|
6834
|
+
}
|
|
6603
6835
|
var CoffeeCommentEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6604
6836
|
if (module.config.coffeeComment)
|
|
6605
6837
|
return;
|
|
@@ -6670,6 +6902,20 @@ var Civet = (() => {
|
|
|
6670
6902
|
return CoffeeIsntEnabled$0(state);
|
|
6671
6903
|
}
|
|
6672
6904
|
}
|
|
6905
|
+
var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6906
|
+
if (module.config.coffeeLineContinuation)
|
|
6907
|
+
return;
|
|
6908
|
+
return $skip;
|
|
6909
|
+
});
|
|
6910
|
+
function CoffeeLineContinuationEnabled(state) {
|
|
6911
|
+
if (state.verbose)
|
|
6912
|
+
console.log("ENTER:", "CoffeeLineContinuationEnabled");
|
|
6913
|
+
if (state.tokenize) {
|
|
6914
|
+
return $TOKEN("CoffeeLineContinuationEnabled", state, CoffeeLineContinuationEnabled$0(state));
|
|
6915
|
+
} else {
|
|
6916
|
+
return CoffeeLineContinuationEnabled$0(state);
|
|
6917
|
+
}
|
|
6918
|
+
}
|
|
6673
6919
|
var CoffeeNotEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6674
6920
|
if (module.config.coffeeNot)
|
|
6675
6921
|
return;
|
|
@@ -6704,13 +6950,16 @@ var Civet = (() => {
|
|
|
6704
6950
|
module.verbose = false;
|
|
6705
6951
|
module.config = {
|
|
6706
6952
|
autoVar: false,
|
|
6953
|
+
coffeeBinaryExistential: false,
|
|
6707
6954
|
coffeeBooleans: false,
|
|
6955
|
+
coffeeClasses: false,
|
|
6708
6956
|
coffeeComment: false,
|
|
6709
6957
|
coffeeDo: false,
|
|
6710
6958
|
coffeeEq: false,
|
|
6711
6959
|
coffeeForLoops: false,
|
|
6712
6960
|
coffeeInterpolation: false,
|
|
6713
6961
|
coffeeIsnt: false,
|
|
6962
|
+
coffeeLineContinuation: false,
|
|
6714
6963
|
coffeeNot: false,
|
|
6715
6964
|
coffeeOf: false,
|
|
6716
6965
|
implicitReturns: true
|
|
@@ -6757,24 +7006,30 @@ var Civet = (() => {
|
|
|
6757
7006
|
set(b) {
|
|
6758
7007
|
if (b) {
|
|
6759
7008
|
this.autoVar = true;
|
|
7009
|
+
this.coffeeBinaryExistential = true;
|
|
6760
7010
|
this.coffeeBooleans = true;
|
|
7011
|
+
this.coffeeClasses = true;
|
|
6761
7012
|
this.coffeeComment = true;
|
|
6762
7013
|
this.coffeeDo = true;
|
|
6763
7014
|
this.coffeeEq = true;
|
|
6764
7015
|
this.coffeeForLoops = true;
|
|
6765
7016
|
this.coffeeInterpolation = true;
|
|
6766
7017
|
this.coffeeIsnt = true;
|
|
7018
|
+
this.coffeeLineContinuation = true;
|
|
6767
7019
|
this.coffeeNot = true;
|
|
6768
7020
|
this.coffeeOf = true;
|
|
6769
7021
|
} else {
|
|
6770
7022
|
this.autoVar = false;
|
|
7023
|
+
this.coffeeBinaryExistential = false;
|
|
6771
7024
|
this.coffeeBooleans = false;
|
|
7025
|
+
this.coffeeClasses = false;
|
|
6772
7026
|
this.coffeeComment = false;
|
|
6773
7027
|
this.coffeeDo = false;
|
|
6774
7028
|
this.coffeeEq = false;
|
|
6775
7029
|
this.coffeeForLoops = false;
|
|
6776
7030
|
this.coffeeInterpolation = false;
|
|
6777
7031
|
this.coffeeIsnt = false;
|
|
7032
|
+
this.coffeeLineContinuation = false;
|
|
6778
7033
|
this.coffeeNot = false;
|
|
6779
7034
|
this.coffeeOf = false;
|
|
6780
7035
|
}
|
|
@@ -6890,13 +7145,13 @@ var Civet = (() => {
|
|
|
6890
7145
|
let i = 2;
|
|
6891
7146
|
while (i < expandedOps.length) {
|
|
6892
7147
|
const op = expandedOps[i];
|
|
6893
|
-
if (op.
|
|
7148
|
+
if (op.ref) {
|
|
6894
7149
|
const [a, wsOp, op2, wsB, b] = expandedOps.slice(i - 2, i + 3);
|
|
6895
7150
|
module.insertTrimmingSpace(wsOp, "");
|
|
6896
7151
|
module.insertTrimmingSpace(wsB, "");
|
|
6897
7152
|
expandedOps.splice(i - 2, 5, {
|
|
6898
7153
|
type: "Call",
|
|
6899
|
-
children: [wsOp, op2, ".call(", wsB, b, ", ", a, ")
|
|
7154
|
+
children: [wsOp, op2.ref, ".call(", wsB, b, ", ", a, ")", op2.suffix]
|
|
6900
7155
|
});
|
|
6901
7156
|
} else {
|
|
6902
7157
|
i += 4;
|
|
@@ -6914,7 +7169,7 @@ var Civet = (() => {
|
|
|
6914
7169
|
let chains = [];
|
|
6915
7170
|
while (i < l) {
|
|
6916
7171
|
const [, op] = binops[i];
|
|
6917
|
-
if (relationalOps.includes(op.token) || op.
|
|
7172
|
+
if (relationalOps.includes(op.token) || op.ref) {
|
|
6918
7173
|
chains.push(i);
|
|
6919
7174
|
} else if (lowerPrecedenceOps.includes(op.token)) {
|
|
6920
7175
|
processChains();
|
|
@@ -7179,7 +7434,7 @@ var Civet = (() => {
|
|
|
7179
7434
|
return Init$0(state);
|
|
7180
7435
|
}
|
|
7181
7436
|
}
|
|
7182
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
7437
|
+
var Indent$0 = $TV($Q($C($EXPECT($L154, fail, 'Indent " "'), $EXPECT($L155, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
7183
7438
|
const level = $1.length;
|
|
7184
7439
|
return {
|
|
7185
7440
|
$loc,
|