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