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