@danielx/civet 0.3.0 → 0.3.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +4 -2
- package/dist/browser.js +395 -361
- package/dist/browser.js.map +2 -2
- package/dist/civet +10 -10
- package/dist/cli.js.map +3 -3
- package/{esbuild-plugin.js → dist/esbuild-plugin.js} +0 -0
- package/dist/esm.mjs +61 -0
- package/dist/main.js +395 -361
- package/package.json +9 -6
- package/register.mjs +5 -17
package/dist/main.js
CHANGED
|
@@ -419,10 +419,11 @@ var require_parser = __commonJS({
|
|
|
419
419
|
UpdateExpressionSymbol,
|
|
420
420
|
AssignmentExpression,
|
|
421
421
|
AssignmentExpressionRest,
|
|
422
|
+
AwaitExpression,
|
|
422
423
|
YieldExpression,
|
|
423
424
|
ArrowFunction,
|
|
424
425
|
FatArrow,
|
|
425
|
-
|
|
426
|
+
FatArrowBody,
|
|
426
427
|
ConditionalExpression,
|
|
427
428
|
ShortCircuitExpression,
|
|
428
429
|
PrimaryExpression,
|
|
@@ -471,7 +472,6 @@ var require_parser = __commonJS({
|
|
|
471
472
|
BracedOrEmptyBlock,
|
|
472
473
|
BracedBlock,
|
|
473
474
|
SingleNestedExpression,
|
|
474
|
-
SingleNestedBlockStatement,
|
|
475
475
|
NestedBlockExpressions,
|
|
476
476
|
BlockExpression,
|
|
477
477
|
Literal,
|
|
@@ -546,6 +546,7 @@ var require_parser = __commonJS({
|
|
|
546
546
|
MaybeNestedExpression,
|
|
547
547
|
Return,
|
|
548
548
|
ImportDeclaration,
|
|
549
|
+
ImpliedImport,
|
|
549
550
|
Import,
|
|
550
551
|
ImportClause,
|
|
551
552
|
NameSpaceImport,
|
|
@@ -555,6 +556,7 @@ var require_parser = __commonJS({
|
|
|
555
556
|
ImportSpecifier,
|
|
556
557
|
ModuleExportName,
|
|
557
558
|
ModuleSpecifier,
|
|
559
|
+
UnquotedSpecifier,
|
|
558
560
|
ImportedBinding,
|
|
559
561
|
ExportDeclaration,
|
|
560
562
|
As,
|
|
@@ -677,93 +679,93 @@ var require_parser = __commonJS({
|
|
|
677
679
|
var $L5 = $L("++");
|
|
678
680
|
var $L6 = $L("--");
|
|
679
681
|
var $L7 = $L("async");
|
|
680
|
-
var $L8 = $L("
|
|
681
|
-
var $L9 = $L("
|
|
682
|
-
var $L10 = $L("
|
|
683
|
-
var $L11 = $L("
|
|
684
|
-
var $L12 = $L("
|
|
685
|
-
var $L13 = $L("
|
|
686
|
-
var $L14 = $L("
|
|
687
|
-
var $L15 = $L("
|
|
688
|
-
var $L16 = $L("
|
|
689
|
-
var $L17 = $L("
|
|
690
|
-
var $L18 = $L("
|
|
691
|
-
var $L19 = $L("
|
|
692
|
-
var $L20 = $L("
|
|
693
|
-
var $L21 = $L("
|
|
694
|
-
var $L22 = $L("
|
|
695
|
-
var $L23 = $L("
|
|
696
|
-
var $L24 = $L("
|
|
697
|
-
var $L25 = $L("
|
|
698
|
-
var $L26 = $L("
|
|
699
|
-
var $L27 = $L("
|
|
700
|
-
var $L28 = $L("
|
|
701
|
-
var $L29 = $L("
|
|
702
|
-
var $L30 = $L("
|
|
703
|
-
var $L31 = $L("");
|
|
704
|
-
var $L32 = $L("
|
|
705
|
-
var $L33 = $L("
|
|
706
|
-
var $L34 = $L("
|
|
707
|
-
var $L35 = $L("
|
|
708
|
-
var $L36 = $L("
|
|
709
|
-
var $L37 = $L("
|
|
710
|
-
var $L38 = $L("
|
|
711
|
-
var $L39 = $L("
|
|
712
|
-
var $L40 = $L("
|
|
713
|
-
var $L41 = $L("
|
|
714
|
-
var $L42 = $L("
|
|
715
|
-
var $L43 = $L("
|
|
716
|
-
var $L44 = $L("
|
|
717
|
-
var $L45 = $L("
|
|
718
|
-
var $L46 = $L("
|
|
719
|
-
var $L47 = $L("
|
|
720
|
-
var $L48 = $L("
|
|
721
|
-
var $L49 = $L("
|
|
722
|
-
var $L50 = $L("
|
|
723
|
-
var $L51 = $L("
|
|
724
|
-
var $L52 = $L("
|
|
725
|
-
var $L53 = $L("
|
|
726
|
-
var $L54 = $L("
|
|
727
|
-
var $L55 = $L("
|
|
728
|
-
var $L56 = $L("
|
|
729
|
-
var $L57 = $L("
|
|
730
|
-
var $L58 = $L("
|
|
731
|
-
var $L59 = $L("
|
|
732
|
-
var $L60 = $L("
|
|
733
|
-
var $L61 = $L("
|
|
734
|
-
var $L62 = $L("
|
|
735
|
-
var $L63 = $L("
|
|
736
|
-
var $L64 = $L("
|
|
737
|
-
var $L65 = $L("
|
|
738
|
-
var $L66 = $L("
|
|
739
|
-
var $L67 = $L("
|
|
740
|
-
var $L68 = $L("
|
|
741
|
-
var $L69 = $L("
|
|
742
|
-
var $L70 = $L("
|
|
743
|
-
var $L71 = $L("
|
|
744
|
-
var $L72 = $L("
|
|
745
|
-
var $L73 = $L("
|
|
746
|
-
var $L74 = $L("
|
|
747
|
-
var $L75 = $L("
|
|
748
|
-
var $L76 = $L("
|
|
749
|
-
var $L77 = $L("
|
|
750
|
-
var $L78 = $L("
|
|
751
|
-
var $L79 = $L("
|
|
752
|
-
var $L80 = $L("
|
|
753
|
-
var $L81 = $L("
|
|
754
|
-
var $L82 = $L("
|
|
755
|
-
var $L83 = $L("
|
|
756
|
-
var $L84 = $L("
|
|
757
|
-
var $L85 = $L("
|
|
758
|
-
var $L86 = $L("
|
|
759
|
-
var $L87 = $L("
|
|
760
|
-
var $L88 = $L("
|
|
761
|
-
var $L89 = $L("
|
|
762
|
-
var $L90 = $L("
|
|
763
|
-
var $L91 = $L("
|
|
764
|
-
var $L92 = $L("
|
|
765
|
-
var $L93 = $L("
|
|
766
|
-
var $L94 = $L("
|
|
682
|
+
var $L8 = $L("await");
|
|
683
|
+
var $L9 = $L("yield");
|
|
684
|
+
var $L10 = $L("*");
|
|
685
|
+
var $L11 = $L("=>");
|
|
686
|
+
var $L12 = $L("{");
|
|
687
|
+
var $L13 = $L("}");
|
|
688
|
+
var $L14 = $L(":");
|
|
689
|
+
var $L15 = $L("class");
|
|
690
|
+
var $L16 = $L("<");
|
|
691
|
+
var $L17 = $L("extends");
|
|
692
|
+
var $L18 = $L("static");
|
|
693
|
+
var $L19 = $L("this");
|
|
694
|
+
var $L20 = $L("#");
|
|
695
|
+
var $L21 = $L("@");
|
|
696
|
+
var $L22 = $L("new");
|
|
697
|
+
var $L23 = $L("super");
|
|
698
|
+
var $L24 = $L("import");
|
|
699
|
+
var $L25 = $L(".");
|
|
700
|
+
var $L26 = $L("[");
|
|
701
|
+
var $L27 = $L("]");
|
|
702
|
+
var $L28 = $L("::");
|
|
703
|
+
var $L29 = $L("super[");
|
|
704
|
+
var $L30 = $L("new.target");
|
|
705
|
+
var $L31 = $L("import.meta");
|
|
706
|
+
var $L32 = $L("");
|
|
707
|
+
var $L33 = $L("...");
|
|
708
|
+
var $L34 = $L("function");
|
|
709
|
+
var $L35 = $L("->");
|
|
710
|
+
var $L36 = $L("null");
|
|
711
|
+
var $L37 = $L("true");
|
|
712
|
+
var $L38 = $L("false");
|
|
713
|
+
var $L39 = $L("get");
|
|
714
|
+
var $L40 = $L("set");
|
|
715
|
+
var $L41 = $L("**=");
|
|
716
|
+
var $L42 = $L("*=");
|
|
717
|
+
var $L43 = $L("/=");
|
|
718
|
+
var $L44 = $L("%=");
|
|
719
|
+
var $L45 = $L("+=");
|
|
720
|
+
var $L46 = $L("-=");
|
|
721
|
+
var $L47 = $L("<<=");
|
|
722
|
+
var $L48 = $L(">>>=");
|
|
723
|
+
var $L49 = $L(">>=");
|
|
724
|
+
var $L50 = $L("&&=");
|
|
725
|
+
var $L51 = $L("&=");
|
|
726
|
+
var $L52 = $L("^=");
|
|
727
|
+
var $L53 = $L("||=");
|
|
728
|
+
var $L54 = $L("|=");
|
|
729
|
+
var $L55 = $L("??=");
|
|
730
|
+
var $L56 = $L("=");
|
|
731
|
+
var $L57 = $L("**");
|
|
732
|
+
var $L58 = $L("/");
|
|
733
|
+
var $L59 = $L("%");
|
|
734
|
+
var $L60 = $L("+");
|
|
735
|
+
var $L61 = $L("-");
|
|
736
|
+
var $L62 = $L("<=");
|
|
737
|
+
var $L63 = $L(">=");
|
|
738
|
+
var $L64 = $L("<<");
|
|
739
|
+
var $L65 = $L(">>>");
|
|
740
|
+
var $L66 = $L(">>");
|
|
741
|
+
var $L67 = $L(">");
|
|
742
|
+
var $L68 = $L("!==");
|
|
743
|
+
var $L69 = $L("!=");
|
|
744
|
+
var $L70 = $L("is");
|
|
745
|
+
var $L71 = $L("===");
|
|
746
|
+
var $L72 = $L("==");
|
|
747
|
+
var $L73 = $L("and");
|
|
748
|
+
var $L74 = $L("&&");
|
|
749
|
+
var $L75 = $L("or");
|
|
750
|
+
var $L76 = $L("||");
|
|
751
|
+
var $L77 = $L("??");
|
|
752
|
+
var $L78 = $L("instanceof");
|
|
753
|
+
var $L79 = $L("in");
|
|
754
|
+
var $L80 = $L("&");
|
|
755
|
+
var $L81 = $L("^");
|
|
756
|
+
var $L82 = $L("|");
|
|
757
|
+
var $L83 = $L("delete");
|
|
758
|
+
var $L84 = $L("void");
|
|
759
|
+
var $L85 = $L("typeof");
|
|
760
|
+
var $L86 = $L("if");
|
|
761
|
+
var $L87 = $L("unless");
|
|
762
|
+
var $L88 = $L(";");
|
|
763
|
+
var $L89 = $L("else");
|
|
764
|
+
var $L90 = $L("loop");
|
|
765
|
+
var $L91 = $L("do");
|
|
766
|
+
var $L92 = $L("while");
|
|
767
|
+
var $L93 = $L("until");
|
|
768
|
+
var $L94 = $L("var");
|
|
767
769
|
var $L95 = $L("of");
|
|
768
770
|
var $L96 = $L("for");
|
|
769
771
|
var $L97 = $L("let");
|
|
@@ -807,39 +809,41 @@ var require_parser = __commonJS({
|
|
|
807
809
|
var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
808
810
|
var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
809
811
|
var $R2 = $R(new RegExp("[!~+-]", "suy"));
|
|
810
|
-
var $R3 = $R(new RegExp("
|
|
811
|
-
var $R4 = $R(new RegExp("\\
|
|
812
|
-
var $R5 = $R(new RegExp("0[
|
|
813
|
-
var $R6 = $R(new RegExp("
|
|
814
|
-
var $R7 = $R(new RegExp("0[
|
|
815
|
-
var $R8 = $R(new RegExp(
|
|
816
|
-
var $R9 = $R(new RegExp("(
|
|
817
|
-
var $R10 = $R(new RegExp('(
|
|
818
|
-
var $R11 = $R(new RegExp("(
|
|
819
|
-
var $R12 = $R(new RegExp("[
|
|
820
|
-
var $R13 = $R(new RegExp("(
|
|
821
|
-
var $R14 = $R(new RegExp("
|
|
822
|
-
var $R15 = $R(new RegExp("(
|
|
823
|
-
var $R16 = $R(new RegExp("(
|
|
824
|
-
var $R17 = $R(new RegExp("
|
|
825
|
-
var $R18 = $R(new RegExp("
|
|
826
|
-
var $R19 = $R(new RegExp("
|
|
827
|
-
var $R20 = $R(new RegExp("
|
|
828
|
-
var $R21 = $R(new RegExp("[\\
|
|
829
|
-
var $R22 = $R(new RegExp("[\\
|
|
830
|
-
var $R23 = $R(new RegExp("
|
|
831
|
-
var $R24 = $R(new RegExp("
|
|
832
|
-
var $R25 = $R(new RegExp(
|
|
833
|
-
var $R26 = $R(new RegExp("
|
|
834
|
-
var $R27 = $R(new RegExp("[^
|
|
835
|
-
var $R28 = $R(new RegExp("
|
|
836
|
-
var $R29 = $R(new RegExp("
|
|
837
|
-
var $R30 = $R(new RegExp("
|
|
838
|
-
var $R31 = $R(new RegExp("
|
|
839
|
-
var $R32 = $R(new RegExp("
|
|
840
|
-
var $R33 = $R(new RegExp("[
|
|
841
|
-
var $R34 = $R(new RegExp("
|
|
842
|
-
var $R35 = $R(new RegExp("
|
|
812
|
+
var $R3 = $R(new RegExp("\\s", "suy"));
|
|
813
|
+
var $R4 = $R(new RegExp('[^"\\s]+', "suy"));
|
|
814
|
+
var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
815
|
+
var $R6 = $R(new RegExp("\\d+(?:\\.\\d*)?", "suy"));
|
|
816
|
+
var $R7 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
|
|
817
|
+
var $R8 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
|
|
818
|
+
var $R9 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
|
|
819
|
+
var $R10 = $R(new RegExp('(?:\\\\.|[^"])+', "suy"));
|
|
820
|
+
var $R11 = $R(new RegExp("(?:\\\\.|[^'])+", "suy"));
|
|
821
|
+
var $R12 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
|
|
822
|
+
var $R13 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])+", "suy"));
|
|
823
|
+
var $R14 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
|
|
824
|
+
var $R15 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
|
|
825
|
+
var $R16 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
826
|
+
var $R17 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
827
|
+
var $R18 = $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|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
828
|
+
var $R19 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
829
|
+
var $R20 = $R(new RegExp(".", "suy"));
|
|
830
|
+
var $R21 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
831
|
+
var $R22 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
832
|
+
var $R23 = $R(new RegExp("[\\t ]+", "suy"));
|
|
833
|
+
var $R24 = $R(new RegExp("[\\s]+", "suy"));
|
|
834
|
+
var $R25 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
835
|
+
var $R26 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
836
|
+
var $R27 = $R(new RegExp('"[^"]*"', "suy"));
|
|
837
|
+
var $R28 = $R(new RegExp("'[^']*'", "suy"));
|
|
838
|
+
var $R29 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
839
|
+
var $R30 = $R(new RegExp("type(?!\\p{ID_Continue})", "suy"));
|
|
840
|
+
var $R31 = $R(new RegExp("interface(?!\\p{ID_Continue})", "suy"));
|
|
841
|
+
var $R32 = $R(new RegExp("[+-]?", "suy"));
|
|
842
|
+
var $R33 = $R(new RegExp("[+-]", "suy"));
|
|
843
|
+
var $R34 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
844
|
+
var $R35 = $R(new RegExp("[\\t ]*", "suy"));
|
|
845
|
+
var $R36 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
846
|
+
var $R37 = $R(new RegExp("$", "suy"));
|
|
843
847
|
var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
|
|
844
848
|
function Program(state) {
|
|
845
849
|
if (state.verbose)
|
|
@@ -993,18 +997,29 @@ var require_parser = __commonJS({
|
|
|
993
997
|
return AssignmentExpression$0(state) || AssignmentExpression$1(state);
|
|
994
998
|
}
|
|
995
999
|
}
|
|
996
|
-
var AssignmentExpressionRest$0 =
|
|
997
|
-
var AssignmentExpressionRest$1 =
|
|
998
|
-
var AssignmentExpressionRest$2 = $S($
|
|
999
|
-
var AssignmentExpressionRest$3 =
|
|
1000
|
+
var AssignmentExpressionRest$0 = AwaitExpression;
|
|
1001
|
+
var AssignmentExpressionRest$1 = YieldExpression;
|
|
1002
|
+
var AssignmentExpressionRest$2 = $S($E($S($EXPECT($L7, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
|
|
1003
|
+
var AssignmentExpressionRest$3 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), Expression);
|
|
1004
|
+
var AssignmentExpressionRest$4 = ConditionalExpression;
|
|
1000
1005
|
function AssignmentExpressionRest(state) {
|
|
1001
1006
|
if (state.tokenize) {
|
|
1002
|
-
return $TOKEN("AssignmentExpressionRest", state, AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state));
|
|
1007
|
+
return $TOKEN("AssignmentExpressionRest", state, AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state) || AssignmentExpressionRest$4(state));
|
|
1003
1008
|
} else {
|
|
1004
|
-
return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state);
|
|
1009
|
+
return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state) || AssignmentExpressionRest$4(state);
|
|
1005
1010
|
}
|
|
1006
1011
|
}
|
|
1007
|
-
var
|
|
1012
|
+
var AwaitExpression$0 = $S($EXPECT($L8, fail, 'AwaitExpression "await"'), NonIdContinue, $Q(TrailingComment), AssignmentExpression);
|
|
1013
|
+
function AwaitExpression(state) {
|
|
1014
|
+
if (state.verbose)
|
|
1015
|
+
console.log("ENTER:", "AwaitExpression");
|
|
1016
|
+
if (state.tokenize) {
|
|
1017
|
+
return $TOKEN("AwaitExpression", state, AwaitExpression$0(state));
|
|
1018
|
+
} else {
|
|
1019
|
+
return AwaitExpression$0(state);
|
|
1020
|
+
}
|
|
1021
|
+
}
|
|
1022
|
+
var YieldExpression$0 = $S($EXPECT($L9, fail, 'YieldExpression "yield"'), NonIdContinue, $E($S($Q(TrailingComment), $EXPECT($L10, fail, 'YieldExpression "*"'))), AssignmentExpression);
|
|
1008
1023
|
function YieldExpression(state) {
|
|
1009
1024
|
if (state.verbose)
|
|
1010
1025
|
console.log("ENTER:", "YieldExpression");
|
|
@@ -1015,7 +1030,7 @@ var require_parser = __commonJS({
|
|
|
1015
1030
|
}
|
|
1016
1031
|
}
|
|
1017
1032
|
var ArrowFunction$0 = ThinArrowFunction;
|
|
1018
|
-
var ArrowFunction$1 = $S(Parameters, $E(ReturnTypeSuffix), FatArrow,
|
|
1033
|
+
var ArrowFunction$1 = $S(Parameters, $E(ReturnTypeSuffix), FatArrow, FatArrowBody);
|
|
1019
1034
|
function ArrowFunction(state) {
|
|
1020
1035
|
if (state.tokenize) {
|
|
1021
1036
|
return $TOKEN("ArrowFunction", state, ArrowFunction$0(state) || ArrowFunction$1(state));
|
|
@@ -1023,7 +1038,7 @@ var require_parser = __commonJS({
|
|
|
1023
1038
|
return ArrowFunction$0(state) || ArrowFunction$1(state);
|
|
1024
1039
|
}
|
|
1025
1040
|
}
|
|
1026
|
-
var FatArrow$0 = $TS($S(__, $EXPECT($
|
|
1041
|
+
var FatArrow$0 = $TS($S(__, $EXPECT($L11, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
|
|
1027
1042
|
var ws = $1;
|
|
1028
1043
|
if (!ws.length)
|
|
1029
1044
|
return " =>";
|
|
@@ -1038,17 +1053,27 @@ var require_parser = __commonJS({
|
|
|
1038
1053
|
return FatArrow$0(state);
|
|
1039
1054
|
}
|
|
1040
1055
|
}
|
|
1041
|
-
var
|
|
1042
|
-
var
|
|
1043
|
-
|
|
1044
|
-
|
|
1056
|
+
var FatArrowBody$0 = $S(__, $EXPECT($L12, fail, 'FatArrowBody "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L13, fail, 'FatArrowBody "}"'));
|
|
1057
|
+
var FatArrowBody$1 = $TS($S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
1058
|
+
var eos = $2;
|
|
1059
|
+
var exps = $3;
|
|
1060
|
+
if (exps.length == 1) {
|
|
1061
|
+
exps[0].pop();
|
|
1062
|
+
return [eos, exps];
|
|
1063
|
+
}
|
|
1064
|
+
return $0;
|
|
1065
|
+
});
|
|
1066
|
+
var FatArrowBody$2 = AssignmentExpression;
|
|
1067
|
+
var FatArrowBody$3 = $S(__, AssignmentExpression);
|
|
1068
|
+
var FatArrowBody$4 = $S(InsertOpenBrace, InsertCloseBrace);
|
|
1069
|
+
function FatArrowBody(state) {
|
|
1045
1070
|
if (state.tokenize) {
|
|
1046
|
-
return $TOKEN("
|
|
1071
|
+
return $TOKEN("FatArrowBody", state, FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state) || FatArrowBody$4(state));
|
|
1047
1072
|
} else {
|
|
1048
|
-
return
|
|
1073
|
+
return FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state) || FatArrowBody$4(state);
|
|
1049
1074
|
}
|
|
1050
1075
|
}
|
|
1051
|
-
var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($
|
|
1076
|
+
var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L14, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
|
|
1052
1077
|
function ConditionalExpression(state) {
|
|
1053
1078
|
if (state.verbose)
|
|
1054
1079
|
console.log("ENTER:", "ConditionalExpression");
|
|
@@ -1107,7 +1132,7 @@ var require_parser = __commonJS({
|
|
|
1107
1132
|
return ClassExpression$0(state);
|
|
1108
1133
|
}
|
|
1109
1134
|
}
|
|
1110
|
-
var Class$0 = $TV($EXPECT($
|
|
1135
|
+
var Class$0 = $TV($EXPECT($L15, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
1111
1136
|
return { $loc, token: $0 };
|
|
1112
1137
|
});
|
|
1113
1138
|
function Class(state) {
|
|
@@ -1129,10 +1154,10 @@ var require_parser = __commonJS({
|
|
|
1129
1154
|
return ClassHeritage$0(state);
|
|
1130
1155
|
}
|
|
1131
1156
|
}
|
|
1132
|
-
var ExtendsToken$0 = $TV($EXPECT($
|
|
1157
|
+
var ExtendsToken$0 = $TV($EXPECT($L16, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
|
|
1133
1158
|
return { $loc, token: "extends" };
|
|
1134
1159
|
});
|
|
1135
|
-
var ExtendsToken$1 = $TV($EXPECT($
|
|
1160
|
+
var ExtendsToken$1 = $TV($EXPECT($L17, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
|
|
1136
1161
|
return { $loc, token: $1 };
|
|
1137
1162
|
});
|
|
1138
1163
|
function ExtendsToken(state) {
|
|
@@ -1142,7 +1167,7 @@ var require_parser = __commonJS({
|
|
|
1142
1167
|
return ExtendsToken$0(state) || ExtendsToken$1(state);
|
|
1143
1168
|
}
|
|
1144
1169
|
}
|
|
1145
|
-
var ClassBody$0 = $S(__, $EXPECT($
|
|
1170
|
+
var ClassBody$0 = $S(__, $EXPECT($L12, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L13, fail, 'ClassBody "}"'));
|
|
1146
1171
|
var ClassBody$1 = $S(InsertOpenBrace, EOS, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1147
1172
|
function ClassBody(state) {
|
|
1148
1173
|
if (state.tokenize) {
|
|
@@ -1185,7 +1210,7 @@ var require_parser = __commonJS({
|
|
|
1185
1210
|
return ClassElement$0(state) || ClassElement$1(state);
|
|
1186
1211
|
}
|
|
1187
1212
|
}
|
|
1188
|
-
var Static$0 = $TV($EXPECT($
|
|
1213
|
+
var Static$0 = $TV($EXPECT($L18, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
1189
1214
|
return { $loc, token: $0 };
|
|
1190
1215
|
});
|
|
1191
1216
|
function Static(state) {
|
|
@@ -1207,11 +1232,11 @@ var require_parser = __commonJS({
|
|
|
1207
1232
|
return FieldDefinition$0(state);
|
|
1208
1233
|
}
|
|
1209
1234
|
}
|
|
1210
|
-
var This$0 = $TV($EXPECT($
|
|
1235
|
+
var This$0 = $TV($EXPECT($L19, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
1211
1236
|
return { $loc, token: $0 };
|
|
1212
1237
|
});
|
|
1213
|
-
var This$1 = $S(AtAccessor, $S($E($EXPECT($
|
|
1214
|
-
var This$2 = $TV($EXPECT($
|
|
1238
|
+
var This$1 = $S(AtAccessor, $S($E($EXPECT($L20, fail, 'This "#"')), IdentifierName));
|
|
1239
|
+
var This$2 = $TV($EXPECT($L21, fail, 'This "@"'), function($skip, $loc, $0, $1) {
|
|
1215
1240
|
return { $loc, token: "this" };
|
|
1216
1241
|
});
|
|
1217
1242
|
function This(state) {
|
|
@@ -1221,7 +1246,7 @@ var require_parser = __commonJS({
|
|
|
1221
1246
|
return This$0(state) || This$1(state) || This$2(state);
|
|
1222
1247
|
}
|
|
1223
1248
|
}
|
|
1224
|
-
var AtAccessor$0 = $TV($EXPECT($
|
|
1249
|
+
var AtAccessor$0 = $TV($EXPECT($L21, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
|
|
1225
1250
|
return { $loc, token: "this." };
|
|
1226
1251
|
});
|
|
1227
1252
|
function AtAccessor(state) {
|
|
@@ -1242,7 +1267,7 @@ var require_parser = __commonJS({
|
|
|
1242
1267
|
return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
|
|
1243
1268
|
}
|
|
1244
1269
|
}
|
|
1245
|
-
var NewExpression$0 = $S($P($S($EXPECT($
|
|
1270
|
+
var NewExpression$0 = $S($P($S($EXPECT($L22, fail, 'NewExpression "new"'), __)), CallExpression);
|
|
1246
1271
|
function NewExpression(state) {
|
|
1247
1272
|
if (state.verbose)
|
|
1248
1273
|
console.log("ENTER:", "NewExpression");
|
|
@@ -1252,8 +1277,8 @@ var require_parser = __commonJS({
|
|
|
1252
1277
|
return NewExpression$0(state);
|
|
1253
1278
|
}
|
|
1254
1279
|
}
|
|
1255
|
-
var CallExpression$0 = $S($EXPECT($
|
|
1256
|
-
var CallExpression$1 = $S($EXPECT($
|
|
1280
|
+
var CallExpression$0 = $S($EXPECT($L23, fail, 'CallExpression "super"'), __, Arguments);
|
|
1281
|
+
var CallExpression$1 = $S($EXPECT($L24, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
|
|
1257
1282
|
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
|
|
1258
1283
|
function CallExpression(state) {
|
|
1259
1284
|
if (state.tokenize) {
|
|
@@ -1273,7 +1298,7 @@ var require_parser = __commonJS({
|
|
|
1273
1298
|
return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
|
|
1274
1299
|
}
|
|
1275
1300
|
}
|
|
1276
|
-
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($
|
|
1301
|
+
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L25, fail, 'OptionalShorthand "."'), InsertDot));
|
|
1277
1302
|
function OptionalShorthand(state) {
|
|
1278
1303
|
if (state.verbose)
|
|
1279
1304
|
console.log("ENTER:", "OptionalShorthand");
|
|
@@ -1293,9 +1318,9 @@ var require_parser = __commonJS({
|
|
|
1293
1318
|
return SpacedApplication$0(state);
|
|
1294
1319
|
}
|
|
1295
1320
|
}
|
|
1296
|
-
var ApplicationStart$0 = $TS($S($E(OptionalShorthand), $TEXT($P(_)), $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1321
|
+
var ApplicationStart$0 = $TS($S($E(OptionalShorthand), $N(EOS), $TEXT($P(_)), $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1297
1322
|
var opt = $1;
|
|
1298
|
-
var spacing = $
|
|
1323
|
+
var spacing = $3;
|
|
1299
1324
|
return [opt, "(", spacing.replace(/^ /, "")];
|
|
1300
1325
|
});
|
|
1301
1326
|
function ApplicationStart(state) {
|
|
@@ -1327,9 +1352,9 @@ var require_parser = __commonJS({
|
|
|
1327
1352
|
return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
|
|
1328
1353
|
}
|
|
1329
1354
|
}
|
|
1330
|
-
var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($
|
|
1355
|
+
var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L26, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L27, fail, 'MemberExpressionRest "]"'));
|
|
1331
1356
|
var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
|
|
1332
|
-
var MemberExpressionRest$2 = $TS($S($EXPECT($
|
|
1357
|
+
var MemberExpressionRest$2 = $TS($S($EXPECT($L28, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
|
|
1333
1358
|
var id = $2;
|
|
1334
1359
|
if (id)
|
|
1335
1360
|
return [".prototype.", id];
|
|
@@ -1342,7 +1367,7 @@ var require_parser = __commonJS({
|
|
|
1342
1367
|
return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state);
|
|
1343
1368
|
}
|
|
1344
1369
|
}
|
|
1345
|
-
var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($
|
|
1370
|
+
var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L25, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
|
|
1346
1371
|
function PropertyAccess(state) {
|
|
1347
1372
|
if (state.verbose)
|
|
1348
1373
|
console.log("ENTER:", "PropertyAccess");
|
|
@@ -1352,7 +1377,7 @@ var require_parser = __commonJS({
|
|
|
1352
1377
|
return PropertyAccess$0(state);
|
|
1353
1378
|
}
|
|
1354
1379
|
}
|
|
1355
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
1380
|
+
var SuperProperty$0 = $S($EXPECT($L29, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L27, fail, 'SuperProperty "]"'));
|
|
1356
1381
|
function SuperProperty(state) {
|
|
1357
1382
|
if (state.verbose)
|
|
1358
1383
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1362,8 +1387,8 @@ var require_parser = __commonJS({
|
|
|
1362
1387
|
return SuperProperty$0(state);
|
|
1363
1388
|
}
|
|
1364
1389
|
}
|
|
1365
|
-
var MetaProperty$0 = $EXPECT($
|
|
1366
|
-
var MetaProperty$1 = $EXPECT($
|
|
1390
|
+
var MetaProperty$0 = $EXPECT($L30, fail, 'MetaProperty "new.target"');
|
|
1391
|
+
var MetaProperty$1 = $EXPECT($L31, fail, 'MetaProperty "import.meta"');
|
|
1367
1392
|
function MetaProperty(state) {
|
|
1368
1393
|
if (state.tokenize) {
|
|
1369
1394
|
return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
|
|
@@ -1372,7 +1397,7 @@ var require_parser = __commonJS({
|
|
|
1372
1397
|
}
|
|
1373
1398
|
}
|
|
1374
1399
|
var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
|
|
1375
|
-
var Parameters$1 = $T($EXPECT($
|
|
1400
|
+
var Parameters$1 = $T($EXPECT($L32, fail, 'Parameters ""'), function(value) {
|
|
1376
1401
|
return "()";
|
|
1377
1402
|
});
|
|
1378
1403
|
function Parameters(state) {
|
|
@@ -1426,7 +1451,7 @@ var require_parser = __commonJS({
|
|
|
1426
1451
|
return BindingPattern$0(state) || BindingPattern$1(state);
|
|
1427
1452
|
}
|
|
1428
1453
|
}
|
|
1429
|
-
var ObjectBindingPattern$0 = $S($EXPECT($
|
|
1454
|
+
var ObjectBindingPattern$0 = $S($EXPECT($L12, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L13, fail, 'ObjectBindingPattern "}"'));
|
|
1430
1455
|
function ObjectBindingPattern(state) {
|
|
1431
1456
|
if (state.verbose)
|
|
1432
1457
|
console.log("ENTER:", "ObjectBindingPattern");
|
|
@@ -1436,7 +1461,7 @@ var require_parser = __commonJS({
|
|
|
1436
1461
|
return ObjectBindingPattern$0(state);
|
|
1437
1462
|
}
|
|
1438
1463
|
}
|
|
1439
|
-
var ArrayBindingPattern$0 = $S($EXPECT($
|
|
1464
|
+
var ArrayBindingPattern$0 = $S($EXPECT($L26, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L27, fail, 'ArrayBindingPattern "]"'));
|
|
1440
1465
|
function ArrayBindingPattern(state) {
|
|
1441
1466
|
if (state.verbose)
|
|
1442
1467
|
console.log("ENTER:", "ArrayBindingPattern");
|
|
@@ -1446,7 +1471,7 @@ var require_parser = __commonJS({
|
|
|
1446
1471
|
return ArrayBindingPattern$0(state);
|
|
1447
1472
|
}
|
|
1448
1473
|
}
|
|
1449
|
-
var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($
|
|
1474
|
+
var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L14, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
|
|
1450
1475
|
var BindingProperty$1 = $S(__, BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
|
|
1451
1476
|
function BindingProperty(state) {
|
|
1452
1477
|
if (state.tokenize) {
|
|
@@ -1455,7 +1480,7 @@ var require_parser = __commonJS({
|
|
|
1455
1480
|
return BindingProperty$0(state) || BindingProperty$1(state);
|
|
1456
1481
|
}
|
|
1457
1482
|
}
|
|
1458
|
-
var BindingRestProperty$0 = $S($EXPECT($
|
|
1483
|
+
var BindingRestProperty$0 = $S($EXPECT($L33, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
|
|
1459
1484
|
function BindingRestProperty(state) {
|
|
1460
1485
|
if (state.verbose)
|
|
1461
1486
|
console.log("ENTER:", "BindingRestProperty");
|
|
@@ -1475,7 +1500,7 @@ var require_parser = __commonJS({
|
|
|
1475
1500
|
return BindingElement$0(state);
|
|
1476
1501
|
}
|
|
1477
1502
|
}
|
|
1478
|
-
var BindingRestElement$0 = $S($EXPECT($
|
|
1503
|
+
var BindingRestElement$0 = $S($EXPECT($L33, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
|
|
1479
1504
|
function BindingRestElement(state) {
|
|
1480
1505
|
if (state.verbose)
|
|
1481
1506
|
console.log("ENTER:", "BindingRestElement");
|
|
@@ -1496,7 +1521,7 @@ var require_parser = __commonJS({
|
|
|
1496
1521
|
}
|
|
1497
1522
|
}
|
|
1498
1523
|
var FunctionExpression$0 = ThinArrowFunction;
|
|
1499
|
-
var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($
|
|
1524
|
+
var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L34, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L10, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
|
|
1500
1525
|
function FunctionExpression(state) {
|
|
1501
1526
|
if (state.tokenize) {
|
|
1502
1527
|
return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
|
|
@@ -1525,7 +1550,7 @@ var require_parser = __commonJS({
|
|
|
1525
1550
|
return ThinArrowFunction$0(state);
|
|
1526
1551
|
}
|
|
1527
1552
|
}
|
|
1528
|
-
var Arrow$0 = $TV($EXPECT($
|
|
1553
|
+
var Arrow$0 = $TV($EXPECT($L35, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
1529
1554
|
return { $loc, token: $1 };
|
|
1530
1555
|
});
|
|
1531
1556
|
function Arrow(state) {
|
|
@@ -1537,7 +1562,7 @@ var require_parser = __commonJS({
|
|
|
1537
1562
|
return Arrow$0(state);
|
|
1538
1563
|
}
|
|
1539
1564
|
}
|
|
1540
|
-
var Block$0 = $S(__, $EXPECT($
|
|
1565
|
+
var Block$0 = $S(__, $EXPECT($L12, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L13, fail, 'Block "}"'));
|
|
1541
1566
|
var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1542
1567
|
var Block$2 = Statement;
|
|
1543
1568
|
var Block$3 = $S(__, Statement);
|
|
@@ -1557,7 +1582,7 @@ var require_parser = __commonJS({
|
|
|
1557
1582
|
return BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state);
|
|
1558
1583
|
}
|
|
1559
1584
|
}
|
|
1560
|
-
var BracedBlock$0 = $S(__, $EXPECT($
|
|
1585
|
+
var BracedBlock$0 = $S(__, $EXPECT($L12, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L13, fail, 'BracedBlock "}"'));
|
|
1561
1586
|
var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1562
1587
|
var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
|
|
1563
1588
|
function BracedBlock(state) {
|
|
@@ -1582,21 +1607,6 @@ var require_parser = __commonJS({
|
|
|
1582
1607
|
return SingleNestedExpression$0(state);
|
|
1583
1608
|
}
|
|
1584
1609
|
}
|
|
1585
|
-
var SingleNestedBlockStatement$0 = $TS($S(PushIndent, $E($S(Nested, StatementListItem)), $C($C($N($S(Nested, StatementListItem)), PopIndent), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1586
|
-
var exp = $2;
|
|
1587
|
-
if (exp)
|
|
1588
|
-
return exp;
|
|
1589
|
-
return $skip;
|
|
1590
|
-
});
|
|
1591
|
-
function SingleNestedBlockStatement(state) {
|
|
1592
|
-
if (state.verbose)
|
|
1593
|
-
console.log("ENTER:", "SingleNestedBlockStatement");
|
|
1594
|
-
if (state.tokenize) {
|
|
1595
|
-
return $TOKEN("SingleNestedBlockStatement", state, SingleNestedBlockStatement$0(state));
|
|
1596
|
-
} else {
|
|
1597
|
-
return SingleNestedBlockStatement$0(state);
|
|
1598
|
-
}
|
|
1599
|
-
}
|
|
1600
1610
|
var NestedBlockExpressions$0 = $TS($S(PushIndent, $Q(BlockExpression), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
1601
1611
|
var exps = $2;
|
|
1602
1612
|
if (!exps.length)
|
|
@@ -1633,7 +1643,7 @@ var require_parser = __commonJS({
|
|
|
1633
1643
|
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
|
|
1634
1644
|
}
|
|
1635
1645
|
}
|
|
1636
|
-
var NullLiteral$0 = $TV($EXPECT($
|
|
1646
|
+
var NullLiteral$0 = $TV($EXPECT($L36, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
1637
1647
|
return { $loc, token: $1 };
|
|
1638
1648
|
});
|
|
1639
1649
|
function NullLiteral(state) {
|
|
@@ -1645,7 +1655,7 @@ var require_parser = __commonJS({
|
|
|
1645
1655
|
return NullLiteral$0(state);
|
|
1646
1656
|
}
|
|
1647
1657
|
}
|
|
1648
|
-
var BooleanLiteral$0 = $TV($C($EXPECT($
|
|
1658
|
+
var BooleanLiteral$0 = $TV($C($EXPECT($L37, fail, 'BooleanLiteral "true"'), $EXPECT($L38, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
|
|
1649
1659
|
return { $loc, token: $1 };
|
|
1650
1660
|
});
|
|
1651
1661
|
function BooleanLiteral(state) {
|
|
@@ -1702,8 +1712,8 @@ var require_parser = __commonJS({
|
|
|
1702
1712
|
return IdentifierReference$0(state);
|
|
1703
1713
|
}
|
|
1704
1714
|
}
|
|
1705
|
-
var ArrayLiteral$0 = $S($EXPECT($
|
|
1706
|
-
var ArrayLiteral$1 = $S($EXPECT($
|
|
1715
|
+
var ArrayLiteral$0 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
|
|
1716
|
+
var ArrayLiteral$1 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
|
|
1707
1717
|
function ArrayLiteral(state) {
|
|
1708
1718
|
if (state.tokenize) {
|
|
1709
1719
|
return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
|
|
@@ -1737,8 +1747,8 @@ var require_parser = __commonJS({
|
|
|
1737
1747
|
}
|
|
1738
1748
|
}
|
|
1739
1749
|
var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
|
|
1740
|
-
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1741
|
-
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
1750
|
+
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L27, fail, 'ArrayElementDelimiter "]"')));
|
|
1751
|
+
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L27, fail, 'ArrayElementDelimiter "]"'))), function(value) {
|
|
1742
1752
|
return ",";
|
|
1743
1753
|
});
|
|
1744
1754
|
var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1771,7 +1781,7 @@ var require_parser = __commonJS({
|
|
|
1771
1781
|
return InlineElementList$0(state);
|
|
1772
1782
|
}
|
|
1773
1783
|
}
|
|
1774
|
-
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($
|
|
1784
|
+
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L33, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
|
|
1775
1785
|
function ArrayElementExpression(state) {
|
|
1776
1786
|
if (state.verbose)
|
|
1777
1787
|
console.log("ENTER:", "ArrayElementExpression");
|
|
@@ -1791,9 +1801,9 @@ var require_parser = __commonJS({
|
|
|
1791
1801
|
return Elision$0(state);
|
|
1792
1802
|
}
|
|
1793
1803
|
}
|
|
1794
|
-
var ObjectLiteral$0 = $S($EXPECT($
|
|
1795
|
-
var ObjectLiteral$1 = $S($EXPECT($
|
|
1796
|
-
var ObjectLiteral$2 = $S($EXPECT($
|
|
1804
|
+
var ObjectLiteral$0 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L13, fail, 'ObjectLiteral "}"'));
|
|
1805
|
+
var ObjectLiteral$1 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L13, fail, 'ObjectLiteral "}"'));
|
|
1806
|
+
var ObjectLiteral$2 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), __, $EXPECT($L13, fail, 'ObjectLiteral "}"'));
|
|
1797
1807
|
var ObjectLiteral$3 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1798
1808
|
function ObjectLiteral(state) {
|
|
1799
1809
|
if (state.tokenize) {
|
|
@@ -1828,8 +1838,8 @@ var require_parser = __commonJS({
|
|
|
1828
1838
|
}
|
|
1829
1839
|
}
|
|
1830
1840
|
var ObjectPropertyDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ObjectPropertyDelimiter ","'));
|
|
1831
|
-
var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1832
|
-
var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
1841
|
+
var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L13, fail, 'ObjectPropertyDelimiter "}"')));
|
|
1842
|
+
var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L13, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
|
|
1833
1843
|
return ",";
|
|
1834
1844
|
});
|
|
1835
1845
|
var ObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1852,9 +1862,9 @@ var require_parser = __commonJS({
|
|
|
1852
1862
|
return PropertyDefinitionList$0(state);
|
|
1853
1863
|
}
|
|
1854
1864
|
}
|
|
1855
|
-
var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($
|
|
1865
|
+
var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L14, fail, 'PropertyDefinition ":"'), AssignmentExpression);
|
|
1856
1866
|
var PropertyDefinition$1 = MethodDefinition;
|
|
1857
|
-
var PropertyDefinition$2 = $S($EXPECT($
|
|
1867
|
+
var PropertyDefinition$2 = $S($EXPECT($L33, fail, 'PropertyDefinition "..."'), AssignmentExpression);
|
|
1858
1868
|
var PropertyDefinition$3 = IdentifierReference;
|
|
1859
1869
|
function PropertyDefinition(state) {
|
|
1860
1870
|
if (state.tokenize) {
|
|
@@ -1866,7 +1876,7 @@ var require_parser = __commonJS({
|
|
|
1866
1876
|
var PropertyName$0 = NumericLiteral;
|
|
1867
1877
|
var PropertyName$1 = StringLiteral;
|
|
1868
1878
|
var PropertyName$2 = IdentifierName;
|
|
1869
|
-
var PropertyName$3 = $S($EXPECT($
|
|
1879
|
+
var PropertyName$3 = $S($EXPECT($L26, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L27, fail, 'PropertyName "]"'));
|
|
1870
1880
|
function PropertyName(state) {
|
|
1871
1881
|
if (state.tokenize) {
|
|
1872
1882
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -1874,8 +1884,8 @@ var require_parser = __commonJS({
|
|
|
1874
1884
|
return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
|
|
1875
1885
|
}
|
|
1876
1886
|
}
|
|
1877
|
-
var MethodDefinition$0 = $S($EXPECT($
|
|
1878
|
-
var MethodDefinition$1 = $S($EXPECT($
|
|
1887
|
+
var MethodDefinition$0 = $S($EXPECT($L39, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1888
|
+
var MethodDefinition$1 = $S($EXPECT($L40, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1879
1889
|
var MethodDefinition$2 = AsyncGeneratorMethod;
|
|
1880
1890
|
var MethodDefinition$3 = AsyncMethod;
|
|
1881
1891
|
var MethodDefinition$4 = GeneratorMethod;
|
|
@@ -1896,7 +1906,7 @@ var require_parser = __commonJS({
|
|
|
1896
1906
|
return ClassElementName$0(state) || ClassElementName$1(state);
|
|
1897
1907
|
}
|
|
1898
1908
|
}
|
|
1899
|
-
var PrivateIdentifier$0 = $S($EXPECT($
|
|
1909
|
+
var PrivateIdentifier$0 = $S($EXPECT($L20, fail, 'PrivateIdentifier "#"'), IdentifierName);
|
|
1900
1910
|
function PrivateIdentifier(state) {
|
|
1901
1911
|
if (state.verbose)
|
|
1902
1912
|
console.log("ENTER:", "PrivateIdentifier");
|
|
@@ -1906,7 +1916,7 @@ var require_parser = __commonJS({
|
|
|
1906
1916
|
return PrivateIdentifier$0(state);
|
|
1907
1917
|
}
|
|
1908
1918
|
}
|
|
1909
|
-
var GeneratorMethod$0 = $S($EXPECT($
|
|
1919
|
+
var GeneratorMethod$0 = $S($EXPECT($L10, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
|
|
1910
1920
|
function GeneratorMethod(state) {
|
|
1911
1921
|
if (state.verbose)
|
|
1912
1922
|
console.log("ENTER:", "GeneratorMethod");
|
|
@@ -1946,7 +1956,7 @@ var require_parser = __commonJS({
|
|
|
1946
1956
|
return AsyncFunctionBody$0(state);
|
|
1947
1957
|
}
|
|
1948
1958
|
}
|
|
1949
|
-
var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($
|
|
1959
|
+
var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L10, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
|
|
1950
1960
|
function AsyncGeneratorMethod(state) {
|
|
1951
1961
|
if (state.verbose)
|
|
1952
1962
|
console.log("ENTER:", "AsyncGeneratorMethod");
|
|
@@ -1978,22 +1988,22 @@ var require_parser = __commonJS({
|
|
|
1978
1988
|
return AssignmentOp$0(state);
|
|
1979
1989
|
}
|
|
1980
1990
|
}
|
|
1981
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
1982
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
1983
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
1984
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
1985
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
1986
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
1987
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
1988
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
1989
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
1990
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
1991
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
1992
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
1993
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
1994
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
1995
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
1996
|
-
var AssignmentOpSymbol$15 = $EXPECT($
|
|
1991
|
+
var AssignmentOpSymbol$0 = $EXPECT($L41, fail, 'AssignmentOpSymbol "**="');
|
|
1992
|
+
var AssignmentOpSymbol$1 = $EXPECT($L42, fail, 'AssignmentOpSymbol "*="');
|
|
1993
|
+
var AssignmentOpSymbol$2 = $EXPECT($L43, fail, 'AssignmentOpSymbol "/="');
|
|
1994
|
+
var AssignmentOpSymbol$3 = $EXPECT($L44, fail, 'AssignmentOpSymbol "%="');
|
|
1995
|
+
var AssignmentOpSymbol$4 = $EXPECT($L45, fail, 'AssignmentOpSymbol "+="');
|
|
1996
|
+
var AssignmentOpSymbol$5 = $EXPECT($L46, fail, 'AssignmentOpSymbol "-="');
|
|
1997
|
+
var AssignmentOpSymbol$6 = $EXPECT($L47, fail, 'AssignmentOpSymbol "<<="');
|
|
1998
|
+
var AssignmentOpSymbol$7 = $EXPECT($L48, fail, 'AssignmentOpSymbol ">>>="');
|
|
1999
|
+
var AssignmentOpSymbol$8 = $EXPECT($L49, fail, 'AssignmentOpSymbol ">>="');
|
|
2000
|
+
var AssignmentOpSymbol$9 = $EXPECT($L50, fail, 'AssignmentOpSymbol "&&="');
|
|
2001
|
+
var AssignmentOpSymbol$10 = $EXPECT($L51, fail, 'AssignmentOpSymbol "&="');
|
|
2002
|
+
var AssignmentOpSymbol$11 = $EXPECT($L52, fail, 'AssignmentOpSymbol "^="');
|
|
2003
|
+
var AssignmentOpSymbol$12 = $EXPECT($L53, fail, 'AssignmentOpSymbol "||="');
|
|
2004
|
+
var AssignmentOpSymbol$13 = $EXPECT($L54, fail, 'AssignmentOpSymbol "|="');
|
|
2005
|
+
var AssignmentOpSymbol$14 = $EXPECT($L55, fail, 'AssignmentOpSymbol "??="');
|
|
2006
|
+
var AssignmentOpSymbol$15 = $EXPECT($L56, fail, 'AssignmentOpSymbol "="');
|
|
1997
2007
|
function AssignmentOpSymbol(state) {
|
|
1998
2008
|
if (state.tokenize) {
|
|
1999
2009
|
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));
|
|
@@ -2013,48 +2023,48 @@ var require_parser = __commonJS({
|
|
|
2013
2023
|
return BinaryOp$0(state);
|
|
2014
2024
|
}
|
|
2015
2025
|
}
|
|
2016
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
2017
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
2018
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
2019
|
-
var BinaryOpSymbol$3 = $EXPECT($
|
|
2020
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
2021
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
2022
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
2023
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
2024
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
2025
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
2026
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
2027
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
2028
|
-
var BinaryOpSymbol$12 = $EXPECT($
|
|
2029
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
2030
|
-
var BinaryOpSymbol$14 = $TV($EXPECT($
|
|
2026
|
+
var BinaryOpSymbol$0 = $EXPECT($L57, fail, 'BinaryOpSymbol "**"');
|
|
2027
|
+
var BinaryOpSymbol$1 = $EXPECT($L10, fail, 'BinaryOpSymbol "*"');
|
|
2028
|
+
var BinaryOpSymbol$2 = $EXPECT($L58, fail, 'BinaryOpSymbol "/"');
|
|
2029
|
+
var BinaryOpSymbol$3 = $EXPECT($L59, fail, 'BinaryOpSymbol "%"');
|
|
2030
|
+
var BinaryOpSymbol$4 = $EXPECT($L60, fail, 'BinaryOpSymbol "+"');
|
|
2031
|
+
var BinaryOpSymbol$5 = $EXPECT($L61, fail, 'BinaryOpSymbol "-"');
|
|
2032
|
+
var BinaryOpSymbol$6 = $EXPECT($L62, fail, 'BinaryOpSymbol "<="');
|
|
2033
|
+
var BinaryOpSymbol$7 = $EXPECT($L63, fail, 'BinaryOpSymbol ">="');
|
|
2034
|
+
var BinaryOpSymbol$8 = $EXPECT($L64, fail, 'BinaryOpSymbol "<<"');
|
|
2035
|
+
var BinaryOpSymbol$9 = $EXPECT($L16, fail, 'BinaryOpSymbol "<"');
|
|
2036
|
+
var BinaryOpSymbol$10 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>>"');
|
|
2037
|
+
var BinaryOpSymbol$11 = $EXPECT($L66, fail, 'BinaryOpSymbol ">>"');
|
|
2038
|
+
var BinaryOpSymbol$12 = $EXPECT($L67, fail, 'BinaryOpSymbol ">"');
|
|
2039
|
+
var BinaryOpSymbol$13 = $EXPECT($L68, fail, 'BinaryOpSymbol "!=="');
|
|
2040
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L69, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
2031
2041
|
if (global.coffeeCompat)
|
|
2032
2042
|
return "!==";
|
|
2033
2043
|
return $1;
|
|
2034
2044
|
});
|
|
2035
|
-
var BinaryOpSymbol$15 = $T($S($EXPECT($
|
|
2045
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L70, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
2036
2046
|
return "===";
|
|
2037
2047
|
});
|
|
2038
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
2039
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
2048
|
+
var BinaryOpSymbol$16 = $EXPECT($L71, fail, 'BinaryOpSymbol "==="');
|
|
2049
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L72, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
2040
2050
|
if (global.coffeeCompat)
|
|
2041
2051
|
return "===";
|
|
2042
2052
|
return $1;
|
|
2043
2053
|
});
|
|
2044
|
-
var BinaryOpSymbol$18 = $T($S($EXPECT($
|
|
2054
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L73, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
2045
2055
|
return "&&";
|
|
2046
2056
|
});
|
|
2047
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
2048
|
-
var BinaryOpSymbol$20 = $T($S($EXPECT($
|
|
2057
|
+
var BinaryOpSymbol$19 = $EXPECT($L74, fail, 'BinaryOpSymbol "&&"');
|
|
2058
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L75, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
2049
2059
|
return "||";
|
|
2050
2060
|
});
|
|
2051
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
2052
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
2053
|
-
var BinaryOpSymbol$23 = $S($EXPECT($
|
|
2054
|
-
var BinaryOpSymbol$24 = $S($EXPECT($
|
|
2055
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
2056
|
-
var BinaryOpSymbol$26 = $EXPECT($
|
|
2057
|
-
var BinaryOpSymbol$27 = $EXPECT($
|
|
2061
|
+
var BinaryOpSymbol$21 = $EXPECT($L76, fail, 'BinaryOpSymbol "||"');
|
|
2062
|
+
var BinaryOpSymbol$22 = $EXPECT($L77, fail, 'BinaryOpSymbol "??"');
|
|
2063
|
+
var BinaryOpSymbol$23 = $S($EXPECT($L78, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue);
|
|
2064
|
+
var BinaryOpSymbol$24 = $S($EXPECT($L79, fail, 'BinaryOpSymbol "in"'), NonIdContinue);
|
|
2065
|
+
var BinaryOpSymbol$25 = $EXPECT($L80, fail, 'BinaryOpSymbol "&"');
|
|
2066
|
+
var BinaryOpSymbol$26 = $EXPECT($L81, fail, 'BinaryOpSymbol "^"');
|
|
2067
|
+
var BinaryOpSymbol$27 = $EXPECT($L82, fail, 'BinaryOpSymbol "|"');
|
|
2058
2068
|
function BinaryOpSymbol(state) {
|
|
2059
2069
|
if (state.tokenize) {
|
|
2060
2070
|
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));
|
|
@@ -2063,7 +2073,7 @@ var require_parser = __commonJS({
|
|
|
2063
2073
|
}
|
|
2064
2074
|
}
|
|
2065
2075
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
2066
|
-
var UnaryOp$1 = $S($C($EXPECT($
|
|
2076
|
+
var UnaryOp$1 = $S($C($EXPECT($L83, fail, 'UnaryOp "delete"'), $EXPECT($L84, fail, 'UnaryOp "void"'), $EXPECT($L85, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
|
|
2067
2077
|
function UnaryOp(state) {
|
|
2068
2078
|
if (state.tokenize) {
|
|
2069
2079
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -2097,7 +2107,7 @@ var require_parser = __commonJS({
|
|
|
2097
2107
|
return StatementListItem$0(state);
|
|
2098
2108
|
}
|
|
2099
2109
|
}
|
|
2100
|
-
var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($
|
|
2110
|
+
var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($L86, fail, 'PostfixConditional "if"'), $EXPECT($L87, fail, 'PostfixConditional "unless"')), NonIdContinue, Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2101
2111
|
var ws = $1;
|
|
2102
2112
|
var cond = $2;
|
|
2103
2113
|
var exp = $4;
|
|
@@ -2130,7 +2140,7 @@ var require_parser = __commonJS({
|
|
|
2130
2140
|
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);
|
|
2131
2141
|
}
|
|
2132
2142
|
}
|
|
2133
|
-
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($
|
|
2143
|
+
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L88, fail, 'EmptyStatement ";"')));
|
|
2134
2144
|
function EmptyStatement(state) {
|
|
2135
2145
|
if (state.verbose)
|
|
2136
2146
|
console.log("ENTER:", "EmptyStatement");
|
|
@@ -2140,7 +2150,7 @@ var require_parser = __commonJS({
|
|
|
2140
2150
|
return EmptyStatement$0(state);
|
|
2141
2151
|
}
|
|
2142
2152
|
}
|
|
2143
|
-
var BlockStatement$0 = $S(__, $EXPECT($
|
|
2153
|
+
var BlockStatement$0 = $S(__, $EXPECT($L12, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L13, fail, 'BlockStatement "}"'));
|
|
2144
2154
|
function BlockStatement(state) {
|
|
2145
2155
|
if (state.verbose)
|
|
2146
2156
|
console.log("ENTER:", "BlockStatement");
|
|
@@ -2150,8 +2160,8 @@ var require_parser = __commonJS({
|
|
|
2150
2160
|
return BlockStatement$0(state);
|
|
2151
2161
|
}
|
|
2152
2162
|
}
|
|
2153
|
-
var IfStatement$0 = $S($EXPECT($
|
|
2154
|
-
var IfStatement$1 = $TS($S($EXPECT($
|
|
2163
|
+
var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L89, fail, 'IfStatement "else"'), Block)));
|
|
2164
|
+
var IfStatement$1 = $TS($S($EXPECT($L87, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
|
|
2155
2165
|
var condition = $2;
|
|
2156
2166
|
var block = $3;
|
|
2157
2167
|
return ["if", condition.map((c) => {
|
|
@@ -2181,7 +2191,7 @@ var require_parser = __commonJS({
|
|
|
2181
2191
|
return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
|
|
2182
2192
|
}
|
|
2183
2193
|
}
|
|
2184
|
-
var LoopStatement$0 = $TS($S($EXPECT($
|
|
2194
|
+
var LoopStatement$0 = $TS($S($EXPECT($L90, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
|
|
2185
2195
|
var b = $3;
|
|
2186
2196
|
return ["while(true)", b];
|
|
2187
2197
|
});
|
|
@@ -2194,7 +2204,7 @@ var require_parser = __commonJS({
|
|
|
2194
2204
|
return LoopStatement$0(state);
|
|
2195
2205
|
}
|
|
2196
2206
|
}
|
|
2197
|
-
var DoWhileStatement$0 = $S($EXPECT($
|
|
2207
|
+
var DoWhileStatement$0 = $S($EXPECT($L91, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
|
|
2198
2208
|
function DoWhileStatement(state) {
|
|
2199
2209
|
if (state.verbose)
|
|
2200
2210
|
console.log("ENTER:", "DoWhileStatement");
|
|
@@ -2214,7 +2224,7 @@ var require_parser = __commonJS({
|
|
|
2214
2224
|
return WhileStatement$0(state);
|
|
2215
2225
|
}
|
|
2216
2226
|
}
|
|
2217
|
-
var WhileClause$0 = $TS($S($C($EXPECT($
|
|
2227
|
+
var WhileClause$0 = $TS($S($C($EXPECT($L92, fail, 'WhileClause "while"'), $EXPECT($L93, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
|
|
2218
2228
|
var kind = $1;
|
|
2219
2229
|
var cond = $3;
|
|
2220
2230
|
if (kind === "until") {
|
|
@@ -2233,7 +2243,7 @@ var require_parser = __commonJS({
|
|
|
2233
2243
|
return WhileClause$0(state);
|
|
2234
2244
|
}
|
|
2235
2245
|
}
|
|
2236
|
-
var ForStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($
|
|
2246
|
+
var ForStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L88, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L88, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
|
|
2237
2247
|
function ForStatement(state) {
|
|
2238
2248
|
if (state.verbose)
|
|
2239
2249
|
console.log("ENTER:", "ForStatement");
|
|
@@ -2243,10 +2253,10 @@ var require_parser = __commonJS({
|
|
|
2243
2253
|
return ForStatement$0(state);
|
|
2244
2254
|
}
|
|
2245
2255
|
}
|
|
2246
|
-
var ForInOfStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($
|
|
2247
|
-
var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($
|
|
2248
|
-
var ForInOfStatement$2 = $S(For, $E($S(__, $EXPECT($
|
|
2249
|
-
var ForInOfStatement$3 = $S(For, $E($S(__, $EXPECT($
|
|
2256
|
+
var ForInOfStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
|
|
2257
|
+
var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
|
|
2258
|
+
var ForInOfStatement$2 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
|
|
2259
|
+
var ForInOfStatement$3 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
|
|
2250
2260
|
function ForInOfStatement(state) {
|
|
2251
2261
|
if (state.tokenize) {
|
|
2252
2262
|
return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
|
|
@@ -2307,7 +2317,7 @@ var require_parser = __commonJS({
|
|
|
2307
2317
|
return SwitchStatement$0(state);
|
|
2308
2318
|
}
|
|
2309
2319
|
}
|
|
2310
|
-
var CaseBlock$0 = $S(__, $EXPECT($
|
|
2320
|
+
var CaseBlock$0 = $S(__, $EXPECT($L12, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L13, fail, 'CaseBlock "}"'));
|
|
2311
2321
|
var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
|
|
2312
2322
|
function CaseBlock(state) {
|
|
2313
2323
|
if (state.tokenize) {
|
|
@@ -2363,8 +2373,8 @@ var require_parser = __commonJS({
|
|
|
2363
2373
|
return When$0(state);
|
|
2364
2374
|
}
|
|
2365
2375
|
}
|
|
2366
|
-
var ImpliedColon$0 = $S(__, $EXPECT($
|
|
2367
|
-
var ImpliedColon$1 = $T($EXPECT($
|
|
2376
|
+
var ImpliedColon$0 = $S(__, $EXPECT($L14, fail, 'ImpliedColon ":"'));
|
|
2377
|
+
var ImpliedColon$1 = $T($EXPECT($L32, fail, 'ImpliedColon ""'), function(value) {
|
|
2368
2378
|
return ":";
|
|
2369
2379
|
});
|
|
2370
2380
|
function ImpliedColon(state) {
|
|
@@ -2486,14 +2496,27 @@ var require_parser = __commonJS({
|
|
|
2486
2496
|
});
|
|
2487
2497
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
2488
2498
|
var ImportDeclaration$2 = $S(Import, __, ModuleSpecifier);
|
|
2499
|
+
var ImportDeclaration$3 = $S(ImpliedImport, ImportClause, __, FromClause);
|
|
2489
2500
|
function ImportDeclaration(state) {
|
|
2490
2501
|
if (state.tokenize) {
|
|
2491
|
-
return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
|
|
2502
|
+
return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state));
|
|
2503
|
+
} else {
|
|
2504
|
+
return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state);
|
|
2505
|
+
}
|
|
2506
|
+
}
|
|
2507
|
+
var ImpliedImport$0 = $T($EXPECT($L32, fail, 'ImpliedImport ""'), function(value) {
|
|
2508
|
+
return "import ";
|
|
2509
|
+
});
|
|
2510
|
+
function ImpliedImport(state) {
|
|
2511
|
+
if (state.verbose)
|
|
2512
|
+
console.log("ENTER:", "ImpliedImport");
|
|
2513
|
+
if (state.tokenize) {
|
|
2514
|
+
return $TOKEN("ImpliedImport", state, ImpliedImport$0(state));
|
|
2492
2515
|
} else {
|
|
2493
|
-
return
|
|
2516
|
+
return ImpliedImport$0(state);
|
|
2494
2517
|
}
|
|
2495
2518
|
}
|
|
2496
|
-
var Import$0 = $TS($S($EXPECT($
|
|
2519
|
+
var Import$0 = $TS($S($EXPECT($L24, fail, 'Import "import"'), $Y($EXPECT($R3, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
2497
2520
|
return { $loc, token: $1 };
|
|
2498
2521
|
});
|
|
2499
2522
|
function Import(state) {
|
|
@@ -2515,7 +2538,7 @@ var require_parser = __commonJS({
|
|
|
2515
2538
|
return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
|
|
2516
2539
|
}
|
|
2517
2540
|
}
|
|
2518
|
-
var NameSpaceImport$0 = $S($EXPECT($
|
|
2541
|
+
var NameSpaceImport$0 = $S($EXPECT($L10, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), NonIdContinue, __, ImportedBinding);
|
|
2519
2542
|
function NameSpaceImport(state) {
|
|
2520
2543
|
if (state.verbose)
|
|
2521
2544
|
console.log("ENTER:", "NameSpaceImport");
|
|
@@ -2525,7 +2548,7 @@ var require_parser = __commonJS({
|
|
|
2525
2548
|
return NameSpaceImport$0(state);
|
|
2526
2549
|
}
|
|
2527
2550
|
}
|
|
2528
|
-
var NamedImports$0 = $S($EXPECT($
|
|
2551
|
+
var NamedImports$0 = $S($EXPECT($L12, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L13, fail, 'NamedImports "}"'));
|
|
2529
2552
|
function NamedImports(state) {
|
|
2530
2553
|
if (state.verbose)
|
|
2531
2554
|
console.log("ENTER:", "NamedImports");
|
|
@@ -2576,13 +2599,25 @@ var require_parser = __commonJS({
|
|
|
2576
2599
|
}
|
|
2577
2600
|
}
|
|
2578
2601
|
var ModuleSpecifier$0 = StringLiteral;
|
|
2602
|
+
var ModuleSpecifier$1 = UnquotedSpecifier;
|
|
2579
2603
|
function ModuleSpecifier(state) {
|
|
2604
|
+
if (state.tokenize) {
|
|
2605
|
+
return $TOKEN("ModuleSpecifier", state, ModuleSpecifier$0(state) || ModuleSpecifier$1(state));
|
|
2606
|
+
} else {
|
|
2607
|
+
return ModuleSpecifier$0(state) || ModuleSpecifier$1(state);
|
|
2608
|
+
}
|
|
2609
|
+
}
|
|
2610
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R4, fail, 'UnquotedSpecifier /[^"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
2611
|
+
var spec = $0;
|
|
2612
|
+
return { $loc, token: `"${spec}"` };
|
|
2613
|
+
});
|
|
2614
|
+
function UnquotedSpecifier(state) {
|
|
2580
2615
|
if (state.verbose)
|
|
2581
|
-
console.log("ENTER:", "
|
|
2616
|
+
console.log("ENTER:", "UnquotedSpecifier");
|
|
2582
2617
|
if (state.tokenize) {
|
|
2583
|
-
return $TOKEN("
|
|
2618
|
+
return $TOKEN("UnquotedSpecifier", state, UnquotedSpecifier$0(state));
|
|
2584
2619
|
} else {
|
|
2585
|
-
return
|
|
2620
|
+
return UnquotedSpecifier$0(state);
|
|
2586
2621
|
}
|
|
2587
2622
|
}
|
|
2588
2623
|
var ImportedBinding$0 = BindingIdentifier;
|
|
@@ -2625,7 +2660,7 @@ var require_parser = __commonJS({
|
|
|
2625
2660
|
return Export$0(state);
|
|
2626
2661
|
}
|
|
2627
2662
|
}
|
|
2628
|
-
var ExportFromClause$0 = $S($EXPECT($
|
|
2663
|
+
var ExportFromClause$0 = $S($EXPECT($L10, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), NonIdContinue, __, ModuleExportName)));
|
|
2629
2664
|
var ExportFromClause$1 = NamedExports;
|
|
2630
2665
|
function ExportFromClause(state) {
|
|
2631
2666
|
if (state.tokenize) {
|
|
@@ -2634,7 +2669,7 @@ var require_parser = __commonJS({
|
|
|
2634
2669
|
return ExportFromClause$0(state) || ExportFromClause$1(state);
|
|
2635
2670
|
}
|
|
2636
2671
|
}
|
|
2637
|
-
var NamedExports$0 = $S($EXPECT($
|
|
2672
|
+
var NamedExports$0 = $S($EXPECT($L12, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L13, fail, 'NamedExports "}"'));
|
|
2638
2673
|
function NamedExports(state) {
|
|
2639
2674
|
if (state.verbose)
|
|
2640
2675
|
console.log("ENTER:", "NamedExports");
|
|
@@ -2720,7 +2755,7 @@ var require_parser = __commonJS({
|
|
|
2720
2755
|
return LexicalBinding$0(state) || LexicalBinding$1(state);
|
|
2721
2756
|
}
|
|
2722
2757
|
}
|
|
2723
|
-
var Initializer$0 = $S(__, $EXPECT($
|
|
2758
|
+
var Initializer$0 = $S(__, $EXPECT($L56, fail, 'Initializer "="'), AssignmentExpression);
|
|
2724
2759
|
function Initializer(state) {
|
|
2725
2760
|
if (state.verbose)
|
|
2726
2761
|
console.log("ENTER:", "Initializer");
|
|
@@ -2730,7 +2765,7 @@ var require_parser = __commonJS({
|
|
|
2730
2765
|
return Initializer$0(state);
|
|
2731
2766
|
}
|
|
2732
2767
|
}
|
|
2733
|
-
var VariableStatement$0 = $S($EXPECT($
|
|
2768
|
+
var VariableStatement$0 = $S($EXPECT($L94, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
|
|
2734
2769
|
function VariableStatement(state) {
|
|
2735
2770
|
if (state.verbose)
|
|
2736
2771
|
console.log("ENTER:", "VariableStatement");
|
|
@@ -2783,7 +2818,7 @@ var require_parser = __commonJS({
|
|
|
2783
2818
|
return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
|
|
2784
2819
|
}
|
|
2785
2820
|
}
|
|
2786
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
2821
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
2787
2822
|
function DecimalBigIntegerLiteral(state) {
|
|
2788
2823
|
if (state.verbose)
|
|
2789
2824
|
console.log("ENTER:", "DecimalBigIntegerLiteral");
|
|
@@ -2793,7 +2828,7 @@ var require_parser = __commonJS({
|
|
|
2793
2828
|
return DecimalBigIntegerLiteral$0(state);
|
|
2794
2829
|
}
|
|
2795
2830
|
}
|
|
2796
|
-
var DecimalLiteral$0 = $R$0($EXPECT($
|
|
2831
|
+
var DecimalLiteral$0 = $R$0($EXPECT($R6, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
|
|
2797
2832
|
function DecimalLiteral(state) {
|
|
2798
2833
|
if (state.verbose)
|
|
2799
2834
|
console.log("ENTER:", "DecimalLiteral");
|
|
@@ -2803,7 +2838,7 @@ var require_parser = __commonJS({
|
|
|
2803
2838
|
return DecimalLiteral$0(state);
|
|
2804
2839
|
}
|
|
2805
2840
|
}
|
|
2806
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
2841
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
|
|
2807
2842
|
function BinaryIntegerLiteral(state) {
|
|
2808
2843
|
if (state.verbose)
|
|
2809
2844
|
console.log("ENTER:", "BinaryIntegerLiteral");
|
|
@@ -2813,7 +2848,7 @@ var require_parser = __commonJS({
|
|
|
2813
2848
|
return BinaryIntegerLiteral$0(state);
|
|
2814
2849
|
}
|
|
2815
2850
|
}
|
|
2816
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
2851
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R8, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*/"));
|
|
2817
2852
|
function OctalIntegerLiteral(state) {
|
|
2818
2853
|
if (state.verbose)
|
|
2819
2854
|
console.log("ENTER:", "OctalIntegerLiteral");
|
|
@@ -2823,7 +2858,7 @@ var require_parser = __commonJS({
|
|
|
2823
2858
|
return OctalIntegerLiteral$0(state);
|
|
2824
2859
|
}
|
|
2825
2860
|
}
|
|
2826
|
-
var HexLiteral$0 = $R$0($EXPECT($
|
|
2861
|
+
var HexLiteral$0 = $R$0($EXPECT($R9, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*/"));
|
|
2827
2862
|
function HexLiteral(state) {
|
|
2828
2863
|
if (state.verbose)
|
|
2829
2864
|
console.log("ENTER:", "HexLiteral");
|
|
@@ -2854,7 +2889,7 @@ var require_parser = __commonJS({
|
|
|
2854
2889
|
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
|
|
2855
2890
|
}
|
|
2856
2891
|
}
|
|
2857
|
-
var DoubleStringCharacter$0 = $R$0($EXPECT($
|
|
2892
|
+
var DoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
|
|
2858
2893
|
function DoubleStringCharacter(state) {
|
|
2859
2894
|
if (state.verbose)
|
|
2860
2895
|
console.log("ENTER:", "DoubleStringCharacter");
|
|
@@ -2864,7 +2899,7 @@ var require_parser = __commonJS({
|
|
|
2864
2899
|
return DoubleStringCharacter$0(state);
|
|
2865
2900
|
}
|
|
2866
2901
|
}
|
|
2867
|
-
var SingleStringCharacter$0 = $R$0($EXPECT($
|
|
2902
|
+
var SingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
|
|
2868
2903
|
function SingleStringCharacter(state) {
|
|
2869
2904
|
if (state.verbose)
|
|
2870
2905
|
console.log("ENTER:", "SingleStringCharacter");
|
|
@@ -2874,7 +2909,7 @@ var require_parser = __commonJS({
|
|
|
2874
2909
|
return SingleStringCharacter$0(state);
|
|
2875
2910
|
}
|
|
2876
2911
|
}
|
|
2877
|
-
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($
|
|
2912
|
+
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R12, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
|
|
2878
2913
|
function TripleDoubleStringCharacter(state) {
|
|
2879
2914
|
if (state.verbose)
|
|
2880
2915
|
console.log("ENTER:", "TripleDoubleStringCharacter");
|
|
@@ -2884,7 +2919,7 @@ var require_parser = __commonJS({
|
|
|
2884
2919
|
return TripleDoubleStringCharacter$0(state);
|
|
2885
2920
|
}
|
|
2886
2921
|
}
|
|
2887
|
-
var TripleSingleStringCharacter$0 = $R$0($EXPECT($
|
|
2922
|
+
var TripleSingleStringCharacter$0 = $R$0($EXPECT($R13, fail, "TripleSingleStringCharacter /(?:'(?!'')|\\\\.|[^'])+/"));
|
|
2888
2923
|
function TripleSingleStringCharacter(state) {
|
|
2889
2924
|
if (state.verbose)
|
|
2890
2925
|
console.log("ENTER:", "TripleSingleStringCharacter");
|
|
@@ -2894,7 +2929,7 @@ var require_parser = __commonJS({
|
|
|
2894
2929
|
return TripleSingleStringCharacter$0(state);
|
|
2895
2930
|
}
|
|
2896
2931
|
}
|
|
2897
|
-
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($
|
|
2932
|
+
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
2898
2933
|
return { $loc, token: $1 };
|
|
2899
2934
|
});
|
|
2900
2935
|
function RegularExpressionLiteral(state) {
|
|
@@ -2906,7 +2941,7 @@ var require_parser = __commonJS({
|
|
|
2906
2941
|
return RegularExpressionLiteral$0(state);
|
|
2907
2942
|
}
|
|
2908
2943
|
}
|
|
2909
|
-
var RegularExpressionBody$0 = $S($R$0($EXPECT($
|
|
2944
|
+
var RegularExpressionBody$0 = $S($R$0($EXPECT($R14, fail, "RegularExpressionBody /[^*\\/\\r\\n]/")), $Q(RegExpCharacter));
|
|
2910
2945
|
function RegularExpressionBody(state) {
|
|
2911
2946
|
if (state.verbose)
|
|
2912
2947
|
console.log("ENTER:", "RegularExpressionBody");
|
|
@@ -2916,7 +2951,7 @@ var require_parser = __commonJS({
|
|
|
2916
2951
|
return RegularExpressionBody$0(state);
|
|
2917
2952
|
}
|
|
2918
2953
|
}
|
|
2919
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
2954
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R15, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
2920
2955
|
function RegExpCharacter(state) {
|
|
2921
2956
|
if (state.verbose)
|
|
2922
2957
|
console.log("ENTER:", "RegExpCharacter");
|
|
@@ -2926,7 +2961,7 @@ var require_parser = __commonJS({
|
|
|
2926
2961
|
return RegExpCharacter$0(state);
|
|
2927
2962
|
}
|
|
2928
2963
|
}
|
|
2929
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
2964
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R16, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
2930
2965
|
function RegularExpressionFlags(state) {
|
|
2931
2966
|
if (state.verbose)
|
|
2932
2967
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -2946,7 +2981,7 @@ var require_parser = __commonJS({
|
|
|
2946
2981
|
return TemplateLiteral$0(state);
|
|
2947
2982
|
}
|
|
2948
2983
|
}
|
|
2949
|
-
var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($
|
|
2984
|
+
var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L13, fail, 'TemplateSubstitution "}"'));
|
|
2950
2985
|
function TemplateSubstitution(state) {
|
|
2951
2986
|
if (state.verbose)
|
|
2952
2987
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -2956,7 +2991,7 @@ var require_parser = __commonJS({
|
|
|
2956
2991
|
return TemplateSubstitution$0(state);
|
|
2957
2992
|
}
|
|
2958
2993
|
}
|
|
2959
|
-
var TemplateCharacters$0 = $R$0($EXPECT($
|
|
2994
|
+
var TemplateCharacters$0 = $R$0($EXPECT($R17, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
|
|
2960
2995
|
function TemplateCharacters(state) {
|
|
2961
2996
|
if (state.verbose)
|
|
2962
2997
|
console.log("ENTER:", "TemplateCharacters");
|
|
@@ -2966,7 +3001,7 @@ var require_parser = __commonJS({
|
|
|
2966
3001
|
return TemplateCharacters$0(state);
|
|
2967
3002
|
}
|
|
2968
3003
|
}
|
|
2969
|
-
var ReservedWord$0 = $R$0($EXPECT($
|
|
3004
|
+
var ReservedWord$0 = $R$0($EXPECT($R18, 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|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
2970
3005
|
function ReservedWord(state) {
|
|
2971
3006
|
if (state.verbose)
|
|
2972
3007
|
console.log("ENTER:", "ReservedWord");
|
|
@@ -2985,7 +3020,7 @@ var require_parser = __commonJS({
|
|
|
2985
3020
|
return Comment$0(state) || Comment$1(state);
|
|
2986
3021
|
}
|
|
2987
3022
|
}
|
|
2988
|
-
var SingleLineComment$0 = $R$0($EXPECT($
|
|
3023
|
+
var SingleLineComment$0 = $R$0($EXPECT($R19, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"));
|
|
2989
3024
|
var SingleLineComment$1 = CoffeeSingleLineComment;
|
|
2990
3025
|
function SingleLineComment(state) {
|
|
2991
3026
|
if (state.tokenize) {
|
|
@@ -3003,7 +3038,7 @@ var require_parser = __commonJS({
|
|
|
3003
3038
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
3004
3039
|
}
|
|
3005
3040
|
}
|
|
3006
|
-
var JSMultiLineComment$0 = $S($EXPECT($L121, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'JSMultiLineComment "*/"')), $EXPECT($
|
|
3041
|
+
var JSMultiLineComment$0 = $S($EXPECT($L121, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'JSMultiLineComment "*/"')), $EXPECT($R20, fail, "JSMultiLineComment /./")))), $EXPECT($L122, fail, 'JSMultiLineComment "*/"'));
|
|
3007
3042
|
function JSMultiLineComment(state) {
|
|
3008
3043
|
if (state.verbose)
|
|
3009
3044
|
console.log("ENTER:", "JSMultiLineComment");
|
|
@@ -3013,7 +3048,7 @@ var require_parser = __commonJS({
|
|
|
3013
3048
|
return JSMultiLineComment$0(state);
|
|
3014
3049
|
}
|
|
3015
3050
|
}
|
|
3016
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
3051
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R21, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3017
3052
|
if (!global.coffeeCompat)
|
|
3018
3053
|
return $skip;
|
|
3019
3054
|
return ["//", $1];
|
|
@@ -3027,7 +3062,7 @@ var require_parser = __commonJS({
|
|
|
3027
3062
|
return CoffeeSingleLineComment$0(state);
|
|
3028
3063
|
}
|
|
3029
3064
|
}
|
|
3030
|
-
var CoffeeMultiLineComment$0 = $T($S($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($
|
|
3065
|
+
var CoffeeMultiLineComment$0 = $T($S($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R20, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), function(value) {
|
|
3031
3066
|
return ["/*", value[1], "*/"];
|
|
3032
3067
|
});
|
|
3033
3068
|
function CoffeeMultiLineComment(state) {
|
|
@@ -3039,7 +3074,7 @@ var require_parser = __commonJS({
|
|
|
3039
3074
|
return CoffeeMultiLineComment$0(state);
|
|
3040
3075
|
}
|
|
3041
3076
|
}
|
|
3042
|
-
var InlineComment$0 = $S($EXPECT($L121, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'InlineComment "*/"')), $EXPECT($
|
|
3077
|
+
var InlineComment$0 = $S($EXPECT($L121, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'InlineComment "*/"')), $EXPECT($R22, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L122, fail, 'InlineComment "*/"'));
|
|
3043
3078
|
function InlineComment(state) {
|
|
3044
3079
|
if (state.verbose)
|
|
3045
3080
|
console.log("ENTER:", "InlineComment");
|
|
@@ -3059,7 +3094,7 @@ var require_parser = __commonJS({
|
|
|
3059
3094
|
return RestOfLine$0(state);
|
|
3060
3095
|
}
|
|
3061
3096
|
}
|
|
3062
|
-
var TrailingComment$0 = $R$0($EXPECT($
|
|
3097
|
+
var TrailingComment$0 = $R$0($EXPECT($R23, fail, "TrailingComment /[\\t ]+/"));
|
|
3063
3098
|
var TrailingComment$1 = InlineComment;
|
|
3064
3099
|
var TrailingComment$2 = SingleLineComment;
|
|
3065
3100
|
function TrailingComment(state) {
|
|
@@ -3069,7 +3104,7 @@ var require_parser = __commonJS({
|
|
|
3069
3104
|
return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
|
|
3070
3105
|
}
|
|
3071
3106
|
}
|
|
3072
|
-
var _$0 = $P($C($R$0($EXPECT($
|
|
3107
|
+
var _$0 = $P($C($R$0($EXPECT($R23, fail, "_ /[\\t ]+/")), Comment));
|
|
3073
3108
|
function _(state) {
|
|
3074
3109
|
if (state.verbose)
|
|
3075
3110
|
console.log("ENTER:", "_");
|
|
@@ -3079,7 +3114,7 @@ var require_parser = __commonJS({
|
|
|
3079
3114
|
return _$0(state);
|
|
3080
3115
|
}
|
|
3081
3116
|
}
|
|
3082
|
-
var __$0 = $Q($C($R$0($EXPECT($
|
|
3117
|
+
var __$0 = $Q($C($R$0($EXPECT($R24, fail, "__ /[\\s]+/")), Comment));
|
|
3083
3118
|
function __(state) {
|
|
3084
3119
|
if (state.verbose)
|
|
3085
3120
|
console.log("ENTER:", "__");
|
|
@@ -3089,7 +3124,7 @@ var require_parser = __commonJS({
|
|
|
3089
3124
|
return __$0(state);
|
|
3090
3125
|
}
|
|
3091
3126
|
}
|
|
3092
|
-
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($
|
|
3127
|
+
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L88, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
|
|
3093
3128
|
var StatementDelimiter$1 = $T($Y(EOS), function(value) {
|
|
3094
3129
|
return [";", value];
|
|
3095
3130
|
});
|
|
@@ -3100,7 +3135,7 @@ var require_parser = __commonJS({
|
|
|
3100
3135
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
3101
3136
|
}
|
|
3102
3137
|
}
|
|
3103
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3138
|
+
var NonIdContinue$0 = $R$0($EXPECT($R25, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
3104
3139
|
function NonIdContinue(state) {
|
|
3105
3140
|
if (state.verbose)
|
|
3106
3141
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -3124,7 +3159,7 @@ var require_parser = __commonJS({
|
|
|
3124
3159
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
3125
3160
|
}
|
|
3126
3161
|
}
|
|
3127
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($
|
|
3162
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L16, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L124, fail, 'JSXSelfClosingElement "/>"'));
|
|
3128
3163
|
function JSXSelfClosingElement(state) {
|
|
3129
3164
|
if (state.verbose)
|
|
3130
3165
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -3134,7 +3169,7 @@ var require_parser = __commonJS({
|
|
|
3134
3169
|
return JSXSelfClosingElement$0(state);
|
|
3135
3170
|
}
|
|
3136
3171
|
}
|
|
3137
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
3172
|
+
var JSXOpeningElement$0 = $S($EXPECT($L16, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L67, fail, 'JSXOpeningElement ">"'));
|
|
3138
3173
|
function JSXOpeningElement(state) {
|
|
3139
3174
|
if (state.verbose)
|
|
3140
3175
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -3144,7 +3179,7 @@ var require_parser = __commonJS({
|
|
|
3144
3179
|
return JSXOpeningElement$0(state);
|
|
3145
3180
|
}
|
|
3146
3181
|
}
|
|
3147
|
-
var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($
|
|
3182
|
+
var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L67, fail, 'JSXClosingElement ">"'));
|
|
3148
3183
|
function JSXClosingElement(state) {
|
|
3149
3184
|
if (state.verbose)
|
|
3150
3185
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -3164,7 +3199,7 @@ var require_parser = __commonJS({
|
|
|
3164
3199
|
return JSXFragment$0(state);
|
|
3165
3200
|
}
|
|
3166
3201
|
}
|
|
3167
|
-
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($
|
|
3202
|
+
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L14, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L25, fail, 'JSXElementName "."'), JSXIdentifierName))));
|
|
3168
3203
|
function JSXElementName(state) {
|
|
3169
3204
|
if (state.verbose)
|
|
3170
3205
|
console.log("ENTER:", "JSXElementName");
|
|
@@ -3174,7 +3209,7 @@ var require_parser = __commonJS({
|
|
|
3174
3209
|
return JSXElementName$0(state);
|
|
3175
3210
|
}
|
|
3176
3211
|
}
|
|
3177
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
3212
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R26, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
3178
3213
|
function JSXIdentifierName(state) {
|
|
3179
3214
|
if (state.verbose)
|
|
3180
3215
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -3194,7 +3229,7 @@ var require_parser = __commonJS({
|
|
|
3194
3229
|
return JSXAttributes$0(state);
|
|
3195
3230
|
}
|
|
3196
3231
|
}
|
|
3197
|
-
var JSXAttribute$0 = $S($EXPECT($
|
|
3232
|
+
var JSXAttribute$0 = $S($EXPECT($L12, fail, 'JSXAttribute "{"'), __, $EXPECT($L33, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L13, fail, 'JSXAttribute "}"'));
|
|
3198
3233
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
3199
3234
|
function JSXAttribute(state) {
|
|
3200
3235
|
if (state.tokenize) {
|
|
@@ -3203,7 +3238,7 @@ var require_parser = __commonJS({
|
|
|
3203
3238
|
return JSXAttribute$0(state) || JSXAttribute$1(state);
|
|
3204
3239
|
}
|
|
3205
3240
|
}
|
|
3206
|
-
var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($
|
|
3241
|
+
var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L14, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
|
|
3207
3242
|
function JSXAttributeName(state) {
|
|
3208
3243
|
if (state.verbose)
|
|
3209
3244
|
console.log("ENTER:", "JSXAttributeName");
|
|
@@ -3213,7 +3248,7 @@ var require_parser = __commonJS({
|
|
|
3213
3248
|
return JSXAttributeName$0(state);
|
|
3214
3249
|
}
|
|
3215
3250
|
}
|
|
3216
|
-
var JSXAttributeInitializer$0 = $S(__, $EXPECT($
|
|
3251
|
+
var JSXAttributeInitializer$0 = $S(__, $EXPECT($L56, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
|
|
3217
3252
|
function JSXAttributeInitializer(state) {
|
|
3218
3253
|
if (state.verbose)
|
|
3219
3254
|
console.log("ENTER:", "JSXAttributeInitializer");
|
|
@@ -3223,9 +3258,9 @@ var require_parser = __commonJS({
|
|
|
3223
3258
|
return JSXAttributeInitializer$0(state);
|
|
3224
3259
|
}
|
|
3225
3260
|
}
|
|
3226
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
3227
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
3228
|
-
var JSXAttributeValue$2 = $S($EXPECT($
|
|
3261
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R27, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
3262
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R28, fail, "JSXAttributeValue /'[^']*'/"));
|
|
3263
|
+
var JSXAttributeValue$2 = $S($EXPECT($L12, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L13, fail, 'JSXAttributeValue "}"'));
|
|
3229
3264
|
var JSXAttributeValue$3 = JSXElement;
|
|
3230
3265
|
var JSXAttributeValue$4 = JSXFragment;
|
|
3231
3266
|
function JSXAttributeValue(state) {
|
|
@@ -3248,7 +3283,7 @@ var require_parser = __commonJS({
|
|
|
3248
3283
|
var JSXChild$0 = JSXText;
|
|
3249
3284
|
var JSXChild$1 = JSXElement;
|
|
3250
3285
|
var JSXChild$2 = JSXFragment;
|
|
3251
|
-
var JSXChild$3 = $S($EXPECT($
|
|
3286
|
+
var JSXChild$3 = $S($EXPECT($L12, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L13, fail, 'JSXChild "}"'));
|
|
3252
3287
|
function JSXChild(state) {
|
|
3253
3288
|
if (state.tokenize) {
|
|
3254
3289
|
return $TOKEN("JSXChild", state, JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state));
|
|
@@ -3256,7 +3291,7 @@ var require_parser = __commonJS({
|
|
|
3256
3291
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
3257
3292
|
}
|
|
3258
3293
|
}
|
|
3259
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
3294
|
+
var JSXText$0 = $R$0($EXPECT($R29, fail, "JSXText /[^{}<>]+/"));
|
|
3260
3295
|
function JSXText(state) {
|
|
3261
3296
|
if (state.verbose)
|
|
3262
3297
|
console.log("ENTER:", "JSXText");
|
|
@@ -3266,7 +3301,7 @@ var require_parser = __commonJS({
|
|
|
3266
3301
|
return JSXText$0(state);
|
|
3267
3302
|
}
|
|
3268
3303
|
}
|
|
3269
|
-
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($
|
|
3304
|
+
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L33, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
|
|
3270
3305
|
function JSXChildExpression(state) {
|
|
3271
3306
|
if (state.verbose)
|
|
3272
3307
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -3276,10 +3311,10 @@ var require_parser = __commonJS({
|
|
|
3276
3311
|
return JSXChildExpression$0(state);
|
|
3277
3312
|
}
|
|
3278
3313
|
}
|
|
3279
|
-
var TypeDeclaration$0 = $T($S($EXPECT($
|
|
3314
|
+
var TypeDeclaration$0 = $T($S($EXPECT($R30, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L56, fail, 'TypeDeclaration "="'), __, Type), function(value) {
|
|
3280
3315
|
return { "ts": true, "children": value };
|
|
3281
3316
|
});
|
|
3282
|
-
var TypeDeclaration$1 = $T($S($EXPECT($
|
|
3317
|
+
var TypeDeclaration$1 = $T($S($EXPECT($R31, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
|
|
3283
3318
|
return { "ts": true, "children": value };
|
|
3284
3319
|
});
|
|
3285
3320
|
function TypeDeclaration(state) {
|
|
@@ -3289,8 +3324,8 @@ var require_parser = __commonJS({
|
|
|
3289
3324
|
return TypeDeclaration$0(state) || TypeDeclaration$1(state);
|
|
3290
3325
|
}
|
|
3291
3326
|
}
|
|
3292
|
-
var InterfaceBlock$0 = $S(__, $EXPECT($
|
|
3293
|
-
var InterfaceBlock$1 = $S(__, $EXPECT($
|
|
3327
|
+
var InterfaceBlock$0 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L13, fail, 'InterfaceBlock "}"'));
|
|
3328
|
+
var InterfaceBlock$1 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), $Q($S(__, InterfaceProperty)), __, $EXPECT($L13, fail, 'InterfaceBlock "}"'));
|
|
3294
3329
|
var InterfaceBlock$2 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
3295
3330
|
function InterfaceBlock(state) {
|
|
3296
3331
|
if (state.tokenize) {
|
|
@@ -3334,9 +3369,9 @@ var require_parser = __commonJS({
|
|
|
3334
3369
|
return InterfaceProperty$0(state);
|
|
3335
3370
|
}
|
|
3336
3371
|
}
|
|
3337
|
-
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($
|
|
3338
|
-
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
3339
|
-
var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
3372
|
+
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L88, fail, 'InterfacePropertyDelimiter ";"'));
|
|
3373
|
+
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L13, fail, 'InterfacePropertyDelimiter "}"')));
|
|
3374
|
+
var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L13, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
|
|
3340
3375
|
return ";";
|
|
3341
3376
|
});
|
|
3342
3377
|
var InterfacePropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -3349,7 +3384,7 @@ var require_parser = __commonJS({
|
|
|
3349
3384
|
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
|
|
3350
3385
|
}
|
|
3351
3386
|
}
|
|
3352
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
3387
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R32, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L128, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L26, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L27, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R33, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
|
|
3353
3388
|
function TypeIndexSignature(state) {
|
|
3354
3389
|
if (state.verbose)
|
|
3355
3390
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -3360,7 +3395,7 @@ var require_parser = __commonJS({
|
|
|
3360
3395
|
}
|
|
3361
3396
|
}
|
|
3362
3397
|
var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
|
|
3363
|
-
var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($
|
|
3398
|
+
var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L79, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
|
|
3364
3399
|
function TypeIndex(state) {
|
|
3365
3400
|
if (state.tokenize) {
|
|
3366
3401
|
return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
|
|
@@ -3368,7 +3403,7 @@ var require_parser = __commonJS({
|
|
|
3368
3403
|
return TypeIndex$0(state) || TypeIndex$1(state);
|
|
3369
3404
|
}
|
|
3370
3405
|
}
|
|
3371
|
-
var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($
|
|
3406
|
+
var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L14, fail, 'TypeSuffix ":"'), Type), function(value) {
|
|
3372
3407
|
return { "ts": true, "children": value };
|
|
3373
3408
|
});
|
|
3374
3409
|
function TypeSuffix(state) {
|
|
@@ -3380,7 +3415,7 @@ var require_parser = __commonJS({
|
|
|
3380
3415
|
return TypeSuffix$0(state);
|
|
3381
3416
|
}
|
|
3382
3417
|
}
|
|
3383
|
-
var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($
|
|
3418
|
+
var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L14, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L129, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
|
|
3384
3419
|
return { "ts": true, "children": value };
|
|
3385
3420
|
});
|
|
3386
3421
|
function ReturnTypeSuffix(state) {
|
|
@@ -3392,7 +3427,7 @@ var require_parser = __commonJS({
|
|
|
3392
3427
|
return ReturnTypeSuffix$0(state);
|
|
3393
3428
|
}
|
|
3394
3429
|
}
|
|
3395
|
-
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($
|
|
3430
|
+
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L70, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
|
|
3396
3431
|
function TypePredicate(state) {
|
|
3397
3432
|
if (state.verbose)
|
|
3398
3433
|
console.log("ENTER:", "TypePredicate");
|
|
@@ -3443,7 +3478,7 @@ var require_parser = __commonJS({
|
|
|
3443
3478
|
}
|
|
3444
3479
|
}
|
|
3445
3480
|
var TypeUnaryOp$0 = $EXPECT($L130, fail, 'TypeUnaryOp "keyof"');
|
|
3446
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
3481
|
+
var TypeUnaryOp$1 = $EXPECT($L85, fail, 'TypeUnaryOp "typeof"');
|
|
3447
3482
|
var TypeUnaryOp$2 = $EXPECT($L131, fail, 'TypeUnaryOp "infer"');
|
|
3448
3483
|
function TypeUnaryOp(state) {
|
|
3449
3484
|
if (state.tokenize) {
|
|
@@ -3452,7 +3487,7 @@ var require_parser = __commonJS({
|
|
|
3452
3487
|
return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
|
|
3453
3488
|
}
|
|
3454
3489
|
}
|
|
3455
|
-
var TypeIndexedAccess$0 = $S(__, $EXPECT($
|
|
3490
|
+
var TypeIndexedAccess$0 = $S(__, $EXPECT($L26, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L27, fail, 'TypeIndexedAccess "]"'));
|
|
3456
3491
|
function TypeIndexedAccess(state) {
|
|
3457
3492
|
if (state.verbose)
|
|
3458
3493
|
console.log("ENTER:", "TypeIndexedAccess");
|
|
@@ -3465,7 +3500,7 @@ var require_parser = __commonJS({
|
|
|
3465
3500
|
var TypePrimary$0 = InterfaceBlock;
|
|
3466
3501
|
var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
|
|
3467
3502
|
var TypePrimary$2 = $S($Q(_), FunctionType);
|
|
3468
|
-
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($
|
|
3503
|
+
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L25, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
|
|
3469
3504
|
var TypePrimary$4 = $S($Q(_), TypeLiteral);
|
|
3470
3505
|
function TypePrimary(state) {
|
|
3471
3506
|
if (state.tokenize) {
|
|
@@ -3474,7 +3509,7 @@ var require_parser = __commonJS({
|
|
|
3474
3509
|
return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
|
|
3475
3510
|
}
|
|
3476
3511
|
}
|
|
3477
|
-
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($
|
|
3512
|
+
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L17, fail, 'TypeConditional "extends"'), Type, $E($S(__, $EXPECT($L3, fail, 'TypeConditional "?"'), Type, __, $EXPECT($L14, fail, 'TypeConditional ":"'), Type)))));
|
|
3478
3513
|
function TypeConditional(state) {
|
|
3479
3514
|
if (state.verbose)
|
|
3480
3515
|
console.log("ENTER:", "TypeConditional");
|
|
@@ -3485,7 +3520,7 @@ var require_parser = __commonJS({
|
|
|
3485
3520
|
}
|
|
3486
3521
|
}
|
|
3487
3522
|
var TypeLiteral$0 = Literal;
|
|
3488
|
-
var TypeLiteral$1 = $EXPECT($
|
|
3523
|
+
var TypeLiteral$1 = $EXPECT($L84, fail, 'TypeLiteral "void"');
|
|
3489
3524
|
var TypeLiteral$2 = $EXPECT($L132, fail, 'TypeLiteral "[]"');
|
|
3490
3525
|
function TypeLiteral(state) {
|
|
3491
3526
|
if (state.tokenize) {
|
|
@@ -3494,8 +3529,8 @@ var require_parser = __commonJS({
|
|
|
3494
3529
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
3495
3530
|
}
|
|
3496
3531
|
}
|
|
3497
|
-
var TypeBinaryOp$0 = $EXPECT($
|
|
3498
|
-
var TypeBinaryOp$1 = $EXPECT($
|
|
3532
|
+
var TypeBinaryOp$0 = $EXPECT($L82, fail, 'TypeBinaryOp "|"');
|
|
3533
|
+
var TypeBinaryOp$1 = $EXPECT($L80, fail, 'TypeBinaryOp "&"');
|
|
3499
3534
|
function TypeBinaryOp(state) {
|
|
3500
3535
|
if (state.tokenize) {
|
|
3501
3536
|
return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
|
|
@@ -3503,7 +3538,7 @@ var require_parser = __commonJS({
|
|
|
3503
3538
|
return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
|
|
3504
3539
|
}
|
|
3505
3540
|
}
|
|
3506
|
-
var FunctionType$0 = $S(Parameters, __, $EXPECT($
|
|
3541
|
+
var FunctionType$0 = $S(Parameters, __, $EXPECT($L11, fail, 'FunctionType "=>"'), Type);
|
|
3507
3542
|
function FunctionType(state) {
|
|
3508
3543
|
if (state.verbose)
|
|
3509
3544
|
console.log("ENTER:", "FunctionType");
|
|
@@ -3513,7 +3548,7 @@ var require_parser = __commonJS({
|
|
|
3513
3548
|
return FunctionType$0(state);
|
|
3514
3549
|
}
|
|
3515
3550
|
}
|
|
3516
|
-
var TypeArguments$0 = $S(__, $EXPECT($
|
|
3551
|
+
var TypeArguments$0 = $S(__, $EXPECT($L16, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L67, fail, 'TypeArguments ">"'));
|
|
3517
3552
|
function TypeArguments(state) {
|
|
3518
3553
|
if (state.verbose)
|
|
3519
3554
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -3523,7 +3558,7 @@ var require_parser = __commonJS({
|
|
|
3523
3558
|
return TypeArguments$0(state);
|
|
3524
3559
|
}
|
|
3525
3560
|
}
|
|
3526
|
-
var TypeParameters$0 = $S(__, $EXPECT($
|
|
3561
|
+
var TypeParameters$0 = $S(__, $EXPECT($L16, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L67, fail, 'TypeParameters ">"'));
|
|
3527
3562
|
function TypeParameters(state) {
|
|
3528
3563
|
if (state.verbose)
|
|
3529
3564
|
console.log("ENTER:", "TypeParameters");
|
|
@@ -3543,7 +3578,7 @@ var require_parser = __commonJS({
|
|
|
3543
3578
|
return TypeParameter$0(state);
|
|
3544
3579
|
}
|
|
3545
3580
|
}
|
|
3546
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
3581
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L17, fail, 'TypeConstraint "extends"'), Type);
|
|
3547
3582
|
function TypeConstraint(state) {
|
|
3548
3583
|
if (state.verbose)
|
|
3549
3584
|
console.log("ENTER:", "TypeConstraint");
|
|
@@ -3554,8 +3589,8 @@ var require_parser = __commonJS({
|
|
|
3554
3589
|
}
|
|
3555
3590
|
}
|
|
3556
3591
|
var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
|
|
3557
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
3558
|
-
var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
3592
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L67, fail, 'TypeParameterDelimiter ">"')));
|
|
3593
|
+
var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L67, fail, 'TypeParameterDelimiter ">"'))), function(value) {
|
|
3559
3594
|
return ",";
|
|
3560
3595
|
});
|
|
3561
3596
|
var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -3568,7 +3603,7 @@ var require_parser = __commonJS({
|
|
|
3568
3603
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
3569
3604
|
}
|
|
3570
3605
|
}
|
|
3571
|
-
var Shebang$0 = $R$0($EXPECT($
|
|
3606
|
+
var Shebang$0 = $R$0($EXPECT($R34, fail, "Shebang /#![^\\r\\n]*/"));
|
|
3572
3607
|
function Shebang(state) {
|
|
3573
3608
|
if (state.verbose)
|
|
3574
3609
|
console.log("ENTER:", "Shebang");
|
|
@@ -3578,7 +3613,7 @@ var require_parser = __commonJS({
|
|
|
3578
3613
|
return Shebang$0(state);
|
|
3579
3614
|
}
|
|
3580
3615
|
}
|
|
3581
|
-
var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($
|
|
3616
|
+
var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R35, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
|
|
3582
3617
|
return $0.map((p) => p.join(""));
|
|
3583
3618
|
});
|
|
3584
3619
|
function DirectivePrologue(state) {
|
|
@@ -3600,7 +3635,7 @@ var require_parser = __commonJS({
|
|
|
3600
3635
|
return EOS$0(state);
|
|
3601
3636
|
}
|
|
3602
3637
|
}
|
|
3603
|
-
var EOL$0 = $R$0($EXPECT($
|
|
3638
|
+
var EOL$0 = $R$0($EXPECT($R36, fail, "EOL /\\r\\n|\\n|\\r|$/"));
|
|
3604
3639
|
function EOL(state) {
|
|
3605
3640
|
if (state.verbose)
|
|
3606
3641
|
console.log("ENTER:", "EOL");
|
|
@@ -3610,7 +3645,7 @@ var require_parser = __commonJS({
|
|
|
3610
3645
|
return EOL$0(state);
|
|
3611
3646
|
}
|
|
3612
3647
|
}
|
|
3613
|
-
var EOF$0 = $R$0($EXPECT($
|
|
3648
|
+
var EOF$0 = $R$0($EXPECT($R37, fail, "EOF /$/"));
|
|
3614
3649
|
function EOF(state) {
|
|
3615
3650
|
if (state.verbose)
|
|
3616
3651
|
console.log("ENTER:", "EOF");
|
|
@@ -3620,7 +3655,7 @@ var require_parser = __commonJS({
|
|
|
3620
3655
|
return EOF$0(state);
|
|
3621
3656
|
}
|
|
3622
3657
|
}
|
|
3623
|
-
var Debugger$0 = $TV($EXPECT($
|
|
3658
|
+
var Debugger$0 = $TV($EXPECT($L32, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
3624
3659
|
debugger;
|
|
3625
3660
|
});
|
|
3626
3661
|
function Debugger(state) {
|
|
@@ -3632,7 +3667,7 @@ var require_parser = __commonJS({
|
|
|
3632
3667
|
return Debugger$0(state);
|
|
3633
3668
|
}
|
|
3634
3669
|
}
|
|
3635
|
-
var InsertOpenParen$0 = $T($EXPECT($
|
|
3670
|
+
var InsertOpenParen$0 = $T($EXPECT($L32, fail, 'InsertOpenParen ""'), function(value) {
|
|
3636
3671
|
return "(";
|
|
3637
3672
|
});
|
|
3638
3673
|
function InsertOpenParen(state) {
|
|
@@ -3644,7 +3679,7 @@ var require_parser = __commonJS({
|
|
|
3644
3679
|
return InsertOpenParen$0(state);
|
|
3645
3680
|
}
|
|
3646
3681
|
}
|
|
3647
|
-
var InsertCloseParen$0 = $T($EXPECT($
|
|
3682
|
+
var InsertCloseParen$0 = $T($EXPECT($L32, fail, 'InsertCloseParen ""'), function(value) {
|
|
3648
3683
|
return ")";
|
|
3649
3684
|
});
|
|
3650
3685
|
function InsertCloseParen(state) {
|
|
@@ -3656,7 +3691,7 @@ var require_parser = __commonJS({
|
|
|
3656
3691
|
return InsertCloseParen$0(state);
|
|
3657
3692
|
}
|
|
3658
3693
|
}
|
|
3659
|
-
var InsertOpenBrace$0 = $T($EXPECT($
|
|
3694
|
+
var InsertOpenBrace$0 = $T($EXPECT($L32, fail, 'InsertOpenBrace ""'), function(value) {
|
|
3660
3695
|
return " {";
|
|
3661
3696
|
});
|
|
3662
3697
|
function InsertOpenBrace(state) {
|
|
@@ -3668,7 +3703,7 @@ var require_parser = __commonJS({
|
|
|
3668
3703
|
return InsertOpenBrace$0(state);
|
|
3669
3704
|
}
|
|
3670
3705
|
}
|
|
3671
|
-
var InsertCloseBrace$0 = $T($EXPECT($
|
|
3706
|
+
var InsertCloseBrace$0 = $T($EXPECT($L32, fail, 'InsertCloseBrace ""'), function(value) {
|
|
3672
3707
|
return "}";
|
|
3673
3708
|
});
|
|
3674
3709
|
function InsertCloseBrace(state) {
|
|
@@ -3680,7 +3715,7 @@ var require_parser = __commonJS({
|
|
|
3680
3715
|
return InsertCloseBrace$0(state);
|
|
3681
3716
|
}
|
|
3682
3717
|
}
|
|
3683
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
3718
|
+
var InsertNewline$0 = $TV($EXPECT($L32, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
3684
3719
|
return "\n";
|
|
3685
3720
|
});
|
|
3686
3721
|
function InsertNewline(state) {
|
|
@@ -3692,7 +3727,7 @@ var require_parser = __commonJS({
|
|
|
3692
3727
|
return InsertNewline$0(state);
|
|
3693
3728
|
}
|
|
3694
3729
|
}
|
|
3695
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
3730
|
+
var InsertIndent$0 = $TV($EXPECT($L32, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
3696
3731
|
return "".padStart(global.currentIndent * 2);
|
|
3697
3732
|
});
|
|
3698
3733
|
function InsertIndent(state) {
|
|
@@ -3704,7 +3739,7 @@ var require_parser = __commonJS({
|
|
|
3704
3739
|
return InsertIndent$0(state);
|
|
3705
3740
|
}
|
|
3706
3741
|
}
|
|
3707
|
-
var InsertSpace$0 = $T($EXPECT($
|
|
3742
|
+
var InsertSpace$0 = $T($EXPECT($L32, fail, 'InsertSpace ""'), function(value) {
|
|
3708
3743
|
return " ";
|
|
3709
3744
|
});
|
|
3710
3745
|
function InsertSpace(state) {
|
|
@@ -3716,7 +3751,7 @@ var require_parser = __commonJS({
|
|
|
3716
3751
|
return InsertSpace$0(state);
|
|
3717
3752
|
}
|
|
3718
3753
|
}
|
|
3719
|
-
var InsertDot$0 = $T($EXPECT($
|
|
3754
|
+
var InsertDot$0 = $T($EXPECT($L32, fail, 'InsertDot ""'), function(value) {
|
|
3720
3755
|
return ".";
|
|
3721
3756
|
});
|
|
3722
3757
|
function InsertDot(state) {
|
|
@@ -3728,7 +3763,7 @@ var require_parser = __commonJS({
|
|
|
3728
3763
|
return InsertDot$0(state);
|
|
3729
3764
|
}
|
|
3730
3765
|
}
|
|
3731
|
-
var InsertBreak$0 = $T($EXPECT($
|
|
3766
|
+
var InsertBreak$0 = $T($EXPECT($L32, fail, 'InsertBreak ""'), function(value) {
|
|
3732
3767
|
return "break;";
|
|
3733
3768
|
});
|
|
3734
3769
|
function InsertBreak(state) {
|
|
@@ -3740,7 +3775,7 @@ var require_parser = __commonJS({
|
|
|
3740
3775
|
return InsertBreak$0(state);
|
|
3741
3776
|
}
|
|
3742
3777
|
}
|
|
3743
|
-
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($
|
|
3778
|
+
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L32, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3744
3779
|
var directives = $2;
|
|
3745
3780
|
global.currentIndent = 0;
|
|
3746
3781
|
global.indentLevels = [0];
|
|
@@ -3754,8 +3789,7 @@ var require_parser = __commonJS({
|
|
|
3754
3789
|
if (spacing) {
|
|
3755
3790
|
str = str.replaceAll(spacing[0], "\n");
|
|
3756
3791
|
}
|
|
3757
|
-
str = str.replace(/^(\r?\n|\n)/, "");
|
|
3758
|
-
str = str.replace(/(\r?\n|\n)$/, "");
|
|
3792
|
+
str = str.replace(/^(\r?\n|\n)/, "").replace(/(\r?\n|\n)[ \t]*$/, "").replace(/(`|\$)/g, "\\$1");
|
|
3759
3793
|
return str;
|
|
3760
3794
|
};
|
|
3761
3795
|
return $0;
|
|
@@ -3781,7 +3815,7 @@ var require_parser = __commonJS({
|
|
|
3781
3815
|
return Indent$0(state);
|
|
3782
3816
|
}
|
|
3783
3817
|
}
|
|
3784
|
-
var PushIndent$0 = $TV($EXPECT($
|
|
3818
|
+
var PushIndent$0 = $TV($EXPECT($L32, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
|
|
3785
3819
|
global.currentIndent++;
|
|
3786
3820
|
if (global.verbose) {
|
|
3787
3821
|
console.log("pushing indent", global.currentIndent);
|
|
@@ -3798,7 +3832,7 @@ var require_parser = __commonJS({
|
|
|
3798
3832
|
return PushIndent$0(state);
|
|
3799
3833
|
}
|
|
3800
3834
|
}
|
|
3801
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
3835
|
+
var PopIndent$0 = $TV($EXPECT($L32, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
3802
3836
|
if (global.verbose) {
|
|
3803
3837
|
console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
|
|
3804
3838
|
}
|