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