@danielx/civet 0.4.8 → 0.4.10
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 +26 -6
- package/dist/browser.js +756 -448
- package/dist/main.js +756 -448
- package/package.json +1 -1
package/dist/main.js
CHANGED
|
@@ -412,10 +412,10 @@ var require_parser = __commonJS({
|
|
|
412
412
|
ArgumentList,
|
|
413
413
|
NestedArgumentList,
|
|
414
414
|
NestedArgument,
|
|
415
|
+
InlineArgumentExpressions,
|
|
415
416
|
ImplicitApplication,
|
|
416
417
|
ApplicationStart,
|
|
417
418
|
IndentedApplicationAllowed,
|
|
418
|
-
CommaExpression,
|
|
419
419
|
BinaryOpExpression,
|
|
420
420
|
UnaryExpression,
|
|
421
421
|
UnaryPostfix,
|
|
@@ -456,6 +456,7 @@ var require_parser = __commonJS({
|
|
|
456
456
|
MetaProperty,
|
|
457
457
|
Parameters,
|
|
458
458
|
NonEmptyParameters,
|
|
459
|
+
FunctionRestParameter,
|
|
459
460
|
ParameterElement,
|
|
460
461
|
ParameterElementDelimiter,
|
|
461
462
|
BindingIdentifier,
|
|
@@ -471,6 +472,7 @@ var require_parser = __commonJS({
|
|
|
471
472
|
BindingElement,
|
|
472
473
|
BindingRestElement,
|
|
473
474
|
FunctionDeclaration,
|
|
475
|
+
FunctionSignature,
|
|
474
476
|
FunctionExpression,
|
|
475
477
|
ThinArrowFunction,
|
|
476
478
|
Arrow,
|
|
@@ -484,6 +486,7 @@ var require_parser = __commonJS({
|
|
|
484
486
|
Literal,
|
|
485
487
|
NullLiteral,
|
|
486
488
|
BooleanLiteral,
|
|
489
|
+
CoffeeScriptBooleanLiteral,
|
|
487
490
|
Comma,
|
|
488
491
|
Identifier,
|
|
489
492
|
IdentifierName,
|
|
@@ -578,6 +581,7 @@ var require_parser = __commonJS({
|
|
|
578
581
|
NumericLiteralKind,
|
|
579
582
|
DecimalBigIntegerLiteral,
|
|
580
583
|
DecimalLiteral,
|
|
584
|
+
ExponentPart,
|
|
581
585
|
BinaryIntegerLiteral,
|
|
582
586
|
OctalIntegerLiteral,
|
|
583
587
|
HexLiteral,
|
|
@@ -588,9 +592,8 @@ var require_parser = __commonJS({
|
|
|
588
592
|
TripleDoubleStringCharacters,
|
|
589
593
|
TripleSingleStringCharacters,
|
|
590
594
|
CoffeeStringSubstitution,
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
CoffeeCompatDoubleQuotedStringCharacters,
|
|
595
|
+
CoffeeInterpolatedDoubleQuotedString,
|
|
596
|
+
CoffeeDoubleQuotedStringCharacters,
|
|
594
597
|
RegularExpressionLiteral,
|
|
595
598
|
RegularExpressionBody,
|
|
596
599
|
RegExpCharacter,
|
|
@@ -630,6 +633,7 @@ var require_parser = __commonJS({
|
|
|
630
633
|
ConstructorShorthand,
|
|
631
634
|
Default,
|
|
632
635
|
Dot,
|
|
636
|
+
DotDotDot,
|
|
633
637
|
DoubleQuote,
|
|
634
638
|
Else,
|
|
635
639
|
Equals,
|
|
@@ -708,6 +712,10 @@ var require_parser = __commonJS({
|
|
|
708
712
|
TypeUnaryOp,
|
|
709
713
|
TypeIndexedAccess,
|
|
710
714
|
TypePrimary,
|
|
715
|
+
TypeTuple,
|
|
716
|
+
TypeList,
|
|
717
|
+
NestedTypeList,
|
|
718
|
+
NestedType,
|
|
711
719
|
TypeConditional,
|
|
712
720
|
TypeLiteral,
|
|
713
721
|
TypeBinaryOp,
|
|
@@ -718,6 +726,10 @@ var require_parser = __commonJS({
|
|
|
718
726
|
TypeConstraint,
|
|
719
727
|
TypeParameterDelimiter,
|
|
720
728
|
Shebang,
|
|
729
|
+
CivetPrologue,
|
|
730
|
+
CivetPrologueContent,
|
|
731
|
+
CivetOption,
|
|
732
|
+
UnknownPrologue,
|
|
721
733
|
DirectivePrologue,
|
|
722
734
|
EOS,
|
|
723
735
|
EOL,
|
|
@@ -734,6 +746,9 @@ var require_parser = __commonJS({
|
|
|
734
746
|
InsertSpace,
|
|
735
747
|
InsertDot,
|
|
736
748
|
InsertBreak,
|
|
749
|
+
CoffeeCommentEnabled,
|
|
750
|
+
CoffeeBooleansEnabled,
|
|
751
|
+
CoffeeInterpolationEnabled,
|
|
737
752
|
Reset,
|
|
738
753
|
Init,
|
|
739
754
|
Indent,
|
|
@@ -761,170 +776,181 @@ var require_parser = __commonJS({
|
|
|
761
776
|
var $L14 = $L("super[");
|
|
762
777
|
var $L15 = $L("import.meta");
|
|
763
778
|
var $L16 = $L(")");
|
|
764
|
-
var $L17 = $L("
|
|
765
|
-
var $L18 = $L("
|
|
766
|
-
var $L19 = $L("
|
|
767
|
-
var $L20 = $L("
|
|
768
|
-
var $L21 = $L("
|
|
769
|
-
var $L22 = $L("
|
|
770
|
-
var $L23 = $L("
|
|
771
|
-
var $L24 = $L("
|
|
772
|
-
var $L25 = $L("
|
|
773
|
-
var $L26 = $L("
|
|
774
|
-
var $L27 = $L("
|
|
775
|
-
var $L28 = $L("
|
|
776
|
-
var $L29 = $L("
|
|
777
|
-
var $L30 = $L("
|
|
778
|
-
var $L31 = $L("
|
|
779
|
-
var $L32 = $L("
|
|
780
|
-
var $L33 = $L("
|
|
781
|
-
var $L34 = $L("
|
|
782
|
-
var $L35 = $L("
|
|
783
|
-
var $L36 = $L("
|
|
784
|
-
var $L37 = $L("
|
|
785
|
-
var $L38 = $L("
|
|
786
|
-
var $L39 = $L("
|
|
787
|
-
var $L40 = $L("
|
|
788
|
-
var $L41 = $L("
|
|
789
|
-
var $L42 = $L("
|
|
790
|
-
var $L43 = $L("
|
|
791
|
-
var $L44 = $L("
|
|
792
|
-
var $L45 = $L("
|
|
793
|
-
var $L46 = $L("
|
|
794
|
-
var $L47 = $L("
|
|
795
|
-
var $L48 = $L("
|
|
796
|
-
var $L49 = $L("
|
|
797
|
-
var $L50 = $L("
|
|
798
|
-
var $L51 = $L("
|
|
799
|
-
var $L52 = $L("
|
|
800
|
-
var $L53 = $L("
|
|
801
|
-
var $L54 = $L("
|
|
802
|
-
var $L55 = $L("
|
|
803
|
-
var $L56 = $L("
|
|
804
|
-
var $L57 = $L("
|
|
805
|
-
var $L58 = $L("
|
|
806
|
-
var $L59 = $L("
|
|
807
|
-
var $L60 = $L("
|
|
808
|
-
var $L61 = $L("
|
|
809
|
-
var $L62 = $L("
|
|
810
|
-
var $L63 = $L("
|
|
811
|
-
var $L64 = $L("
|
|
812
|
-
var $L65 = $L("
|
|
813
|
-
var $L66 = $L("
|
|
814
|
-
var $L67 = $L("
|
|
815
|
-
var $L68 = $L("
|
|
816
|
-
var $L69 = $L("
|
|
817
|
-
var $L70 = $L("
|
|
818
|
-
var $L71 = $L("
|
|
819
|
-
var $L72 = $L("
|
|
820
|
-
var $L73 = $L("
|
|
821
|
-
var $L74 = $L("
|
|
822
|
-
var $L75 = $L("
|
|
823
|
-
var $L76 = $L("
|
|
824
|
-
var $L77 = $L("
|
|
825
|
-
var $L78 = $L("
|
|
826
|
-
var $L79 = $L("
|
|
827
|
-
var $L80 = $L("
|
|
828
|
-
var $L81 = $L("
|
|
829
|
-
var $L82 = $L("
|
|
830
|
-
var $L83 = $L("
|
|
831
|
-
var $L84 = $L("
|
|
832
|
-
var $L85 = $L("
|
|
833
|
-
var $L86 = $L("
|
|
834
|
-
var $L87 = $L("
|
|
835
|
-
var $L88 = $L("
|
|
836
|
-
var $L89 = $L("
|
|
837
|
-
var $L90 = $L("
|
|
838
|
-
var $L91 = $L("
|
|
839
|
-
var $L92 = $L("
|
|
840
|
-
var $L93 = $L("
|
|
841
|
-
var $L94 = $L("
|
|
842
|
-
var $L95 = $L(
|
|
843
|
-
var $L96 = $L("
|
|
844
|
-
var $L97 = $L("
|
|
845
|
-
var $L98 = $L("
|
|
846
|
-
var $L99 = $L("
|
|
847
|
-
var $L100 = $L("
|
|
848
|
-
var $L101 = $L("
|
|
849
|
-
var $L102 = $L("
|
|
850
|
-
var $L103 = $L("
|
|
851
|
-
var $L104 = $L("
|
|
852
|
-
var $L105 = $L("
|
|
853
|
-
var $L106 = $L("
|
|
854
|
-
var $L107 = $L("
|
|
855
|
-
var $L108 = $L("
|
|
856
|
-
var $L109 = $L("
|
|
857
|
-
var $L110 = $L("
|
|
858
|
-
var $L111 = $L("
|
|
859
|
-
var $L112 = $L("
|
|
860
|
-
var $L113 = $L("
|
|
861
|
-
var $L114 = $L("
|
|
862
|
-
var $L115 = $L("
|
|
863
|
-
var $L116 = $L("
|
|
864
|
-
var $L117 = $L("
|
|
865
|
-
var $L118 = $L("
|
|
866
|
-
var $L119 = $L("
|
|
867
|
-
var $L120 = $L(
|
|
868
|
-
var $L121 = $L("
|
|
869
|
-
var $L122 = $L("
|
|
870
|
-
var $L123 = $L("
|
|
871
|
-
var $L124 = $L("
|
|
872
|
-
var $L125 = $L("
|
|
873
|
-
var $L126 = $L("
|
|
874
|
-
var $L127 = $L("
|
|
875
|
-
var $L128 = $L("
|
|
876
|
-
var $L129 = $L("
|
|
877
|
-
var $L130 = $L("
|
|
878
|
-
var $L131 = $L("
|
|
879
|
-
var $L132 = $L("
|
|
880
|
-
var $L133 = $L("
|
|
881
|
-
var $L134 = $L("
|
|
882
|
-
var $L135 = $L("
|
|
883
|
-
var $L136 = $L("
|
|
884
|
-
var $L137 = $L("
|
|
885
|
-
var $L138 = $L("
|
|
886
|
-
var $L139 = $L("
|
|
887
|
-
var $L140 = $L("
|
|
888
|
-
var $L141 = $L("
|
|
889
|
-
var $L142 = $L("
|
|
779
|
+
var $L17 = $L("->");
|
|
780
|
+
var $L18 = $L("null");
|
|
781
|
+
var $L19 = $L("true");
|
|
782
|
+
var $L20 = $L("false");
|
|
783
|
+
var $L21 = $L("yes");
|
|
784
|
+
var $L22 = $L("on");
|
|
785
|
+
var $L23 = $L("no");
|
|
786
|
+
var $L24 = $L("off");
|
|
787
|
+
var $L25 = $L(",");
|
|
788
|
+
var $L26 = $L("]");
|
|
789
|
+
var $L27 = $L("}");
|
|
790
|
+
var $L28 = $L("**=");
|
|
791
|
+
var $L29 = $L("*=");
|
|
792
|
+
var $L30 = $L("/=");
|
|
793
|
+
var $L31 = $L("%=");
|
|
794
|
+
var $L32 = $L("+=");
|
|
795
|
+
var $L33 = $L("-=");
|
|
796
|
+
var $L34 = $L("<<=");
|
|
797
|
+
var $L35 = $L(">>>=");
|
|
798
|
+
var $L36 = $L(">>=");
|
|
799
|
+
var $L37 = $L("&&=");
|
|
800
|
+
var $L38 = $L("&=");
|
|
801
|
+
var $L39 = $L("^=");
|
|
802
|
+
var $L40 = $L("||=");
|
|
803
|
+
var $L41 = $L("|=");
|
|
804
|
+
var $L42 = $L("??=");
|
|
805
|
+
var $L43 = $L("?=");
|
|
806
|
+
var $L44 = $L("=");
|
|
807
|
+
var $L45 = $L("**");
|
|
808
|
+
var $L46 = $L("*");
|
|
809
|
+
var $L47 = $L("/");
|
|
810
|
+
var $L48 = $L("%");
|
|
811
|
+
var $L49 = $L("+");
|
|
812
|
+
var $L50 = $L("-");
|
|
813
|
+
var $L51 = $L("<=");
|
|
814
|
+
var $L52 = $L(">=");
|
|
815
|
+
var $L53 = $L("<<");
|
|
816
|
+
var $L54 = $L(">>>");
|
|
817
|
+
var $L55 = $L(">>");
|
|
818
|
+
var $L56 = $L(">");
|
|
819
|
+
var $L57 = $L("!==");
|
|
820
|
+
var $L58 = $L("!=");
|
|
821
|
+
var $L59 = $L("is");
|
|
822
|
+
var $L60 = $L("===");
|
|
823
|
+
var $L61 = $L("==");
|
|
824
|
+
var $L62 = $L("and");
|
|
825
|
+
var $L63 = $L("&&");
|
|
826
|
+
var $L64 = $L("or");
|
|
827
|
+
var $L65 = $L("||");
|
|
828
|
+
var $L66 = $L("??");
|
|
829
|
+
var $L67 = $L("instanceof");
|
|
830
|
+
var $L68 = $L("in");
|
|
831
|
+
var $L69 = $L("&");
|
|
832
|
+
var $L70 = $L("^");
|
|
833
|
+
var $L71 = $L("|");
|
|
834
|
+
var $L72 = $L("delete");
|
|
835
|
+
var $L73 = $L("void");
|
|
836
|
+
var $L74 = $L("typeof");
|
|
837
|
+
var $L75 = $L(";");
|
|
838
|
+
var $L76 = $L("do");
|
|
839
|
+
var $L77 = $L("while");
|
|
840
|
+
var $L78 = $L("until");
|
|
841
|
+
var $L79 = $L("finally");
|
|
842
|
+
var $L80 = $L("break");
|
|
843
|
+
var $L81 = $L("continue");
|
|
844
|
+
var $L82 = $L("debugger");
|
|
845
|
+
var $L83 = $L("import type");
|
|
846
|
+
var $L84 = $L("default");
|
|
847
|
+
var $L85 = $L(":=");
|
|
848
|
+
var $L86 = $L("/*");
|
|
849
|
+
var $L87 = $L("*/");
|
|
850
|
+
var $L88 = $L("###");
|
|
851
|
+
var $L89 = $L("as");
|
|
852
|
+
var $L90 = $L("async");
|
|
853
|
+
var $L91 = $L("await");
|
|
854
|
+
var $L92 = $L("case");
|
|
855
|
+
var $L93 = $L("catch");
|
|
856
|
+
var $L94 = $L("class");
|
|
857
|
+
var $L95 = $L("#{");
|
|
858
|
+
var $L96 = $L(":");
|
|
859
|
+
var $L97 = $L(".");
|
|
860
|
+
var $L98 = $L("...");
|
|
861
|
+
var $L99 = $L('"');
|
|
862
|
+
var $L100 = $L("else");
|
|
863
|
+
var $L101 = $L("export");
|
|
864
|
+
var $L102 = $L("for");
|
|
865
|
+
var $L103 = $L("from");
|
|
866
|
+
var $L104 = $L("function");
|
|
867
|
+
var $L105 = $L("get");
|
|
868
|
+
var $L106 = $L("set");
|
|
869
|
+
var $L107 = $L("if");
|
|
870
|
+
var $L108 = $L("let");
|
|
871
|
+
var $L109 = $L("const");
|
|
872
|
+
var $L110 = $L("loop");
|
|
873
|
+
var $L111 = $L("new");
|
|
874
|
+
var $L112 = $L("of");
|
|
875
|
+
var $L113 = $L("{");
|
|
876
|
+
var $L114 = $L("[");
|
|
877
|
+
var $L115 = $L("(");
|
|
878
|
+
var $L116 = $L("?");
|
|
879
|
+
var $L117 = $L("return");
|
|
880
|
+
var $L118 = $L("'");
|
|
881
|
+
var $L119 = $L("static");
|
|
882
|
+
var $L120 = $L("${");
|
|
883
|
+
var $L121 = $L("switch");
|
|
884
|
+
var $L122 = $L("target");
|
|
885
|
+
var $L123 = $L("throw");
|
|
886
|
+
var $L124 = $L('"""');
|
|
887
|
+
var $L125 = $L("'''");
|
|
888
|
+
var $L126 = $L("```");
|
|
889
|
+
var $L127 = $L("try");
|
|
890
|
+
var $L128 = $L("unless");
|
|
891
|
+
var $L129 = $L("var");
|
|
892
|
+
var $L130 = $L("when");
|
|
893
|
+
var $L131 = $L("yield");
|
|
894
|
+
var $L132 = $L("/>");
|
|
895
|
+
var $L133 = $L("</");
|
|
896
|
+
var $L134 = $L("<>");
|
|
897
|
+
var $L135 = $L("</>");
|
|
898
|
+
var $L136 = $L("declare");
|
|
899
|
+
var $L137 = $L("type");
|
|
900
|
+
var $L138 = $L("interface");
|
|
901
|
+
var $L139 = $L("namespace");
|
|
902
|
+
var $L140 = $L("readonly");
|
|
903
|
+
var $L141 = $L("asserts");
|
|
904
|
+
var $L142 = $L("keyof");
|
|
905
|
+
var $L143 = $L("infer");
|
|
906
|
+
var $L144 = $L("[]");
|
|
907
|
+
var $L145 = $L("civet");
|
|
908
|
+
var $L146 = $L(" ");
|
|
909
|
+
var $L147 = $L(" ");
|
|
890
910
|
var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
891
911
|
var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
892
912
|
var $R2 = $R(new RegExp("[!~+-]", "suy"));
|
|
893
913
|
var $R3 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
894
914
|
var $R4 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
895
|
-
var $R5 = $R(new RegExp("
|
|
896
|
-
var $R6 = $R(new RegExp("0[
|
|
897
|
-
var $R7 = $R(new RegExp("
|
|
898
|
-
var $R8 = $R(new RegExp("
|
|
899
|
-
var $R9 = $R(new RegExp(
|
|
900
|
-
var $R10 = $R(new RegExp("(
|
|
901
|
-
var $R11 = $R(new RegExp(
|
|
902
|
-
var $R12 = $R(new RegExp(
|
|
903
|
-
var $R13 = $R(new RegExp(
|
|
904
|
-
var $R14 = $R(new RegExp("[
|
|
905
|
-
var $R15 = $R(new RegExp("(
|
|
906
|
-
var $R16 = $R(new RegExp(
|
|
907
|
-
var $R17 = $R(new RegExp("
|
|
908
|
-
var $R18 = $R(new RegExp("(
|
|
909
|
-
var $R19 = $R(new RegExp("(
|
|
910
|
-
var $R20 = $R(new RegExp("
|
|
911
|
-
var $R21 = $R(new RegExp("
|
|
912
|
-
var $R22 = $R(new RegExp("
|
|
913
|
-
var $R23 = $R(new RegExp("
|
|
914
|
-
var $R24 = $R(new RegExp("[
|
|
915
|
-
var $R25 = $R(new RegExp("
|
|
916
|
-
var $R26 = $R(new RegExp("(
|
|
917
|
-
var $R27 = $R(new RegExp("\\
|
|
918
|
-
var $R28 = $R(new RegExp("
|
|
919
|
-
var $R29 = $R(new RegExp(
|
|
920
|
-
var $R30 = $R(new RegExp("
|
|
921
|
-
var $R31 = $R(new RegExp("
|
|
922
|
-
var $R32 = $R(new RegExp("[
|
|
923
|
-
var $R33 = $R(new RegExp("[
|
|
924
|
-
var $R34 = $R(new RegExp("
|
|
925
|
-
var $R35 = $R(new RegExp("[
|
|
926
|
-
var $R36 = $R(new RegExp("
|
|
927
|
-
var $R37 = $R(new RegExp("
|
|
915
|
+
var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))", "suy"));
|
|
916
|
+
var $R6 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*)?)?", "suy"));
|
|
917
|
+
var $R7 = $R(new RegExp("(?:\\.(?!\\p{ID_Start})[0-9](?:_[0-9]|[0-9])*)", "suy"));
|
|
918
|
+
var $R8 = $R(new RegExp("(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)", "suy"));
|
|
919
|
+
var $R9 = $R(new RegExp("0[bB][01](?:[01]|_[01])*n?", "suy"));
|
|
920
|
+
var $R10 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*n?", "suy"));
|
|
921
|
+
var $R11 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?", "suy"));
|
|
922
|
+
var $R12 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
923
|
+
var $R13 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
924
|
+
var $R14 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
925
|
+
var $R15 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
926
|
+
var $R16 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
927
|
+
var $R17 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
928
|
+
var $R18 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
|
|
929
|
+
var $R19 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
930
|
+
var $R20 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
931
|
+
var $R21 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
932
|
+
var $R22 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
933
|
+
var $R23 = $R(new RegExp("(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
934
|
+
var $R24 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
935
|
+
var $R25 = $R(new RegExp(".", "suy"));
|
|
936
|
+
var $R26 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
937
|
+
var $R27 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
938
|
+
var $R28 = $R(new RegExp("[ \\t]+", "suy"));
|
|
939
|
+
var $R29 = $R(new RegExp("[\\s]+", "suy"));
|
|
940
|
+
var $R30 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
941
|
+
var $R31 = $R(new RegExp("\\s", "suy"));
|
|
942
|
+
var $R32 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
943
|
+
var $R33 = $R(new RegExp('"[^"]*"', "suy"));
|
|
944
|
+
var $R34 = $R(new RegExp("'[^']*'", "suy"));
|
|
945
|
+
var $R35 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
946
|
+
var $R36 = $R(new RegExp("[+-]?", "suy"));
|
|
947
|
+
var $R37 = $R(new RegExp("[+-]", "suy"));
|
|
948
|
+
var $R38 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
949
|
+
var $R39 = $R(new RegExp("[\\t ]*", "suy"));
|
|
950
|
+
var $R40 = $R(new RegExp("[\\s]*", "suy"));
|
|
951
|
+
var $R41 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
|
|
952
|
+
var $R42 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
953
|
+
var $R43 = $R(new RegExp("$", "suy"));
|
|
928
954
|
var Program$0 = $S(Reset, Init, __, $Q(TopLevelStatement), __);
|
|
929
955
|
function Program(state) {
|
|
930
956
|
if (state.verbose)
|
|
@@ -983,7 +1009,7 @@ var require_parser = __commonJS({
|
|
|
983
1009
|
}
|
|
984
1010
|
}
|
|
985
1011
|
var ArgumentList$0 = $S($Y(EOS), NestedArgumentList);
|
|
986
|
-
var ArgumentList$1 =
|
|
1012
|
+
var ArgumentList$1 = InlineArgumentExpressions;
|
|
987
1013
|
function ArgumentList(state) {
|
|
988
1014
|
if (state.tokenize) {
|
|
989
1015
|
return $TOKEN("ArgumentList", state, ArgumentList$0(state) || ArgumentList$1(state));
|
|
@@ -1006,7 +1032,7 @@ var require_parser = __commonJS({
|
|
|
1006
1032
|
return NestedArgumentList$0(state);
|
|
1007
1033
|
}
|
|
1008
1034
|
}
|
|
1009
|
-
var NestedArgument$0 = $S(Nested,
|
|
1035
|
+
var NestedArgument$0 = $S(Nested, InlineArgumentExpressions, ParameterElementDelimiter);
|
|
1010
1036
|
function NestedArgument(state) {
|
|
1011
1037
|
if (state.verbose)
|
|
1012
1038
|
console.log("ENTER:", "NestedArgument");
|
|
@@ -1016,6 +1042,20 @@ var require_parser = __commonJS({
|
|
|
1016
1042
|
return NestedArgument$0(state);
|
|
1017
1043
|
}
|
|
1018
1044
|
}
|
|
1045
|
+
var InlineArgumentExpressions$0 = $TS($S($S($E(DotDotDot), AssignmentExpressionRest), $Q($S(__, Comma, $Q(TrailingComment), $E(DotDotDot), AssignmentExpressionRest))), function($skip, $loc, $0, $1, $2) {
|
|
1046
|
+
if ($2.length == 0)
|
|
1047
|
+
return $1;
|
|
1048
|
+
return $0;
|
|
1049
|
+
});
|
|
1050
|
+
function InlineArgumentExpressions(state) {
|
|
1051
|
+
if (state.verbose)
|
|
1052
|
+
console.log("ENTER:", "InlineArgumentExpressions");
|
|
1053
|
+
if (state.tokenize) {
|
|
1054
|
+
return $TOKEN("InlineArgumentExpressions", state, InlineArgumentExpressions$0(state));
|
|
1055
|
+
} else {
|
|
1056
|
+
return InlineArgumentExpressions$0(state);
|
|
1057
|
+
}
|
|
1058
|
+
}
|
|
1019
1059
|
var ImplicitApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen);
|
|
1020
1060
|
function ImplicitApplication(state) {
|
|
1021
1061
|
if (state.verbose)
|
|
@@ -1054,19 +1094,10 @@ var require_parser = __commonJS({
|
|
|
1054
1094
|
return IndentedApplicationAllowed$0(state);
|
|
1055
1095
|
}
|
|
1056
1096
|
}
|
|
1057
|
-
var CommaExpression$0 = $S(__, Comma, Expression);
|
|
1058
|
-
function CommaExpression(state) {
|
|
1059
|
-
if (state.verbose)
|
|
1060
|
-
console.log("ENTER:", "CommaExpression");
|
|
1061
|
-
if (state.tokenize) {
|
|
1062
|
-
return $TOKEN("CommaExpression", state, CommaExpression$0(state));
|
|
1063
|
-
} else {
|
|
1064
|
-
return CommaExpression$0(state);
|
|
1065
|
-
}
|
|
1066
|
-
}
|
|
1067
1097
|
var BinaryOpExpression$0 = $TS($S(UnaryExpression, $Q($S(__, BinaryOp, __, UnaryExpression))), function($skip, $loc, $0, $1, $2) {
|
|
1068
|
-
if ($2.length)
|
|
1069
|
-
return $0;
|
|
1098
|
+
if ($2.length) {
|
|
1099
|
+
return module2.expandChainedComparisons($0);
|
|
1100
|
+
}
|
|
1070
1101
|
return $1;
|
|
1071
1102
|
});
|
|
1072
1103
|
function BinaryOpExpression(state) {
|
|
@@ -1083,9 +1114,16 @@ var require_parser = __commonJS({
|
|
|
1083
1114
|
var exp = $2;
|
|
1084
1115
|
var post = $3;
|
|
1085
1116
|
if (post?.token === "?") {
|
|
1086
|
-
return ["(", pre,
|
|
1087
|
-
}
|
|
1088
|
-
|
|
1117
|
+
return ["(", pre, "(", exp, ") != null)"];
|
|
1118
|
+
}
|
|
1119
|
+
const result = [pre, exp, post];
|
|
1120
|
+
if (!post)
|
|
1121
|
+
result.pop();
|
|
1122
|
+
if (!pre.length)
|
|
1123
|
+
result.shift();
|
|
1124
|
+
if (result.length === 1)
|
|
1125
|
+
return result[0];
|
|
1126
|
+
return result;
|
|
1089
1127
|
});
|
|
1090
1128
|
function UnaryExpression(state) {
|
|
1091
1129
|
if (state.verbose)
|
|
@@ -1097,7 +1135,7 @@ var require_parser = __commonJS({
|
|
|
1097
1135
|
}
|
|
1098
1136
|
}
|
|
1099
1137
|
var UnaryPostfix$0 = QuestionMark;
|
|
1100
|
-
var UnaryPostfix$1 = $T($S(__, As,
|
|
1138
|
+
var UnaryPostfix$1 = $T($P($S(__, As, Type)), function(value) {
|
|
1101
1139
|
return { "ts": true, "children": value };
|
|
1102
1140
|
});
|
|
1103
1141
|
function UnaryPostfix(state) {
|
|
@@ -1185,7 +1223,7 @@ var require_parser = __commonJS({
|
|
|
1185
1223
|
var expOrBlock = $4;
|
|
1186
1224
|
const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
|
|
1187
1225
|
const isBlock = expOrBlock.type === "BlockStatement";
|
|
1188
|
-
if (module2.implicitReturns && !isVoid && isBlock) {
|
|
1226
|
+
if (module2.config.implicitReturns && !isVoid && isBlock) {
|
|
1189
1227
|
module2.addImplicitReturns(expOrBlock);
|
|
1190
1228
|
}
|
|
1191
1229
|
return {
|
|
@@ -1552,7 +1590,7 @@ var require_parser = __commonJS({
|
|
|
1552
1590
|
return Parameters$0(state) || Parameters$1(state);
|
|
1553
1591
|
}
|
|
1554
1592
|
}
|
|
1555
|
-
var NonEmptyParameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), __, CloseParen);
|
|
1593
|
+
var NonEmptyParameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), $E(FunctionRestParameter), __, CloseParen);
|
|
1556
1594
|
function NonEmptyParameters(state) {
|
|
1557
1595
|
if (state.verbose)
|
|
1558
1596
|
console.log("ENTER:", "NonEmptyParameters");
|
|
@@ -1562,6 +1600,16 @@ var require_parser = __commonJS({
|
|
|
1562
1600
|
return NonEmptyParameters$0(state);
|
|
1563
1601
|
}
|
|
1564
1602
|
}
|
|
1603
|
+
var FunctionRestParameter$0 = $S(__, BindingRestElement, $E(TypeSuffix));
|
|
1604
|
+
function FunctionRestParameter(state) {
|
|
1605
|
+
if (state.verbose)
|
|
1606
|
+
console.log("ENTER:", "FunctionRestParameter");
|
|
1607
|
+
if (state.tokenize) {
|
|
1608
|
+
return $TOKEN("FunctionRestParameter", state, FunctionRestParameter$0(state));
|
|
1609
|
+
} else {
|
|
1610
|
+
return FunctionRestParameter$0(state);
|
|
1611
|
+
}
|
|
1612
|
+
}
|
|
1565
1613
|
var ParameterElement$0 = $S(__, $C(BindingIdentifier, BindingPattern), $E(TypeSuffix), $E(Initializer), ParameterElementDelimiter);
|
|
1566
1614
|
function ParameterElement(state) {
|
|
1567
1615
|
if (state.verbose)
|
|
@@ -1573,18 +1621,15 @@ var require_parser = __commonJS({
|
|
|
1573
1621
|
}
|
|
1574
1622
|
}
|
|
1575
1623
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
1576
|
-
var ParameterElementDelimiter$1 = $Y($S(
|
|
1577
|
-
var ParameterElementDelimiter$2 = $TV($Y(
|
|
1578
|
-
return { $loc, token: "," };
|
|
1579
|
-
});
|
|
1580
|
-
var ParameterElementDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1624
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L16, fail, 'ParameterElementDelimiter ")"')));
|
|
1625
|
+
var ParameterElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1581
1626
|
return { $loc, token: "," };
|
|
1582
1627
|
});
|
|
1583
1628
|
function ParameterElementDelimiter(state) {
|
|
1584
1629
|
if (state.tokenize) {
|
|
1585
|
-
return $TOKEN("ParameterElementDelimiter", state, ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state)
|
|
1630
|
+
return $TOKEN("ParameterElementDelimiter", state, ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state));
|
|
1586
1631
|
} else {
|
|
1587
|
-
return ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state)
|
|
1632
|
+
return ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state);
|
|
1588
1633
|
}
|
|
1589
1634
|
}
|
|
1590
1635
|
var BindingIdentifier$0 = $S(__, Identifier);
|
|
@@ -1661,7 +1706,7 @@ var require_parser = __commonJS({
|
|
|
1661
1706
|
return BindingProperty$0(state) || BindingProperty$1(state);
|
|
1662
1707
|
}
|
|
1663
1708
|
}
|
|
1664
|
-
var BindingRestProperty$0 = $S(
|
|
1709
|
+
var BindingRestProperty$0 = $S(DotDotDot, BindingIdentifier);
|
|
1665
1710
|
function BindingRestProperty(state) {
|
|
1666
1711
|
if (state.verbose)
|
|
1667
1712
|
console.log("ENTER:", "BindingRestProperty");
|
|
@@ -1709,7 +1754,7 @@ var require_parser = __commonJS({
|
|
|
1709
1754
|
return BindingElement$0(state);
|
|
1710
1755
|
}
|
|
1711
1756
|
}
|
|
1712
|
-
var BindingRestElement$0 = $S(
|
|
1757
|
+
var BindingRestElement$0 = $S(DotDotDot, __, $C(BindingIdentifier, BindingPattern));
|
|
1713
1758
|
function BindingRestElement(state) {
|
|
1714
1759
|
if (state.verbose)
|
|
1715
1760
|
console.log("ENTER:", "BindingRestElement");
|
|
@@ -1729,17 +1774,35 @@ var require_parser = __commonJS({
|
|
|
1729
1774
|
return FunctionDeclaration$0(state);
|
|
1730
1775
|
}
|
|
1731
1776
|
}
|
|
1777
|
+
var FunctionSignature$0 = $S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix));
|
|
1778
|
+
function FunctionSignature(state) {
|
|
1779
|
+
if (state.verbose)
|
|
1780
|
+
console.log("ENTER:", "FunctionSignature");
|
|
1781
|
+
if (state.tokenize) {
|
|
1782
|
+
return $TOKEN("FunctionSignature", state, FunctionSignature$0(state));
|
|
1783
|
+
} else {
|
|
1784
|
+
return FunctionSignature$0(state);
|
|
1785
|
+
}
|
|
1786
|
+
}
|
|
1732
1787
|
var FunctionExpression$0 = ThinArrowFunction;
|
|
1733
|
-
var FunctionExpression$1 = $TS($S(
|
|
1734
|
-
var
|
|
1735
|
-
|
|
1788
|
+
var FunctionExpression$1 = $TS($S(FunctionSignature, $E(BracedBlock)), function($skip, $loc, $0, $1, $2) {
|
|
1789
|
+
var block = $2;
|
|
1790
|
+
if (!block) {
|
|
1791
|
+
return {
|
|
1792
|
+
type: "FunctionDeclaration",
|
|
1793
|
+
ts: true,
|
|
1794
|
+
children: $1
|
|
1795
|
+
};
|
|
1796
|
+
}
|
|
1797
|
+
const suffix = $1[$1.length - 1];
|
|
1736
1798
|
const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
|
|
1737
|
-
if (module2.implicitReturns && !isVoid) {
|
|
1799
|
+
if (module2.config.implicitReturns && !isVoid) {
|
|
1738
1800
|
module2.addImplicitReturns(block);
|
|
1739
1801
|
}
|
|
1802
|
+
$1.push(block);
|
|
1740
1803
|
return {
|
|
1741
1804
|
type: "FunctionExpression",
|
|
1742
|
-
children: $
|
|
1805
|
+
children: $1
|
|
1743
1806
|
};
|
|
1744
1807
|
});
|
|
1745
1808
|
function FunctionExpression(state) {
|
|
@@ -1755,7 +1818,7 @@ var require_parser = __commonJS({
|
|
|
1755
1818
|
var arrow = $4;
|
|
1756
1819
|
var block = $5;
|
|
1757
1820
|
const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
|
|
1758
|
-
if (module2.implicitReturns && !isVoid) {
|
|
1821
|
+
if (module2.config.implicitReturns && !isVoid) {
|
|
1759
1822
|
block = module2.addImplicitReturns(block);
|
|
1760
1823
|
}
|
|
1761
1824
|
return {
|
|
@@ -1777,7 +1840,7 @@ var require_parser = __commonJS({
|
|
|
1777
1840
|
return ThinArrowFunction$0(state);
|
|
1778
1841
|
}
|
|
1779
1842
|
}
|
|
1780
|
-
var Arrow$0 = $TV($EXPECT($
|
|
1843
|
+
var Arrow$0 = $TV($EXPECT($L17, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
1781
1844
|
return { $loc, token: $1 };
|
|
1782
1845
|
});
|
|
1783
1846
|
function Arrow(state) {
|
|
@@ -1901,7 +1964,7 @@ var require_parser = __commonJS({
|
|
|
1901
1964
|
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
|
|
1902
1965
|
}
|
|
1903
1966
|
}
|
|
1904
|
-
var NullLiteral$0 = $TV($EXPECT($
|
|
1967
|
+
var NullLiteral$0 = $TV($EXPECT($L18, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
1905
1968
|
return { $loc, token: $1 };
|
|
1906
1969
|
});
|
|
1907
1970
|
function NullLiteral(state) {
|
|
@@ -1913,19 +1976,31 @@ var require_parser = __commonJS({
|
|
|
1913
1976
|
return NullLiteral$0(state);
|
|
1914
1977
|
}
|
|
1915
1978
|
}
|
|
1916
|
-
var BooleanLiteral$0 =
|
|
1979
|
+
var BooleanLiteral$0 = CoffeeScriptBooleanLiteral;
|
|
1980
|
+
var BooleanLiteral$1 = $TV($C($EXPECT($L19, fail, 'BooleanLiteral "true"'), $EXPECT($L20, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
|
|
1917
1981
|
return { $loc, token: $1 };
|
|
1918
1982
|
});
|
|
1919
1983
|
function BooleanLiteral(state) {
|
|
1920
|
-
if (state.verbose)
|
|
1921
|
-
console.log("ENTER:", "BooleanLiteral");
|
|
1922
1984
|
if (state.tokenize) {
|
|
1923
|
-
return $TOKEN("BooleanLiteral", state, BooleanLiteral$0(state));
|
|
1985
|
+
return $TOKEN("BooleanLiteral", state, BooleanLiteral$0(state) || BooleanLiteral$1(state));
|
|
1924
1986
|
} else {
|
|
1925
|
-
return BooleanLiteral$0(state);
|
|
1987
|
+
return BooleanLiteral$0(state) || BooleanLiteral$1(state);
|
|
1926
1988
|
}
|
|
1927
1989
|
}
|
|
1928
|
-
var
|
|
1990
|
+
var CoffeeScriptBooleanLiteral$0 = $TV($C($EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "on"')), function($skip, $loc, $0, $1) {
|
|
1991
|
+
return { $loc, token: "true" };
|
|
1992
|
+
});
|
|
1993
|
+
var CoffeeScriptBooleanLiteral$1 = $TV($C($EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L24, fail, 'CoffeeScriptBooleanLiteral "off"')), function($skip, $loc, $0, $1) {
|
|
1994
|
+
return { $loc, token: "false" };
|
|
1995
|
+
});
|
|
1996
|
+
function CoffeeScriptBooleanLiteral(state) {
|
|
1997
|
+
if (state.tokenize) {
|
|
1998
|
+
return $TOKEN("CoffeeScriptBooleanLiteral", state, CoffeeScriptBooleanLiteral$0(state) || CoffeeScriptBooleanLiteral$1(state));
|
|
1999
|
+
} else {
|
|
2000
|
+
return CoffeeScriptBooleanLiteral$0(state) || CoffeeScriptBooleanLiteral$1(state);
|
|
2001
|
+
}
|
|
2002
|
+
}
|
|
2003
|
+
var Comma$0 = $TV($EXPECT($L25, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
1929
2004
|
return { $loc, token: $1 };
|
|
1930
2005
|
});
|
|
1931
2006
|
function Comma(state) {
|
|
@@ -1951,6 +2026,7 @@ var require_parser = __commonJS({
|
|
|
1951
2026
|
}
|
|
1952
2027
|
var IdentifierName$0 = $TR($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
1953
2028
|
return {
|
|
2029
|
+
type: "Identifier",
|
|
1954
2030
|
$loc,
|
|
1955
2031
|
token: $0
|
|
1956
2032
|
};
|
|
@@ -2009,7 +2085,7 @@ var require_parser = __commonJS({
|
|
|
2009
2085
|
}
|
|
2010
2086
|
}
|
|
2011
2087
|
var ArrayElementDelimiter$0 = $S($Q(_), Comma);
|
|
2012
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2088
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
|
|
2013
2089
|
var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2014
2090
|
return { $loc, token: "," };
|
|
2015
2091
|
});
|
|
@@ -2040,7 +2116,7 @@ var require_parser = __commonJS({
|
|
|
2040
2116
|
return InlineElementList$0(state);
|
|
2041
2117
|
}
|
|
2042
2118
|
}
|
|
2043
|
-
var ArrayElementExpression$0 = $E($S($E($S(
|
|
2119
|
+
var ArrayElementExpression$0 = $E($S($E($S(DotDotDot, __)), AssignmentExpression));
|
|
2044
2120
|
function ArrayElementExpression(state) {
|
|
2045
2121
|
if (state.verbose)
|
|
2046
2122
|
console.log("ENTER:", "ArrayElementExpression");
|
|
@@ -2107,7 +2183,7 @@ var require_parser = __commonJS({
|
|
|
2107
2183
|
}
|
|
2108
2184
|
}
|
|
2109
2185
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
2110
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2186
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L27, fail, 'ObjectPropertyDelimiter "}"')));
|
|
2111
2187
|
var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2112
2188
|
return { $loc, token: "," };
|
|
2113
2189
|
});
|
|
@@ -2130,7 +2206,7 @@ var require_parser = __commonJS({
|
|
|
2130
2206
|
}
|
|
2131
2207
|
var PropertyDefinition$0 = $S(PropertyName, __, Colon, AssignmentExpression);
|
|
2132
2208
|
var PropertyDefinition$1 = MethodDefinition;
|
|
2133
|
-
var PropertyDefinition$2 = $S(
|
|
2209
|
+
var PropertyDefinition$2 = $S(DotDotDot, AssignmentExpression);
|
|
2134
2210
|
var PropertyDefinition$3 = IdentifierReference;
|
|
2135
2211
|
function PropertyDefinition(state) {
|
|
2136
2212
|
if (state.tokenize) {
|
|
@@ -2142,7 +2218,7 @@ var require_parser = __commonJS({
|
|
|
2142
2218
|
var PropertyName$0 = NumericLiteral;
|
|
2143
2219
|
var PropertyName$1 = StringLiteral;
|
|
2144
2220
|
var PropertyName$2 = IdentifierName;
|
|
2145
|
-
var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($
|
|
2221
|
+
var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L26, fail, 'PropertyName "]"'));
|
|
2146
2222
|
function PropertyName(state) {
|
|
2147
2223
|
if (state.tokenize) {
|
|
2148
2224
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -2156,7 +2232,7 @@ var require_parser = __commonJS({
|
|
|
2156
2232
|
const isConstructor = sig.name === "constructor";
|
|
2157
2233
|
const isVoid = sig.returnType === "void";
|
|
2158
2234
|
const isSet = sig.modifier === "set";
|
|
2159
|
-
if (module2.implicitReturns && !isConstructor && !isSet && !isVoid) {
|
|
2235
|
+
if (module2.config.implicitReturns && !isConstructor && !isSet && !isVoid) {
|
|
2160
2236
|
block = module2.addImplicitReturns(block);
|
|
2161
2237
|
}
|
|
2162
2238
|
return $0;
|
|
@@ -2244,25 +2320,25 @@ var require_parser = __commonJS({
|
|
|
2244
2320
|
return AssignmentOp$0(state);
|
|
2245
2321
|
}
|
|
2246
2322
|
}
|
|
2247
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
2248
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
2249
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
2250
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
2251
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
2252
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
2253
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
2254
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
2255
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
2256
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
2257
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
2258
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
2259
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
2260
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
2261
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
2262
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
2323
|
+
var AssignmentOpSymbol$0 = $EXPECT($L28, fail, 'AssignmentOpSymbol "**="');
|
|
2324
|
+
var AssignmentOpSymbol$1 = $EXPECT($L29, fail, 'AssignmentOpSymbol "*="');
|
|
2325
|
+
var AssignmentOpSymbol$2 = $EXPECT($L30, fail, 'AssignmentOpSymbol "/="');
|
|
2326
|
+
var AssignmentOpSymbol$3 = $EXPECT($L31, fail, 'AssignmentOpSymbol "%="');
|
|
2327
|
+
var AssignmentOpSymbol$4 = $EXPECT($L32, fail, 'AssignmentOpSymbol "+="');
|
|
2328
|
+
var AssignmentOpSymbol$5 = $EXPECT($L33, fail, 'AssignmentOpSymbol "-="');
|
|
2329
|
+
var AssignmentOpSymbol$6 = $EXPECT($L34, fail, 'AssignmentOpSymbol "<<="');
|
|
2330
|
+
var AssignmentOpSymbol$7 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>>="');
|
|
2331
|
+
var AssignmentOpSymbol$8 = $EXPECT($L36, fail, 'AssignmentOpSymbol ">>="');
|
|
2332
|
+
var AssignmentOpSymbol$9 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&&="');
|
|
2333
|
+
var AssignmentOpSymbol$10 = $EXPECT($L38, fail, 'AssignmentOpSymbol "&="');
|
|
2334
|
+
var AssignmentOpSymbol$11 = $EXPECT($L39, fail, 'AssignmentOpSymbol "^="');
|
|
2335
|
+
var AssignmentOpSymbol$12 = $EXPECT($L40, fail, 'AssignmentOpSymbol "||="');
|
|
2336
|
+
var AssignmentOpSymbol$13 = $EXPECT($L41, fail, 'AssignmentOpSymbol "|="');
|
|
2337
|
+
var AssignmentOpSymbol$14 = $EXPECT($L42, fail, 'AssignmentOpSymbol "??="');
|
|
2338
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L43, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
2263
2339
|
return "??=";
|
|
2264
2340
|
});
|
|
2265
|
-
var AssignmentOpSymbol$16 = $EXPECT($
|
|
2341
|
+
var AssignmentOpSymbol$16 = $EXPECT($L44, fail, 'AssignmentOpSymbol "="');
|
|
2266
2342
|
function AssignmentOpSymbol(state) {
|
|
2267
2343
|
if (state.tokenize) {
|
|
2268
2344
|
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));
|
|
@@ -2282,52 +2358,52 @@ var require_parser = __commonJS({
|
|
|
2282
2358
|
return BinaryOp$0(state);
|
|
2283
2359
|
}
|
|
2284
2360
|
}
|
|
2285
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
2286
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
2287
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
2288
|
-
var BinaryOpSymbol$3 = $EXPECT($
|
|
2289
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
2290
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
2291
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
2292
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
2293
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
2361
|
+
var BinaryOpSymbol$0 = $EXPECT($L45, fail, 'BinaryOpSymbol "**"');
|
|
2362
|
+
var BinaryOpSymbol$1 = $EXPECT($L46, fail, 'BinaryOpSymbol "*"');
|
|
2363
|
+
var BinaryOpSymbol$2 = $EXPECT($L47, fail, 'BinaryOpSymbol "/"');
|
|
2364
|
+
var BinaryOpSymbol$3 = $EXPECT($L48, fail, 'BinaryOpSymbol "%"');
|
|
2365
|
+
var BinaryOpSymbol$4 = $EXPECT($L49, fail, 'BinaryOpSymbol "+"');
|
|
2366
|
+
var BinaryOpSymbol$5 = $EXPECT($L50, fail, 'BinaryOpSymbol "-"');
|
|
2367
|
+
var BinaryOpSymbol$6 = $EXPECT($L51, fail, 'BinaryOpSymbol "<="');
|
|
2368
|
+
var BinaryOpSymbol$7 = $EXPECT($L52, fail, 'BinaryOpSymbol ">="');
|
|
2369
|
+
var BinaryOpSymbol$8 = $EXPECT($L53, fail, 'BinaryOpSymbol "<<"');
|
|
2294
2370
|
var BinaryOpSymbol$9 = $EXPECT($L5, fail, 'BinaryOpSymbol "<"');
|
|
2295
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
2296
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
2297
|
-
var BinaryOpSymbol$12 = $EXPECT($
|
|
2298
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
2299
|
-
var BinaryOpSymbol$14 = $TV($EXPECT($
|
|
2300
|
-
if (module2.
|
|
2371
|
+
var BinaryOpSymbol$10 = $EXPECT($L54, fail, 'BinaryOpSymbol ">>>"');
|
|
2372
|
+
var BinaryOpSymbol$11 = $EXPECT($L55, fail, 'BinaryOpSymbol ">>"');
|
|
2373
|
+
var BinaryOpSymbol$12 = $EXPECT($L56, fail, 'BinaryOpSymbol ">"');
|
|
2374
|
+
var BinaryOpSymbol$13 = $EXPECT($L57, fail, 'BinaryOpSymbol "!=="');
|
|
2375
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L58, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
2376
|
+
if (module2.config.coffeeEq)
|
|
2301
2377
|
return "!==";
|
|
2302
2378
|
return $1;
|
|
2303
2379
|
});
|
|
2304
|
-
var BinaryOpSymbol$15 = $T($S($EXPECT($
|
|
2380
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L59, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
2305
2381
|
return "===";
|
|
2306
2382
|
});
|
|
2307
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
2308
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
2309
|
-
if (module2.
|
|
2383
|
+
var BinaryOpSymbol$16 = $EXPECT($L60, fail, 'BinaryOpSymbol "==="');
|
|
2384
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L61, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
2385
|
+
if (module2.config.coffeeEq)
|
|
2310
2386
|
return "===";
|
|
2311
2387
|
return $1;
|
|
2312
2388
|
});
|
|
2313
|
-
var BinaryOpSymbol$18 = $T($S($EXPECT($
|
|
2389
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
2314
2390
|
return "&&";
|
|
2315
2391
|
});
|
|
2316
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
2317
|
-
var BinaryOpSymbol$20 = $T($S($EXPECT($
|
|
2392
|
+
var BinaryOpSymbol$19 = $EXPECT($L63, fail, 'BinaryOpSymbol "&&"');
|
|
2393
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L64, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
2318
2394
|
return "||";
|
|
2319
2395
|
});
|
|
2320
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
2321
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
2322
|
-
var BinaryOpSymbol$23 = $TS($S($EXPECT($
|
|
2396
|
+
var BinaryOpSymbol$21 = $EXPECT($L65, fail, 'BinaryOpSymbol "||"');
|
|
2397
|
+
var BinaryOpSymbol$22 = $EXPECT($L66, fail, 'BinaryOpSymbol "??"');
|
|
2398
|
+
var BinaryOpSymbol$23 = $TS($S($EXPECT($L67, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2323
2399
|
return $1;
|
|
2324
2400
|
});
|
|
2325
|
-
var BinaryOpSymbol$24 = $TS($S($EXPECT($
|
|
2401
|
+
var BinaryOpSymbol$24 = $TS($S($EXPECT($L68, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2326
2402
|
return $1;
|
|
2327
2403
|
});
|
|
2328
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
2329
|
-
var BinaryOpSymbol$26 = $EXPECT($
|
|
2330
|
-
var BinaryOpSymbol$27 = $EXPECT($
|
|
2404
|
+
var BinaryOpSymbol$25 = $EXPECT($L69, fail, 'BinaryOpSymbol "&"');
|
|
2405
|
+
var BinaryOpSymbol$26 = $EXPECT($L70, fail, 'BinaryOpSymbol "^"');
|
|
2406
|
+
var BinaryOpSymbol$27 = $EXPECT($L71, fail, 'BinaryOpSymbol "|"');
|
|
2331
2407
|
function BinaryOpSymbol(state) {
|
|
2332
2408
|
if (state.tokenize) {
|
|
2333
2409
|
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));
|
|
@@ -2336,7 +2412,7 @@ var require_parser = __commonJS({
|
|
|
2336
2412
|
}
|
|
2337
2413
|
}
|
|
2338
2414
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
2339
|
-
var UnaryOp$1 = $S($C($EXPECT($
|
|
2415
|
+
var UnaryOp$1 = $S($C($EXPECT($L72, fail, 'UnaryOp "delete"'), $EXPECT($L73, fail, 'UnaryOp "void"'), $EXPECT($L74, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
|
|
2340
2416
|
function UnaryOp(state) {
|
|
2341
2417
|
if (state.tokenize) {
|
|
2342
2418
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -2415,7 +2491,7 @@ var require_parser = __commonJS({
|
|
|
2415
2491
|
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);
|
|
2416
2492
|
}
|
|
2417
2493
|
}
|
|
2418
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
2494
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L75, fail, 'EmptyStatement ";"'))), function(value) {
|
|
2419
2495
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
2420
2496
|
});
|
|
2421
2497
|
function EmptyStatement(state) {
|
|
@@ -2427,7 +2503,10 @@ var require_parser = __commonJS({
|
|
|
2427
2503
|
return EmptyStatement$0(state);
|
|
2428
2504
|
}
|
|
2429
2505
|
}
|
|
2430
|
-
var BlockStatement$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace)
|
|
2506
|
+
var BlockStatement$0 = $T($S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace), function(value) {
|
|
2507
|
+
var exps = value[3];
|
|
2508
|
+
return { "type": "BlockStatement", "children": value, "expressions": exps };
|
|
2509
|
+
});
|
|
2431
2510
|
function BlockStatement(state) {
|
|
2432
2511
|
if (state.verbose)
|
|
2433
2512
|
console.log("ENTER:", "BlockStatement");
|
|
@@ -2493,7 +2572,7 @@ var require_parser = __commonJS({
|
|
|
2493
2572
|
return LoopStatement$0(state);
|
|
2494
2573
|
}
|
|
2495
2574
|
}
|
|
2496
|
-
var DoWhileStatement$0 = $T($S($EXPECT($
|
|
2575
|
+
var DoWhileStatement$0 = $T($S($EXPECT($L76, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause), function(value) {
|
|
2497
2576
|
return { "type": "IterationStatement", "children": value };
|
|
2498
2577
|
});
|
|
2499
2578
|
function DoWhileStatement(state) {
|
|
@@ -2517,7 +2596,7 @@ var require_parser = __commonJS({
|
|
|
2517
2596
|
return WhileStatement$0(state);
|
|
2518
2597
|
}
|
|
2519
2598
|
}
|
|
2520
|
-
var WhileClause$0 = $TS($S($C($EXPECT($
|
|
2599
|
+
var WhileClause$0 = $TS($S($C($EXPECT($L77, fail, 'WhileClause "while"'), $EXPECT($L78, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
|
|
2521
2600
|
var kind = $1;
|
|
2522
2601
|
var cond = $3;
|
|
2523
2602
|
if (kind === "until") {
|
|
@@ -2755,7 +2834,7 @@ var require_parser = __commonJS({
|
|
|
2755
2834
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2756
2835
|
}
|
|
2757
2836
|
}
|
|
2758
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2837
|
+
var Finally$0 = $S(__, $EXPECT($L79, fail, 'Finally "finally"'), BracedBlock);
|
|
2759
2838
|
function Finally(state) {
|
|
2760
2839
|
if (state.verbose)
|
|
2761
2840
|
console.log("ENTER:", "Finally");
|
|
@@ -2821,13 +2900,13 @@ var require_parser = __commonJS({
|
|
|
2821
2900
|
return ExpressionStatement$0(state);
|
|
2822
2901
|
}
|
|
2823
2902
|
}
|
|
2824
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
2903
|
+
var KeywordStatement$0 = $T($S($EXPECT($L80, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
2825
2904
|
return { "type": "BreakStatement", "children": value };
|
|
2826
2905
|
});
|
|
2827
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
2906
|
+
var KeywordStatement$1 = $T($S($EXPECT($L81, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
2828
2907
|
return { "type": "ContinueStatement", "children": value };
|
|
2829
2908
|
});
|
|
2830
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
2909
|
+
var KeywordStatement$2 = $T($S($EXPECT($L82, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
2831
2910
|
return { "type": "DebuggerStatement", "children": value };
|
|
2832
2911
|
});
|
|
2833
2912
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
@@ -2852,7 +2931,7 @@ var require_parser = __commonJS({
|
|
|
2852
2931
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2853
2932
|
}
|
|
2854
2933
|
}
|
|
2855
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2934
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L83, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2856
2935
|
return { "ts": true, "children": value };
|
|
2857
2936
|
});
|
|
2858
2937
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
@@ -2990,7 +3069,7 @@ var require_parser = __commonJS({
|
|
|
2990
3069
|
return ImportedBinding$0(state);
|
|
2991
3070
|
}
|
|
2992
3071
|
}
|
|
2993
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
3072
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L84, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2994
3073
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
2995
3074
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
2996
3075
|
function ExportDeclaration(state) {
|
|
@@ -3072,7 +3151,7 @@ var require_parser = __commonJS({
|
|
|
3072
3151
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
3073
3152
|
}
|
|
3074
3153
|
}
|
|
3075
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
3154
|
+
var ConstAssignment$0 = $TV($EXPECT($L85, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
3076
3155
|
return { $loc, token: "=" };
|
|
3077
3156
|
});
|
|
3078
3157
|
function ConstAssignment(state) {
|
|
@@ -3168,17 +3247,29 @@ var require_parser = __commonJS({
|
|
|
3168
3247
|
return DecimalBigIntegerLiteral$0(state);
|
|
3169
3248
|
}
|
|
3170
3249
|
}
|
|
3171
|
-
var DecimalLiteral$0 = $
|
|
3250
|
+
var DecimalLiteral$0 = $TV($TEXT($EXPECT($R5, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?=\\.(?:\\p{ID_Start}|[_$]))/")), function($skip, $loc, $0, $1) {
|
|
3251
|
+
return $1 + ".";
|
|
3252
|
+
});
|
|
3253
|
+
var DecimalLiteral$1 = $TEXT($S($EXPECT($R6, fail, "DecimalLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)(?:\\.(?:[0-9](?:_[0-9]|[0-9])*)?)?/"), $E(ExponentPart)));
|
|
3254
|
+
var DecimalLiteral$2 = $TEXT($S($EXPECT($R7, fail, "DecimalLiteral /(?:\\.(?!\\p{ID_Start})[0-9](?:_[0-9]|[0-9])*)/"), $E(ExponentPart)));
|
|
3172
3255
|
function DecimalLiteral(state) {
|
|
3256
|
+
if (state.tokenize) {
|
|
3257
|
+
return $TOKEN("DecimalLiteral", state, DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state));
|
|
3258
|
+
} else {
|
|
3259
|
+
return DecimalLiteral$0(state) || DecimalLiteral$1(state) || DecimalLiteral$2(state);
|
|
3260
|
+
}
|
|
3261
|
+
}
|
|
3262
|
+
var ExponentPart$0 = $R$0($EXPECT($R8, fail, "ExponentPart /(?:[eE][+-]?[0-9]+(?:_[0-9]|[0-9])*)/"));
|
|
3263
|
+
function ExponentPart(state) {
|
|
3173
3264
|
if (state.verbose)
|
|
3174
|
-
console.log("ENTER:", "
|
|
3265
|
+
console.log("ENTER:", "ExponentPart");
|
|
3175
3266
|
if (state.tokenize) {
|
|
3176
|
-
return $TOKEN("
|
|
3267
|
+
return $TOKEN("ExponentPart", state, ExponentPart$0(state));
|
|
3177
3268
|
} else {
|
|
3178
|
-
return
|
|
3269
|
+
return ExponentPart$0(state);
|
|
3179
3270
|
}
|
|
3180
3271
|
}
|
|
3181
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
3272
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R9, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*n?/"));
|
|
3182
3273
|
function BinaryIntegerLiteral(state) {
|
|
3183
3274
|
if (state.verbose)
|
|
3184
3275
|
console.log("ENTER:", "BinaryIntegerLiteral");
|
|
@@ -3188,7 +3279,7 @@ var require_parser = __commonJS({
|
|
|
3188
3279
|
return BinaryIntegerLiteral$0(state);
|
|
3189
3280
|
}
|
|
3190
3281
|
}
|
|
3191
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
3282
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R10, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*n?/"));
|
|
3192
3283
|
function OctalIntegerLiteral(state) {
|
|
3193
3284
|
if (state.verbose)
|
|
3194
3285
|
console.log("ENTER:", "OctalIntegerLiteral");
|
|
@@ -3198,7 +3289,7 @@ var require_parser = __commonJS({
|
|
|
3198
3289
|
return OctalIntegerLiteral$0(state);
|
|
3199
3290
|
}
|
|
3200
3291
|
}
|
|
3201
|
-
var HexLiteral$0 = $R$0($EXPECT($
|
|
3292
|
+
var HexLiteral$0 = $R$0($EXPECT($R11, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*n?/"));
|
|
3202
3293
|
function HexLiteral(state) {
|
|
3203
3294
|
if (state.verbose)
|
|
3204
3295
|
console.log("ENTER:", "HexLiteral");
|
|
@@ -3217,7 +3308,7 @@ var require_parser = __commonJS({
|
|
|
3217
3308
|
var e = $3;
|
|
3218
3309
|
return [s, module2.dedentBlockString(str), e];
|
|
3219
3310
|
});
|
|
3220
|
-
var StringLiteral$2 =
|
|
3311
|
+
var StringLiteral$2 = CoffeeInterpolatedDoubleQuotedString;
|
|
3221
3312
|
var StringLiteral$3 = BasicStringLiteral;
|
|
3222
3313
|
function StringLiteral(state) {
|
|
3223
3314
|
if (state.tokenize) {
|
|
@@ -3247,7 +3338,7 @@ var require_parser = __commonJS({
|
|
|
3247
3338
|
return BasicStringLiteral$0(state) || BasicStringLiteral$1(state);
|
|
3248
3339
|
}
|
|
3249
3340
|
}
|
|
3250
|
-
var DoubleStringCharacters$0 = $TR($EXPECT($
|
|
3341
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R12, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3251
3342
|
return { $loc, token: $0 };
|
|
3252
3343
|
});
|
|
3253
3344
|
function DoubleStringCharacters(state) {
|
|
@@ -3259,7 +3350,7 @@ var require_parser = __commonJS({
|
|
|
3259
3350
|
return DoubleStringCharacters$0(state);
|
|
3260
3351
|
}
|
|
3261
3352
|
}
|
|
3262
|
-
var SingleStringCharacters$0 = $TR($EXPECT($
|
|
3353
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R13, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3263
3354
|
return { $loc, token: $0 };
|
|
3264
3355
|
});
|
|
3265
3356
|
function SingleStringCharacters(state) {
|
|
@@ -3271,7 +3362,7 @@ var require_parser = __commonJS({
|
|
|
3271
3362
|
return SingleStringCharacters$0(state);
|
|
3272
3363
|
}
|
|
3273
3364
|
}
|
|
3274
|
-
var TripleDoubleStringCharacters$0 = $TR($EXPECT($
|
|
3365
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R14, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3275
3366
|
return { $loc, token: $0 };
|
|
3276
3367
|
});
|
|
3277
3368
|
function TripleDoubleStringCharacters(state) {
|
|
@@ -3283,7 +3374,7 @@ var require_parser = __commonJS({
|
|
|
3283
3374
|
return TripleDoubleStringCharacters$0(state);
|
|
3284
3375
|
}
|
|
3285
3376
|
}
|
|
3286
|
-
var TripleSingleStringCharacters$0 = $TR($EXPECT($
|
|
3377
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R15, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3287
3378
|
return { $loc, token: $0 };
|
|
3288
3379
|
});
|
|
3289
3380
|
function TripleSingleStringCharacters(state) {
|
|
@@ -3305,21 +3396,7 @@ var require_parser = __commonJS({
|
|
|
3305
3396
|
return CoffeeStringSubstitution$0(state);
|
|
3306
3397
|
}
|
|
3307
3398
|
}
|
|
3308
|
-
var
|
|
3309
|
-
if (module2.coffeeCompat)
|
|
3310
|
-
return;
|
|
3311
|
-
return $skip;
|
|
3312
|
-
});
|
|
3313
|
-
function CoffeeCompat(state) {
|
|
3314
|
-
if (state.verbose)
|
|
3315
|
-
console.log("ENTER:", "CoffeeCompat");
|
|
3316
|
-
if (state.tokenize) {
|
|
3317
|
-
return $TOKEN("CoffeeCompat", state, CoffeeCompat$0(state));
|
|
3318
|
-
} else {
|
|
3319
|
-
return CoffeeCompat$0(state);
|
|
3320
|
-
}
|
|
3321
|
-
}
|
|
3322
|
-
var CoffeeCompatDoubleQuotedString$0 = $TS($S(CoffeeCompat, DoubleQuote, $Q($C(CoffeeCompatDoubleQuotedStringCharacters, CoffeeStringSubstitution)), DoubleQuote), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
3399
|
+
var CoffeeInterpolatedDoubleQuotedString$0 = $TS($S(CoffeeInterpolationEnabled, DoubleQuote, $Q($C(CoffeeDoubleQuotedStringCharacters, CoffeeStringSubstitution)), DoubleQuote), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
3323
3400
|
var s = $2;
|
|
3324
3401
|
var parts = $3;
|
|
3325
3402
|
var e = $4;
|
|
@@ -3339,28 +3416,28 @@ var require_parser = __commonJS({
|
|
|
3339
3416
|
s.token = e.token = "`";
|
|
3340
3417
|
return [s, parts, e];
|
|
3341
3418
|
});
|
|
3342
|
-
function
|
|
3419
|
+
function CoffeeInterpolatedDoubleQuotedString(state) {
|
|
3343
3420
|
if (state.verbose)
|
|
3344
|
-
console.log("ENTER:", "
|
|
3421
|
+
console.log("ENTER:", "CoffeeInterpolatedDoubleQuotedString");
|
|
3345
3422
|
if (state.tokenize) {
|
|
3346
|
-
return $TOKEN("
|
|
3423
|
+
return $TOKEN("CoffeeInterpolatedDoubleQuotedString", state, CoffeeInterpolatedDoubleQuotedString$0(state));
|
|
3347
3424
|
} else {
|
|
3348
|
-
return
|
|
3425
|
+
return CoffeeInterpolatedDoubleQuotedString$0(state);
|
|
3349
3426
|
}
|
|
3350
3427
|
}
|
|
3351
|
-
var
|
|
3428
|
+
var CoffeeDoubleQuotedStringCharacters$0 = $TR($EXPECT($R16, fail, 'CoffeeDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3352
3429
|
return { $loc, token: $0 };
|
|
3353
3430
|
});
|
|
3354
|
-
function
|
|
3431
|
+
function CoffeeDoubleQuotedStringCharacters(state) {
|
|
3355
3432
|
if (state.verbose)
|
|
3356
|
-
console.log("ENTER:", "
|
|
3433
|
+
console.log("ENTER:", "CoffeeDoubleQuotedStringCharacters");
|
|
3357
3434
|
if (state.tokenize) {
|
|
3358
|
-
return $TOKEN("
|
|
3435
|
+
return $TOKEN("CoffeeDoubleQuotedStringCharacters", state, CoffeeDoubleQuotedStringCharacters$0(state));
|
|
3359
3436
|
} else {
|
|
3360
|
-
return
|
|
3437
|
+
return CoffeeDoubleQuotedStringCharacters$0(state);
|
|
3361
3438
|
}
|
|
3362
3439
|
}
|
|
3363
|
-
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($
|
|
3440
|
+
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L47, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L47, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
3364
3441
|
return { $loc, token: $1 };
|
|
3365
3442
|
});
|
|
3366
3443
|
function RegularExpressionLiteral(state) {
|
|
@@ -3372,7 +3449,7 @@ var require_parser = __commonJS({
|
|
|
3372
3449
|
return RegularExpressionLiteral$0(state);
|
|
3373
3450
|
}
|
|
3374
3451
|
}
|
|
3375
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
3452
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R17, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
|
|
3376
3453
|
function RegularExpressionBody(state) {
|
|
3377
3454
|
if (state.verbose)
|
|
3378
3455
|
console.log("ENTER:", "RegularExpressionBody");
|
|
@@ -3382,7 +3459,7 @@ var require_parser = __commonJS({
|
|
|
3382
3459
|
return RegularExpressionBody$0(state);
|
|
3383
3460
|
}
|
|
3384
3461
|
}
|
|
3385
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
3462
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R18, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
3386
3463
|
function RegExpCharacter(state) {
|
|
3387
3464
|
if (state.verbose)
|
|
3388
3465
|
console.log("ENTER:", "RegExpCharacter");
|
|
@@ -3392,7 +3469,7 @@ var require_parser = __commonJS({
|
|
|
3392
3469
|
return RegExpCharacter$0(state);
|
|
3393
3470
|
}
|
|
3394
3471
|
}
|
|
3395
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
3472
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R19, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
3396
3473
|
function RegularExpressionFlags(state) {
|
|
3397
3474
|
if (state.verbose)
|
|
3398
3475
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -3423,7 +3500,7 @@ var require_parser = __commonJS({
|
|
|
3423
3500
|
return TemplateSubstitution$0(state);
|
|
3424
3501
|
}
|
|
3425
3502
|
}
|
|
3426
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
3503
|
+
var TemplateCharacters$0 = $TR($EXPECT($R20, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3427
3504
|
return { $loc, token: $0 };
|
|
3428
3505
|
});
|
|
3429
3506
|
function TemplateCharacters(state) {
|
|
@@ -3435,7 +3512,7 @@ var require_parser = __commonJS({
|
|
|
3435
3512
|
return TemplateCharacters$0(state);
|
|
3436
3513
|
}
|
|
3437
3514
|
}
|
|
3438
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
3515
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R21, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3439
3516
|
return { $loc, token: $0 };
|
|
3440
3517
|
});
|
|
3441
3518
|
function TemplateBlockCharacters(state) {
|
|
@@ -3447,14 +3524,13 @@ var require_parser = __commonJS({
|
|
|
3447
3524
|
return TemplateBlockCharacters$0(state);
|
|
3448
3525
|
}
|
|
3449
3526
|
}
|
|
3450
|
-
var ReservedWord$0 = $R$0($EXPECT($
|
|
3527
|
+
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R22, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
|
|
3528
|
+
var ReservedWord$1 = $R$0($EXPECT($R23, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
3451
3529
|
function ReservedWord(state) {
|
|
3452
|
-
if (state.verbose)
|
|
3453
|
-
console.log("ENTER:", "ReservedWord");
|
|
3454
3530
|
if (state.tokenize) {
|
|
3455
|
-
return $TOKEN("ReservedWord", state, ReservedWord$0(state));
|
|
3531
|
+
return $TOKEN("ReservedWord", state, ReservedWord$0(state) || ReservedWord$1(state));
|
|
3456
3532
|
} else {
|
|
3457
|
-
return ReservedWord$0(state);
|
|
3533
|
+
return ReservedWord$0(state) || ReservedWord$1(state);
|
|
3458
3534
|
}
|
|
3459
3535
|
}
|
|
3460
3536
|
var Comment$0 = MultiLineComment;
|
|
@@ -3466,10 +3542,10 @@ var require_parser = __commonJS({
|
|
|
3466
3542
|
return Comment$0(state) || Comment$1(state);
|
|
3467
3543
|
}
|
|
3468
3544
|
}
|
|
3469
|
-
var SingleLineComment$0 = $TR($EXPECT($
|
|
3545
|
+
var SingleLineComment$0 = $TR($EXPECT($R24, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3470
3546
|
return { $loc, token: $0 };
|
|
3471
3547
|
});
|
|
3472
|
-
var SingleLineComment$1 = $S(
|
|
3548
|
+
var SingleLineComment$1 = $S(CoffeeCommentEnabled, CoffeeSingleLineComment);
|
|
3473
3549
|
function SingleLineComment(state) {
|
|
3474
3550
|
if (state.tokenize) {
|
|
3475
3551
|
return $TOKEN("SingleLineComment", state, SingleLineComment$0(state) || SingleLineComment$1(state));
|
|
@@ -3486,7 +3562,7 @@ var require_parser = __commonJS({
|
|
|
3486
3562
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
3487
3563
|
}
|
|
3488
3564
|
}
|
|
3489
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
3565
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L86, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L87, fail, 'JSMultiLineComment "*/"')), $EXPECT($R25, fail, "JSMultiLineComment /./"))), $EXPECT($L87, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
3490
3566
|
return { $loc, token: $1 };
|
|
3491
3567
|
});
|
|
3492
3568
|
function JSMultiLineComment(state) {
|
|
@@ -3498,7 +3574,7 @@ var require_parser = __commonJS({
|
|
|
3498
3574
|
return JSMultiLineComment$0(state);
|
|
3499
3575
|
}
|
|
3500
3576
|
}
|
|
3501
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
3577
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R26, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3502
3578
|
return { $loc, token: `//${$1}` };
|
|
3503
3579
|
});
|
|
3504
3580
|
function CoffeeSingleLineComment(state) {
|
|
@@ -3510,7 +3586,7 @@ var require_parser = __commonJS({
|
|
|
3510
3586
|
return CoffeeSingleLineComment$0(state);
|
|
3511
3587
|
}
|
|
3512
3588
|
}
|
|
3513
|
-
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($
|
|
3589
|
+
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L88, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L88, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L87, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R25, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L88, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3514
3590
|
return { $loc, token: `/*${$2}*/` };
|
|
3515
3591
|
});
|
|
3516
3592
|
function CoffeeMultiLineComment(state) {
|
|
@@ -3522,7 +3598,7 @@ var require_parser = __commonJS({
|
|
|
3522
3598
|
return CoffeeMultiLineComment$0(state);
|
|
3523
3599
|
}
|
|
3524
3600
|
}
|
|
3525
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
3601
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L86, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L87, fail, 'InlineComment "*/"')), $EXPECT($R27, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L87, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
3526
3602
|
return { $loc, token: $1 };
|
|
3527
3603
|
});
|
|
3528
3604
|
function InlineComment(state) {
|
|
@@ -3564,7 +3640,7 @@ var require_parser = __commonJS({
|
|
|
3564
3640
|
return _$0(state);
|
|
3565
3641
|
}
|
|
3566
3642
|
}
|
|
3567
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
3643
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R28, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3568
3644
|
return { $loc, token: $0 };
|
|
3569
3645
|
});
|
|
3570
3646
|
function NonNewlineWhitespace(state) {
|
|
@@ -3586,7 +3662,7 @@ var require_parser = __commonJS({
|
|
|
3586
3662
|
return __$0(state);
|
|
3587
3663
|
}
|
|
3588
3664
|
}
|
|
3589
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
3665
|
+
var Whitespace$0 = $TR($EXPECT($R29, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3590
3666
|
return { $loc, token: $0 };
|
|
3591
3667
|
});
|
|
3592
3668
|
function Whitespace(state) {
|
|
@@ -3609,7 +3685,7 @@ var require_parser = __commonJS({
|
|
|
3609
3685
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
3610
3686
|
}
|
|
3611
3687
|
}
|
|
3612
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3688
|
+
var NonIdContinue$0 = $R$0($EXPECT($R30, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
3613
3689
|
function NonIdContinue(state) {
|
|
3614
3690
|
if (state.verbose)
|
|
3615
3691
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -3631,7 +3707,7 @@ var require_parser = __commonJS({
|
|
|
3631
3707
|
return Loc$0(state);
|
|
3632
3708
|
}
|
|
3633
3709
|
}
|
|
3634
|
-
var As$0 = $TS($S($EXPECT($
|
|
3710
|
+
var As$0 = $TS($S($EXPECT($L89, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3635
3711
|
return { $loc, token: $1 };
|
|
3636
3712
|
});
|
|
3637
3713
|
function As(state) {
|
|
@@ -3643,7 +3719,7 @@ var require_parser = __commonJS({
|
|
|
3643
3719
|
return As$0(state);
|
|
3644
3720
|
}
|
|
3645
3721
|
}
|
|
3646
|
-
var Async$0 = $TV($EXPECT($
|
|
3722
|
+
var Async$0 = $TV($EXPECT($L90, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
|
|
3647
3723
|
return { $loc, token: $1 };
|
|
3648
3724
|
});
|
|
3649
3725
|
function Async(state) {
|
|
@@ -3655,7 +3731,7 @@ var require_parser = __commonJS({
|
|
|
3655
3731
|
return Async$0(state);
|
|
3656
3732
|
}
|
|
3657
3733
|
}
|
|
3658
|
-
var Await$0 = $TS($S($EXPECT($
|
|
3734
|
+
var Await$0 = $TS($S($EXPECT($L91, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3659
3735
|
return { $loc, token: $1 };
|
|
3660
3736
|
});
|
|
3661
3737
|
function Await(state) {
|
|
@@ -3667,7 +3743,7 @@ var require_parser = __commonJS({
|
|
|
3667
3743
|
return Await$0(state);
|
|
3668
3744
|
}
|
|
3669
3745
|
}
|
|
3670
|
-
var Case$0 = $TS($S($EXPECT($
|
|
3746
|
+
var Case$0 = $TS($S($EXPECT($L92, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3671
3747
|
return { $loc, token: $1 };
|
|
3672
3748
|
});
|
|
3673
3749
|
function Case(state) {
|
|
@@ -3679,7 +3755,7 @@ var require_parser = __commonJS({
|
|
|
3679
3755
|
return Case$0(state);
|
|
3680
3756
|
}
|
|
3681
3757
|
}
|
|
3682
|
-
var Catch$0 = $TV($EXPECT($
|
|
3758
|
+
var Catch$0 = $TV($EXPECT($L93, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
3683
3759
|
return { $loc, token: $1 };
|
|
3684
3760
|
});
|
|
3685
3761
|
function Catch(state) {
|
|
@@ -3691,7 +3767,7 @@ var require_parser = __commonJS({
|
|
|
3691
3767
|
return Catch$0(state);
|
|
3692
3768
|
}
|
|
3693
3769
|
}
|
|
3694
|
-
var Class$0 = $TV($EXPECT($
|
|
3770
|
+
var Class$0 = $TV($EXPECT($L94, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
3695
3771
|
return { $loc, token: $1 };
|
|
3696
3772
|
});
|
|
3697
3773
|
function Class(state) {
|
|
@@ -3703,7 +3779,7 @@ var require_parser = __commonJS({
|
|
|
3703
3779
|
return Class$0(state);
|
|
3704
3780
|
}
|
|
3705
3781
|
}
|
|
3706
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
3782
|
+
var CloseBrace$0 = $TV($EXPECT($L27, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
3707
3783
|
return { $loc, token: $1 };
|
|
3708
3784
|
});
|
|
3709
3785
|
function CloseBrace(state) {
|
|
@@ -3715,7 +3791,7 @@ var require_parser = __commonJS({
|
|
|
3715
3791
|
return CloseBrace$0(state);
|
|
3716
3792
|
}
|
|
3717
3793
|
}
|
|
3718
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
3794
|
+
var CloseBracket$0 = $TV($EXPECT($L26, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
3719
3795
|
return { $loc, token: $1 };
|
|
3720
3796
|
});
|
|
3721
3797
|
function CloseBracket(state) {
|
|
@@ -3739,7 +3815,7 @@ var require_parser = __commonJS({
|
|
|
3739
3815
|
return CloseParen$0(state);
|
|
3740
3816
|
}
|
|
3741
3817
|
}
|
|
3742
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
3818
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L95, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
3743
3819
|
return { $loc, token: "${" };
|
|
3744
3820
|
});
|
|
3745
3821
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -3751,7 +3827,7 @@ var require_parser = __commonJS({
|
|
|
3751
3827
|
return CoffeeSubstitutionStart$0(state);
|
|
3752
3828
|
}
|
|
3753
3829
|
}
|
|
3754
|
-
var Colon$0 = $TV($EXPECT($
|
|
3830
|
+
var Colon$0 = $TV($EXPECT($L96, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
3755
3831
|
return { $loc, token: $1 };
|
|
3756
3832
|
});
|
|
3757
3833
|
function Colon(state) {
|
|
@@ -3775,7 +3851,7 @@ var require_parser = __commonJS({
|
|
|
3775
3851
|
return ConstructorShorthand$0(state);
|
|
3776
3852
|
}
|
|
3777
3853
|
}
|
|
3778
|
-
var Default$0 = $TS($S($EXPECT($
|
|
3854
|
+
var Default$0 = $TS($S($EXPECT($L84, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3779
3855
|
return { $loc, token: $1 };
|
|
3780
3856
|
});
|
|
3781
3857
|
function Default(state) {
|
|
@@ -3787,7 +3863,7 @@ var require_parser = __commonJS({
|
|
|
3787
3863
|
return Default$0(state);
|
|
3788
3864
|
}
|
|
3789
3865
|
}
|
|
3790
|
-
var Dot$0 = $TV($EXPECT($
|
|
3866
|
+
var Dot$0 = $TV($EXPECT($L97, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
3791
3867
|
return { $loc, token: $1 };
|
|
3792
3868
|
});
|
|
3793
3869
|
function Dot(state) {
|
|
@@ -3799,7 +3875,19 @@ var require_parser = __commonJS({
|
|
|
3799
3875
|
return Dot$0(state);
|
|
3800
3876
|
}
|
|
3801
3877
|
}
|
|
3802
|
-
var
|
|
3878
|
+
var DotDotDot$0 = $TV($EXPECT($L98, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
3879
|
+
return { $loc, token: $1 };
|
|
3880
|
+
});
|
|
3881
|
+
function DotDotDot(state) {
|
|
3882
|
+
if (state.verbose)
|
|
3883
|
+
console.log("ENTER:", "DotDotDot");
|
|
3884
|
+
if (state.tokenize) {
|
|
3885
|
+
return $TOKEN("DotDotDot", state, DotDotDot$0(state));
|
|
3886
|
+
} else {
|
|
3887
|
+
return DotDotDot$0(state);
|
|
3888
|
+
}
|
|
3889
|
+
}
|
|
3890
|
+
var DoubleQuote$0 = $TV($EXPECT($L99, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
3803
3891
|
return { $loc, token: $1 };
|
|
3804
3892
|
});
|
|
3805
3893
|
function DoubleQuote(state) {
|
|
@@ -3811,7 +3899,7 @@ var require_parser = __commonJS({
|
|
|
3811
3899
|
return DoubleQuote$0(state);
|
|
3812
3900
|
}
|
|
3813
3901
|
}
|
|
3814
|
-
var Else$0 = $TV($EXPECT($
|
|
3902
|
+
var Else$0 = $TV($EXPECT($L100, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
3815
3903
|
return { $loc, token: $1 };
|
|
3816
3904
|
});
|
|
3817
3905
|
function Else(state) {
|
|
@@ -3823,7 +3911,7 @@ var require_parser = __commonJS({
|
|
|
3823
3911
|
return Else$0(state);
|
|
3824
3912
|
}
|
|
3825
3913
|
}
|
|
3826
|
-
var Equals$0 = $TV($EXPECT($
|
|
3914
|
+
var Equals$0 = $TV($EXPECT($L44, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
3827
3915
|
return { $loc, token: $1 };
|
|
3828
3916
|
});
|
|
3829
3917
|
function Equals(state) {
|
|
@@ -3835,7 +3923,7 @@ var require_parser = __commonJS({
|
|
|
3835
3923
|
return Equals$0(state);
|
|
3836
3924
|
}
|
|
3837
3925
|
}
|
|
3838
|
-
var Export$0 = $TS($S($EXPECT($
|
|
3926
|
+
var Export$0 = $TS($S($EXPECT($L101, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3839
3927
|
return { $loc, token: $1 };
|
|
3840
3928
|
});
|
|
3841
3929
|
function Export(state) {
|
|
@@ -3847,7 +3935,7 @@ var require_parser = __commonJS({
|
|
|
3847
3935
|
return Export$0(state);
|
|
3848
3936
|
}
|
|
3849
3937
|
}
|
|
3850
|
-
var For$0 = $TS($S($EXPECT($
|
|
3938
|
+
var For$0 = $TS($S($EXPECT($L102, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3851
3939
|
return { $loc, token: $1 };
|
|
3852
3940
|
});
|
|
3853
3941
|
function For(state) {
|
|
@@ -3859,7 +3947,7 @@ var require_parser = __commonJS({
|
|
|
3859
3947
|
return For$0(state);
|
|
3860
3948
|
}
|
|
3861
3949
|
}
|
|
3862
|
-
var From$0 = $TS($S($EXPECT($
|
|
3950
|
+
var From$0 = $TS($S($EXPECT($L103, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3863
3951
|
return { $loc, token: $1 };
|
|
3864
3952
|
});
|
|
3865
3953
|
function From(state) {
|
|
@@ -3871,7 +3959,7 @@ var require_parser = __commonJS({
|
|
|
3871
3959
|
return From$0(state);
|
|
3872
3960
|
}
|
|
3873
3961
|
}
|
|
3874
|
-
var Function$0 = $TV($EXPECT($
|
|
3962
|
+
var Function$0 = $TV($EXPECT($L104, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
3875
3963
|
return { $loc, token: $1 };
|
|
3876
3964
|
});
|
|
3877
3965
|
function Function(state) {
|
|
@@ -3883,7 +3971,7 @@ var require_parser = __commonJS({
|
|
|
3883
3971
|
return Function$0(state);
|
|
3884
3972
|
}
|
|
3885
3973
|
}
|
|
3886
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
3974
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L105, fail, 'GetOrSet "get"'), $EXPECT($L106, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3887
3975
|
return { $loc, token: $1 };
|
|
3888
3976
|
});
|
|
3889
3977
|
function GetOrSet(state) {
|
|
@@ -3895,7 +3983,7 @@ var require_parser = __commonJS({
|
|
|
3895
3983
|
return GetOrSet$0(state);
|
|
3896
3984
|
}
|
|
3897
3985
|
}
|
|
3898
|
-
var If$0 = $TV($EXPECT($
|
|
3986
|
+
var If$0 = $TV($EXPECT($L107, fail, 'If "if"'), function($skip, $loc, $0, $1) {
|
|
3899
3987
|
return { $loc, token: $1 };
|
|
3900
3988
|
});
|
|
3901
3989
|
function If(state) {
|
|
@@ -3907,7 +3995,7 @@ var require_parser = __commonJS({
|
|
|
3907
3995
|
return If$0(state);
|
|
3908
3996
|
}
|
|
3909
3997
|
}
|
|
3910
|
-
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($
|
|
3998
|
+
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R31, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
3911
3999
|
return { $loc, token: $1 };
|
|
3912
4000
|
});
|
|
3913
4001
|
function Import(state) {
|
|
@@ -3919,7 +4007,7 @@ var require_parser = __commonJS({
|
|
|
3919
4007
|
return Import$0(state);
|
|
3920
4008
|
}
|
|
3921
4009
|
}
|
|
3922
|
-
var In$0 = $TV($EXPECT($
|
|
4010
|
+
var In$0 = $TV($EXPECT($L68, fail, 'In "in"'), function($skip, $loc, $0, $1) {
|
|
3923
4011
|
return { $loc, token: $1 };
|
|
3924
4012
|
});
|
|
3925
4013
|
function In(state) {
|
|
@@ -3931,7 +4019,7 @@ var require_parser = __commonJS({
|
|
|
3931
4019
|
return In$0(state);
|
|
3932
4020
|
}
|
|
3933
4021
|
}
|
|
3934
|
-
var LetOrConst$0 = $TV($C($EXPECT($
|
|
4022
|
+
var LetOrConst$0 = $TV($C($EXPECT($L108, fail, 'LetOrConst "let"'), $EXPECT($L109, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
3935
4023
|
return { $loc, token: $1 };
|
|
3936
4024
|
});
|
|
3937
4025
|
function LetOrConst(state) {
|
|
@@ -3943,7 +4031,7 @@ var require_parser = __commonJS({
|
|
|
3943
4031
|
return LetOrConst$0(state);
|
|
3944
4032
|
}
|
|
3945
4033
|
}
|
|
3946
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
4034
|
+
var Loop$0 = $TS($S($EXPECT($L110, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3947
4035
|
return { $loc, token: "while(true)" };
|
|
3948
4036
|
});
|
|
3949
4037
|
function Loop(state) {
|
|
@@ -3955,7 +4043,7 @@ var require_parser = __commonJS({
|
|
|
3955
4043
|
return Loop$0(state);
|
|
3956
4044
|
}
|
|
3957
4045
|
}
|
|
3958
|
-
var New$0 = $TV($EXPECT($
|
|
4046
|
+
var New$0 = $TV($EXPECT($L111, fail, 'New "new"'), function($skip, $loc, $0, $1) {
|
|
3959
4047
|
return { $loc, token: $1 };
|
|
3960
4048
|
});
|
|
3961
4049
|
function New(state) {
|
|
@@ -3967,7 +4055,7 @@ var require_parser = __commonJS({
|
|
|
3967
4055
|
return New$0(state);
|
|
3968
4056
|
}
|
|
3969
4057
|
}
|
|
3970
|
-
var Of$0 = $TV($EXPECT($
|
|
4058
|
+
var Of$0 = $TV($EXPECT($L112, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
3971
4059
|
return { $loc, token: $1 };
|
|
3972
4060
|
});
|
|
3973
4061
|
function Of(state) {
|
|
@@ -3979,7 +4067,7 @@ var require_parser = __commonJS({
|
|
|
3979
4067
|
return Of$0(state);
|
|
3980
4068
|
}
|
|
3981
4069
|
}
|
|
3982
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
4070
|
+
var OpenBrace$0 = $TV($EXPECT($L113, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
3983
4071
|
return { $loc, token: $1 };
|
|
3984
4072
|
});
|
|
3985
4073
|
function OpenBrace(state) {
|
|
@@ -3991,7 +4079,7 @@ var require_parser = __commonJS({
|
|
|
3991
4079
|
return OpenBrace$0(state);
|
|
3992
4080
|
}
|
|
3993
4081
|
}
|
|
3994
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
4082
|
+
var OpenBracket$0 = $TV($EXPECT($L114, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
3995
4083
|
return { $loc, token: $1 };
|
|
3996
4084
|
});
|
|
3997
4085
|
function OpenBracket(state) {
|
|
@@ -4003,7 +4091,7 @@ var require_parser = __commonJS({
|
|
|
4003
4091
|
return OpenBracket$0(state);
|
|
4004
4092
|
}
|
|
4005
4093
|
}
|
|
4006
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
4094
|
+
var OpenParen$0 = $TV($EXPECT($L115, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
4007
4095
|
return { $loc, token: $1 };
|
|
4008
4096
|
});
|
|
4009
4097
|
function OpenParen(state) {
|
|
@@ -4015,7 +4103,7 @@ var require_parser = __commonJS({
|
|
|
4015
4103
|
return OpenParen$0(state);
|
|
4016
4104
|
}
|
|
4017
4105
|
}
|
|
4018
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
4106
|
+
var QuestionMark$0 = $TV($EXPECT($L116, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
4019
4107
|
return { $loc, token: $1 };
|
|
4020
4108
|
});
|
|
4021
4109
|
function QuestionMark(state) {
|
|
@@ -4027,7 +4115,7 @@ var require_parser = __commonJS({
|
|
|
4027
4115
|
return QuestionMark$0(state);
|
|
4028
4116
|
}
|
|
4029
4117
|
}
|
|
4030
|
-
var Return$0 = $TS($S($EXPECT($
|
|
4118
|
+
var Return$0 = $TS($S($EXPECT($L117, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4031
4119
|
return { $loc, token: $1 };
|
|
4032
4120
|
});
|
|
4033
4121
|
function Return(state) {
|
|
@@ -4039,7 +4127,7 @@ var require_parser = __commonJS({
|
|
|
4039
4127
|
return Return$0(state);
|
|
4040
4128
|
}
|
|
4041
4129
|
}
|
|
4042
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
4130
|
+
var Semicolon$0 = $TV($EXPECT($L75, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
4043
4131
|
return { $loc, token: $1 };
|
|
4044
4132
|
});
|
|
4045
4133
|
function Semicolon(state) {
|
|
@@ -4051,7 +4139,7 @@ var require_parser = __commonJS({
|
|
|
4051
4139
|
return Semicolon$0(state);
|
|
4052
4140
|
}
|
|
4053
4141
|
}
|
|
4054
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
4142
|
+
var SingleQuote$0 = $TV($EXPECT($L118, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
4055
4143
|
return { $loc, token: $1 };
|
|
4056
4144
|
});
|
|
4057
4145
|
function SingleQuote(state) {
|
|
@@ -4063,7 +4151,7 @@ var require_parser = __commonJS({
|
|
|
4063
4151
|
return SingleQuote$0(state);
|
|
4064
4152
|
}
|
|
4065
4153
|
}
|
|
4066
|
-
var Star$0 = $TV($EXPECT($
|
|
4154
|
+
var Star$0 = $TV($EXPECT($L46, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
4067
4155
|
return { $loc, token: $1 };
|
|
4068
4156
|
});
|
|
4069
4157
|
function Star(state) {
|
|
@@ -4075,10 +4163,10 @@ var require_parser = __commonJS({
|
|
|
4075
4163
|
return Star$0(state);
|
|
4076
4164
|
}
|
|
4077
4165
|
}
|
|
4078
|
-
var Static$0 = $TV($EXPECT($
|
|
4166
|
+
var Static$0 = $TV($EXPECT($L119, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
4079
4167
|
return { $loc, token: $1 };
|
|
4080
4168
|
});
|
|
4081
|
-
var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($
|
|
4169
|
+
var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L115, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
|
|
4082
4170
|
return { $loc, token: "static " };
|
|
4083
4171
|
});
|
|
4084
4172
|
function Static(state) {
|
|
@@ -4088,7 +4176,7 @@ var require_parser = __commonJS({
|
|
|
4088
4176
|
return Static$0(state) || Static$1(state);
|
|
4089
4177
|
}
|
|
4090
4178
|
}
|
|
4091
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
4179
|
+
var SubstitutionStart$0 = $TV($EXPECT($L120, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
4092
4180
|
return { $loc, token: $1 };
|
|
4093
4181
|
});
|
|
4094
4182
|
function SubstitutionStart(state) {
|
|
@@ -4100,7 +4188,7 @@ var require_parser = __commonJS({
|
|
|
4100
4188
|
return SubstitutionStart$0(state);
|
|
4101
4189
|
}
|
|
4102
4190
|
}
|
|
4103
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
4191
|
+
var Switch$0 = $TS($S($EXPECT($L121, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4104
4192
|
return { $loc, token: $1 };
|
|
4105
4193
|
});
|
|
4106
4194
|
function Switch(state) {
|
|
@@ -4112,7 +4200,7 @@ var require_parser = __commonJS({
|
|
|
4112
4200
|
return Switch$0(state);
|
|
4113
4201
|
}
|
|
4114
4202
|
}
|
|
4115
|
-
var Target$0 = $TV($EXPECT($
|
|
4203
|
+
var Target$0 = $TV($EXPECT($L122, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
|
|
4116
4204
|
return { $loc, token: $1 };
|
|
4117
4205
|
});
|
|
4118
4206
|
function Target(state) {
|
|
@@ -4124,7 +4212,7 @@ var require_parser = __commonJS({
|
|
|
4124
4212
|
return Target$0(state);
|
|
4125
4213
|
}
|
|
4126
4214
|
}
|
|
4127
|
-
var Throw$0 = $TS($S($EXPECT($
|
|
4215
|
+
var Throw$0 = $TS($S($EXPECT($L123, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4128
4216
|
return { $loc, token: $1 };
|
|
4129
4217
|
});
|
|
4130
4218
|
function Throw(state) {
|
|
@@ -4136,7 +4224,7 @@ var require_parser = __commonJS({
|
|
|
4136
4224
|
return Throw$0(state);
|
|
4137
4225
|
}
|
|
4138
4226
|
}
|
|
4139
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
4227
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L124, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
4140
4228
|
return { $loc, token: "`" };
|
|
4141
4229
|
});
|
|
4142
4230
|
function TripleDoubleQuote(state) {
|
|
@@ -4148,7 +4236,7 @@ var require_parser = __commonJS({
|
|
|
4148
4236
|
return TripleDoubleQuote$0(state);
|
|
4149
4237
|
}
|
|
4150
4238
|
}
|
|
4151
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
4239
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L125, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
4152
4240
|
return { $loc, token: "`" };
|
|
4153
4241
|
});
|
|
4154
4242
|
function TripleSingleQuote(state) {
|
|
@@ -4160,7 +4248,7 @@ var require_parser = __commonJS({
|
|
|
4160
4248
|
return TripleSingleQuote$0(state);
|
|
4161
4249
|
}
|
|
4162
4250
|
}
|
|
4163
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
4251
|
+
var TripleTick$0 = $TV($EXPECT($L126, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
4164
4252
|
return { $loc, token: "`" };
|
|
4165
4253
|
});
|
|
4166
4254
|
function TripleTick(state) {
|
|
@@ -4172,7 +4260,7 @@ var require_parser = __commonJS({
|
|
|
4172
4260
|
return TripleTick$0(state);
|
|
4173
4261
|
}
|
|
4174
4262
|
}
|
|
4175
|
-
var Try$0 = $TV($EXPECT($
|
|
4263
|
+
var Try$0 = $TV($EXPECT($L127, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
4176
4264
|
return { $loc, token: $1 };
|
|
4177
4265
|
});
|
|
4178
4266
|
function Try(state) {
|
|
@@ -4184,7 +4272,7 @@ var require_parser = __commonJS({
|
|
|
4184
4272
|
return Try$0(state);
|
|
4185
4273
|
}
|
|
4186
4274
|
}
|
|
4187
|
-
var Unless$0 = $TV($EXPECT($
|
|
4275
|
+
var Unless$0 = $TV($EXPECT($L128, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
4188
4276
|
return { $loc, token: $1 };
|
|
4189
4277
|
});
|
|
4190
4278
|
function Unless(state) {
|
|
@@ -4196,7 +4284,7 @@ var require_parser = __commonJS({
|
|
|
4196
4284
|
return Unless$0(state);
|
|
4197
4285
|
}
|
|
4198
4286
|
}
|
|
4199
|
-
var Var$0 = $TV($EXPECT($
|
|
4287
|
+
var Var$0 = $TV($EXPECT($L129, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
4200
4288
|
return { $loc, token: $1 };
|
|
4201
4289
|
});
|
|
4202
4290
|
function Var(state) {
|
|
@@ -4208,7 +4296,7 @@ var require_parser = __commonJS({
|
|
|
4208
4296
|
return Var$0(state);
|
|
4209
4297
|
}
|
|
4210
4298
|
}
|
|
4211
|
-
var When$0 = $TS($S($EXPECT($
|
|
4299
|
+
var When$0 = $TS($S($EXPECT($L130, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4212
4300
|
return { $loc, token: "case" };
|
|
4213
4301
|
});
|
|
4214
4302
|
function When(state) {
|
|
@@ -4220,7 +4308,7 @@ var require_parser = __commonJS({
|
|
|
4220
4308
|
return When$0(state);
|
|
4221
4309
|
}
|
|
4222
4310
|
}
|
|
4223
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
4311
|
+
var Yield$0 = $TS($S($EXPECT($L131, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4224
4312
|
return { $loc, token: $1 };
|
|
4225
4313
|
});
|
|
4226
4314
|
function Yield(state) {
|
|
@@ -4246,7 +4334,7 @@ var require_parser = __commonJS({
|
|
|
4246
4334
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
4247
4335
|
}
|
|
4248
4336
|
}
|
|
4249
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
4337
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L132, fail, 'JSXSelfClosingElement "/>"'));
|
|
4250
4338
|
function JSXSelfClosingElement(state) {
|
|
4251
4339
|
if (state.verbose)
|
|
4252
4340
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -4256,7 +4344,7 @@ var require_parser = __commonJS({
|
|
|
4256
4344
|
return JSXSelfClosingElement$0(state);
|
|
4257
4345
|
}
|
|
4258
4346
|
}
|
|
4259
|
-
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
4347
|
+
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L56, fail, 'JSXOpeningElement ">"'));
|
|
4260
4348
|
function JSXOpeningElement(state) {
|
|
4261
4349
|
if (state.verbose)
|
|
4262
4350
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -4266,7 +4354,7 @@ var require_parser = __commonJS({
|
|
|
4266
4354
|
return JSXOpeningElement$0(state);
|
|
4267
4355
|
}
|
|
4268
4356
|
}
|
|
4269
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
4357
|
+
var JSXClosingElement$0 = $S($EXPECT($L133, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L56, fail, 'JSXClosingElement ">"'));
|
|
4270
4358
|
function JSXClosingElement(state) {
|
|
4271
4359
|
if (state.verbose)
|
|
4272
4360
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -4276,7 +4364,7 @@ var require_parser = __commonJS({
|
|
|
4276
4364
|
return JSXClosingElement$0(state);
|
|
4277
4365
|
}
|
|
4278
4366
|
}
|
|
4279
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
4367
|
+
var JSXFragment$0 = $S($EXPECT($L134, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L135, fail, 'JSXFragment "</>"'));
|
|
4280
4368
|
function JSXFragment(state) {
|
|
4281
4369
|
if (state.verbose)
|
|
4282
4370
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -4296,7 +4384,7 @@ var require_parser = __commonJS({
|
|
|
4296
4384
|
return JSXElementName$0(state);
|
|
4297
4385
|
}
|
|
4298
4386
|
}
|
|
4299
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
4387
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R32, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
4300
4388
|
function JSXIdentifierName(state) {
|
|
4301
4389
|
if (state.verbose)
|
|
4302
4390
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -4316,7 +4404,7 @@ var require_parser = __commonJS({
|
|
|
4316
4404
|
return JSXAttributes$0(state);
|
|
4317
4405
|
}
|
|
4318
4406
|
}
|
|
4319
|
-
var JSXAttribute$0 = $S(OpenBrace, __,
|
|
4407
|
+
var JSXAttribute$0 = $S(OpenBrace, __, DotDotDot, __, AssignmentExpression, __, CloseBrace);
|
|
4320
4408
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
4321
4409
|
function JSXAttribute(state) {
|
|
4322
4410
|
if (state.tokenize) {
|
|
@@ -4345,8 +4433,8 @@ var require_parser = __commonJS({
|
|
|
4345
4433
|
return JSXAttributeInitializer$0(state);
|
|
4346
4434
|
}
|
|
4347
4435
|
}
|
|
4348
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
4349
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
4436
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R33, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
4437
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R34, fail, "JSXAttributeValue /'[^']*'/"));
|
|
4350
4438
|
var JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
|
|
4351
4439
|
var JSXAttributeValue$3 = JSXElement;
|
|
4352
4440
|
var JSXAttributeValue$4 = JSXFragment;
|
|
@@ -4378,7 +4466,7 @@ var require_parser = __commonJS({
|
|
|
4378
4466
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
4379
4467
|
}
|
|
4380
4468
|
}
|
|
4381
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
4469
|
+
var JSXText$0 = $R$0($EXPECT($R35, fail, "JSXText /[^{}<>]+/"));
|
|
4382
4470
|
function JSXText(state) {
|
|
4383
4471
|
if (state.verbose)
|
|
4384
4472
|
console.log("ENTER:", "JSXText");
|
|
@@ -4388,7 +4476,7 @@ var require_parser = __commonJS({
|
|
|
4388
4476
|
return JSXText$0(state);
|
|
4389
4477
|
}
|
|
4390
4478
|
}
|
|
4391
|
-
var JSXChildExpression$0 = $S(__, $E($S(
|
|
4479
|
+
var JSXChildExpression$0 = $S(__, $E($S(DotDotDot, __)), AssignmentExpression);
|
|
4392
4480
|
function JSXChildExpression(state) {
|
|
4393
4481
|
if (state.verbose)
|
|
4394
4482
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -4410,7 +4498,7 @@ var require_parser = __commonJS({
|
|
|
4410
4498
|
return TypeDeclaration$0(state);
|
|
4411
4499
|
}
|
|
4412
4500
|
}
|
|
4413
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
4501
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L136, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
4414
4502
|
var TypeDeclarationModifier$1 = Export;
|
|
4415
4503
|
function TypeDeclarationModifier(state) {
|
|
4416
4504
|
if (state.tokenize) {
|
|
@@ -4420,16 +4508,17 @@ var require_parser = __commonJS({
|
|
|
4420
4508
|
}
|
|
4421
4509
|
}
|
|
4422
4510
|
var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, Equals, __, Type);
|
|
4423
|
-
var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, InterfaceBlock);
|
|
4511
|
+
var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, $E(TypeParameters), InterfaceBlock);
|
|
4424
4512
|
var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
|
|
4513
|
+
var TypeDeclarationRest$3 = FunctionSignature;
|
|
4425
4514
|
function TypeDeclarationRest(state) {
|
|
4426
4515
|
if (state.tokenize) {
|
|
4427
|
-
return $TOKEN("TypeDeclarationRest", state, TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state));
|
|
4516
|
+
return $TOKEN("TypeDeclarationRest", state, TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state));
|
|
4428
4517
|
} else {
|
|
4429
|
-
return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state);
|
|
4518
|
+
return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state);
|
|
4430
4519
|
}
|
|
4431
4520
|
}
|
|
4432
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
4521
|
+
var TypeKeyword$0 = $S($EXPECT($L137, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
4433
4522
|
function TypeKeyword(state) {
|
|
4434
4523
|
if (state.verbose)
|
|
4435
4524
|
console.log("ENTER:", "TypeKeyword");
|
|
@@ -4439,7 +4528,7 @@ var require_parser = __commonJS({
|
|
|
4439
4528
|
return TypeKeyword$0(state);
|
|
4440
4529
|
}
|
|
4441
4530
|
}
|
|
4442
|
-
var Interface$0 = $S($EXPECT($
|
|
4531
|
+
var Interface$0 = $S($EXPECT($L138, fail, 'Interface "interface"'), NonIdContinue);
|
|
4443
4532
|
function Interface(state) {
|
|
4444
4533
|
if (state.verbose)
|
|
4445
4534
|
console.log("ENTER:", "Interface");
|
|
@@ -4449,7 +4538,7 @@ var require_parser = __commonJS({
|
|
|
4449
4538
|
return Interface$0(state);
|
|
4450
4539
|
}
|
|
4451
4540
|
}
|
|
4452
|
-
var Namespace$0 = $S($EXPECT($
|
|
4541
|
+
var Namespace$0 = $S($EXPECT($L139, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
4453
4542
|
function Namespace(state) {
|
|
4454
4543
|
if (state.verbose)
|
|
4455
4544
|
console.log("ENTER:", "Namespace");
|
|
@@ -4495,27 +4584,23 @@ var require_parser = __commonJS({
|
|
|
4495
4584
|
}
|
|
4496
4585
|
}
|
|
4497
4586
|
var InterfaceProperty$0 = $S($C(TypeIndexSignature, PropertyName), TypeSuffix, InterfacePropertyDelimiter);
|
|
4498
|
-
var InterfaceProperty$1 =
|
|
4587
|
+
var InterfaceProperty$1 = $S(NonEmptyParameters, TypeSuffix, InterfacePropertyDelimiter);
|
|
4588
|
+
var InterfaceProperty$2 = $S(MethodSignature, InterfacePropertyDelimiter);
|
|
4499
4589
|
function InterfaceProperty(state) {
|
|
4500
4590
|
if (state.tokenize) {
|
|
4501
|
-
return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state));
|
|
4591
|
+
return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state) || InterfaceProperty$2(state));
|
|
4502
4592
|
} else {
|
|
4503
|
-
return InterfaceProperty$0(state) || InterfaceProperty$1(state);
|
|
4593
|
+
return InterfaceProperty$0(state) || InterfaceProperty$1(state) || InterfaceProperty$2(state);
|
|
4504
4594
|
}
|
|
4505
4595
|
}
|
|
4506
|
-
var InterfacePropertyDelimiter$0 = $S($Q(_), Semicolon);
|
|
4507
|
-
var InterfacePropertyDelimiter$1 = $Y($S(
|
|
4508
|
-
var InterfacePropertyDelimiter$2 = $
|
|
4509
|
-
return { $loc, token: ";" };
|
|
4510
|
-
});
|
|
4511
|
-
var InterfacePropertyDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
4512
|
-
return { $loc, token: ";" };
|
|
4513
|
-
});
|
|
4596
|
+
var InterfacePropertyDelimiter$0 = $S($Q(_), $C(Semicolon, Comma));
|
|
4597
|
+
var InterfacePropertyDelimiter$1 = $Y($S(__, CloseBrace));
|
|
4598
|
+
var InterfacePropertyDelimiter$2 = $Y(EOS);
|
|
4514
4599
|
function InterfacePropertyDelimiter(state) {
|
|
4515
4600
|
if (state.tokenize) {
|
|
4516
|
-
return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state)
|
|
4601
|
+
return $TOKEN("InterfacePropertyDelimiter", state, InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state));
|
|
4517
4602
|
} else {
|
|
4518
|
-
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state)
|
|
4603
|
+
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state);
|
|
4519
4604
|
}
|
|
4520
4605
|
}
|
|
4521
4606
|
var NamespaceBlock$0 = $S(__, OpenBrace, EOS, NestedTypeDeclarations, __, CloseBrace);
|
|
@@ -4553,7 +4638,7 @@ var require_parser = __commonJS({
|
|
|
4553
4638
|
return NestedTypeDeclaration$0(state);
|
|
4554
4639
|
}
|
|
4555
4640
|
}
|
|
4556
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
4641
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R36, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L140, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R37, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
4557
4642
|
function TypeIndexSignature(state) {
|
|
4558
4643
|
if (state.verbose)
|
|
4559
4644
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -4584,7 +4669,7 @@ var require_parser = __commonJS({
|
|
|
4584
4669
|
return TypeSuffix$0(state);
|
|
4585
4670
|
}
|
|
4586
4671
|
}
|
|
4587
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
4672
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L141, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
4588
4673
|
if (!$3)
|
|
4589
4674
|
$0.splice(2, 1);
|
|
4590
4675
|
if ($1.length === 0)
|
|
@@ -4604,7 +4689,7 @@ var require_parser = __commonJS({
|
|
|
4604
4689
|
return ReturnTypeSuffix$0(state);
|
|
4605
4690
|
}
|
|
4606
4691
|
}
|
|
4607
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
4692
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L59, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
4608
4693
|
if (!$2)
|
|
4609
4694
|
return $1;
|
|
4610
4695
|
return $0;
|
|
@@ -4659,18 +4744,17 @@ var require_parser = __commonJS({
|
|
|
4659
4744
|
}
|
|
4660
4745
|
}
|
|
4661
4746
|
var TypeUnarySuffix$0 = TypeIndexedAccess;
|
|
4747
|
+
var TypeUnarySuffix$1 = QuestionMark;
|
|
4662
4748
|
function TypeUnarySuffix(state) {
|
|
4663
|
-
if (state.verbose)
|
|
4664
|
-
console.log("ENTER:", "TypeUnarySuffix");
|
|
4665
4749
|
if (state.tokenize) {
|
|
4666
|
-
return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state));
|
|
4750
|
+
return $TOKEN("TypeUnarySuffix", state, TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state));
|
|
4667
4751
|
} else {
|
|
4668
|
-
return TypeUnarySuffix$0(state);
|
|
4752
|
+
return TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state);
|
|
4669
4753
|
}
|
|
4670
4754
|
}
|
|
4671
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
4672
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
4673
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
4755
|
+
var TypeUnaryOp$0 = $EXPECT($L142, fail, 'TypeUnaryOp "keyof"');
|
|
4756
|
+
var TypeUnaryOp$1 = $EXPECT($L74, fail, 'TypeUnaryOp "typeof"');
|
|
4757
|
+
var TypeUnaryOp$2 = $EXPECT($L143, fail, 'TypeUnaryOp "infer"');
|
|
4674
4758
|
function TypeUnaryOp(state) {
|
|
4675
4759
|
if (state.tokenize) {
|
|
4676
4760
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -4690,14 +4774,59 @@ var require_parser = __commonJS({
|
|
|
4690
4774
|
}
|
|
4691
4775
|
var TypePrimary$0 = InterfaceBlock;
|
|
4692
4776
|
var TypePrimary$1 = $S(__, OpenParen, Type, __, CloseParen);
|
|
4693
|
-
var TypePrimary$2 = $S(
|
|
4694
|
-
var TypePrimary$3 = $S($Q(_),
|
|
4695
|
-
var TypePrimary$4 = $S($Q(_),
|
|
4777
|
+
var TypePrimary$2 = $S(__, TypeTuple);
|
|
4778
|
+
var TypePrimary$3 = $S($Q(_), FunctionType);
|
|
4779
|
+
var TypePrimary$4 = $S($Q(_), TypeLiteral);
|
|
4780
|
+
var TypePrimary$5 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
4696
4781
|
function TypePrimary(state) {
|
|
4697
4782
|
if (state.tokenize) {
|
|
4698
|
-
return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state));
|
|
4783
|
+
return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state));
|
|
4784
|
+
} else {
|
|
4785
|
+
return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state) || TypePrimary$5(state);
|
|
4786
|
+
}
|
|
4787
|
+
}
|
|
4788
|
+
var TypeTuple$0 = $S(OpenBracket, NestedTypeList, __, CloseBracket);
|
|
4789
|
+
var TypeTuple$1 = $S(OpenBracket, $E(TypeList), __, CloseBracket);
|
|
4790
|
+
function TypeTuple(state) {
|
|
4791
|
+
if (state.tokenize) {
|
|
4792
|
+
return $TOKEN("TypeTuple", state, TypeTuple$0(state) || TypeTuple$1(state));
|
|
4793
|
+
} else {
|
|
4794
|
+
return TypeTuple$0(state) || TypeTuple$1(state);
|
|
4795
|
+
}
|
|
4796
|
+
}
|
|
4797
|
+
var TypeList$0 = $S(Type, $Q($S(__, Comma, Type)));
|
|
4798
|
+
function TypeList(state) {
|
|
4799
|
+
if (state.verbose)
|
|
4800
|
+
console.log("ENTER:", "TypeList");
|
|
4801
|
+
if (state.tokenize) {
|
|
4802
|
+
return $TOKEN("TypeList", state, TypeList$0(state));
|
|
4803
|
+
} else {
|
|
4804
|
+
return TypeList$0(state);
|
|
4805
|
+
}
|
|
4806
|
+
}
|
|
4807
|
+
var NestedTypeList$0 = $TS($S(PushIndent, $Q(NestedType), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
4808
|
+
var types = $2;
|
|
4809
|
+
if (types.length)
|
|
4810
|
+
return types;
|
|
4811
|
+
return $skip;
|
|
4812
|
+
});
|
|
4813
|
+
function NestedTypeList(state) {
|
|
4814
|
+
if (state.verbose)
|
|
4815
|
+
console.log("ENTER:", "NestedTypeList");
|
|
4816
|
+
if (state.tokenize) {
|
|
4817
|
+
return $TOKEN("NestedTypeList", state, NestedTypeList$0(state));
|
|
4699
4818
|
} else {
|
|
4700
|
-
return
|
|
4819
|
+
return NestedTypeList$0(state);
|
|
4820
|
+
}
|
|
4821
|
+
}
|
|
4822
|
+
var NestedType$0 = $S(Nested, Type, ArrayElementDelimiter);
|
|
4823
|
+
function NestedType(state) {
|
|
4824
|
+
if (state.verbose)
|
|
4825
|
+
console.log("ENTER:", "NestedType");
|
|
4826
|
+
if (state.tokenize) {
|
|
4827
|
+
return $TOKEN("NestedType", state, NestedType$0(state));
|
|
4828
|
+
} else {
|
|
4829
|
+
return NestedType$0(state);
|
|
4701
4830
|
}
|
|
4702
4831
|
}
|
|
4703
4832
|
var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
|
|
@@ -4715,10 +4844,10 @@ var require_parser = __commonJS({
|
|
|
4715
4844
|
}
|
|
4716
4845
|
}
|
|
4717
4846
|
var TypeLiteral$0 = Literal;
|
|
4718
|
-
var TypeLiteral$1 = $TV($EXPECT($
|
|
4847
|
+
var TypeLiteral$1 = $TV($EXPECT($L73, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
|
|
4719
4848
|
return { $loc, token: "void" };
|
|
4720
4849
|
});
|
|
4721
|
-
var TypeLiteral$2 = $TV($EXPECT($
|
|
4850
|
+
var TypeLiteral$2 = $TV($EXPECT($L144, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
4722
4851
|
return { $loc, token: "[]" };
|
|
4723
4852
|
});
|
|
4724
4853
|
function TypeLiteral(state) {
|
|
@@ -4728,10 +4857,10 @@ var require_parser = __commonJS({
|
|
|
4728
4857
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
4729
4858
|
}
|
|
4730
4859
|
}
|
|
4731
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
4860
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L71, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
4732
4861
|
return { $loc, token: "|" };
|
|
4733
4862
|
});
|
|
4734
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
4863
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L69, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
4735
4864
|
return { $loc, token: "&" };
|
|
4736
4865
|
});
|
|
4737
4866
|
function TypeBinaryOp(state) {
|
|
@@ -4751,7 +4880,7 @@ var require_parser = __commonJS({
|
|
|
4751
4880
|
return FunctionType$0(state);
|
|
4752
4881
|
}
|
|
4753
4882
|
}
|
|
4754
|
-
var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
4883
|
+
var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L56, fail, 'TypeArguments ">"'));
|
|
4755
4884
|
function TypeArguments(state) {
|
|
4756
4885
|
if (state.verbose)
|
|
4757
4886
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -4761,7 +4890,7 @@ var require_parser = __commonJS({
|
|
|
4761
4890
|
return TypeArguments$0(state);
|
|
4762
4891
|
}
|
|
4763
4892
|
}
|
|
4764
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
4893
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L56, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
4765
4894
|
return { ts: true, children: $0 };
|
|
4766
4895
|
});
|
|
4767
4896
|
function TypeParameters(state) {
|
|
@@ -4794,8 +4923,8 @@ var require_parser = __commonJS({
|
|
|
4794
4923
|
}
|
|
4795
4924
|
}
|
|
4796
4925
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
4797
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
4798
|
-
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($
|
|
4926
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L56, fail, 'TypeParameterDelimiter ">"')));
|
|
4927
|
+
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L56, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
|
|
4799
4928
|
return { $loc, token: "," };
|
|
4800
4929
|
});
|
|
4801
4930
|
var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
@@ -4808,7 +4937,7 @@ var require_parser = __commonJS({
|
|
|
4808
4937
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
4809
4938
|
}
|
|
4810
4939
|
}
|
|
4811
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
4940
|
+
var Shebang$0 = $S($R$0($EXPECT($R38, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
4812
4941
|
function Shebang(state) {
|
|
4813
4942
|
if (state.verbose)
|
|
4814
4943
|
console.log("ENTER:", "Shebang");
|
|
@@ -4818,14 +4947,73 @@ var require_parser = __commonJS({
|
|
|
4818
4947
|
return Shebang$0(state);
|
|
4819
4948
|
}
|
|
4820
4949
|
}
|
|
4821
|
-
var
|
|
4822
|
-
|
|
4950
|
+
var CivetPrologue$0 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
4951
|
+
var content = value[2];
|
|
4952
|
+
return content;
|
|
4953
|
+
});
|
|
4954
|
+
var CivetPrologue$1 = $T($S($EXPECT($R39, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
4955
|
+
var content = value[2];
|
|
4956
|
+
return content;
|
|
4957
|
+
});
|
|
4958
|
+
function CivetPrologue(state) {
|
|
4959
|
+
if (state.tokenize) {
|
|
4960
|
+
return $TOKEN("CivetPrologue", state, CivetPrologue$0(state) || CivetPrologue$1(state));
|
|
4961
|
+
} else {
|
|
4962
|
+
return CivetPrologue$0(state) || CivetPrologue$1(state);
|
|
4963
|
+
}
|
|
4964
|
+
}
|
|
4965
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L145, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R40, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
4966
|
+
var options = $2;
|
|
4967
|
+
return {
|
|
4968
|
+
type: "CivetPrologue",
|
|
4969
|
+
children: [],
|
|
4970
|
+
config: Object.fromEntries(options)
|
|
4971
|
+
};
|
|
4972
|
+
});
|
|
4973
|
+
function CivetPrologueContent(state) {
|
|
4974
|
+
if (state.verbose)
|
|
4975
|
+
console.log("ENTER:", "CivetPrologueContent");
|
|
4976
|
+
if (state.tokenize) {
|
|
4977
|
+
return $TOKEN("CivetPrologueContent", state, CivetPrologueContent$0(state));
|
|
4978
|
+
} else {
|
|
4979
|
+
return CivetPrologueContent$0(state);
|
|
4980
|
+
}
|
|
4981
|
+
}
|
|
4982
|
+
var CivetOption$0 = $TR($EXPECT($R41, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
4983
|
+
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
4984
|
+
if (l)
|
|
4985
|
+
return l.toUpperCase();
|
|
4986
|
+
return "";
|
|
4987
|
+
});
|
|
4988
|
+
const value = $1 === "-" ? false : true;
|
|
4989
|
+
return [optionName, value];
|
|
4990
|
+
});
|
|
4991
|
+
function CivetOption(state) {
|
|
4992
|
+
if (state.verbose)
|
|
4993
|
+
console.log("ENTER:", "CivetOption");
|
|
4994
|
+
if (state.tokenize) {
|
|
4995
|
+
return $TOKEN("CivetOption", state, CivetOption$0(state));
|
|
4996
|
+
} else {
|
|
4997
|
+
return CivetOption$0(state);
|
|
4998
|
+
}
|
|
4999
|
+
}
|
|
5000
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R39, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
|
|
5001
|
+
function UnknownPrologue(state) {
|
|
4823
5002
|
if (state.verbose)
|
|
4824
|
-
console.log("ENTER:", "
|
|
5003
|
+
console.log("ENTER:", "UnknownPrologue");
|
|
5004
|
+
if (state.tokenize) {
|
|
5005
|
+
return $TOKEN("UnknownPrologue", state, UnknownPrologue$0(state));
|
|
5006
|
+
} else {
|
|
5007
|
+
return UnknownPrologue$0(state);
|
|
5008
|
+
}
|
|
5009
|
+
}
|
|
5010
|
+
var DirectivePrologue$0 = CivetPrologue;
|
|
5011
|
+
var DirectivePrologue$1 = UnknownPrologue;
|
|
5012
|
+
function DirectivePrologue(state) {
|
|
4825
5013
|
if (state.tokenize) {
|
|
4826
|
-
return $TOKEN("DirectivePrologue", state, DirectivePrologue$0(state));
|
|
5014
|
+
return $TOKEN("DirectivePrologue", state, DirectivePrologue$0(state) || DirectivePrologue$1(state));
|
|
4827
5015
|
} else {
|
|
4828
|
-
return DirectivePrologue$0(state);
|
|
5016
|
+
return DirectivePrologue$0(state) || DirectivePrologue$1(state);
|
|
4829
5017
|
}
|
|
4830
5018
|
}
|
|
4831
5019
|
var EOS$0 = $P(RestOfLine);
|
|
@@ -4838,7 +5026,7 @@ var require_parser = __commonJS({
|
|
|
4838
5026
|
return EOS$0(state);
|
|
4839
5027
|
}
|
|
4840
5028
|
}
|
|
4841
|
-
var EOL$0 = $R$0($EXPECT($
|
|
5029
|
+
var EOL$0 = $R$0($EXPECT($R42, fail, "EOL /\\r\\n|\\n|\\r|$/"));
|
|
4842
5030
|
function EOL(state) {
|
|
4843
5031
|
if (state.verbose)
|
|
4844
5032
|
console.log("ENTER:", "EOL");
|
|
@@ -4848,7 +5036,7 @@ var require_parser = __commonJS({
|
|
|
4848
5036
|
return EOL$0(state);
|
|
4849
5037
|
}
|
|
4850
5038
|
}
|
|
4851
|
-
var EOF$0 = $R$0($EXPECT($
|
|
5039
|
+
var EOF$0 = $R$0($EXPECT($R43, fail, "EOF /$/"));
|
|
4852
5040
|
function EOF(state) {
|
|
4853
5041
|
if (state.verbose)
|
|
4854
5042
|
console.log("ENTER:", "EOF");
|
|
@@ -5002,12 +5190,82 @@ var require_parser = __commonJS({
|
|
|
5002
5190
|
return InsertBreak$0(state);
|
|
5003
5191
|
}
|
|
5004
5192
|
}
|
|
5193
|
+
var CoffeeCommentEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
|
|
5194
|
+
if (module2.config.coffeeComment)
|
|
5195
|
+
return;
|
|
5196
|
+
return $skip;
|
|
5197
|
+
});
|
|
5198
|
+
function CoffeeCommentEnabled(state) {
|
|
5199
|
+
if (state.verbose)
|
|
5200
|
+
console.log("ENTER:", "CoffeeCommentEnabled");
|
|
5201
|
+
if (state.tokenize) {
|
|
5202
|
+
return $TOKEN("CoffeeCommentEnabled", state, CoffeeCommentEnabled$0(state));
|
|
5203
|
+
} else {
|
|
5204
|
+
return CoffeeCommentEnabled$0(state);
|
|
5205
|
+
}
|
|
5206
|
+
}
|
|
5207
|
+
var CoffeeBooleansEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
|
|
5208
|
+
if (module2.config.coffeeBooleans)
|
|
5209
|
+
return;
|
|
5210
|
+
return $skip;
|
|
5211
|
+
});
|
|
5212
|
+
function CoffeeBooleansEnabled(state) {
|
|
5213
|
+
if (state.verbose)
|
|
5214
|
+
console.log("ENTER:", "CoffeeBooleansEnabled");
|
|
5215
|
+
if (state.tokenize) {
|
|
5216
|
+
return $TOKEN("CoffeeBooleansEnabled", state, CoffeeBooleansEnabled$0(state));
|
|
5217
|
+
} else {
|
|
5218
|
+
return CoffeeBooleansEnabled$0(state);
|
|
5219
|
+
}
|
|
5220
|
+
}
|
|
5221
|
+
var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L1, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
|
|
5222
|
+
if (module2.config.coffeeInterpolation)
|
|
5223
|
+
return;
|
|
5224
|
+
return $skip;
|
|
5225
|
+
});
|
|
5226
|
+
function CoffeeInterpolationEnabled(state) {
|
|
5227
|
+
if (state.verbose)
|
|
5228
|
+
console.log("ENTER:", "CoffeeInterpolationEnabled");
|
|
5229
|
+
if (state.tokenize) {
|
|
5230
|
+
return $TOKEN("CoffeeInterpolationEnabled", state, CoffeeInterpolationEnabled$0(state));
|
|
5231
|
+
} else {
|
|
5232
|
+
return CoffeeInterpolationEnabled$0(state);
|
|
5233
|
+
}
|
|
5234
|
+
}
|
|
5005
5235
|
var Reset$0 = $TV($EXPECT($L1, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
5006
5236
|
module2.currentIndent = 0;
|
|
5007
5237
|
module2.indentLevels = [0];
|
|
5008
5238
|
module2.verbose = false;
|
|
5009
|
-
module2.
|
|
5010
|
-
|
|
5239
|
+
module2.config = {
|
|
5240
|
+
autoVar: false,
|
|
5241
|
+
coffeeBooleans: false,
|
|
5242
|
+
coffeeComment: false,
|
|
5243
|
+
coffeeEq: false,
|
|
5244
|
+
coffeeInterpolation: false,
|
|
5245
|
+
implicitReturns: true
|
|
5246
|
+
};
|
|
5247
|
+
Object.defineProperty(module2.config, "coffeeCompat", {
|
|
5248
|
+
set(b) {
|
|
5249
|
+
if (b) {
|
|
5250
|
+
this.autoVar = true;
|
|
5251
|
+
this.coffeeBooleans = true;
|
|
5252
|
+
this.coffeeComment = true;
|
|
5253
|
+
this.coffeeEq = true;
|
|
5254
|
+
this.coffeeInterpolation = true;
|
|
5255
|
+
this.implicitReturns = true;
|
|
5256
|
+
} else {
|
|
5257
|
+
this.autoVar = false;
|
|
5258
|
+
this.coffeeBooleans = false;
|
|
5259
|
+
this.coffeeComment = false;
|
|
5260
|
+
this.coffeeEq = false;
|
|
5261
|
+
this.coffeeInterpolation = false;
|
|
5262
|
+
this.implicitReturns = false;
|
|
5263
|
+
}
|
|
5264
|
+
}
|
|
5265
|
+
});
|
|
5266
|
+
module2.modifyString = function(str) {
|
|
5267
|
+
return str.replace(/(?<!\\)(\\\\)*\n/g, "$1\\n");
|
|
5268
|
+
};
|
|
5011
5269
|
});
|
|
5012
5270
|
function Reset(state) {
|
|
5013
5271
|
if (state.verbose)
|
|
@@ -5018,12 +5276,13 @@ var require_parser = __commonJS({
|
|
|
5018
5276
|
return Reset$0(state);
|
|
5019
5277
|
}
|
|
5020
5278
|
}
|
|
5021
|
-
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
5279
|
+
var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
5022
5280
|
var directives = $2;
|
|
5023
|
-
|
|
5024
|
-
|
|
5025
|
-
|
|
5026
|
-
|
|
5281
|
+
directives.forEach((directive) => {
|
|
5282
|
+
if (directive.type === "CivetPrologue") {
|
|
5283
|
+
Object.assign(module2.config, directive.config);
|
|
5284
|
+
}
|
|
5285
|
+
});
|
|
5027
5286
|
function hasReturnStatement(node) {
|
|
5028
5287
|
if (!node)
|
|
5029
5288
|
return false;
|
|
@@ -5044,6 +5303,9 @@ var require_parser = __commonJS({
|
|
|
5044
5303
|
case "AssignmentExpression":
|
|
5045
5304
|
node.children.unshift("return ");
|
|
5046
5305
|
return;
|
|
5306
|
+
case "Identifier":
|
|
5307
|
+
node.token = "return " + node.token;
|
|
5308
|
+
return;
|
|
5047
5309
|
case "BlockStatement":
|
|
5048
5310
|
insertReturn(node.expressions[node.expressions.length - 1]);
|
|
5049
5311
|
return;
|
|
@@ -5064,7 +5326,7 @@ var require_parser = __commonJS({
|
|
|
5064
5326
|
}
|
|
5065
5327
|
if (!Array.isArray(node))
|
|
5066
5328
|
return;
|
|
5067
|
-
const [, exp] = node;
|
|
5329
|
+
const [indent, exp] = node;
|
|
5068
5330
|
if (!exp)
|
|
5069
5331
|
return;
|
|
5070
5332
|
switch (exp.type) {
|
|
@@ -5076,10 +5338,15 @@ var require_parser = __commonJS({
|
|
|
5076
5338
|
case "ThrowStatement":
|
|
5077
5339
|
case "VariableDeclaration":
|
|
5078
5340
|
return;
|
|
5341
|
+
case "BlockStatement":
|
|
5342
|
+
insertReturn(exp.expressions[exp.expressions.length - 1]);
|
|
5343
|
+
return;
|
|
5079
5344
|
case "IfStatement":
|
|
5080
5345
|
insertReturn(exp.children[2]);
|
|
5081
5346
|
if (exp.children[3])
|
|
5082
5347
|
insertReturn(exp.children[3][2]);
|
|
5348
|
+
else
|
|
5349
|
+
exp.children.push(["\n", indent, "return"]);
|
|
5083
5350
|
return;
|
|
5084
5351
|
case "SwitchStatement":
|
|
5085
5352
|
insertReturn(exp.children[2]);
|
|
@@ -5097,6 +5364,50 @@ var require_parser = __commonJS({
|
|
|
5097
5364
|
insertReturn(block);
|
|
5098
5365
|
return block;
|
|
5099
5366
|
};
|
|
5367
|
+
module2.expandChainedComparisons = function([first, binops]) {
|
|
5368
|
+
const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in", "instanceof"];
|
|
5369
|
+
const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
|
|
5370
|
+
let results = [];
|
|
5371
|
+
let i = 0;
|
|
5372
|
+
let l = binops.length;
|
|
5373
|
+
let start = 0;
|
|
5374
|
+
let chains = [];
|
|
5375
|
+
while (i < l) {
|
|
5376
|
+
const [, op] = binops[i];
|
|
5377
|
+
if (relationalOps.includes(op.token)) {
|
|
5378
|
+
chains.push(i);
|
|
5379
|
+
} else if (lowerPrecedenceOps.includes(op.token)) {
|
|
5380
|
+
processChains();
|
|
5381
|
+
first = [];
|
|
5382
|
+
}
|
|
5383
|
+
i++;
|
|
5384
|
+
}
|
|
5385
|
+
processChains();
|
|
5386
|
+
return results;
|
|
5387
|
+
function processChains() {
|
|
5388
|
+
if (chains.length > 1) {
|
|
5389
|
+
chains.forEach((index, k) => {
|
|
5390
|
+
if (k > 0) {
|
|
5391
|
+
results.push(" && ");
|
|
5392
|
+
}
|
|
5393
|
+
const [pre, op, post, exp] = binops[index];
|
|
5394
|
+
let endIndex;
|
|
5395
|
+
if (k < chains.length - 1) {
|
|
5396
|
+
endIndex = chains[k + 1];
|
|
5397
|
+
} else {
|
|
5398
|
+
endIndex = i + 1;
|
|
5399
|
+
}
|
|
5400
|
+
results = results.concat(first, ...binops.slice(start, endIndex));
|
|
5401
|
+
first = [exp].concat(binops.slice(index + 1, endIndex));
|
|
5402
|
+
start = endIndex;
|
|
5403
|
+
});
|
|
5404
|
+
} else {
|
|
5405
|
+
results = results.concat(first, ...binops.slice(start, i + 1));
|
|
5406
|
+
start = i + 1;
|
|
5407
|
+
}
|
|
5408
|
+
chains.length = 0;
|
|
5409
|
+
}
|
|
5410
|
+
};
|
|
5100
5411
|
module2.parsePosition = function() {
|
|
5101
5412
|
let s = Error().stack.split(/\n at /);
|
|
5102
5413
|
s.shift();
|
|
@@ -5133,9 +5444,6 @@ var require_parser = __commonJS({
|
|
|
5133
5444
|
}
|
|
5134
5445
|
return spacing;
|
|
5135
5446
|
};
|
|
5136
|
-
module2.modifyString = function(str) {
|
|
5137
|
-
return str.replace(/(?<!\\)(\\\\)*\n/g, "$1\\n");
|
|
5138
|
-
};
|
|
5139
5447
|
module2.dedentBlockSubstitutions = function($02) {
|
|
5140
5448
|
const [s, strWithSubstitutions, e] = $02;
|
|
5141
5449
|
if (strWithSubstitutions.length === 0) {
|
|
@@ -5196,7 +5504,7 @@ var require_parser = __commonJS({
|
|
|
5196
5504
|
return Init$0(state);
|
|
5197
5505
|
}
|
|
5198
5506
|
}
|
|
5199
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
5507
|
+
var Indent$0 = $TV($Q($C($EXPECT($L146, fail, 'Indent " "'), $EXPECT($L147, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
5200
5508
|
const level = $1.length;
|
|
5201
5509
|
return {
|
|
5202
5510
|
$loc,
|