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