@danielx/civet 0.4.4 → 0.4.6
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 +7 -2
- package/dist/browser.js +569 -355
- package/dist/main.js +569 -355
- package/package.json +1 -1
package/dist/main.js
CHANGED
|
@@ -504,7 +504,6 @@ var require_parser = __commonJS({
|
|
|
504
504
|
PropertyName,
|
|
505
505
|
MethodDefinition,
|
|
506
506
|
MethodModifier,
|
|
507
|
-
ConstructorShorthand,
|
|
508
507
|
MethodSignature,
|
|
509
508
|
ClassElementName,
|
|
510
509
|
PrivateIdentifier,
|
|
@@ -534,6 +533,7 @@ var require_parser = __commonJS({
|
|
|
534
533
|
NestedCaseClauses,
|
|
535
534
|
NestedCaseClause,
|
|
536
535
|
CaseClause,
|
|
536
|
+
CaseExpressionList,
|
|
537
537
|
ImpliedColon,
|
|
538
538
|
TryStatement,
|
|
539
539
|
CatchClause,
|
|
@@ -579,12 +579,15 @@ var require_parser = __commonJS({
|
|
|
579
579
|
OctalIntegerLiteral,
|
|
580
580
|
HexLiteral,
|
|
581
581
|
StringLiteral,
|
|
582
|
-
|
|
583
|
-
|
|
582
|
+
BasicStringLiteral,
|
|
583
|
+
DoubleStringCharacters,
|
|
584
|
+
SingleStringCharacters,
|
|
584
585
|
TripleDoubleStringCharacters,
|
|
585
586
|
TripleSingleStringCharacters,
|
|
586
587
|
CoffeeStringSubstitution,
|
|
587
|
-
|
|
588
|
+
CoffeeCompat,
|
|
589
|
+
CoffeeCompatDoubleQuotedString,
|
|
590
|
+
CoffeeCompatDoubleQuotedStringCharacters,
|
|
588
591
|
RegularExpressionLiteral,
|
|
589
592
|
RegularExpressionBody,
|
|
590
593
|
RegExpCharacter,
|
|
@@ -613,13 +616,18 @@ var require_parser = __commonJS({
|
|
|
613
616
|
As,
|
|
614
617
|
Async,
|
|
615
618
|
Await,
|
|
619
|
+
Case,
|
|
616
620
|
Catch,
|
|
617
621
|
Class,
|
|
618
622
|
CloseBrace,
|
|
619
623
|
CloseBracket,
|
|
620
624
|
CloseParen,
|
|
625
|
+
CoffeeSubstitutionStart,
|
|
621
626
|
Colon,
|
|
627
|
+
ConstructorShorthand,
|
|
628
|
+
Default,
|
|
622
629
|
Dot,
|
|
630
|
+
DoubleQuote,
|
|
623
631
|
Else,
|
|
624
632
|
Equals,
|
|
625
633
|
Export,
|
|
@@ -640,7 +648,10 @@ var require_parser = __commonJS({
|
|
|
640
648
|
QuestionMark,
|
|
641
649
|
Return,
|
|
642
650
|
Semicolon,
|
|
651
|
+
SingleQuote,
|
|
652
|
+
Star,
|
|
643
653
|
Static,
|
|
654
|
+
SubstitutionStart,
|
|
644
655
|
Switch,
|
|
645
656
|
Target,
|
|
646
657
|
TripleDoubleQuote,
|
|
@@ -650,6 +661,7 @@ var require_parser = __commonJS({
|
|
|
650
661
|
Unless,
|
|
651
662
|
Var,
|
|
652
663
|
When,
|
|
664
|
+
Yield,
|
|
653
665
|
JSXElement,
|
|
654
666
|
JSXSelfClosingElement,
|
|
655
667
|
JSXOpeningElement,
|
|
@@ -718,6 +730,7 @@ var require_parser = __commonJS({
|
|
|
718
730
|
InsertSpace,
|
|
719
731
|
InsertDot,
|
|
720
732
|
InsertBreak,
|
|
733
|
+
Reset,
|
|
721
734
|
Init,
|
|
722
735
|
Indent,
|
|
723
736
|
TrackIndent,
|
|
@@ -731,130 +744,130 @@ var require_parser = __commonJS({
|
|
|
731
744
|
var $L1 = $L("");
|
|
732
745
|
var $L2 = $L("++");
|
|
733
746
|
var $L3 = $L("--");
|
|
734
|
-
var $L4 = $L("
|
|
735
|
-
var $L5 = $L("
|
|
736
|
-
var $L6 = $L("
|
|
737
|
-
var $L7 = $L("
|
|
738
|
-
var $L8 = $L("
|
|
739
|
-
var $L9 = $L("
|
|
740
|
-
var $L10 = $L("
|
|
741
|
-
var $L11 = $L("
|
|
742
|
-
var $L12 = $L("
|
|
743
|
-
var $L13 = $L("
|
|
744
|
-
var $L14 = $L("
|
|
745
|
-
var $L15 = $L("
|
|
746
|
-
var $L16 = $L("
|
|
747
|
-
var $L17 = $L("
|
|
748
|
-
var $L18 = $L("
|
|
749
|
-
var $L19 = $L("
|
|
750
|
-
var $L20 = $L("
|
|
751
|
-
var $L21 = $L("
|
|
752
|
-
var $L22 = $L("
|
|
753
|
-
var $L23 = $L("
|
|
754
|
-
var $L24 = $L("
|
|
755
|
-
var $L25 = $L("
|
|
756
|
-
var $L26 = $L("
|
|
757
|
-
var $L27 = $L("
|
|
758
|
-
var $L28 = $L("
|
|
759
|
-
var $L29 = $L("
|
|
760
|
-
var $L30 = $L("
|
|
761
|
-
var $L31 = $L("
|
|
762
|
-
var $L32 = $L("
|
|
763
|
-
var $L33 = $L("
|
|
764
|
-
var $L34 = $L("
|
|
765
|
-
var $L35 = $L("
|
|
766
|
-
var $L36 = $L("
|
|
767
|
-
var $L37 = $L("
|
|
768
|
-
var $L38 = $L("
|
|
769
|
-
var $L39 = $L("
|
|
770
|
-
var $L40 = $L("
|
|
771
|
-
var $L41 = $L("
|
|
772
|
-
var $L42 = $L("
|
|
773
|
-
var $L43 = $L("
|
|
774
|
-
var $L44 = $L("
|
|
775
|
-
var $L45 = $L("
|
|
776
|
-
var $L46 = $L("
|
|
777
|
-
var $L47 = $L("
|
|
778
|
-
var $L48 = $L("
|
|
779
|
-
var $L49 = $L("
|
|
780
|
-
var $L50 = $L("
|
|
781
|
-
var $L51 = $L("
|
|
782
|
-
var $L52 = $L("
|
|
783
|
-
var $L53 = $L("
|
|
784
|
-
var $L54 = $L("
|
|
785
|
-
var $L55 = $L("
|
|
786
|
-
var $L56 = $L("
|
|
787
|
-
var $L57 = $L("
|
|
788
|
-
var $L58 = $L("
|
|
789
|
-
var $L59 = $L("
|
|
790
|
-
var $L60 = $L("
|
|
791
|
-
var $L61 = $L("
|
|
792
|
-
var $L62 = $L("
|
|
793
|
-
var $L63 = $L("
|
|
794
|
-
var $L64 = $L("
|
|
795
|
-
var $L65 = $L("
|
|
796
|
-
var $L66 = $L("
|
|
797
|
-
var $L67 = $L("
|
|
798
|
-
var $L68 = $L("
|
|
799
|
-
var $L69 = $L("
|
|
800
|
-
var $L70 = $L("
|
|
801
|
-
var $L71 = $L("
|
|
802
|
-
var $L72 = $L("
|
|
803
|
-
var $L73 = $L("
|
|
804
|
-
var $L74 = $L("
|
|
805
|
-
var $L75 = $L("
|
|
806
|
-
var $L76 = $L("
|
|
807
|
-
var $L77 = $L("
|
|
808
|
-
var $L78 = $L("
|
|
809
|
-
var $L79 = $L("
|
|
810
|
-
var $L80 = $L("
|
|
811
|
-
var $L81 = $L("
|
|
812
|
-
var $L82 = $L("
|
|
813
|
-
var $L83 = $L("
|
|
814
|
-
var $L84 = $L("
|
|
815
|
-
var $L85 = $L("
|
|
816
|
-
var $L86 = $L(
|
|
817
|
-
var $L87 = $L("
|
|
818
|
-
var $L88 = $L("
|
|
819
|
-
var $L89 = $L("
|
|
820
|
-
var $L90 = $L("
|
|
821
|
-
var $L91 = $L("
|
|
822
|
-
var $L92 = $L("
|
|
823
|
-
var $L93 = $L("
|
|
824
|
-
var $L94 = $L("
|
|
825
|
-
var $L95 = $L("
|
|
826
|
-
var $L96 = $L("
|
|
827
|
-
var $L97 = $L("
|
|
828
|
-
var $L98 = $L("
|
|
829
|
-
var $L99 = $L("
|
|
830
|
-
var $L100 = $L("
|
|
831
|
-
var $L101 = $L("
|
|
832
|
-
var $L102 = $L("
|
|
833
|
-
var $L103 = $L("
|
|
834
|
-
var $L104 = $L("
|
|
835
|
-
var $L105 = $L("
|
|
836
|
-
var $L106 = $L("
|
|
837
|
-
var $L107 = $L("
|
|
838
|
-
var $L108 = $L("
|
|
839
|
-
var $L109 = $L("
|
|
840
|
-
var $L110 = $L("
|
|
841
|
-
var $L111 = $L("
|
|
842
|
-
var $L112 = $L("
|
|
843
|
-
var $L113 = $L("
|
|
844
|
-
var $L114 = $L("
|
|
845
|
-
var $L115 = $L("
|
|
846
|
-
var $L116 = $L("
|
|
847
|
-
var $L117 = $L("
|
|
848
|
-
var $L118 = $L("
|
|
849
|
-
var $L119 = $L("
|
|
850
|
-
var $L120 = $L("
|
|
851
|
-
var $L121 = $L('"
|
|
852
|
-
var $L122 = $L("
|
|
853
|
-
var $L123 = $L("
|
|
854
|
-
var $L124 = $L("
|
|
855
|
-
var $L125 = $L("
|
|
856
|
-
var $L126 = $L("
|
|
857
|
-
var $L127 = $L("
|
|
747
|
+
var $L4 = $L("=>");
|
|
748
|
+
var $L5 = $L("<");
|
|
749
|
+
var $L6 = $L("extends");
|
|
750
|
+
var $L7 = $L("this");
|
|
751
|
+
var $L8 = $L("#");
|
|
752
|
+
var $L9 = $L("@");
|
|
753
|
+
var $L10 = $L("super");
|
|
754
|
+
var $L11 = $L("import");
|
|
755
|
+
var $L12 = $L("!");
|
|
756
|
+
var $L13 = $L("::");
|
|
757
|
+
var $L14 = $L("super[");
|
|
758
|
+
var $L15 = $L("import.meta");
|
|
759
|
+
var $L16 = $L(")");
|
|
760
|
+
var $L17 = $L("...");
|
|
761
|
+
var $L18 = $L("->");
|
|
762
|
+
var $L19 = $L("null");
|
|
763
|
+
var $L20 = $L("true");
|
|
764
|
+
var $L21 = $L("false");
|
|
765
|
+
var $L22 = $L(",");
|
|
766
|
+
var $L23 = $L("]");
|
|
767
|
+
var $L24 = $L("}");
|
|
768
|
+
var $L25 = $L("**=");
|
|
769
|
+
var $L26 = $L("*=");
|
|
770
|
+
var $L27 = $L("/=");
|
|
771
|
+
var $L28 = $L("%=");
|
|
772
|
+
var $L29 = $L("+=");
|
|
773
|
+
var $L30 = $L("-=");
|
|
774
|
+
var $L31 = $L("<<=");
|
|
775
|
+
var $L32 = $L(">>>=");
|
|
776
|
+
var $L33 = $L(">>=");
|
|
777
|
+
var $L34 = $L("&&=");
|
|
778
|
+
var $L35 = $L("&=");
|
|
779
|
+
var $L36 = $L("^=");
|
|
780
|
+
var $L37 = $L("||=");
|
|
781
|
+
var $L38 = $L("|=");
|
|
782
|
+
var $L39 = $L("??=");
|
|
783
|
+
var $L40 = $L("?=");
|
|
784
|
+
var $L41 = $L("=");
|
|
785
|
+
var $L42 = $L("**");
|
|
786
|
+
var $L43 = $L("*");
|
|
787
|
+
var $L44 = $L("/");
|
|
788
|
+
var $L45 = $L("%");
|
|
789
|
+
var $L46 = $L("+");
|
|
790
|
+
var $L47 = $L("-");
|
|
791
|
+
var $L48 = $L("<=");
|
|
792
|
+
var $L49 = $L(">=");
|
|
793
|
+
var $L50 = $L("<<");
|
|
794
|
+
var $L51 = $L(">>>");
|
|
795
|
+
var $L52 = $L(">>");
|
|
796
|
+
var $L53 = $L(">");
|
|
797
|
+
var $L54 = $L("!==");
|
|
798
|
+
var $L55 = $L("!=");
|
|
799
|
+
var $L56 = $L("is");
|
|
800
|
+
var $L57 = $L("===");
|
|
801
|
+
var $L58 = $L("==");
|
|
802
|
+
var $L59 = $L("and");
|
|
803
|
+
var $L60 = $L("&&");
|
|
804
|
+
var $L61 = $L("or");
|
|
805
|
+
var $L62 = $L("||");
|
|
806
|
+
var $L63 = $L("??");
|
|
807
|
+
var $L64 = $L("instanceof");
|
|
808
|
+
var $L65 = $L("in");
|
|
809
|
+
var $L66 = $L("&");
|
|
810
|
+
var $L67 = $L("^");
|
|
811
|
+
var $L68 = $L("|");
|
|
812
|
+
var $L69 = $L("delete");
|
|
813
|
+
var $L70 = $L("void");
|
|
814
|
+
var $L71 = $L("typeof");
|
|
815
|
+
var $L72 = $L(";");
|
|
816
|
+
var $L73 = $L("do");
|
|
817
|
+
var $L74 = $L("while");
|
|
818
|
+
var $L75 = $L("until");
|
|
819
|
+
var $L76 = $L("finally");
|
|
820
|
+
var $L77 = $L("break");
|
|
821
|
+
var $L78 = $L("continue");
|
|
822
|
+
var $L79 = $L("debugger");
|
|
823
|
+
var $L80 = $L("throw");
|
|
824
|
+
var $L81 = $L("import type");
|
|
825
|
+
var $L82 = $L("default");
|
|
826
|
+
var $L83 = $L(":=");
|
|
827
|
+
var $L84 = $L("/*");
|
|
828
|
+
var $L85 = $L("*/");
|
|
829
|
+
var $L86 = $L("###");
|
|
830
|
+
var $L87 = $L("as");
|
|
831
|
+
var $L88 = $L("async");
|
|
832
|
+
var $L89 = $L("await");
|
|
833
|
+
var $L90 = $L("case");
|
|
834
|
+
var $L91 = $L("catch");
|
|
835
|
+
var $L92 = $L("class");
|
|
836
|
+
var $L93 = $L("#{");
|
|
837
|
+
var $L94 = $L(":");
|
|
838
|
+
var $L95 = $L(".");
|
|
839
|
+
var $L96 = $L('"');
|
|
840
|
+
var $L97 = $L("else");
|
|
841
|
+
var $L98 = $L("export");
|
|
842
|
+
var $L99 = $L("for");
|
|
843
|
+
var $L100 = $L("from");
|
|
844
|
+
var $L101 = $L("function");
|
|
845
|
+
var $L102 = $L("get");
|
|
846
|
+
var $L103 = $L("set");
|
|
847
|
+
var $L104 = $L("if");
|
|
848
|
+
var $L105 = $L("let");
|
|
849
|
+
var $L106 = $L("const");
|
|
850
|
+
var $L107 = $L("loop");
|
|
851
|
+
var $L108 = $L("new");
|
|
852
|
+
var $L109 = $L("of");
|
|
853
|
+
var $L110 = $L("{");
|
|
854
|
+
var $L111 = $L("[");
|
|
855
|
+
var $L112 = $L("(");
|
|
856
|
+
var $L113 = $L("?");
|
|
857
|
+
var $L114 = $L("return");
|
|
858
|
+
var $L115 = $L("'");
|
|
859
|
+
var $L116 = $L("static");
|
|
860
|
+
var $L117 = $L("${");
|
|
861
|
+
var $L118 = $L("switch");
|
|
862
|
+
var $L119 = $L("target");
|
|
863
|
+
var $L120 = $L('"""');
|
|
864
|
+
var $L121 = $L("'''");
|
|
865
|
+
var $L122 = $L("```");
|
|
866
|
+
var $L123 = $L("try");
|
|
867
|
+
var $L124 = $L("unless");
|
|
868
|
+
var $L125 = $L("var");
|
|
869
|
+
var $L126 = $L("when");
|
|
870
|
+
var $L127 = $L("yield");
|
|
858
871
|
var $L128 = $L("/>");
|
|
859
872
|
var $L129 = $L("</");
|
|
860
873
|
var $L130 = $L("<>");
|
|
@@ -879,22 +892,22 @@ var require_parser = __commonJS({
|
|
|
879
892
|
var $R6 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
|
|
880
893
|
var $R7 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
|
|
881
894
|
var $R8 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
|
|
882
|
-
var $R9 = $R(new RegExp('(?:\\\\.|[^"])
|
|
883
|
-
var $R10 = $R(new RegExp("(?:\\\\.|[^'])
|
|
895
|
+
var $R9 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
|
|
896
|
+
var $R10 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
|
|
884
897
|
var $R11 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
|
|
885
898
|
var $R12 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
886
|
-
var $R13 = $R(new RegExp("
|
|
887
|
-
var $R14 = $R(new RegExp("
|
|
888
|
-
var $R15 = $R(new RegExp("(
|
|
889
|
-
var $R16 = $R(new RegExp("(
|
|
890
|
-
var $R17 = $R(new RegExp("(?:\\$(?!\\{)
|
|
891
|
-
var $R18 = $R(new RegExp("(
|
|
892
|
-
var $R19 = $R(new RegExp("
|
|
893
|
-
var $R20 = $R(new RegExp("
|
|
894
|
-
var $R21 = $R(new RegExp("
|
|
895
|
-
var $R22 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
896
|
-
var $R23 = $R(new RegExp("[
|
|
897
|
-
var $R24 = $R(new RegExp("[\\t
|
|
899
|
+
var $R13 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
|
|
900
|
+
var $R14 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
901
|
+
var $R15 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
|
|
902
|
+
var $R16 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
903
|
+
var $R17 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
904
|
+
var $R18 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
905
|
+
var $R19 = $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"));
|
|
906
|
+
var $R20 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
907
|
+
var $R21 = $R(new RegExp(".", "suy"));
|
|
908
|
+
var $R22 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
909
|
+
var $R23 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
910
|
+
var $R24 = $R(new RegExp("[ \\t]+", "suy"));
|
|
898
911
|
var $R25 = $R(new RegExp("[\\s]+", "suy"));
|
|
899
912
|
var $R26 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
900
913
|
var $R27 = $R(new RegExp("\\s", "suy"));
|
|
@@ -908,7 +921,7 @@ var require_parser = __commonJS({
|
|
|
908
921
|
var $R35 = $R(new RegExp("[\\t ]*", "suy"));
|
|
909
922
|
var $R36 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
910
923
|
var $R37 = $R(new RegExp("$", "suy"));
|
|
911
|
-
var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
|
|
924
|
+
var Program$0 = $S(Reset, Init, __, $Q(TopLevelStatement), __);
|
|
912
925
|
function Program(state) {
|
|
913
926
|
if (state.verbose)
|
|
914
927
|
console.log("ENTER:", "Program");
|
|
@@ -1007,8 +1020,7 @@ var require_parser = __commonJS({
|
|
|
1007
1020
|
}
|
|
1008
1021
|
var ApplicationStart$0 = $TS($S($N(EOS), _, $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1009
1022
|
var spacing = $2;
|
|
1010
|
-
|
|
1011
|
-
return spacing;
|
|
1023
|
+
return module2.insertTrimmingSpace(spacing, "(");
|
|
1012
1024
|
});
|
|
1013
1025
|
var ApplicationStart$1 = $S(IndentedApplicationAllowed, $Y(NestedObjectLiteral), InsertOpenParen);
|
|
1014
1026
|
function ApplicationStart(state) {
|
|
@@ -1133,7 +1145,7 @@ var require_parser = __commonJS({
|
|
|
1133
1145
|
return AwaitExpression$0(state);
|
|
1134
1146
|
}
|
|
1135
1147
|
}
|
|
1136
|
-
var YieldExpression$0 = $S(
|
|
1148
|
+
var YieldExpression$0 = $S(Yield, $E($S($Q(TrailingComment), Star)), AssignmentExpression);
|
|
1137
1149
|
function YieldExpression(state) {
|
|
1138
1150
|
if (state.verbose)
|
|
1139
1151
|
console.log("ENTER:", "YieldExpression");
|
|
@@ -1152,7 +1164,7 @@ var require_parser = __commonJS({
|
|
|
1152
1164
|
return ArrowFunction$0(state) || ArrowFunction$1(state);
|
|
1153
1165
|
}
|
|
1154
1166
|
}
|
|
1155
|
-
var FatArrow$0 = $TS($S(__, $EXPECT($
|
|
1167
|
+
var FatArrow$0 = $TS($S(__, $EXPECT($L4, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
|
|
1156
1168
|
var ws = $1;
|
|
1157
1169
|
if (!ws.length)
|
|
1158
1170
|
return " =>";
|
|
@@ -1248,10 +1260,10 @@ var require_parser = __commonJS({
|
|
|
1248
1260
|
return ClassHeritage$0(state);
|
|
1249
1261
|
}
|
|
1250
1262
|
}
|
|
1251
|
-
var ExtendsToken$0 = $TV($EXPECT($
|
|
1263
|
+
var ExtendsToken$0 = $TV($EXPECT($L5, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
|
|
1252
1264
|
return { $loc, token: "extends" };
|
|
1253
1265
|
});
|
|
1254
|
-
var ExtendsToken$1 = $TV($EXPECT($
|
|
1266
|
+
var ExtendsToken$1 = $TV($EXPECT($L6, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
|
|
1255
1267
|
return { $loc, token: $1 };
|
|
1256
1268
|
});
|
|
1257
1269
|
function ExtendsToken(state) {
|
|
@@ -1321,11 +1333,11 @@ var require_parser = __commonJS({
|
|
|
1321
1333
|
return FieldDefinition$0(state) || FieldDefinition$1(state);
|
|
1322
1334
|
}
|
|
1323
1335
|
}
|
|
1324
|
-
var This$0 = $TV($EXPECT($
|
|
1336
|
+
var This$0 = $TV($EXPECT($L7, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
1325
1337
|
return { $loc, token: $1 };
|
|
1326
1338
|
});
|
|
1327
|
-
var This$1 = $S(AtAccessor, $S($E($EXPECT($
|
|
1328
|
-
var This$2 = $TV($EXPECT($
|
|
1339
|
+
var This$1 = $S(AtAccessor, $S($E($EXPECT($L8, fail, 'This "#"')), IdentifierName));
|
|
1340
|
+
var This$2 = $TV($EXPECT($L9, fail, 'This "@"'), function($skip, $loc, $0, $1) {
|
|
1329
1341
|
return { $loc, token: "this" };
|
|
1330
1342
|
});
|
|
1331
1343
|
function This(state) {
|
|
@@ -1335,7 +1347,7 @@ var require_parser = __commonJS({
|
|
|
1335
1347
|
return This$0(state) || This$1(state) || This$2(state);
|
|
1336
1348
|
}
|
|
1337
1349
|
}
|
|
1338
|
-
var AtAccessor$0 = $TV($EXPECT($
|
|
1350
|
+
var AtAccessor$0 = $TV($EXPECT($L9, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
|
|
1339
1351
|
return { $loc, token: "this." };
|
|
1340
1352
|
});
|
|
1341
1353
|
function AtAccessor(state) {
|
|
@@ -1366,8 +1378,8 @@ var require_parser = __commonJS({
|
|
|
1366
1378
|
return NewExpression$0(state);
|
|
1367
1379
|
}
|
|
1368
1380
|
}
|
|
1369
|
-
var CallExpression$0 = $S($EXPECT($
|
|
1370
|
-
var CallExpression$1 = $S($EXPECT($
|
|
1381
|
+
var CallExpression$0 = $S($EXPECT($L10, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
|
|
1382
|
+
var CallExpression$1 = $S($EXPECT($L11, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
|
|
1371
1383
|
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
|
|
1372
1384
|
function CallExpression(state) {
|
|
1373
1385
|
if (state.tokenize) {
|
|
@@ -1396,7 +1408,7 @@ var require_parser = __commonJS({
|
|
|
1396
1408
|
return OptionalShorthand$0(state);
|
|
1397
1409
|
}
|
|
1398
1410
|
}
|
|
1399
|
-
var NonNullAssertion$0 = $T($EXPECT($
|
|
1411
|
+
var NonNullAssertion$0 = $T($EXPECT($L12, fail, 'NonNullAssertion "!"'), function(value) {
|
|
1400
1412
|
return { "ts": true, "children": value };
|
|
1401
1413
|
});
|
|
1402
1414
|
function NonNullAssertion(state) {
|
|
@@ -1430,7 +1442,7 @@ var require_parser = __commonJS({
|
|
|
1430
1442
|
}
|
|
1431
1443
|
var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), OpenBracket, Expression, __, CloseBracket);
|
|
1432
1444
|
var MemberExpressionRest$1 = $S($E($S($Y(EOS), IndentedFurther)), PropertyAccess);
|
|
1433
|
-
var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($
|
|
1445
|
+
var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L13, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1434
1446
|
var id = $3;
|
|
1435
1447
|
if (id)
|
|
1436
1448
|
return [".prototype.", id];
|
|
@@ -1454,7 +1466,7 @@ var require_parser = __commonJS({
|
|
|
1454
1466
|
return PropertyAccess$0(state);
|
|
1455
1467
|
}
|
|
1456
1468
|
}
|
|
1457
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
1469
|
+
var SuperProperty$0 = $S($EXPECT($L14, fail, 'SuperProperty "super["'), Expression, __, CloseBracket);
|
|
1458
1470
|
function SuperProperty(state) {
|
|
1459
1471
|
if (state.verbose)
|
|
1460
1472
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1465,7 +1477,7 @@ var require_parser = __commonJS({
|
|
|
1465
1477
|
}
|
|
1466
1478
|
}
|
|
1467
1479
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
1468
|
-
var MetaProperty$1 = $TV($EXPECT($
|
|
1480
|
+
var MetaProperty$1 = $TV($EXPECT($L15, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
|
|
1469
1481
|
return { $loc, token: $1 };
|
|
1470
1482
|
});
|
|
1471
1483
|
function MetaProperty(state) {
|
|
@@ -1497,8 +1509,8 @@ var require_parser = __commonJS({
|
|
|
1497
1509
|
}
|
|
1498
1510
|
}
|
|
1499
1511
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
1500
|
-
var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1501
|
-
var ParameterElementDelimiter$2 = $TV($Y($S(__, $EXPECT($
|
|
1512
|
+
var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'ParameterElementDelimiter ")"')));
|
|
1513
|
+
var ParameterElementDelimiter$2 = $TV($Y($S(__, $EXPECT($L16, fail, 'ParameterElementDelimiter ")"'))), function($skip, $loc, $0, $1) {
|
|
1502
1514
|
return { $loc, token: "," };
|
|
1503
1515
|
});
|
|
1504
1516
|
var ParameterElementDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
@@ -1585,7 +1597,7 @@ var require_parser = __commonJS({
|
|
|
1585
1597
|
return BindingProperty$0(state) || BindingProperty$1(state);
|
|
1586
1598
|
}
|
|
1587
1599
|
}
|
|
1588
|
-
var BindingRestProperty$0 = $S($EXPECT($
|
|
1600
|
+
var BindingRestProperty$0 = $S($EXPECT($L17, fail, 'BindingRestProperty "..."'), BindingIdentifier);
|
|
1589
1601
|
function BindingRestProperty(state) {
|
|
1590
1602
|
if (state.verbose)
|
|
1591
1603
|
console.log("ENTER:", "BindingRestProperty");
|
|
@@ -1633,7 +1645,7 @@ var require_parser = __commonJS({
|
|
|
1633
1645
|
return BindingElement$0(state);
|
|
1634
1646
|
}
|
|
1635
1647
|
}
|
|
1636
|
-
var BindingRestElement$0 = $S($EXPECT($
|
|
1648
|
+
var BindingRestElement$0 = $S($EXPECT($L17, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
|
|
1637
1649
|
function BindingRestElement(state) {
|
|
1638
1650
|
if (state.verbose)
|
|
1639
1651
|
console.log("ENTER:", "BindingRestElement");
|
|
@@ -1654,7 +1666,7 @@ var require_parser = __commonJS({
|
|
|
1654
1666
|
}
|
|
1655
1667
|
}
|
|
1656
1668
|
var FunctionExpression$0 = ThinArrowFunction;
|
|
1657
|
-
var FunctionExpression$1 = $S($E($S(Async, __)), Function, $E($S(
|
|
1669
|
+
var FunctionExpression$1 = $S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
|
|
1658
1670
|
function FunctionExpression(state) {
|
|
1659
1671
|
if (state.tokenize) {
|
|
1660
1672
|
return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
|
|
@@ -1683,7 +1695,7 @@ var require_parser = __commonJS({
|
|
|
1683
1695
|
return ThinArrowFunction$0(state);
|
|
1684
1696
|
}
|
|
1685
1697
|
}
|
|
1686
|
-
var Arrow$0 = $TV($EXPECT($
|
|
1698
|
+
var Arrow$0 = $TV($EXPECT($L18, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
1687
1699
|
return { $loc, token: $1 };
|
|
1688
1700
|
});
|
|
1689
1701
|
function Arrow(state) {
|
|
@@ -1776,7 +1788,7 @@ var require_parser = __commonJS({
|
|
|
1776
1788
|
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
|
|
1777
1789
|
}
|
|
1778
1790
|
}
|
|
1779
|
-
var NullLiteral$0 = $TV($EXPECT($
|
|
1791
|
+
var NullLiteral$0 = $TV($EXPECT($L19, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
1780
1792
|
return { $loc, token: $1 };
|
|
1781
1793
|
});
|
|
1782
1794
|
function NullLiteral(state) {
|
|
@@ -1788,7 +1800,7 @@ var require_parser = __commonJS({
|
|
|
1788
1800
|
return NullLiteral$0(state);
|
|
1789
1801
|
}
|
|
1790
1802
|
}
|
|
1791
|
-
var BooleanLiteral$0 = $TV($C($EXPECT($
|
|
1803
|
+
var BooleanLiteral$0 = $TV($C($EXPECT($L20, fail, 'BooleanLiteral "true"'), $EXPECT($L21, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
|
|
1792
1804
|
return { $loc, token: $1 };
|
|
1793
1805
|
});
|
|
1794
1806
|
function BooleanLiteral(state) {
|
|
@@ -1800,7 +1812,7 @@ var require_parser = __commonJS({
|
|
|
1800
1812
|
return BooleanLiteral$0(state);
|
|
1801
1813
|
}
|
|
1802
1814
|
}
|
|
1803
|
-
var Comma$0 = $TV($EXPECT($
|
|
1815
|
+
var Comma$0 = $TV($EXPECT($L22, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
1804
1816
|
return { $loc, token: $1 };
|
|
1805
1817
|
});
|
|
1806
1818
|
function Comma(state) {
|
|
@@ -1882,7 +1894,7 @@ var require_parser = __commonJS({
|
|
|
1882
1894
|
}
|
|
1883
1895
|
}
|
|
1884
1896
|
var ArrayElementDelimiter$0 = $S($Q(_), Comma);
|
|
1885
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
1897
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L23, fail, 'ArrayElementDelimiter "]"')));
|
|
1886
1898
|
var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1887
1899
|
return { $loc, token: "," };
|
|
1888
1900
|
});
|
|
@@ -1913,7 +1925,7 @@ var require_parser = __commonJS({
|
|
|
1913
1925
|
return InlineElementList$0(state);
|
|
1914
1926
|
}
|
|
1915
1927
|
}
|
|
1916
|
-
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($
|
|
1928
|
+
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L17, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
|
|
1917
1929
|
function ArrayElementExpression(state) {
|
|
1918
1930
|
if (state.verbose)
|
|
1919
1931
|
console.log("ENTER:", "ArrayElementExpression");
|
|
@@ -1980,7 +1992,7 @@ var require_parser = __commonJS({
|
|
|
1980
1992
|
}
|
|
1981
1993
|
}
|
|
1982
1994
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
1983
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
1995
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L24, fail, 'ObjectPropertyDelimiter "}"')));
|
|
1984
1996
|
var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1985
1997
|
return { $loc, token: "," };
|
|
1986
1998
|
});
|
|
@@ -2003,7 +2015,7 @@ var require_parser = __commonJS({
|
|
|
2003
2015
|
}
|
|
2004
2016
|
var PropertyDefinition$0 = $S(PropertyName, __, Colon, AssignmentExpression);
|
|
2005
2017
|
var PropertyDefinition$1 = MethodDefinition;
|
|
2006
|
-
var PropertyDefinition$2 = $S($EXPECT($
|
|
2018
|
+
var PropertyDefinition$2 = $S($EXPECT($L17, fail, 'PropertyDefinition "..."'), AssignmentExpression);
|
|
2007
2019
|
var PropertyDefinition$3 = IdentifierReference;
|
|
2008
2020
|
function PropertyDefinition(state) {
|
|
2009
2021
|
if (state.tokenize) {
|
|
@@ -2015,7 +2027,7 @@ var require_parser = __commonJS({
|
|
|
2015
2027
|
var PropertyName$0 = NumericLiteral;
|
|
2016
2028
|
var PropertyName$1 = StringLiteral;
|
|
2017
2029
|
var PropertyName$2 = IdentifierName;
|
|
2018
|
-
var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($
|
|
2030
|
+
var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L23, fail, 'PropertyName "]"'));
|
|
2019
2031
|
function PropertyName(state) {
|
|
2020
2032
|
if (state.tokenize) {
|
|
2021
2033
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -2034,8 +2046,8 @@ var require_parser = __commonJS({
|
|
|
2034
2046
|
}
|
|
2035
2047
|
}
|
|
2036
2048
|
var MethodModifier$0 = $S(GetOrSet, $Q(TrailingComment));
|
|
2037
|
-
var MethodModifier$1 = $S($S(Async, __), $E($S(
|
|
2038
|
-
var MethodModifier$2 = $S(
|
|
2049
|
+
var MethodModifier$1 = $S($S(Async, __), $E($S(Star, __)));
|
|
2050
|
+
var MethodModifier$2 = $S(Star, __);
|
|
2039
2051
|
var MethodModifier$3 = $S(Async, __);
|
|
2040
2052
|
function MethodModifier(state) {
|
|
2041
2053
|
if (state.tokenize) {
|
|
@@ -2044,18 +2056,6 @@ var require_parser = __commonJS({
|
|
|
2044
2056
|
return MethodModifier$0(state) || MethodModifier$1(state) || MethodModifier$2(state) || MethodModifier$3(state);
|
|
2045
2057
|
}
|
|
2046
2058
|
}
|
|
2047
|
-
var ConstructorShorthand$0 = $TV($EXPECT($L11, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
2048
|
-
return { $loc, token: "constructor" };
|
|
2049
|
-
});
|
|
2050
|
-
function ConstructorShorthand(state) {
|
|
2051
|
-
if (state.verbose)
|
|
2052
|
-
console.log("ENTER:", "ConstructorShorthand");
|
|
2053
|
-
if (state.tokenize) {
|
|
2054
|
-
return $TOKEN("ConstructorShorthand", state, ConstructorShorthand$0(state));
|
|
2055
|
-
} else {
|
|
2056
|
-
return ConstructorShorthand$0(state);
|
|
2057
|
-
}
|
|
2058
|
-
}
|
|
2059
2059
|
var MethodSignature$0 = $S(ConstructorShorthand, Parameters);
|
|
2060
2060
|
var MethodSignature$1 = $S($E(MethodModifier), ClassElementName, $Q(_), Parameters);
|
|
2061
2061
|
function MethodSignature(state) {
|
|
@@ -2074,7 +2074,7 @@ var require_parser = __commonJS({
|
|
|
2074
2074
|
return ClassElementName$0(state) || ClassElementName$1(state);
|
|
2075
2075
|
}
|
|
2076
2076
|
}
|
|
2077
|
-
var PrivateIdentifier$0 = $S($EXPECT($
|
|
2077
|
+
var PrivateIdentifier$0 = $S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName);
|
|
2078
2078
|
function PrivateIdentifier(state) {
|
|
2079
2079
|
if (state.verbose)
|
|
2080
2080
|
console.log("ENTER:", "PrivateIdentifier");
|
|
@@ -2096,25 +2096,25 @@ var require_parser = __commonJS({
|
|
|
2096
2096
|
return AssignmentOp$0(state);
|
|
2097
2097
|
}
|
|
2098
2098
|
}
|
|
2099
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
2100
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
2101
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
2102
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
2103
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
2104
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
2105
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
2106
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
2107
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
2108
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
2109
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
2110
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
2111
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
2112
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
2113
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
2114
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
2099
|
+
var AssignmentOpSymbol$0 = $EXPECT($L25, fail, 'AssignmentOpSymbol "**="');
|
|
2100
|
+
var AssignmentOpSymbol$1 = $EXPECT($L26, fail, 'AssignmentOpSymbol "*="');
|
|
2101
|
+
var AssignmentOpSymbol$2 = $EXPECT($L27, fail, 'AssignmentOpSymbol "/="');
|
|
2102
|
+
var AssignmentOpSymbol$3 = $EXPECT($L28, fail, 'AssignmentOpSymbol "%="');
|
|
2103
|
+
var AssignmentOpSymbol$4 = $EXPECT($L29, fail, 'AssignmentOpSymbol "+="');
|
|
2104
|
+
var AssignmentOpSymbol$5 = $EXPECT($L30, fail, 'AssignmentOpSymbol "-="');
|
|
2105
|
+
var AssignmentOpSymbol$6 = $EXPECT($L31, fail, 'AssignmentOpSymbol "<<="');
|
|
2106
|
+
var AssignmentOpSymbol$7 = $EXPECT($L32, fail, 'AssignmentOpSymbol ">>>="');
|
|
2107
|
+
var AssignmentOpSymbol$8 = $EXPECT($L33, fail, 'AssignmentOpSymbol ">>="');
|
|
2108
|
+
var AssignmentOpSymbol$9 = $EXPECT($L34, fail, 'AssignmentOpSymbol "&&="');
|
|
2109
|
+
var AssignmentOpSymbol$10 = $EXPECT($L35, fail, 'AssignmentOpSymbol "&="');
|
|
2110
|
+
var AssignmentOpSymbol$11 = $EXPECT($L36, fail, 'AssignmentOpSymbol "^="');
|
|
2111
|
+
var AssignmentOpSymbol$12 = $EXPECT($L37, fail, 'AssignmentOpSymbol "||="');
|
|
2112
|
+
var AssignmentOpSymbol$13 = $EXPECT($L38, fail, 'AssignmentOpSymbol "|="');
|
|
2113
|
+
var AssignmentOpSymbol$14 = $EXPECT($L39, fail, 'AssignmentOpSymbol "??="');
|
|
2114
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L40, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
2115
2115
|
return "??=";
|
|
2116
2116
|
});
|
|
2117
|
-
var AssignmentOpSymbol$16 = $EXPECT($
|
|
2117
|
+
var AssignmentOpSymbol$16 = $EXPECT($L41, fail, 'AssignmentOpSymbol "="');
|
|
2118
2118
|
function AssignmentOpSymbol(state) {
|
|
2119
2119
|
if (state.tokenize) {
|
|
2120
2120
|
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));
|
|
@@ -2134,52 +2134,52 @@ var require_parser = __commonJS({
|
|
|
2134
2134
|
return BinaryOp$0(state);
|
|
2135
2135
|
}
|
|
2136
2136
|
}
|
|
2137
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
2138
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
2139
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
2140
|
-
var BinaryOpSymbol$3 = $EXPECT($
|
|
2141
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
2142
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
2143
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
2144
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
2145
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
2146
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
2147
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
2148
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
2149
|
-
var BinaryOpSymbol$12 = $EXPECT($
|
|
2150
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
2151
|
-
var BinaryOpSymbol$14 = $TV($EXPECT($
|
|
2137
|
+
var BinaryOpSymbol$0 = $EXPECT($L42, fail, 'BinaryOpSymbol "**"');
|
|
2138
|
+
var BinaryOpSymbol$1 = $EXPECT($L43, fail, 'BinaryOpSymbol "*"');
|
|
2139
|
+
var BinaryOpSymbol$2 = $EXPECT($L44, fail, 'BinaryOpSymbol "/"');
|
|
2140
|
+
var BinaryOpSymbol$3 = $EXPECT($L45, fail, 'BinaryOpSymbol "%"');
|
|
2141
|
+
var BinaryOpSymbol$4 = $EXPECT($L46, fail, 'BinaryOpSymbol "+"');
|
|
2142
|
+
var BinaryOpSymbol$5 = $EXPECT($L47, fail, 'BinaryOpSymbol "-"');
|
|
2143
|
+
var BinaryOpSymbol$6 = $EXPECT($L48, fail, 'BinaryOpSymbol "<="');
|
|
2144
|
+
var BinaryOpSymbol$7 = $EXPECT($L49, fail, 'BinaryOpSymbol ">="');
|
|
2145
|
+
var BinaryOpSymbol$8 = $EXPECT($L50, fail, 'BinaryOpSymbol "<<"');
|
|
2146
|
+
var BinaryOpSymbol$9 = $EXPECT($L5, fail, 'BinaryOpSymbol "<"');
|
|
2147
|
+
var BinaryOpSymbol$10 = $EXPECT($L51, fail, 'BinaryOpSymbol ">>>"');
|
|
2148
|
+
var BinaryOpSymbol$11 = $EXPECT($L52, fail, 'BinaryOpSymbol ">>"');
|
|
2149
|
+
var BinaryOpSymbol$12 = $EXPECT($L53, fail, 'BinaryOpSymbol ">"');
|
|
2150
|
+
var BinaryOpSymbol$13 = $EXPECT($L54, fail, 'BinaryOpSymbol "!=="');
|
|
2151
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L55, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
2152
2152
|
if (module2.coffeeCompat)
|
|
2153
2153
|
return "!==";
|
|
2154
2154
|
return $1;
|
|
2155
2155
|
});
|
|
2156
|
-
var BinaryOpSymbol$15 = $T($S($EXPECT($
|
|
2156
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L56, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
2157
2157
|
return "===";
|
|
2158
2158
|
});
|
|
2159
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
2160
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
2159
|
+
var BinaryOpSymbol$16 = $EXPECT($L57, fail, 'BinaryOpSymbol "==="');
|
|
2160
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L58, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
2161
2161
|
if (module2.coffeeCompat)
|
|
2162
2162
|
return "===";
|
|
2163
2163
|
return $1;
|
|
2164
2164
|
});
|
|
2165
|
-
var BinaryOpSymbol$18 = $T($S($EXPECT($
|
|
2165
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L59, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
2166
2166
|
return "&&";
|
|
2167
2167
|
});
|
|
2168
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
2169
|
-
var BinaryOpSymbol$20 = $T($S($EXPECT($
|
|
2168
|
+
var BinaryOpSymbol$19 = $EXPECT($L60, fail, 'BinaryOpSymbol "&&"');
|
|
2169
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L61, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
2170
2170
|
return "||";
|
|
2171
2171
|
});
|
|
2172
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
2173
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
2174
|
-
var BinaryOpSymbol$23 = $TS($S($EXPECT($
|
|
2172
|
+
var BinaryOpSymbol$21 = $EXPECT($L62, fail, 'BinaryOpSymbol "||"');
|
|
2173
|
+
var BinaryOpSymbol$22 = $EXPECT($L63, fail, 'BinaryOpSymbol "??"');
|
|
2174
|
+
var BinaryOpSymbol$23 = $TS($S($EXPECT($L64, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2175
2175
|
return $1;
|
|
2176
2176
|
});
|
|
2177
|
-
var BinaryOpSymbol$24 = $TS($S($EXPECT($
|
|
2177
|
+
var BinaryOpSymbol$24 = $TS($S($EXPECT($L65, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2178
2178
|
return $1;
|
|
2179
2179
|
});
|
|
2180
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
2181
|
-
var BinaryOpSymbol$26 = $EXPECT($
|
|
2182
|
-
var BinaryOpSymbol$27 = $EXPECT($
|
|
2180
|
+
var BinaryOpSymbol$25 = $EXPECT($L66, fail, 'BinaryOpSymbol "&"');
|
|
2181
|
+
var BinaryOpSymbol$26 = $EXPECT($L67, fail, 'BinaryOpSymbol "^"');
|
|
2182
|
+
var BinaryOpSymbol$27 = $EXPECT($L68, fail, 'BinaryOpSymbol "|"');
|
|
2183
2183
|
function BinaryOpSymbol(state) {
|
|
2184
2184
|
if (state.tokenize) {
|
|
2185
2185
|
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));
|
|
@@ -2188,7 +2188,7 @@ var require_parser = __commonJS({
|
|
|
2188
2188
|
}
|
|
2189
2189
|
}
|
|
2190
2190
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
2191
|
-
var UnaryOp$1 = $S($C($EXPECT($
|
|
2191
|
+
var UnaryOp$1 = $S($C($EXPECT($L69, fail, 'UnaryOp "delete"'), $EXPECT($L70, fail, 'UnaryOp "void"'), $EXPECT($L71, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
|
|
2192
2192
|
function UnaryOp(state) {
|
|
2193
2193
|
if (state.tokenize) {
|
|
2194
2194
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -2268,7 +2268,7 @@ var require_parser = __commonJS({
|
|
|
2268
2268
|
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);
|
|
2269
2269
|
}
|
|
2270
2270
|
}
|
|
2271
|
-
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($
|
|
2271
|
+
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L72, fail, 'EmptyStatement ";"')));
|
|
2272
2272
|
function EmptyStatement(state) {
|
|
2273
2273
|
if (state.verbose)
|
|
2274
2274
|
console.log("ENTER:", "EmptyStatement");
|
|
@@ -2333,7 +2333,7 @@ var require_parser = __commonJS({
|
|
|
2333
2333
|
return LoopStatement$0(state);
|
|
2334
2334
|
}
|
|
2335
2335
|
}
|
|
2336
|
-
var DoWhileStatement$0 = $S($EXPECT($
|
|
2336
|
+
var DoWhileStatement$0 = $S($EXPECT($L73, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
|
|
2337
2337
|
function DoWhileStatement(state) {
|
|
2338
2338
|
if (state.verbose)
|
|
2339
2339
|
console.log("ENTER:", "DoWhileStatement");
|
|
@@ -2353,7 +2353,7 @@ var require_parser = __commonJS({
|
|
|
2353
2353
|
return WhileStatement$0(state);
|
|
2354
2354
|
}
|
|
2355
2355
|
}
|
|
2356
|
-
var WhileClause$0 = $TS($S($C($EXPECT($
|
|
2356
|
+
var WhileClause$0 = $TS($S($C($EXPECT($L74, fail, 'WhileClause "while"'), $EXPECT($L75, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
|
|
2357
2357
|
var kind = $1;
|
|
2358
2358
|
var cond = $3;
|
|
2359
2359
|
if (kind === "until") {
|
|
@@ -2412,7 +2412,7 @@ var require_parser = __commonJS({
|
|
|
2412
2412
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
2413
2413
|
}
|
|
2414
2414
|
}
|
|
2415
|
-
var SwitchStatement$0 = $S(Switch,
|
|
2415
|
+
var SwitchStatement$0 = $S(Switch, Condition, CaseBlock);
|
|
2416
2416
|
function SwitchStatement(state) {
|
|
2417
2417
|
if (state.verbose)
|
|
2418
2418
|
console.log("ENTER:", "SwitchStatement");
|
|
@@ -2456,9 +2456,9 @@ var require_parser = __commonJS({
|
|
|
2456
2456
|
return NestedCaseClause$0(state);
|
|
2457
2457
|
}
|
|
2458
2458
|
}
|
|
2459
|
-
var CaseClause$0 = $S(
|
|
2460
|
-
var CaseClause$1 = $S(When,
|
|
2461
|
-
var CaseClause$2 = $S(
|
|
2459
|
+
var CaseClause$0 = $S(Case, CaseExpressionList, NestedBlockExpressions);
|
|
2460
|
+
var CaseClause$1 = $S(When, CaseExpressionList, NestedBlockExpressions, InsertBreak);
|
|
2461
|
+
var CaseClause$2 = $S(Default, ImpliedColon, NestedBlockExpressions);
|
|
2462
2462
|
function CaseClause(state) {
|
|
2463
2463
|
if (state.tokenize) {
|
|
2464
2464
|
return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
|
|
@@ -2466,6 +2466,25 @@ var require_parser = __commonJS({
|
|
|
2466
2466
|
return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
|
|
2467
2467
|
}
|
|
2468
2468
|
}
|
|
2469
|
+
var CaseExpressionList$0 = $TS($S($S($Q(_), ExpressionWithIndentedApplicationSuppressed, ImpliedColon), $Q($S(__, Comma, ExpressionWithIndentedApplicationSuppressed, ImpliedColon))), function($skip, $loc, $0, $1, $2) {
|
|
2470
|
+
const result = $2.map(([ws, _comma, exp, col]) => {
|
|
2471
|
+
module2.insertTrimmingSpace(exp, "");
|
|
2472
|
+
if (ws.length)
|
|
2473
|
+
return [module2.insertTrimmingSpace("case ", ws), exp, col];
|
|
2474
|
+
return ["case ", exp, col];
|
|
2475
|
+
});
|
|
2476
|
+
result.unshift($1);
|
|
2477
|
+
return result;
|
|
2478
|
+
});
|
|
2479
|
+
function CaseExpressionList(state) {
|
|
2480
|
+
if (state.verbose)
|
|
2481
|
+
console.log("ENTER:", "CaseExpressionList");
|
|
2482
|
+
if (state.tokenize) {
|
|
2483
|
+
return $TOKEN("CaseExpressionList", state, CaseExpressionList$0(state));
|
|
2484
|
+
} else {
|
|
2485
|
+
return CaseExpressionList$0(state);
|
|
2486
|
+
}
|
|
2487
|
+
}
|
|
2469
2488
|
var ImpliedColon$0 = $S(__, Colon);
|
|
2470
2489
|
var ImpliedColon$1 = $TV($EXPECT($L1, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
2471
2490
|
return { $loc, token: ":" };
|
|
@@ -2513,7 +2532,7 @@ var require_parser = __commonJS({
|
|
|
2513
2532
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2514
2533
|
}
|
|
2515
2534
|
}
|
|
2516
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2535
|
+
var Finally$0 = $S(__, $EXPECT($L76, fail, 'Finally "finally"'), BracedBlock);
|
|
2517
2536
|
function Finally(state) {
|
|
2518
2537
|
if (state.verbose)
|
|
2519
2538
|
console.log("ENTER:", "Finally");
|
|
@@ -2541,7 +2560,7 @@ var require_parser = __commonJS({
|
|
|
2541
2560
|
return Condition$0(state) || Condition$1(state);
|
|
2542
2561
|
}
|
|
2543
2562
|
}
|
|
2544
|
-
var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(
|
|
2563
|
+
var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(AssignmentExpression)), function($skip, $loc, $0, $1, $2) {
|
|
2545
2564
|
var exp = $2;
|
|
2546
2565
|
module2.suppressIndentedApplication = false;
|
|
2547
2566
|
if (exp)
|
|
@@ -2579,11 +2598,11 @@ var require_parser = __commonJS({
|
|
|
2579
2598
|
return ExpressionStatement$0(state);
|
|
2580
2599
|
}
|
|
2581
2600
|
}
|
|
2582
|
-
var KeywordStatement$0 = $S($EXPECT($
|
|
2583
|
-
var KeywordStatement$1 = $S($EXPECT($
|
|
2584
|
-
var KeywordStatement$2 = $S($EXPECT($
|
|
2601
|
+
var KeywordStatement$0 = $S($EXPECT($L77, fail, 'KeywordStatement "break"'), NonIdContinue);
|
|
2602
|
+
var KeywordStatement$1 = $S($EXPECT($L78, fail, 'KeywordStatement "continue"'), NonIdContinue);
|
|
2603
|
+
var KeywordStatement$2 = $S($EXPECT($L79, fail, 'KeywordStatement "debugger"'), NonIdContinue);
|
|
2585
2604
|
var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
|
|
2586
|
-
var KeywordStatement$4 = $S($EXPECT($
|
|
2605
|
+
var KeywordStatement$4 = $S($EXPECT($L80, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
|
|
2587
2606
|
function KeywordStatement(state) {
|
|
2588
2607
|
if (state.tokenize) {
|
|
2589
2608
|
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
|
|
@@ -2600,7 +2619,7 @@ var require_parser = __commonJS({
|
|
|
2600
2619
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2601
2620
|
}
|
|
2602
2621
|
}
|
|
2603
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2622
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L81, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2604
2623
|
return { "ts": true, "children": value };
|
|
2605
2624
|
});
|
|
2606
2625
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
@@ -2645,7 +2664,7 @@ var require_parser = __commonJS({
|
|
|
2645
2664
|
return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
|
|
2646
2665
|
}
|
|
2647
2666
|
}
|
|
2648
|
-
var NameSpaceImport$0 = $S(
|
|
2667
|
+
var NameSpaceImport$0 = $S(Star, __, As, NonIdContinue, __, ImportedBinding);
|
|
2649
2668
|
function NameSpaceImport(state) {
|
|
2650
2669
|
if (state.verbose)
|
|
2651
2670
|
console.log("ENTER:", "NameSpaceImport");
|
|
@@ -2706,7 +2725,7 @@ var require_parser = __commonJS({
|
|
|
2706
2725
|
return ModuleSpecifier$0(state);
|
|
2707
2726
|
}
|
|
2708
2727
|
}
|
|
2709
|
-
var UnprocessedModuleSpecifier$0 =
|
|
2728
|
+
var UnprocessedModuleSpecifier$0 = BasicStringLiteral;
|
|
2710
2729
|
var UnprocessedModuleSpecifier$1 = UnquotedSpecifier;
|
|
2711
2730
|
function UnprocessedModuleSpecifier(state) {
|
|
2712
2731
|
if (state.tokenize) {
|
|
@@ -2738,7 +2757,7 @@ var require_parser = __commonJS({
|
|
|
2738
2757
|
return ImportedBinding$0(state);
|
|
2739
2758
|
}
|
|
2740
2759
|
}
|
|
2741
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
2760
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L82, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2742
2761
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
2743
2762
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
2744
2763
|
function ExportDeclaration(state) {
|
|
@@ -2748,7 +2767,7 @@ var require_parser = __commonJS({
|
|
|
2748
2767
|
return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
|
|
2749
2768
|
}
|
|
2750
2769
|
}
|
|
2751
|
-
var ExportFromClause$0 = $S(
|
|
2770
|
+
var ExportFromClause$0 = $S(Star, $E($S(__, As, NonIdContinue, __, ModuleExportName)));
|
|
2752
2771
|
var ExportFromClause$1 = NamedExports;
|
|
2753
2772
|
function ExportFromClause(state) {
|
|
2754
2773
|
if (state.tokenize) {
|
|
@@ -2815,7 +2834,7 @@ var require_parser = __commonJS({
|
|
|
2815
2834
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
2816
2835
|
}
|
|
2817
2836
|
}
|
|
2818
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
2837
|
+
var ConstAssignment$0 = $TV($EXPECT($L83, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
2819
2838
|
return { $loc, token: "=" };
|
|
2820
2839
|
});
|
|
2821
2840
|
function ConstAssignment(state) {
|
|
@@ -2958,12 +2977,8 @@ var require_parser = __commonJS({
|
|
|
2958
2977
|
var e = $3;
|
|
2959
2978
|
return [s, module2.dedentBlockString(str), e];
|
|
2960
2979
|
});
|
|
2961
|
-
var StringLiteral$2 =
|
|
2962
|
-
|
|
2963
|
-
});
|
|
2964
|
-
var StringLiteral$3 = $TV($TEXT($S($EXPECT($L87, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L87, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
|
|
2965
|
-
return { $loc, token: $1 };
|
|
2966
|
-
});
|
|
2980
|
+
var StringLiteral$2 = CoffeeCompatDoubleQuotedString;
|
|
2981
|
+
var StringLiteral$3 = BasicStringLiteral;
|
|
2967
2982
|
function StringLiteral(state) {
|
|
2968
2983
|
if (state.tokenize) {
|
|
2969
2984
|
return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state));
|
|
@@ -2971,24 +2986,49 @@ var require_parser = __commonJS({
|
|
|
2971
2986
|
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
|
|
2972
2987
|
}
|
|
2973
2988
|
}
|
|
2974
|
-
var
|
|
2975
|
-
|
|
2989
|
+
var BasicStringLiteral$0 = $TS($S(DoubleQuote, DoubleStringCharacters, DoubleQuote), function($skip, $loc, $0, $1, $2, $3) {
|
|
2990
|
+
var str = $2;
|
|
2991
|
+
return {
|
|
2992
|
+
token: `"${module2.modifyString(str.token)}"`,
|
|
2993
|
+
$loc
|
|
2994
|
+
};
|
|
2995
|
+
});
|
|
2996
|
+
var BasicStringLiteral$1 = $TS($S(SingleQuote, SingleStringCharacters, SingleQuote), function($skip, $loc, $0, $1, $2, $3) {
|
|
2997
|
+
var str = $2;
|
|
2998
|
+
return {
|
|
2999
|
+
token: `'${module2.modifyString(str.token)}'`,
|
|
3000
|
+
$loc
|
|
3001
|
+
};
|
|
3002
|
+
});
|
|
3003
|
+
function BasicStringLiteral(state) {
|
|
3004
|
+
if (state.tokenize) {
|
|
3005
|
+
return $TOKEN("BasicStringLiteral", state, BasicStringLiteral$0(state) || BasicStringLiteral$1(state));
|
|
3006
|
+
} else {
|
|
3007
|
+
return BasicStringLiteral$0(state) || BasicStringLiteral$1(state);
|
|
3008
|
+
}
|
|
3009
|
+
}
|
|
3010
|
+
var DoubleStringCharacters$0 = $TR($EXPECT($R9, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3011
|
+
return { $loc, token: $0 };
|
|
3012
|
+
});
|
|
3013
|
+
function DoubleStringCharacters(state) {
|
|
2976
3014
|
if (state.verbose)
|
|
2977
|
-
console.log("ENTER:", "
|
|
3015
|
+
console.log("ENTER:", "DoubleStringCharacters");
|
|
2978
3016
|
if (state.tokenize) {
|
|
2979
|
-
return $TOKEN("
|
|
3017
|
+
return $TOKEN("DoubleStringCharacters", state, DoubleStringCharacters$0(state));
|
|
2980
3018
|
} else {
|
|
2981
|
-
return
|
|
3019
|
+
return DoubleStringCharacters$0(state);
|
|
2982
3020
|
}
|
|
2983
3021
|
}
|
|
2984
|
-
var
|
|
2985
|
-
|
|
3022
|
+
var SingleStringCharacters$0 = $TR($EXPECT($R10, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3023
|
+
return { $loc, token: $0 };
|
|
3024
|
+
});
|
|
3025
|
+
function SingleStringCharacters(state) {
|
|
2986
3026
|
if (state.verbose)
|
|
2987
|
-
console.log("ENTER:", "
|
|
3027
|
+
console.log("ENTER:", "SingleStringCharacters");
|
|
2988
3028
|
if (state.tokenize) {
|
|
2989
|
-
return $TOKEN("
|
|
3029
|
+
return $TOKEN("SingleStringCharacters", state, SingleStringCharacters$0(state));
|
|
2990
3030
|
} else {
|
|
2991
|
-
return
|
|
3031
|
+
return SingleStringCharacters$0(state);
|
|
2992
3032
|
}
|
|
2993
3033
|
}
|
|
2994
3034
|
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R11, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
@@ -3025,19 +3065,62 @@ var require_parser = __commonJS({
|
|
|
3025
3065
|
return CoffeeStringSubstitution$0(state);
|
|
3026
3066
|
}
|
|
3027
3067
|
}
|
|
3028
|
-
var
|
|
3029
|
-
|
|
3068
|
+
var CoffeeCompat$0 = $TV($EXPECT($L1, fail, 'CoffeeCompat ""'), function($skip, $loc, $0, $1) {
|
|
3069
|
+
if (module2.coffeeCompat)
|
|
3070
|
+
return;
|
|
3071
|
+
return $skip;
|
|
3030
3072
|
});
|
|
3031
|
-
function
|
|
3073
|
+
function CoffeeCompat(state) {
|
|
3032
3074
|
if (state.verbose)
|
|
3033
|
-
console.log("ENTER:", "
|
|
3075
|
+
console.log("ENTER:", "CoffeeCompat");
|
|
3034
3076
|
if (state.tokenize) {
|
|
3035
|
-
return $TOKEN("
|
|
3077
|
+
return $TOKEN("CoffeeCompat", state, CoffeeCompat$0(state));
|
|
3036
3078
|
} else {
|
|
3037
|
-
return
|
|
3079
|
+
return CoffeeCompat$0(state);
|
|
3038
3080
|
}
|
|
3039
3081
|
}
|
|
3040
|
-
var
|
|
3082
|
+
var CoffeeCompatDoubleQuotedString$0 = $TS($S(CoffeeCompat, DoubleQuote, $Q($C(CoffeeCompatDoubleQuotedStringCharacters, CoffeeStringSubstitution)), DoubleQuote), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
3083
|
+
var s = $2;
|
|
3084
|
+
var parts = $3;
|
|
3085
|
+
var e = $4;
|
|
3086
|
+
const noInterpolations = parts.length === 1 && parts[0].token != null;
|
|
3087
|
+
if (noInterpolations) {
|
|
3088
|
+
return {
|
|
3089
|
+
token: `"${module2.modifyString(parts[0].token)}"`,
|
|
3090
|
+
$loc
|
|
3091
|
+
};
|
|
3092
|
+
}
|
|
3093
|
+
parts.forEach((part) => {
|
|
3094
|
+
if (part.token) {
|
|
3095
|
+
const str = part.token.replace(/(`|\$\{)/g, "\\$1");
|
|
3096
|
+
part.token = module2.modifyString(str);
|
|
3097
|
+
}
|
|
3098
|
+
});
|
|
3099
|
+
s.token = e.token = "`";
|
|
3100
|
+
return [s, parts, e];
|
|
3101
|
+
});
|
|
3102
|
+
function CoffeeCompatDoubleQuotedString(state) {
|
|
3103
|
+
if (state.verbose)
|
|
3104
|
+
console.log("ENTER:", "CoffeeCompatDoubleQuotedString");
|
|
3105
|
+
if (state.tokenize) {
|
|
3106
|
+
return $TOKEN("CoffeeCompatDoubleQuotedString", state, CoffeeCompatDoubleQuotedString$0(state));
|
|
3107
|
+
} else {
|
|
3108
|
+
return CoffeeCompatDoubleQuotedString$0(state);
|
|
3109
|
+
}
|
|
3110
|
+
}
|
|
3111
|
+
var CoffeeCompatDoubleQuotedStringCharacters$0 = $TR($EXPECT($R13, fail, 'CoffeeCompatDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3112
|
+
return { $loc, token: $0 };
|
|
3113
|
+
});
|
|
3114
|
+
function CoffeeCompatDoubleQuotedStringCharacters(state) {
|
|
3115
|
+
if (state.verbose)
|
|
3116
|
+
console.log("ENTER:", "CoffeeCompatDoubleQuotedStringCharacters");
|
|
3117
|
+
if (state.tokenize) {
|
|
3118
|
+
return $TOKEN("CoffeeCompatDoubleQuotedStringCharacters", state, CoffeeCompatDoubleQuotedStringCharacters$0(state));
|
|
3119
|
+
} else {
|
|
3120
|
+
return CoffeeCompatDoubleQuotedStringCharacters$0(state);
|
|
3121
|
+
}
|
|
3122
|
+
}
|
|
3123
|
+
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L44, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L44, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
3041
3124
|
return { $loc, token: $1 };
|
|
3042
3125
|
});
|
|
3043
3126
|
function RegularExpressionLiteral(state) {
|
|
@@ -3049,7 +3132,7 @@ var require_parser = __commonJS({
|
|
|
3049
3132
|
return RegularExpressionLiteral$0(state);
|
|
3050
3133
|
}
|
|
3051
3134
|
}
|
|
3052
|
-
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($
|
|
3135
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R14, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
|
|
3053
3136
|
function RegularExpressionBody(state) {
|
|
3054
3137
|
if (state.verbose)
|
|
3055
3138
|
console.log("ENTER:", "RegularExpressionBody");
|
|
@@ -3059,7 +3142,7 @@ var require_parser = __commonJS({
|
|
|
3059
3142
|
return RegularExpressionBody$0(state);
|
|
3060
3143
|
}
|
|
3061
3144
|
}
|
|
3062
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
3145
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R15, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
3063
3146
|
function RegExpCharacter(state) {
|
|
3064
3147
|
if (state.verbose)
|
|
3065
3148
|
console.log("ENTER:", "RegExpCharacter");
|
|
@@ -3069,7 +3152,7 @@ var require_parser = __commonJS({
|
|
|
3069
3152
|
return RegExpCharacter$0(state);
|
|
3070
3153
|
}
|
|
3071
3154
|
}
|
|
3072
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
3155
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R16, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
3073
3156
|
function RegularExpressionFlags(state) {
|
|
3074
3157
|
if (state.verbose)
|
|
3075
3158
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -3090,7 +3173,7 @@ var require_parser = __commonJS({
|
|
|
3090
3173
|
return TemplateLiteral$0(state) || TemplateLiteral$1(state);
|
|
3091
3174
|
}
|
|
3092
3175
|
}
|
|
3093
|
-
var TemplateSubstitution$0 = $S(
|
|
3176
|
+
var TemplateSubstitution$0 = $S(SubstitutionStart, Expression, __, CloseBrace);
|
|
3094
3177
|
function TemplateSubstitution(state) {
|
|
3095
3178
|
if (state.verbose)
|
|
3096
3179
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -3100,7 +3183,7 @@ var require_parser = __commonJS({
|
|
|
3100
3183
|
return TemplateSubstitution$0(state);
|
|
3101
3184
|
}
|
|
3102
3185
|
}
|
|
3103
|
-
var TemplateCharacters$0 = $TR($EXPECT($
|
|
3186
|
+
var TemplateCharacters$0 = $TR($EXPECT($R17, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3104
3187
|
return { $loc, token: $0 };
|
|
3105
3188
|
});
|
|
3106
3189
|
function TemplateCharacters(state) {
|
|
@@ -3112,7 +3195,7 @@ var require_parser = __commonJS({
|
|
|
3112
3195
|
return TemplateCharacters$0(state);
|
|
3113
3196
|
}
|
|
3114
3197
|
}
|
|
3115
|
-
var TemplateBlockCharacters$0 = $TR($EXPECT($
|
|
3198
|
+
var TemplateBlockCharacters$0 = $TR($EXPECT($R18, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3116
3199
|
return { $loc, token: $0 };
|
|
3117
3200
|
});
|
|
3118
3201
|
function TemplateBlockCharacters(state) {
|
|
@@ -3124,7 +3207,7 @@ var require_parser = __commonJS({
|
|
|
3124
3207
|
return TemplateBlockCharacters$0(state);
|
|
3125
3208
|
}
|
|
3126
3209
|
}
|
|
3127
|
-
var ReservedWord$0 = $R$0($EXPECT($
|
|
3210
|
+
var ReservedWord$0 = $R$0($EXPECT($R19, 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})/"));
|
|
3128
3211
|
function ReservedWord(state) {
|
|
3129
3212
|
if (state.verbose)
|
|
3130
3213
|
console.log("ENTER:", "ReservedWord");
|
|
@@ -3143,10 +3226,10 @@ var require_parser = __commonJS({
|
|
|
3143
3226
|
return Comment$0(state) || Comment$1(state);
|
|
3144
3227
|
}
|
|
3145
3228
|
}
|
|
3146
|
-
var SingleLineComment$0 = $TR($EXPECT($
|
|
3229
|
+
var SingleLineComment$0 = $TR($EXPECT($R20, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3147
3230
|
return { $loc, token: $0 };
|
|
3148
3231
|
});
|
|
3149
|
-
var SingleLineComment$1 = CoffeeSingleLineComment;
|
|
3232
|
+
var SingleLineComment$1 = $S(CoffeeCompat, CoffeeSingleLineComment);
|
|
3150
3233
|
function SingleLineComment(state) {
|
|
3151
3234
|
if (state.tokenize) {
|
|
3152
3235
|
return $TOKEN("SingleLineComment", state, SingleLineComment$0(state) || SingleLineComment$1(state));
|
|
@@ -3163,7 +3246,7 @@ var require_parser = __commonJS({
|
|
|
3163
3246
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
3164
3247
|
}
|
|
3165
3248
|
}
|
|
3166
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
3249
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L85, fail, 'JSMultiLineComment "*/"')), $EXPECT($R21, fail, "JSMultiLineComment /./"))), $EXPECT($L85, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
3167
3250
|
return { $loc, token: $1 };
|
|
3168
3251
|
});
|
|
3169
3252
|
function JSMultiLineComment(state) {
|
|
@@ -3175,9 +3258,7 @@ var require_parser = __commonJS({
|
|
|
3175
3258
|
return JSMultiLineComment$0(state);
|
|
3176
3259
|
}
|
|
3177
3260
|
}
|
|
3178
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
3179
|
-
if (!module2.coffeeCompat)
|
|
3180
|
-
return $skip;
|
|
3261
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R22, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3181
3262
|
return { $loc, token: `//${$1}` };
|
|
3182
3263
|
});
|
|
3183
3264
|
function CoffeeSingleLineComment(state) {
|
|
@@ -3189,7 +3270,7 @@ var require_parser = __commonJS({
|
|
|
3189
3270
|
return CoffeeSingleLineComment$0(state);
|
|
3190
3271
|
}
|
|
3191
3272
|
}
|
|
3192
|
-
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($
|
|
3273
|
+
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L85, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R21, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L86, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3193
3274
|
return { $loc, token: `/*${$2}*/` };
|
|
3194
3275
|
});
|
|
3195
3276
|
function CoffeeMultiLineComment(state) {
|
|
@@ -3201,7 +3282,7 @@ var require_parser = __commonJS({
|
|
|
3201
3282
|
return CoffeeMultiLineComment$0(state);
|
|
3202
3283
|
}
|
|
3203
3284
|
}
|
|
3204
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
3285
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L85, fail, 'InlineComment "*/"')), $EXPECT($R23, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L85, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
3205
3286
|
return { $loc, token: $1 };
|
|
3206
3287
|
});
|
|
3207
3288
|
function InlineComment(state) {
|
|
@@ -3213,7 +3294,7 @@ var require_parser = __commonJS({
|
|
|
3213
3294
|
return InlineComment$0(state);
|
|
3214
3295
|
}
|
|
3215
3296
|
}
|
|
3216
|
-
var RestOfLine$0 = $S($Q($C(
|
|
3297
|
+
var RestOfLine$0 = $S($Q($C(NonNewlineWhitespace, SingleLineComment, MultiLineComment)), EOL);
|
|
3217
3298
|
function RestOfLine(state) {
|
|
3218
3299
|
if (state.verbose)
|
|
3219
3300
|
console.log("ENTER:", "RestOfLine");
|
|
@@ -3223,7 +3304,7 @@ var require_parser = __commonJS({
|
|
|
3223
3304
|
return RestOfLine$0(state);
|
|
3224
3305
|
}
|
|
3225
3306
|
}
|
|
3226
|
-
var TrailingComment$0 =
|
|
3307
|
+
var TrailingComment$0 = NonNewlineWhitespace;
|
|
3227
3308
|
var TrailingComment$1 = InlineComment;
|
|
3228
3309
|
var TrailingComment$2 = SingleLineComment;
|
|
3229
3310
|
function TrailingComment(state) {
|
|
@@ -3243,7 +3324,7 @@ var require_parser = __commonJS({
|
|
|
3243
3324
|
return _$0(state);
|
|
3244
3325
|
}
|
|
3245
3326
|
}
|
|
3246
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
3327
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R24, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3247
3328
|
return { $loc, token: $0 };
|
|
3248
3329
|
});
|
|
3249
3330
|
function NonNewlineWhitespace(state) {
|
|
@@ -3310,7 +3391,7 @@ var require_parser = __commonJS({
|
|
|
3310
3391
|
return Loc$0(state);
|
|
3311
3392
|
}
|
|
3312
3393
|
}
|
|
3313
|
-
var As$0 = $TS($S($EXPECT($
|
|
3394
|
+
var As$0 = $TS($S($EXPECT($L87, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3314
3395
|
return { $loc, token: $1 };
|
|
3315
3396
|
});
|
|
3316
3397
|
function As(state) {
|
|
@@ -3322,7 +3403,7 @@ var require_parser = __commonJS({
|
|
|
3322
3403
|
return As$0(state);
|
|
3323
3404
|
}
|
|
3324
3405
|
}
|
|
3325
|
-
var Async$0 = $TV($EXPECT($
|
|
3406
|
+
var Async$0 = $TV($EXPECT($L88, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
|
|
3326
3407
|
return { $loc, token: $1 };
|
|
3327
3408
|
});
|
|
3328
3409
|
function Async(state) {
|
|
@@ -3334,7 +3415,7 @@ var require_parser = __commonJS({
|
|
|
3334
3415
|
return Async$0(state);
|
|
3335
3416
|
}
|
|
3336
3417
|
}
|
|
3337
|
-
var Await$0 = $TS($S($EXPECT($
|
|
3418
|
+
var Await$0 = $TS($S($EXPECT($L89, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3338
3419
|
return { $loc, token: $1 };
|
|
3339
3420
|
});
|
|
3340
3421
|
function Await(state) {
|
|
@@ -3346,7 +3427,19 @@ var require_parser = __commonJS({
|
|
|
3346
3427
|
return Await$0(state);
|
|
3347
3428
|
}
|
|
3348
3429
|
}
|
|
3349
|
-
var
|
|
3430
|
+
var Case$0 = $TS($S($EXPECT($L90, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3431
|
+
return { $loc, token: $1 };
|
|
3432
|
+
});
|
|
3433
|
+
function Case(state) {
|
|
3434
|
+
if (state.verbose)
|
|
3435
|
+
console.log("ENTER:", "Case");
|
|
3436
|
+
if (state.tokenize) {
|
|
3437
|
+
return $TOKEN("Case", state, Case$0(state));
|
|
3438
|
+
} else {
|
|
3439
|
+
return Case$0(state);
|
|
3440
|
+
}
|
|
3441
|
+
}
|
|
3442
|
+
var Catch$0 = $TV($EXPECT($L91, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
3350
3443
|
return { $loc, token: $1 };
|
|
3351
3444
|
});
|
|
3352
3445
|
function Catch(state) {
|
|
@@ -3358,7 +3451,7 @@ var require_parser = __commonJS({
|
|
|
3358
3451
|
return Catch$0(state);
|
|
3359
3452
|
}
|
|
3360
3453
|
}
|
|
3361
|
-
var Class$0 = $TV($EXPECT($
|
|
3454
|
+
var Class$0 = $TV($EXPECT($L92, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
3362
3455
|
return { $loc, token: $1 };
|
|
3363
3456
|
});
|
|
3364
3457
|
function Class(state) {
|
|
@@ -3370,7 +3463,7 @@ var require_parser = __commonJS({
|
|
|
3370
3463
|
return Class$0(state);
|
|
3371
3464
|
}
|
|
3372
3465
|
}
|
|
3373
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
3466
|
+
var CloseBrace$0 = $TV($EXPECT($L24, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
3374
3467
|
return { $loc, token: $1 };
|
|
3375
3468
|
});
|
|
3376
3469
|
function CloseBrace(state) {
|
|
@@ -3382,7 +3475,7 @@ var require_parser = __commonJS({
|
|
|
3382
3475
|
return CloseBrace$0(state);
|
|
3383
3476
|
}
|
|
3384
3477
|
}
|
|
3385
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
3478
|
+
var CloseBracket$0 = $TV($EXPECT($L23, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
3386
3479
|
return { $loc, token: $1 };
|
|
3387
3480
|
});
|
|
3388
3481
|
function CloseBracket(state) {
|
|
@@ -3394,7 +3487,7 @@ var require_parser = __commonJS({
|
|
|
3394
3487
|
return CloseBracket$0(state);
|
|
3395
3488
|
}
|
|
3396
3489
|
}
|
|
3397
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
3490
|
+
var CloseParen$0 = $TV($EXPECT($L16, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
3398
3491
|
return { $loc, token: $1 };
|
|
3399
3492
|
});
|
|
3400
3493
|
function CloseParen(state) {
|
|
@@ -3406,7 +3499,19 @@ var require_parser = __commonJS({
|
|
|
3406
3499
|
return CloseParen$0(state);
|
|
3407
3500
|
}
|
|
3408
3501
|
}
|
|
3409
|
-
var
|
|
3502
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L93, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
3503
|
+
return { $loc, token: "${" };
|
|
3504
|
+
});
|
|
3505
|
+
function CoffeeSubstitutionStart(state) {
|
|
3506
|
+
if (state.verbose)
|
|
3507
|
+
console.log("ENTER:", "CoffeeSubstitutionStart");
|
|
3508
|
+
if (state.tokenize) {
|
|
3509
|
+
return $TOKEN("CoffeeSubstitutionStart", state, CoffeeSubstitutionStart$0(state));
|
|
3510
|
+
} else {
|
|
3511
|
+
return CoffeeSubstitutionStart$0(state);
|
|
3512
|
+
}
|
|
3513
|
+
}
|
|
3514
|
+
var Colon$0 = $TV($EXPECT($L94, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
3410
3515
|
return { $loc, token: $1 };
|
|
3411
3516
|
});
|
|
3412
3517
|
function Colon(state) {
|
|
@@ -3418,7 +3523,31 @@ var require_parser = __commonJS({
|
|
|
3418
3523
|
return Colon$0(state);
|
|
3419
3524
|
}
|
|
3420
3525
|
}
|
|
3421
|
-
var
|
|
3526
|
+
var ConstructorShorthand$0 = $TV($EXPECT($L9, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
|
|
3527
|
+
return { $loc, token: "constructor" };
|
|
3528
|
+
});
|
|
3529
|
+
function ConstructorShorthand(state) {
|
|
3530
|
+
if (state.verbose)
|
|
3531
|
+
console.log("ENTER:", "ConstructorShorthand");
|
|
3532
|
+
if (state.tokenize) {
|
|
3533
|
+
return $TOKEN("ConstructorShorthand", state, ConstructorShorthand$0(state));
|
|
3534
|
+
} else {
|
|
3535
|
+
return ConstructorShorthand$0(state);
|
|
3536
|
+
}
|
|
3537
|
+
}
|
|
3538
|
+
var Default$0 = $TS($S($EXPECT($L82, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3539
|
+
return { $loc, token: $1 };
|
|
3540
|
+
});
|
|
3541
|
+
function Default(state) {
|
|
3542
|
+
if (state.verbose)
|
|
3543
|
+
console.log("ENTER:", "Default");
|
|
3544
|
+
if (state.tokenize) {
|
|
3545
|
+
return $TOKEN("Default", state, Default$0(state));
|
|
3546
|
+
} else {
|
|
3547
|
+
return Default$0(state);
|
|
3548
|
+
}
|
|
3549
|
+
}
|
|
3550
|
+
var Dot$0 = $TV($EXPECT($L95, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
3422
3551
|
return { $loc, token: $1 };
|
|
3423
3552
|
});
|
|
3424
3553
|
function Dot(state) {
|
|
@@ -3430,7 +3559,19 @@ var require_parser = __commonJS({
|
|
|
3430
3559
|
return Dot$0(state);
|
|
3431
3560
|
}
|
|
3432
3561
|
}
|
|
3433
|
-
var
|
|
3562
|
+
var DoubleQuote$0 = $TV($EXPECT($L96, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
3563
|
+
return { $loc, token: $1 };
|
|
3564
|
+
});
|
|
3565
|
+
function DoubleQuote(state) {
|
|
3566
|
+
if (state.verbose)
|
|
3567
|
+
console.log("ENTER:", "DoubleQuote");
|
|
3568
|
+
if (state.tokenize) {
|
|
3569
|
+
return $TOKEN("DoubleQuote", state, DoubleQuote$0(state));
|
|
3570
|
+
} else {
|
|
3571
|
+
return DoubleQuote$0(state);
|
|
3572
|
+
}
|
|
3573
|
+
}
|
|
3574
|
+
var Else$0 = $TV($EXPECT($L97, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
3434
3575
|
return { $loc, token: $1 };
|
|
3435
3576
|
});
|
|
3436
3577
|
function Else(state) {
|
|
@@ -3442,7 +3583,7 @@ var require_parser = __commonJS({
|
|
|
3442
3583
|
return Else$0(state);
|
|
3443
3584
|
}
|
|
3444
3585
|
}
|
|
3445
|
-
var Equals$0 = $TV($EXPECT($
|
|
3586
|
+
var Equals$0 = $TV($EXPECT($L41, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
3446
3587
|
return { $loc, token: $1 };
|
|
3447
3588
|
});
|
|
3448
3589
|
function Equals(state) {
|
|
@@ -3454,7 +3595,7 @@ var require_parser = __commonJS({
|
|
|
3454
3595
|
return Equals$0(state);
|
|
3455
3596
|
}
|
|
3456
3597
|
}
|
|
3457
|
-
var Export$0 = $TS($S($EXPECT($
|
|
3598
|
+
var Export$0 = $TS($S($EXPECT($L98, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3458
3599
|
return { $loc, token: $1 };
|
|
3459
3600
|
});
|
|
3460
3601
|
function Export(state) {
|
|
@@ -3466,7 +3607,7 @@ var require_parser = __commonJS({
|
|
|
3466
3607
|
return Export$0(state);
|
|
3467
3608
|
}
|
|
3468
3609
|
}
|
|
3469
|
-
var For$0 = $TS($S($EXPECT($
|
|
3610
|
+
var For$0 = $TS($S($EXPECT($L99, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3470
3611
|
return { $loc, token: $1 };
|
|
3471
3612
|
});
|
|
3472
3613
|
function For(state) {
|
|
@@ -3478,7 +3619,7 @@ var require_parser = __commonJS({
|
|
|
3478
3619
|
return For$0(state);
|
|
3479
3620
|
}
|
|
3480
3621
|
}
|
|
3481
|
-
var From$0 = $TS($S($EXPECT($
|
|
3622
|
+
var From$0 = $TS($S($EXPECT($L100, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3482
3623
|
return { $loc, token: $1 };
|
|
3483
3624
|
});
|
|
3484
3625
|
function From(state) {
|
|
@@ -3490,7 +3631,7 @@ var require_parser = __commonJS({
|
|
|
3490
3631
|
return From$0(state);
|
|
3491
3632
|
}
|
|
3492
3633
|
}
|
|
3493
|
-
var Function$0 = $TV($EXPECT($
|
|
3634
|
+
var Function$0 = $TV($EXPECT($L101, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
3494
3635
|
return { $loc, token: $1 };
|
|
3495
3636
|
});
|
|
3496
3637
|
function Function(state) {
|
|
@@ -3502,7 +3643,7 @@ var require_parser = __commonJS({
|
|
|
3502
3643
|
return Function$0(state);
|
|
3503
3644
|
}
|
|
3504
3645
|
}
|
|
3505
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
3646
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L102, fail, 'GetOrSet "get"'), $EXPECT($L103, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3506
3647
|
return { $loc, token: $1 };
|
|
3507
3648
|
});
|
|
3508
3649
|
function GetOrSet(state) {
|
|
@@ -3514,7 +3655,7 @@ var require_parser = __commonJS({
|
|
|
3514
3655
|
return GetOrSet$0(state);
|
|
3515
3656
|
}
|
|
3516
3657
|
}
|
|
3517
|
-
var If$0 = $TV($EXPECT($
|
|
3658
|
+
var If$0 = $TV($EXPECT($L104, fail, 'If "if"'), function($skip, $loc, $0, $1) {
|
|
3518
3659
|
return { $loc, token: $1 };
|
|
3519
3660
|
});
|
|
3520
3661
|
function If(state) {
|
|
@@ -3526,7 +3667,7 @@ var require_parser = __commonJS({
|
|
|
3526
3667
|
return If$0(state);
|
|
3527
3668
|
}
|
|
3528
3669
|
}
|
|
3529
|
-
var Import$0 = $TS($S($EXPECT($
|
|
3670
|
+
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R27, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
3530
3671
|
return { $loc, token: $1 };
|
|
3531
3672
|
});
|
|
3532
3673
|
function Import(state) {
|
|
@@ -3538,7 +3679,7 @@ var require_parser = __commonJS({
|
|
|
3538
3679
|
return Import$0(state);
|
|
3539
3680
|
}
|
|
3540
3681
|
}
|
|
3541
|
-
var In$0 = $TV($EXPECT($
|
|
3682
|
+
var In$0 = $TV($EXPECT($L65, fail, 'In "in"'), function($skip, $loc, $0, $1) {
|
|
3542
3683
|
return { $loc, token: $1 };
|
|
3543
3684
|
});
|
|
3544
3685
|
function In(state) {
|
|
@@ -3550,7 +3691,7 @@ var require_parser = __commonJS({
|
|
|
3550
3691
|
return In$0(state);
|
|
3551
3692
|
}
|
|
3552
3693
|
}
|
|
3553
|
-
var LetOrConst$0 = $TV($C($EXPECT($
|
|
3694
|
+
var LetOrConst$0 = $TV($C($EXPECT($L105, fail, 'LetOrConst "let"'), $EXPECT($L106, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
3554
3695
|
return { $loc, token: $1 };
|
|
3555
3696
|
});
|
|
3556
3697
|
function LetOrConst(state) {
|
|
@@ -3562,7 +3703,7 @@ var require_parser = __commonJS({
|
|
|
3562
3703
|
return LetOrConst$0(state);
|
|
3563
3704
|
}
|
|
3564
3705
|
}
|
|
3565
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
3706
|
+
var Loop$0 = $TS($S($EXPECT($L107, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3566
3707
|
return { $loc, token: "while(true)" };
|
|
3567
3708
|
});
|
|
3568
3709
|
function Loop(state) {
|
|
@@ -3574,7 +3715,7 @@ var require_parser = __commonJS({
|
|
|
3574
3715
|
return Loop$0(state);
|
|
3575
3716
|
}
|
|
3576
3717
|
}
|
|
3577
|
-
var New$0 = $TV($EXPECT($
|
|
3718
|
+
var New$0 = $TV($EXPECT($L108, fail, 'New "new"'), function($skip, $loc, $0, $1) {
|
|
3578
3719
|
return { $loc, token: $1 };
|
|
3579
3720
|
});
|
|
3580
3721
|
function New(state) {
|
|
@@ -3586,7 +3727,7 @@ var require_parser = __commonJS({
|
|
|
3586
3727
|
return New$0(state);
|
|
3587
3728
|
}
|
|
3588
3729
|
}
|
|
3589
|
-
var Of$0 = $TV($EXPECT($
|
|
3730
|
+
var Of$0 = $TV($EXPECT($L109, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
3590
3731
|
return { $loc, token: $1 };
|
|
3591
3732
|
});
|
|
3592
3733
|
function Of(state) {
|
|
@@ -3598,7 +3739,7 @@ var require_parser = __commonJS({
|
|
|
3598
3739
|
return Of$0(state);
|
|
3599
3740
|
}
|
|
3600
3741
|
}
|
|
3601
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
3742
|
+
var OpenBrace$0 = $TV($EXPECT($L110, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
3602
3743
|
return { $loc, token: $1 };
|
|
3603
3744
|
});
|
|
3604
3745
|
function OpenBrace(state) {
|
|
@@ -3610,7 +3751,7 @@ var require_parser = __commonJS({
|
|
|
3610
3751
|
return OpenBrace$0(state);
|
|
3611
3752
|
}
|
|
3612
3753
|
}
|
|
3613
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
3754
|
+
var OpenBracket$0 = $TV($EXPECT($L111, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
3614
3755
|
return { $loc, token: $1 };
|
|
3615
3756
|
});
|
|
3616
3757
|
function OpenBracket(state) {
|
|
@@ -3622,7 +3763,7 @@ var require_parser = __commonJS({
|
|
|
3622
3763
|
return OpenBracket$0(state);
|
|
3623
3764
|
}
|
|
3624
3765
|
}
|
|
3625
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
3766
|
+
var OpenParen$0 = $TV($EXPECT($L112, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
3626
3767
|
return { $loc, token: $1 };
|
|
3627
3768
|
});
|
|
3628
3769
|
function OpenParen(state) {
|
|
@@ -3634,7 +3775,7 @@ var require_parser = __commonJS({
|
|
|
3634
3775
|
return OpenParen$0(state);
|
|
3635
3776
|
}
|
|
3636
3777
|
}
|
|
3637
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
3778
|
+
var QuestionMark$0 = $TV($EXPECT($L113, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
3638
3779
|
return { $loc, token: $1 };
|
|
3639
3780
|
});
|
|
3640
3781
|
function QuestionMark(state) {
|
|
@@ -3646,7 +3787,7 @@ var require_parser = __commonJS({
|
|
|
3646
3787
|
return QuestionMark$0(state);
|
|
3647
3788
|
}
|
|
3648
3789
|
}
|
|
3649
|
-
var Return$0 = $TS($S($EXPECT($
|
|
3790
|
+
var Return$0 = $TS($S($EXPECT($L114, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3650
3791
|
return { $loc, token: $1 };
|
|
3651
3792
|
});
|
|
3652
3793
|
function Return(state) {
|
|
@@ -3658,7 +3799,7 @@ var require_parser = __commonJS({
|
|
|
3658
3799
|
return Return$0(state);
|
|
3659
3800
|
}
|
|
3660
3801
|
}
|
|
3661
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
3802
|
+
var Semicolon$0 = $TV($EXPECT($L72, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
3662
3803
|
return { $loc, token: $1 };
|
|
3663
3804
|
});
|
|
3664
3805
|
function Semicolon(state) {
|
|
@@ -3670,10 +3811,34 @@ var require_parser = __commonJS({
|
|
|
3670
3811
|
return Semicolon$0(state);
|
|
3671
3812
|
}
|
|
3672
3813
|
}
|
|
3673
|
-
var
|
|
3814
|
+
var SingleQuote$0 = $TV($EXPECT($L115, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
3674
3815
|
return { $loc, token: $1 };
|
|
3675
3816
|
});
|
|
3676
|
-
|
|
3817
|
+
function SingleQuote(state) {
|
|
3818
|
+
if (state.verbose)
|
|
3819
|
+
console.log("ENTER:", "SingleQuote");
|
|
3820
|
+
if (state.tokenize) {
|
|
3821
|
+
return $TOKEN("SingleQuote", state, SingleQuote$0(state));
|
|
3822
|
+
} else {
|
|
3823
|
+
return SingleQuote$0(state);
|
|
3824
|
+
}
|
|
3825
|
+
}
|
|
3826
|
+
var Star$0 = $TV($EXPECT($L43, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
3827
|
+
return { $loc, token: $1 };
|
|
3828
|
+
});
|
|
3829
|
+
function Star(state) {
|
|
3830
|
+
if (state.verbose)
|
|
3831
|
+
console.log("ENTER:", "Star");
|
|
3832
|
+
if (state.tokenize) {
|
|
3833
|
+
return $TOKEN("Star", state, Star$0(state));
|
|
3834
|
+
} else {
|
|
3835
|
+
return Star$0(state);
|
|
3836
|
+
}
|
|
3837
|
+
}
|
|
3838
|
+
var Static$0 = $TV($EXPECT($L116, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
3839
|
+
return { $loc, token: $1 };
|
|
3840
|
+
});
|
|
3841
|
+
var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L112, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
|
|
3677
3842
|
return { $loc, token: "static " };
|
|
3678
3843
|
});
|
|
3679
3844
|
function Static(state) {
|
|
@@ -3683,7 +3848,19 @@ var require_parser = __commonJS({
|
|
|
3683
3848
|
return Static$0(state) || Static$1(state);
|
|
3684
3849
|
}
|
|
3685
3850
|
}
|
|
3686
|
-
var
|
|
3851
|
+
var SubstitutionStart$0 = $TV($EXPECT($L117, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
3852
|
+
return { $loc, token: $1 };
|
|
3853
|
+
});
|
|
3854
|
+
function SubstitutionStart(state) {
|
|
3855
|
+
if (state.verbose)
|
|
3856
|
+
console.log("ENTER:", "SubstitutionStart");
|
|
3857
|
+
if (state.tokenize) {
|
|
3858
|
+
return $TOKEN("SubstitutionStart", state, SubstitutionStart$0(state));
|
|
3859
|
+
} else {
|
|
3860
|
+
return SubstitutionStart$0(state);
|
|
3861
|
+
}
|
|
3862
|
+
}
|
|
3863
|
+
var Switch$0 = $TS($S($EXPECT($L118, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3687
3864
|
return { $loc, token: $1 };
|
|
3688
3865
|
});
|
|
3689
3866
|
function Switch(state) {
|
|
@@ -3695,7 +3872,7 @@ var require_parser = __commonJS({
|
|
|
3695
3872
|
return Switch$0(state);
|
|
3696
3873
|
}
|
|
3697
3874
|
}
|
|
3698
|
-
var Target$0 = $TV($EXPECT($
|
|
3875
|
+
var Target$0 = $TV($EXPECT($L119, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
|
|
3699
3876
|
return { $loc, token: $1 };
|
|
3700
3877
|
});
|
|
3701
3878
|
function Target(state) {
|
|
@@ -3707,7 +3884,7 @@ var require_parser = __commonJS({
|
|
|
3707
3884
|
return Target$0(state);
|
|
3708
3885
|
}
|
|
3709
3886
|
}
|
|
3710
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
3887
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L120, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
3711
3888
|
return { $loc, token: "`" };
|
|
3712
3889
|
});
|
|
3713
3890
|
function TripleDoubleQuote(state) {
|
|
@@ -3719,7 +3896,7 @@ var require_parser = __commonJS({
|
|
|
3719
3896
|
return TripleDoubleQuote$0(state);
|
|
3720
3897
|
}
|
|
3721
3898
|
}
|
|
3722
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
3899
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L121, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
3723
3900
|
return { $loc, token: "`" };
|
|
3724
3901
|
});
|
|
3725
3902
|
function TripleSingleQuote(state) {
|
|
@@ -3731,7 +3908,7 @@ var require_parser = __commonJS({
|
|
|
3731
3908
|
return TripleSingleQuote$0(state);
|
|
3732
3909
|
}
|
|
3733
3910
|
}
|
|
3734
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
3911
|
+
var TripleTick$0 = $TV($EXPECT($L122, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
3735
3912
|
return { $loc, token: "`" };
|
|
3736
3913
|
});
|
|
3737
3914
|
function TripleTick(state) {
|
|
@@ -3743,7 +3920,7 @@ var require_parser = __commonJS({
|
|
|
3743
3920
|
return TripleTick$0(state);
|
|
3744
3921
|
}
|
|
3745
3922
|
}
|
|
3746
|
-
var Try$0 = $TV($EXPECT($
|
|
3923
|
+
var Try$0 = $TV($EXPECT($L123, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
3747
3924
|
return { $loc, token: $1 };
|
|
3748
3925
|
});
|
|
3749
3926
|
function Try(state) {
|
|
@@ -3755,7 +3932,7 @@ var require_parser = __commonJS({
|
|
|
3755
3932
|
return Try$0(state);
|
|
3756
3933
|
}
|
|
3757
3934
|
}
|
|
3758
|
-
var Unless$0 = $TV($EXPECT($
|
|
3935
|
+
var Unless$0 = $TV($EXPECT($L124, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
3759
3936
|
return { $loc, token: $1 };
|
|
3760
3937
|
});
|
|
3761
3938
|
function Unless(state) {
|
|
@@ -3767,7 +3944,7 @@ var require_parser = __commonJS({
|
|
|
3767
3944
|
return Unless$0(state);
|
|
3768
3945
|
}
|
|
3769
3946
|
}
|
|
3770
|
-
var Var$0 = $TV($EXPECT($
|
|
3947
|
+
var Var$0 = $TV($EXPECT($L125, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
3771
3948
|
return { $loc, token: $1 };
|
|
3772
3949
|
});
|
|
3773
3950
|
function Var(state) {
|
|
@@ -3779,7 +3956,7 @@ var require_parser = __commonJS({
|
|
|
3779
3956
|
return Var$0(state);
|
|
3780
3957
|
}
|
|
3781
3958
|
}
|
|
3782
|
-
var When$0 = $TS($S($EXPECT($
|
|
3959
|
+
var When$0 = $TS($S($EXPECT($L126, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3783
3960
|
return { $loc, token: "case" };
|
|
3784
3961
|
});
|
|
3785
3962
|
function When(state) {
|
|
@@ -3791,6 +3968,18 @@ var require_parser = __commonJS({
|
|
|
3791
3968
|
return When$0(state);
|
|
3792
3969
|
}
|
|
3793
3970
|
}
|
|
3971
|
+
var Yield$0 = $TS($S($EXPECT($L127, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3972
|
+
return { $loc, token: $1 };
|
|
3973
|
+
});
|
|
3974
|
+
function Yield(state) {
|
|
3975
|
+
if (state.verbose)
|
|
3976
|
+
console.log("ENTER:", "Yield");
|
|
3977
|
+
if (state.tokenize) {
|
|
3978
|
+
return $TOKEN("Yield", state, Yield$0(state));
|
|
3979
|
+
} else {
|
|
3980
|
+
return Yield$0(state);
|
|
3981
|
+
}
|
|
3982
|
+
}
|
|
3794
3983
|
var JSXElement$0 = JSXSelfClosingElement;
|
|
3795
3984
|
var JSXElement$1 = $TS($S(JSXOpeningElement, $Q(JSXChildren), __, JSXClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
3796
3985
|
if ($1[1] !== $4[2]) {
|
|
@@ -3805,7 +3994,7 @@ var require_parser = __commonJS({
|
|
|
3805
3994
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
3806
3995
|
}
|
|
3807
3996
|
}
|
|
3808
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($
|
|
3997
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L128, fail, 'JSXSelfClosingElement "/>"'));
|
|
3809
3998
|
function JSXSelfClosingElement(state) {
|
|
3810
3999
|
if (state.verbose)
|
|
3811
4000
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -3815,7 +4004,7 @@ var require_parser = __commonJS({
|
|
|
3815
4004
|
return JSXSelfClosingElement$0(state);
|
|
3816
4005
|
}
|
|
3817
4006
|
}
|
|
3818
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
4007
|
+
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L53, fail, 'JSXOpeningElement ">"'));
|
|
3819
4008
|
function JSXOpeningElement(state) {
|
|
3820
4009
|
if (state.verbose)
|
|
3821
4010
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -3825,7 +4014,7 @@ var require_parser = __commonJS({
|
|
|
3825
4014
|
return JSXOpeningElement$0(state);
|
|
3826
4015
|
}
|
|
3827
4016
|
}
|
|
3828
|
-
var JSXClosingElement$0 = $S($EXPECT($L129, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($
|
|
4017
|
+
var JSXClosingElement$0 = $S($EXPECT($L129, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L53, fail, 'JSXClosingElement ">"'));
|
|
3829
4018
|
function JSXClosingElement(state) {
|
|
3830
4019
|
if (state.verbose)
|
|
3831
4020
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -3875,7 +4064,7 @@ var require_parser = __commonJS({
|
|
|
3875
4064
|
return JSXAttributes$0(state);
|
|
3876
4065
|
}
|
|
3877
4066
|
}
|
|
3878
|
-
var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($
|
|
4067
|
+
var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($L17, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, CloseBrace);
|
|
3879
4068
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
3880
4069
|
function JSXAttribute(state) {
|
|
3881
4070
|
if (state.tokenize) {
|
|
@@ -3947,7 +4136,7 @@ var require_parser = __commonJS({
|
|
|
3947
4136
|
return JSXText$0(state);
|
|
3948
4137
|
}
|
|
3949
4138
|
}
|
|
3950
|
-
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($
|
|
4139
|
+
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L17, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
|
|
3951
4140
|
function JSXChildExpression(state) {
|
|
3952
4141
|
if (state.verbose)
|
|
3953
4142
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -4155,7 +4344,7 @@ var require_parser = __commonJS({
|
|
|
4155
4344
|
return ReturnTypeSuffix$0(state);
|
|
4156
4345
|
}
|
|
4157
4346
|
}
|
|
4158
|
-
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($
|
|
4347
|
+
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L56, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
|
|
4159
4348
|
function TypePredicate(state) {
|
|
4160
4349
|
if (state.verbose)
|
|
4161
4350
|
console.log("ENTER:", "TypePredicate");
|
|
@@ -4206,7 +4395,7 @@ var require_parser = __commonJS({
|
|
|
4206
4395
|
}
|
|
4207
4396
|
}
|
|
4208
4397
|
var TypeUnaryOp$0 = $EXPECT($L138, fail, 'TypeUnaryOp "keyof"');
|
|
4209
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
4398
|
+
var TypeUnaryOp$1 = $EXPECT($L71, fail, 'TypeUnaryOp "typeof"');
|
|
4210
4399
|
var TypeUnaryOp$2 = $EXPECT($L139, fail, 'TypeUnaryOp "infer"');
|
|
4211
4400
|
function TypeUnaryOp(state) {
|
|
4212
4401
|
if (state.tokenize) {
|
|
@@ -4237,7 +4426,7 @@ var require_parser = __commonJS({
|
|
|
4237
4426
|
return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
|
|
4238
4427
|
}
|
|
4239
4428
|
}
|
|
4240
|
-
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($
|
|
4429
|
+
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type)))));
|
|
4241
4430
|
function TypeConditional(state) {
|
|
4242
4431
|
if (state.verbose)
|
|
4243
4432
|
console.log("ENTER:", "TypeConditional");
|
|
@@ -4248,7 +4437,7 @@ var require_parser = __commonJS({
|
|
|
4248
4437
|
}
|
|
4249
4438
|
}
|
|
4250
4439
|
var TypeLiteral$0 = Literal;
|
|
4251
|
-
var TypeLiteral$1 = $EXPECT($
|
|
4440
|
+
var TypeLiteral$1 = $EXPECT($L70, fail, 'TypeLiteral "void"');
|
|
4252
4441
|
var TypeLiteral$2 = $EXPECT($L140, fail, 'TypeLiteral "[]"');
|
|
4253
4442
|
function TypeLiteral(state) {
|
|
4254
4443
|
if (state.tokenize) {
|
|
@@ -4257,8 +4446,8 @@ var require_parser = __commonJS({
|
|
|
4257
4446
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
4258
4447
|
}
|
|
4259
4448
|
}
|
|
4260
|
-
var TypeBinaryOp$0 = $EXPECT($
|
|
4261
|
-
var TypeBinaryOp$1 = $EXPECT($
|
|
4449
|
+
var TypeBinaryOp$0 = $EXPECT($L68, fail, 'TypeBinaryOp "|"');
|
|
4450
|
+
var TypeBinaryOp$1 = $EXPECT($L66, fail, 'TypeBinaryOp "&"');
|
|
4262
4451
|
function TypeBinaryOp(state) {
|
|
4263
4452
|
if (state.tokenize) {
|
|
4264
4453
|
return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
|
|
@@ -4266,7 +4455,7 @@ var require_parser = __commonJS({
|
|
|
4266
4455
|
return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
|
|
4267
4456
|
}
|
|
4268
4457
|
}
|
|
4269
|
-
var FunctionType$0 = $S(Parameters, __, $EXPECT($
|
|
4458
|
+
var FunctionType$0 = $S(Parameters, __, $EXPECT($L4, fail, 'FunctionType "=>"'), Type);
|
|
4270
4459
|
function FunctionType(state) {
|
|
4271
4460
|
if (state.verbose)
|
|
4272
4461
|
console.log("ENTER:", "FunctionType");
|
|
@@ -4276,7 +4465,7 @@ var require_parser = __commonJS({
|
|
|
4276
4465
|
return FunctionType$0(state);
|
|
4277
4466
|
}
|
|
4278
4467
|
}
|
|
4279
|
-
var TypeArguments$0 = $S(__, $EXPECT($
|
|
4468
|
+
var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L53, fail, 'TypeArguments ">"'));
|
|
4280
4469
|
function TypeArguments(state) {
|
|
4281
4470
|
if (state.verbose)
|
|
4282
4471
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -4286,7 +4475,7 @@ var require_parser = __commonJS({
|
|
|
4286
4475
|
return TypeArguments$0(state);
|
|
4287
4476
|
}
|
|
4288
4477
|
}
|
|
4289
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
4478
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L53, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
4290
4479
|
return { ts: true, children: $0 };
|
|
4291
4480
|
});
|
|
4292
4481
|
function TypeParameters(state) {
|
|
@@ -4308,7 +4497,7 @@ var require_parser = __commonJS({
|
|
|
4308
4497
|
return TypeParameter$0(state);
|
|
4309
4498
|
}
|
|
4310
4499
|
}
|
|
4311
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
4500
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L6, fail, 'TypeConstraint "extends"'), Type);
|
|
4312
4501
|
function TypeConstraint(state) {
|
|
4313
4502
|
if (state.verbose)
|
|
4314
4503
|
console.log("ENTER:", "TypeConstraint");
|
|
@@ -4319,8 +4508,8 @@ var require_parser = __commonJS({
|
|
|
4319
4508
|
}
|
|
4320
4509
|
}
|
|
4321
4510
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
4322
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
4323
|
-
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($
|
|
4511
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L53, fail, 'TypeParameterDelimiter ">"')));
|
|
4512
|
+
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L53, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
|
|
4324
4513
|
return { $loc, token: "," };
|
|
4325
4514
|
});
|
|
4326
4515
|
var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
@@ -4527,11 +4716,23 @@ var require_parser = __commonJS({
|
|
|
4527
4716
|
return InsertBreak$0(state);
|
|
4528
4717
|
}
|
|
4529
4718
|
}
|
|
4530
|
-
var
|
|
4531
|
-
var directives = $2;
|
|
4719
|
+
var Reset$0 = $TV($EXPECT($L1, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
4532
4720
|
module2.currentIndent = 0;
|
|
4533
4721
|
module2.indentLevels = [0];
|
|
4534
4722
|
module2.verbose = false;
|
|
4723
|
+
module2.coffeeCompat = false;
|
|
4724
|
+
});
|
|
4725
|
+
function Reset(state) {
|
|
4726
|
+
if (state.verbose)
|
|
4727
|
+
console.log("ENTER:", "Reset");
|
|
4728
|
+
if (state.tokenize) {
|
|
4729
|
+
return $TOKEN("Reset", state, Reset$0(state));
|
|
4730
|
+
} else {
|
|
4731
|
+
return Reset$0(state);
|
|
4732
|
+
}
|
|
4733
|
+
}
|
|
4734
|
+
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
4735
|
+
var directives = $2;
|
|
4535
4736
|
if (directives) {
|
|
4536
4737
|
const compatRe = /use coffee-compat/;
|
|
4537
4738
|
module2.coffeeCompat = directives.some((d) => d[1].token?.match(compatRe));
|
|
@@ -4543,6 +4744,19 @@ var require_parser = __commonJS({
|
|
|
4543
4744
|
s = s.slice(1, s.indexOf("Program") + 1);
|
|
4544
4745
|
return s;
|
|
4545
4746
|
};
|
|
4747
|
+
module2.insertTrimmingSpace = function(spacing, c) {
|
|
4748
|
+
let target = spacing;
|
|
4749
|
+
while (Array.isArray(target)) {
|
|
4750
|
+
target = target[0];
|
|
4751
|
+
}
|
|
4752
|
+
if (target.token) {
|
|
4753
|
+
target.token = target.token.replace(/^ ?/, c);
|
|
4754
|
+
}
|
|
4755
|
+
return spacing;
|
|
4756
|
+
};
|
|
4757
|
+
module2.modifyString = function(str) {
|
|
4758
|
+
return str.replace(/(?<!\\)(\\\\)*\n/g, "$1\\n");
|
|
4759
|
+
};
|
|
4546
4760
|
module2.dedentBlockSubstitutions = function($02) {
|
|
4547
4761
|
const [s, strWithSubstitutions, e] = $02;
|
|
4548
4762
|
if (strWithSubstitutions.length === 0) {
|
|
@@ -4586,7 +4800,7 @@ var require_parser = __commonJS({
|
|
|
4586
4800
|
if (trim) {
|
|
4587
4801
|
str = str.replace(/^(\r?\n|\n)/, "").replace(/(\r?\n|\n)[ \t]*$/, "");
|
|
4588
4802
|
}
|
|
4589
|
-
str = str.replace(/(
|
|
4803
|
+
str = str.replace(/(`|\$\{)/g, "\\$1");
|
|
4590
4804
|
return {
|
|
4591
4805
|
$loc: $loc2,
|
|
4592
4806
|
token: str
|