@danielx/civet 0.2.11 → 0.2.14
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 +25 -8
- package/dist/browser.js +488 -292
- package/dist/browser.js.map +2 -2
- package/dist/civet +12 -11
- package/dist/cli.js.map +3 -3
- package/dist/main.js +488 -292
- package/dist/types.d.ts +1 -0
- package/esbuild-plugin.js +27 -0
- package/package.json +2 -1
package/dist/browser.js
CHANGED
|
@@ -445,6 +445,8 @@ var Civet = (() => {
|
|
|
445
445
|
ApplicationStart,
|
|
446
446
|
AdditionalReservedWords,
|
|
447
447
|
MemberExpression,
|
|
448
|
+
MemberExpressionRest,
|
|
449
|
+
PropertyAccess,
|
|
448
450
|
SuperProperty,
|
|
449
451
|
MetaProperty,
|
|
450
452
|
Parameters,
|
|
@@ -463,7 +465,8 @@ var Civet = (() => {
|
|
|
463
465
|
ThinArrowFunction,
|
|
464
466
|
Block,
|
|
465
467
|
BracedBlock,
|
|
466
|
-
|
|
468
|
+
SingleNestedExpression,
|
|
469
|
+
SingleNestedBlockStatement,
|
|
467
470
|
NestedBlockExpressions,
|
|
468
471
|
BlockExpression,
|
|
469
472
|
Literal,
|
|
@@ -509,6 +512,7 @@ var Civet = (() => {
|
|
|
509
512
|
LoopStatement,
|
|
510
513
|
DoWhileStatement,
|
|
511
514
|
WhileStatement,
|
|
515
|
+
WhileClause,
|
|
512
516
|
ForStatement,
|
|
513
517
|
ForInOfStatement,
|
|
514
518
|
ForDeclaration,
|
|
@@ -528,6 +532,8 @@ var Civet = (() => {
|
|
|
528
532
|
Condition,
|
|
529
533
|
ExpressionStatement,
|
|
530
534
|
KeywordStatement,
|
|
535
|
+
MaybeNestedExpression,
|
|
536
|
+
Return,
|
|
531
537
|
ImportDeclaration,
|
|
532
538
|
ImportClause,
|
|
533
539
|
NameSpaceImport,
|
|
@@ -546,6 +552,7 @@ var Civet = (() => {
|
|
|
546
552
|
Declaration,
|
|
547
553
|
HoistableDeclaration,
|
|
548
554
|
LexicalDeclaration,
|
|
555
|
+
ConstAssignment,
|
|
549
556
|
LexicalBinding,
|
|
550
557
|
Initializer,
|
|
551
558
|
VariableStatement,
|
|
@@ -631,6 +638,7 @@ var Civet = (() => {
|
|
|
631
638
|
EOS,
|
|
632
639
|
EOL,
|
|
633
640
|
EOF,
|
|
641
|
+
Debugger,
|
|
634
642
|
InsertOpenParen,
|
|
635
643
|
InsertCloseParen,
|
|
636
644
|
InsertOpenBrace,
|
|
@@ -644,7 +652,8 @@ var Civet = (() => {
|
|
|
644
652
|
Indent,
|
|
645
653
|
PushIndent,
|
|
646
654
|
PopIndent,
|
|
647
|
-
Nested
|
|
655
|
+
Nested,
|
|
656
|
+
NestedFurther
|
|
648
657
|
});
|
|
649
658
|
var $L0 = $L(",");
|
|
650
659
|
var $L1 = $L("(");
|
|
@@ -670,116 +679,118 @@ var Civet = (() => {
|
|
|
670
679
|
var $L21 = $L("new");
|
|
671
680
|
var $L22 = $L("super");
|
|
672
681
|
var $L23 = $L("import");
|
|
673
|
-
var $L24 = $L("
|
|
674
|
-
var $L25 = $L("
|
|
675
|
-
var $L26 = $L("
|
|
676
|
-
var $L27 = $L("
|
|
677
|
-
var $L28 = $L("
|
|
678
|
-
var $L29 = $L("
|
|
679
|
-
var $L30 = $L("");
|
|
680
|
-
var $L31 = $L("
|
|
681
|
-
var $L32 = $L("
|
|
682
|
-
var $L33 = $L("
|
|
683
|
-
var $L34 = $L("
|
|
684
|
-
var $L35 = $L("
|
|
685
|
-
var $L36 = $L("
|
|
686
|
-
var $L37 = $L("
|
|
687
|
-
var $L38 = $L("
|
|
688
|
-
var $L39 = $L("
|
|
689
|
-
var $L40 = $L("
|
|
690
|
-
var $L41 = $L("
|
|
691
|
-
var $L42 = $L("
|
|
692
|
-
var $L43 = $L("
|
|
693
|
-
var $L44 = $L("
|
|
694
|
-
var $L45 = $L("
|
|
695
|
-
var $L46 = $L("
|
|
696
|
-
var $L47 = $L("
|
|
697
|
-
var $L48 = $L("
|
|
698
|
-
var $L49 = $L("
|
|
699
|
-
var $L50 = $L("
|
|
700
|
-
var $L51 = $L("
|
|
701
|
-
var $L52 = $L("
|
|
702
|
-
var $L53 = $L("
|
|
703
|
-
var $L54 = $L("
|
|
704
|
-
var $L55 = $L("
|
|
705
|
-
var $L56 = $L("
|
|
706
|
-
var $L57 = $L("
|
|
707
|
-
var $L58 = $L("
|
|
708
|
-
var $L59 = $L("
|
|
709
|
-
var $L60 = $L("
|
|
710
|
-
var $L61 = $L("
|
|
711
|
-
var $L62 = $L("
|
|
712
|
-
var $L63 = $L("
|
|
713
|
-
var $L64 = $L("
|
|
714
|
-
var $L65 = $L("
|
|
715
|
-
var $L66 = $L("
|
|
716
|
-
var $L67 = $L("
|
|
717
|
-
var $L68 = $L("
|
|
718
|
-
var $L69 = $L("
|
|
719
|
-
var $L70 = $L("
|
|
720
|
-
var $L71 = $L("
|
|
721
|
-
var $L72 = $L("
|
|
722
|
-
var $L73 = $L("
|
|
723
|
-
var $L74 = $L("
|
|
724
|
-
var $L75 = $L("
|
|
725
|
-
var $L76 = $L("
|
|
726
|
-
var $L77 = $L("
|
|
727
|
-
var $L78 = $L("
|
|
728
|
-
var $L79 = $L("
|
|
729
|
-
var $L80 = $L("
|
|
730
|
-
var $L81 = $L("
|
|
731
|
-
var $L82 = $L("
|
|
732
|
-
var $L83 = $L("
|
|
733
|
-
var $L84 = $L("
|
|
734
|
-
var $L85 = $L("
|
|
735
|
-
var $L86 = $L("
|
|
736
|
-
var $L87 = $L("
|
|
737
|
-
var $L88 = $L("
|
|
738
|
-
var $L89 = $L("
|
|
739
|
-
var $L90 = $L("
|
|
740
|
-
var $L91 = $L("
|
|
741
|
-
var $L92 = $L("
|
|
742
|
-
var $L93 = $L("
|
|
743
|
-
var $L94 = $L("
|
|
744
|
-
var $L95 = $L("
|
|
745
|
-
var $L96 = $L("
|
|
746
|
-
var $L97 = $L("
|
|
747
|
-
var $L98 = $L("
|
|
748
|
-
var $L99 = $L("
|
|
749
|
-
var $L100 = $L("
|
|
750
|
-
var $L101 = $L("
|
|
751
|
-
var $L102 = $L("
|
|
752
|
-
var $L103 = $L("
|
|
753
|
-
var $L104 = $L("
|
|
754
|
-
var $L105 = $L("
|
|
755
|
-
var $L106 = $L("
|
|
756
|
-
var $L107 = $L("
|
|
757
|
-
var $L108 = $L("
|
|
758
|
-
var $L109 = $L("
|
|
759
|
-
var $L110 = $L("
|
|
760
|
-
var $L111 = $L("
|
|
761
|
-
var $L112 = $L("
|
|
762
|
-
var $L113 = $L("
|
|
763
|
-
var $L114 = $L(
|
|
764
|
-
var $L115 = $L(
|
|
765
|
-
var $L116 = $L("'
|
|
766
|
-
var $L117 = $L("
|
|
767
|
-
var $L118 = $L("
|
|
768
|
-
var $L119 = $L("
|
|
769
|
-
var $L120 = $L("
|
|
770
|
-
var $L121 = $L("
|
|
771
|
-
var $L122 = $L("
|
|
772
|
-
var $L123 = $L("
|
|
773
|
-
var $L124 = $L("
|
|
774
|
-
var $L125 = $L("
|
|
775
|
-
var $L126 = $L("
|
|
776
|
-
var $L127 = $L("
|
|
777
|
-
var $L128 = $L("
|
|
778
|
-
var $L129 = $L("
|
|
779
|
-
var $L130 = $L("
|
|
780
|
-
var $L131 = $L("
|
|
781
|
-
var $L132 = $L("
|
|
782
|
-
var $L133 = $L("
|
|
682
|
+
var $L24 = $L(".");
|
|
683
|
+
var $L25 = $L("[");
|
|
684
|
+
var $L26 = $L("]");
|
|
685
|
+
var $L27 = $L("::");
|
|
686
|
+
var $L28 = $L("super[");
|
|
687
|
+
var $L29 = $L("new.target");
|
|
688
|
+
var $L30 = $L("import.meta");
|
|
689
|
+
var $L31 = $L("");
|
|
690
|
+
var $L32 = $L("...");
|
|
691
|
+
var $L33 = $L("function");
|
|
692
|
+
var $L34 = $L("->");
|
|
693
|
+
var $L35 = $L("true");
|
|
694
|
+
var $L36 = $L("false");
|
|
695
|
+
var $L37 = $L("null");
|
|
696
|
+
var $L38 = $L("undefined");
|
|
697
|
+
var $L39 = $L("get");
|
|
698
|
+
var $L40 = $L("set");
|
|
699
|
+
var $L41 = $L("**=");
|
|
700
|
+
var $L42 = $L("*=");
|
|
701
|
+
var $L43 = $L("/=");
|
|
702
|
+
var $L44 = $L("%=");
|
|
703
|
+
var $L45 = $L("+=");
|
|
704
|
+
var $L46 = $L("-=");
|
|
705
|
+
var $L47 = $L("<<=");
|
|
706
|
+
var $L48 = $L(">>>=");
|
|
707
|
+
var $L49 = $L(">>=");
|
|
708
|
+
var $L50 = $L("&&=");
|
|
709
|
+
var $L51 = $L("&=");
|
|
710
|
+
var $L52 = $L("^=");
|
|
711
|
+
var $L53 = $L("||=");
|
|
712
|
+
var $L54 = $L("|=");
|
|
713
|
+
var $L55 = $L("??=");
|
|
714
|
+
var $L56 = $L("=");
|
|
715
|
+
var $L57 = $L("**");
|
|
716
|
+
var $L58 = $L("/");
|
|
717
|
+
var $L59 = $L("%");
|
|
718
|
+
var $L60 = $L("+");
|
|
719
|
+
var $L61 = $L("-");
|
|
720
|
+
var $L62 = $L("<=");
|
|
721
|
+
var $L63 = $L(">=");
|
|
722
|
+
var $L64 = $L("<<");
|
|
723
|
+
var $L65 = $L(">>>");
|
|
724
|
+
var $L66 = $L(">>");
|
|
725
|
+
var $L67 = $L(">");
|
|
726
|
+
var $L68 = $L("!==");
|
|
727
|
+
var $L69 = $L("!=");
|
|
728
|
+
var $L70 = $L("is");
|
|
729
|
+
var $L71 = $L("===");
|
|
730
|
+
var $L72 = $L("==");
|
|
731
|
+
var $L73 = $L("and");
|
|
732
|
+
var $L74 = $L("&&");
|
|
733
|
+
var $L75 = $L("or");
|
|
734
|
+
var $L76 = $L("||");
|
|
735
|
+
var $L77 = $L("??");
|
|
736
|
+
var $L78 = $L("instanceof");
|
|
737
|
+
var $L79 = $L("in");
|
|
738
|
+
var $L80 = $L("&");
|
|
739
|
+
var $L81 = $L("^");
|
|
740
|
+
var $L82 = $L("|");
|
|
741
|
+
var $L83 = $L("delete");
|
|
742
|
+
var $L84 = $L("void");
|
|
743
|
+
var $L85 = $L("typeof");
|
|
744
|
+
var $L86 = $L("if");
|
|
745
|
+
var $L87 = $L("unless");
|
|
746
|
+
var $L88 = $L(";");
|
|
747
|
+
var $L89 = $L("else");
|
|
748
|
+
var $L90 = $L("loop");
|
|
749
|
+
var $L91 = $L("do");
|
|
750
|
+
var $L92 = $L("while");
|
|
751
|
+
var $L93 = $L("until");
|
|
752
|
+
var $L94 = $L("for");
|
|
753
|
+
var $L95 = $L("var");
|
|
754
|
+
var $L96 = $L("await");
|
|
755
|
+
var $L97 = $L("of");
|
|
756
|
+
var $L98 = $L("let");
|
|
757
|
+
var $L99 = $L("const");
|
|
758
|
+
var $L100 = $L("switch");
|
|
759
|
+
var $L101 = $L("case");
|
|
760
|
+
var $L102 = $L("default");
|
|
761
|
+
var $L103 = $L("when");
|
|
762
|
+
var $L104 = $L("try");
|
|
763
|
+
var $L105 = $L("catch");
|
|
764
|
+
var $L106 = $L("finally");
|
|
765
|
+
var $L107 = $L("break");
|
|
766
|
+
var $L108 = $L("continue");
|
|
767
|
+
var $L109 = $L("debugger");
|
|
768
|
+
var $L110 = $L("throw");
|
|
769
|
+
var $L111 = $L("return");
|
|
770
|
+
var $L112 = $L("import type");
|
|
771
|
+
var $L113 = $L("from");
|
|
772
|
+
var $L114 = $L("export");
|
|
773
|
+
var $L115 = $L(":=");
|
|
774
|
+
var $L116 = $L('"""');
|
|
775
|
+
var $L117 = $L('"');
|
|
776
|
+
var $L118 = $L("'");
|
|
777
|
+
var $L119 = $L("\\");
|
|
778
|
+
var $L120 = $L("`");
|
|
779
|
+
var $L121 = $L("${");
|
|
780
|
+
var $L122 = $L("/*");
|
|
781
|
+
var $L123 = $L("*/");
|
|
782
|
+
var $L124 = $L("###");
|
|
783
|
+
var $L125 = $L("/>");
|
|
784
|
+
var $L126 = $L("</");
|
|
785
|
+
var $L127 = $L("<>");
|
|
786
|
+
var $L128 = $L("</>");
|
|
787
|
+
var $L129 = $L("readonly");
|
|
788
|
+
var $L130 = $L("asserts");
|
|
789
|
+
var $L131 = $L("keyof");
|
|
790
|
+
var $L132 = $L("infer");
|
|
791
|
+
var $L133 = $L("[]");
|
|
792
|
+
var $L134 = $L(" ");
|
|
793
|
+
var $L135 = $L(" ");
|
|
783
794
|
var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
784
795
|
var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
785
796
|
var $R2 = $R(new RegExp("[!~+-]", "suy"));
|
|
@@ -999,7 +1010,7 @@ var Civet = (() => {
|
|
|
999
1010
|
return FatArrow$0(state);
|
|
1000
1011
|
}
|
|
1001
1012
|
}
|
|
1002
|
-
var ConciseBody$0 = $S(EOS,
|
|
1013
|
+
var ConciseBody$0 = $S(EOS, SingleNestedBlockStatement);
|
|
1003
1014
|
var ConciseBody$1 = $S($N($S($Q(_), $EXPECT($L11, fail, 'ConciseBody "{"'))), AssignmentExpression);
|
|
1004
1015
|
var ConciseBody$2 = BracedBlock;
|
|
1005
1016
|
function ConciseBody(state) {
|
|
@@ -1068,7 +1079,7 @@ var Civet = (() => {
|
|
|
1068
1079
|
return ClassExpression$0(state);
|
|
1069
1080
|
}
|
|
1070
1081
|
}
|
|
1071
|
-
var ClassHeritage$0 = $S(ExtendsToken, __,
|
|
1082
|
+
var ClassHeritage$0 = $S(ExtendsToken, __, MemberExpression);
|
|
1072
1083
|
function ClassHeritage(state) {
|
|
1073
1084
|
if (state.verbose)
|
|
1074
1085
|
console.log("ENTER:", "ClassHeritage");
|
|
@@ -1147,8 +1158,8 @@ var Civet = (() => {
|
|
|
1147
1158
|
var ref = value[1];
|
|
1148
1159
|
return ["this.", ref];
|
|
1149
1160
|
});
|
|
1150
|
-
var This$2 = $
|
|
1151
|
-
return "this";
|
|
1161
|
+
var This$2 = $TV($EXPECT($L19, fail, 'This "@"'), function($skip, $loc, $0, $1) {
|
|
1162
|
+
return { $loc, token: "this" };
|
|
1152
1163
|
});
|
|
1153
1164
|
function This(state) {
|
|
1154
1165
|
if (state.tokenize) {
|
|
@@ -1166,7 +1177,7 @@ var Civet = (() => {
|
|
|
1166
1177
|
return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
|
|
1167
1178
|
}
|
|
1168
1179
|
}
|
|
1169
|
-
var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)),
|
|
1180
|
+
var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)), CallExpression);
|
|
1170
1181
|
function NewExpression(state) {
|
|
1171
1182
|
if (state.verbose)
|
|
1172
1183
|
console.log("ENTER:", "NewExpression");
|
|
@@ -1178,7 +1189,7 @@ var Civet = (() => {
|
|
|
1178
1189
|
}
|
|
1179
1190
|
var CallExpression$0 = $S($EXPECT($L22, fail, 'CallExpression "super"'), __, Arguments);
|
|
1180
1191
|
var CallExpression$1 = $S($EXPECT($L23, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
|
|
1181
|
-
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest)
|
|
1192
|
+
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
|
|
1182
1193
|
function CallExpression(state) {
|
|
1183
1194
|
if (state.tokenize) {
|
|
1184
1195
|
return $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state));
|
|
@@ -1187,8 +1198,8 @@ var Civet = (() => {
|
|
|
1187
1198
|
}
|
|
1188
1199
|
}
|
|
1189
1200
|
var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
|
|
1190
|
-
var CallExpressionRest$1 =
|
|
1191
|
-
var CallExpressionRest$2 =
|
|
1201
|
+
var CallExpressionRest$1 = MemberExpressionRest;
|
|
1202
|
+
var CallExpressionRest$2 = SpacedApplication;
|
|
1192
1203
|
var CallExpressionRest$3 = TemplateLiteral;
|
|
1193
1204
|
function CallExpressionRest(state) {
|
|
1194
1205
|
if (state.tokenize) {
|
|
@@ -1197,7 +1208,7 @@ var Civet = (() => {
|
|
|
1197
1208
|
return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
|
|
1198
1209
|
}
|
|
1199
1210
|
}
|
|
1200
|
-
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($
|
|
1211
|
+
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L24, fail, 'OptionalShorthand "."'), InsertDot));
|
|
1201
1212
|
function OptionalShorthand(state) {
|
|
1202
1213
|
if (state.verbose)
|
|
1203
1214
|
console.log("ENTER:", "OptionalShorthand");
|
|
@@ -1207,7 +1218,7 @@ var Civet = (() => {
|
|
|
1207
1218
|
return OptionalShorthand$0(state);
|
|
1208
1219
|
}
|
|
1209
1220
|
}
|
|
1210
|
-
var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen);
|
|
1221
|
+
var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen, $Q($S($Y(EOS), Nested, CallExpressionRest)));
|
|
1211
1222
|
function SpacedApplication(state) {
|
|
1212
1223
|
if (state.verbose)
|
|
1213
1224
|
console.log("ENTER:", "SpacedApplication");
|
|
@@ -1241,7 +1252,7 @@ var Civet = (() => {
|
|
|
1241
1252
|
return AdditionalReservedWords$0(state);
|
|
1242
1253
|
}
|
|
1243
1254
|
}
|
|
1244
|
-
var MemberExpression$0 = $S(PrimaryExpression, $Q(
|
|
1255
|
+
var MemberExpression$0 = $S(PrimaryExpression, $Q(MemberExpressionRest));
|
|
1245
1256
|
var MemberExpression$1 = $S($Q(TrailingComment), SuperProperty);
|
|
1246
1257
|
var MemberExpression$2 = $S($Q(TrailingComment), MetaProperty);
|
|
1247
1258
|
function MemberExpression(state) {
|
|
@@ -1251,7 +1262,32 @@ var Civet = (() => {
|
|
|
1251
1262
|
return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
|
|
1252
1263
|
}
|
|
1253
1264
|
}
|
|
1254
|
-
var
|
|
1265
|
+
var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L25, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L26, fail, 'MemberExpressionRest "]"'));
|
|
1266
|
+
var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
|
|
1267
|
+
var MemberExpressionRest$2 = $TS($S($EXPECT($L27, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
|
|
1268
|
+
var id = $2;
|
|
1269
|
+
if (id)
|
|
1270
|
+
return [".prototype.", id];
|
|
1271
|
+
return ".prototype";
|
|
1272
|
+
});
|
|
1273
|
+
function MemberExpressionRest(state) {
|
|
1274
|
+
if (state.tokenize) {
|
|
1275
|
+
return $TOKEN("MemberExpressionRest", state, MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state));
|
|
1276
|
+
} else {
|
|
1277
|
+
return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state);
|
|
1278
|
+
}
|
|
1279
|
+
}
|
|
1280
|
+
var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L24, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
|
|
1281
|
+
function PropertyAccess(state) {
|
|
1282
|
+
if (state.verbose)
|
|
1283
|
+
console.log("ENTER:", "PropertyAccess");
|
|
1284
|
+
if (state.tokenize) {
|
|
1285
|
+
return $TOKEN("PropertyAccess", state, PropertyAccess$0(state));
|
|
1286
|
+
} else {
|
|
1287
|
+
return PropertyAccess$0(state);
|
|
1288
|
+
}
|
|
1289
|
+
}
|
|
1290
|
+
var SuperProperty$0 = $S($EXPECT($L28, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L26, fail, 'SuperProperty "]"'));
|
|
1255
1291
|
function SuperProperty(state) {
|
|
1256
1292
|
if (state.verbose)
|
|
1257
1293
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1261,8 +1297,8 @@ var Civet = (() => {
|
|
|
1261
1297
|
return SuperProperty$0(state);
|
|
1262
1298
|
}
|
|
1263
1299
|
}
|
|
1264
|
-
var MetaProperty$0 = $EXPECT($
|
|
1265
|
-
var MetaProperty$1 = $EXPECT($
|
|
1300
|
+
var MetaProperty$0 = $EXPECT($L29, fail, 'MetaProperty "new.target"');
|
|
1301
|
+
var MetaProperty$1 = $EXPECT($L30, fail, 'MetaProperty "import.meta"');
|
|
1266
1302
|
function MetaProperty(state) {
|
|
1267
1303
|
if (state.tokenize) {
|
|
1268
1304
|
return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
|
|
@@ -1271,7 +1307,7 @@ var Civet = (() => {
|
|
|
1271
1307
|
}
|
|
1272
1308
|
}
|
|
1273
1309
|
var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
|
|
1274
|
-
var Parameters$1 = $T($EXPECT($
|
|
1310
|
+
var Parameters$1 = $T($EXPECT($L31, fail, 'Parameters ""'), function(value) {
|
|
1275
1311
|
return "()";
|
|
1276
1312
|
});
|
|
1277
1313
|
function Parameters(state) {
|
|
@@ -1335,7 +1371,7 @@ var Civet = (() => {
|
|
|
1335
1371
|
return ObjectBindingPattern$0(state);
|
|
1336
1372
|
}
|
|
1337
1373
|
}
|
|
1338
|
-
var ArrayBindingPattern$0 = $S($EXPECT($
|
|
1374
|
+
var ArrayBindingPattern$0 = $S($EXPECT($L25, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L26, fail, 'ArrayBindingPattern "]"'));
|
|
1339
1375
|
function ArrayBindingPattern(state) {
|
|
1340
1376
|
if (state.verbose)
|
|
1341
1377
|
console.log("ENTER:", "ArrayBindingPattern");
|
|
@@ -1354,7 +1390,7 @@ var Civet = (() => {
|
|
|
1354
1390
|
return BindingProperty$0(state) || BindingProperty$1(state);
|
|
1355
1391
|
}
|
|
1356
1392
|
}
|
|
1357
|
-
var BindingRestProperty$0 = $S($EXPECT($
|
|
1393
|
+
var BindingRestProperty$0 = $S($EXPECT($L32, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
|
|
1358
1394
|
function BindingRestProperty(state) {
|
|
1359
1395
|
if (state.verbose)
|
|
1360
1396
|
console.log("ENTER:", "BindingRestProperty");
|
|
@@ -1374,7 +1410,7 @@ var Civet = (() => {
|
|
|
1374
1410
|
return BindingElement$0(state);
|
|
1375
1411
|
}
|
|
1376
1412
|
}
|
|
1377
|
-
var BindingRestElement$0 = $S($EXPECT($
|
|
1413
|
+
var BindingRestElement$0 = $S($EXPECT($L32, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
|
|
1378
1414
|
function BindingRestElement(state) {
|
|
1379
1415
|
if (state.verbose)
|
|
1380
1416
|
console.log("ENTER:", "BindingRestElement");
|
|
@@ -1395,7 +1431,7 @@ var Civet = (() => {
|
|
|
1395
1431
|
}
|
|
1396
1432
|
}
|
|
1397
1433
|
var FunctionExpression$0 = ThinArrowFunction;
|
|
1398
|
-
var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($
|
|
1434
|
+
var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L33, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L9, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
|
|
1399
1435
|
function FunctionExpression(state) {
|
|
1400
1436
|
if (state.tokenize) {
|
|
1401
1437
|
return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
|
|
@@ -1403,7 +1439,7 @@ var Civet = (() => {
|
|
|
1403
1439
|
return FunctionExpression$0(state) || FunctionExpression$1(state);
|
|
1404
1440
|
}
|
|
1405
1441
|
}
|
|
1406
|
-
var ThinArrowFunction$0 = $T($S(Parameters, $E(ReturnTypeSuffix), __, $EXPECT($
|
|
1442
|
+
var ThinArrowFunction$0 = $T($S(Parameters, $E(ReturnTypeSuffix), __, $EXPECT($L34, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
|
|
1407
1443
|
var params = value[0];
|
|
1408
1444
|
var suffix = value[1];
|
|
1409
1445
|
var block = value[4];
|
|
@@ -1439,19 +1475,34 @@ var Civet = (() => {
|
|
|
1439
1475
|
return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state);
|
|
1440
1476
|
}
|
|
1441
1477
|
}
|
|
1442
|
-
var
|
|
1478
|
+
var SingleNestedExpression$0 = $TS($S(PushIndent, $E($S(Nested, Expression, StatementDelimiter)), $C($S($N($S(Nested, Expression)), PopIndent), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1443
1479
|
var exp = $2;
|
|
1444
1480
|
if (exp)
|
|
1445
1481
|
return exp;
|
|
1446
1482
|
return $skip;
|
|
1447
1483
|
});
|
|
1448
|
-
function
|
|
1484
|
+
function SingleNestedExpression(state) {
|
|
1449
1485
|
if (state.verbose)
|
|
1450
|
-
console.log("ENTER:", "
|
|
1486
|
+
console.log("ENTER:", "SingleNestedExpression");
|
|
1451
1487
|
if (state.tokenize) {
|
|
1452
|
-
return $TOKEN("
|
|
1488
|
+
return $TOKEN("SingleNestedExpression", state, SingleNestedExpression$0(state));
|
|
1453
1489
|
} else {
|
|
1454
|
-
return
|
|
1490
|
+
return SingleNestedExpression$0(state);
|
|
1491
|
+
}
|
|
1492
|
+
}
|
|
1493
|
+
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) {
|
|
1494
|
+
var exp = $2;
|
|
1495
|
+
if (exp)
|
|
1496
|
+
return exp;
|
|
1497
|
+
return $skip;
|
|
1498
|
+
});
|
|
1499
|
+
function SingleNestedBlockStatement(state) {
|
|
1500
|
+
if (state.verbose)
|
|
1501
|
+
console.log("ENTER:", "SingleNestedBlockStatement");
|
|
1502
|
+
if (state.tokenize) {
|
|
1503
|
+
return $TOKEN("SingleNestedBlockStatement", state, SingleNestedBlockStatement$0(state));
|
|
1504
|
+
} else {
|
|
1505
|
+
return SingleNestedBlockStatement$0(state);
|
|
1455
1506
|
}
|
|
1456
1507
|
}
|
|
1457
1508
|
var NestedBlockExpressions$0 = $TS($S(PushIndent, $Q(BlockExpression), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
@@ -1481,10 +1532,10 @@ var Civet = (() => {
|
|
|
1481
1532
|
}
|
|
1482
1533
|
var Literal$0 = StringLiteral;
|
|
1483
1534
|
var Literal$1 = NumericLiteral;
|
|
1484
|
-
var Literal$2 = $EXPECT($
|
|
1485
|
-
var Literal$3 = $EXPECT($
|
|
1486
|
-
var Literal$4 = $EXPECT($
|
|
1487
|
-
var Literal$5 = $EXPECT($
|
|
1535
|
+
var Literal$2 = $EXPECT($L35, fail, 'Literal "true"');
|
|
1536
|
+
var Literal$3 = $EXPECT($L36, fail, 'Literal "false"');
|
|
1537
|
+
var Literal$4 = $EXPECT($L37, fail, 'Literal "null"');
|
|
1538
|
+
var Literal$5 = $EXPECT($L38, fail, 'Literal "undefined"');
|
|
1488
1539
|
function Literal(state) {
|
|
1489
1540
|
if (state.tokenize) {
|
|
1490
1541
|
return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state) || Literal$4(state) || Literal$5(state));
|
|
@@ -1512,7 +1563,12 @@ var Civet = (() => {
|
|
|
1512
1563
|
return Identifier$0(state);
|
|
1513
1564
|
}
|
|
1514
1565
|
}
|
|
1515
|
-
var IdentifierName$0 = $
|
|
1566
|
+
var IdentifierName$0 = $TR($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
1567
|
+
return {
|
|
1568
|
+
$loc,
|
|
1569
|
+
token: $0
|
|
1570
|
+
};
|
|
1571
|
+
});
|
|
1516
1572
|
function IdentifierName(state) {
|
|
1517
1573
|
if (state.verbose)
|
|
1518
1574
|
console.log("ENTER:", "IdentifierName");
|
|
@@ -1532,8 +1588,8 @@ var Civet = (() => {
|
|
|
1532
1588
|
return IdentifierReference$0(state);
|
|
1533
1589
|
}
|
|
1534
1590
|
}
|
|
1535
|
-
var ArrayLiteral$0 = $S($EXPECT($
|
|
1536
|
-
var ArrayLiteral$1 = $S($EXPECT($
|
|
1591
|
+
var ArrayLiteral$0 = $S($EXPECT($L25, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L26, fail, 'ArrayLiteral "]"'));
|
|
1592
|
+
var ArrayLiteral$1 = $S($EXPECT($L25, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L26, fail, 'ArrayLiteral "]"'));
|
|
1537
1593
|
function ArrayLiteral(state) {
|
|
1538
1594
|
if (state.tokenize) {
|
|
1539
1595
|
return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
|
|
@@ -1567,8 +1623,8 @@ var Civet = (() => {
|
|
|
1567
1623
|
}
|
|
1568
1624
|
}
|
|
1569
1625
|
var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
|
|
1570
|
-
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1571
|
-
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
1626
|
+
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
|
|
1627
|
+
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"'))), function(value) {
|
|
1572
1628
|
return ",";
|
|
1573
1629
|
});
|
|
1574
1630
|
var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1601,7 +1657,7 @@ var Civet = (() => {
|
|
|
1601
1657
|
return InlineElementList$0(state);
|
|
1602
1658
|
}
|
|
1603
1659
|
}
|
|
1604
|
-
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($
|
|
1660
|
+
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L32, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
|
|
1605
1661
|
function ArrayElementExpression(state) {
|
|
1606
1662
|
if (state.verbose)
|
|
1607
1663
|
console.log("ENTER:", "ArrayElementExpression");
|
|
@@ -1684,7 +1740,7 @@ var Civet = (() => {
|
|
|
1684
1740
|
}
|
|
1685
1741
|
var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L12, fail, 'PropertyDefinition ":"'), AssignmentExpression);
|
|
1686
1742
|
var PropertyDefinition$1 = MethodDefinition;
|
|
1687
|
-
var PropertyDefinition$2 = $S($EXPECT($
|
|
1743
|
+
var PropertyDefinition$2 = $S($EXPECT($L32, fail, 'PropertyDefinition "..."'), AssignmentExpression);
|
|
1688
1744
|
var PropertyDefinition$3 = IdentifierReference;
|
|
1689
1745
|
function PropertyDefinition(state) {
|
|
1690
1746
|
if (state.tokenize) {
|
|
@@ -1696,7 +1752,7 @@ var Civet = (() => {
|
|
|
1696
1752
|
var PropertyName$0 = NumericLiteral;
|
|
1697
1753
|
var PropertyName$1 = StringLiteral;
|
|
1698
1754
|
var PropertyName$2 = IdentifierName;
|
|
1699
|
-
var PropertyName$3 = $S($EXPECT($
|
|
1755
|
+
var PropertyName$3 = $S($EXPECT($L25, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L26, fail, 'PropertyName "]"'));
|
|
1700
1756
|
function PropertyName(state) {
|
|
1701
1757
|
if (state.tokenize) {
|
|
1702
1758
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -1704,8 +1760,8 @@ var Civet = (() => {
|
|
|
1704
1760
|
return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
|
|
1705
1761
|
}
|
|
1706
1762
|
}
|
|
1707
|
-
var MethodDefinition$0 = $S($EXPECT($
|
|
1708
|
-
var MethodDefinition$1 = $S($EXPECT($
|
|
1763
|
+
var MethodDefinition$0 = $S($EXPECT($L39, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1764
|
+
var MethodDefinition$1 = $S($EXPECT($L40, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1709
1765
|
var MethodDefinition$2 = AsyncGeneratorMethod;
|
|
1710
1766
|
var MethodDefinition$3 = AsyncMethod;
|
|
1711
1767
|
var MethodDefinition$4 = GeneratorMethod;
|
|
@@ -1796,22 +1852,22 @@ var Civet = (() => {
|
|
|
1796
1852
|
return AsyncGeneratorBody$0(state);
|
|
1797
1853
|
}
|
|
1798
1854
|
}
|
|
1799
|
-
var AssignmentOp$0 = $EXPECT($
|
|
1800
|
-
var AssignmentOp$1 = $EXPECT($
|
|
1801
|
-
var AssignmentOp$2 = $EXPECT($
|
|
1802
|
-
var AssignmentOp$3 = $EXPECT($
|
|
1803
|
-
var AssignmentOp$4 = $EXPECT($
|
|
1804
|
-
var AssignmentOp$5 = $EXPECT($
|
|
1805
|
-
var AssignmentOp$6 = $EXPECT($
|
|
1806
|
-
var AssignmentOp$7 = $EXPECT($
|
|
1807
|
-
var AssignmentOp$8 = $EXPECT($
|
|
1808
|
-
var AssignmentOp$9 = $EXPECT($
|
|
1809
|
-
var AssignmentOp$10 = $EXPECT($
|
|
1810
|
-
var AssignmentOp$11 = $EXPECT($
|
|
1811
|
-
var AssignmentOp$12 = $EXPECT($
|
|
1812
|
-
var AssignmentOp$13 = $EXPECT($
|
|
1813
|
-
var AssignmentOp$14 = $EXPECT($
|
|
1814
|
-
var AssignmentOp$15 = $EXPECT($
|
|
1855
|
+
var AssignmentOp$0 = $EXPECT($L41, fail, 'AssignmentOp "**="');
|
|
1856
|
+
var AssignmentOp$1 = $EXPECT($L42, fail, 'AssignmentOp "*="');
|
|
1857
|
+
var AssignmentOp$2 = $EXPECT($L43, fail, 'AssignmentOp "/="');
|
|
1858
|
+
var AssignmentOp$3 = $EXPECT($L44, fail, 'AssignmentOp "%="');
|
|
1859
|
+
var AssignmentOp$4 = $EXPECT($L45, fail, 'AssignmentOp "+="');
|
|
1860
|
+
var AssignmentOp$5 = $EXPECT($L46, fail, 'AssignmentOp "-="');
|
|
1861
|
+
var AssignmentOp$6 = $EXPECT($L47, fail, 'AssignmentOp "<<="');
|
|
1862
|
+
var AssignmentOp$7 = $EXPECT($L48, fail, 'AssignmentOp ">>>="');
|
|
1863
|
+
var AssignmentOp$8 = $EXPECT($L49, fail, 'AssignmentOp ">>="');
|
|
1864
|
+
var AssignmentOp$9 = $EXPECT($L50, fail, 'AssignmentOp "&&="');
|
|
1865
|
+
var AssignmentOp$10 = $EXPECT($L51, fail, 'AssignmentOp "&="');
|
|
1866
|
+
var AssignmentOp$11 = $EXPECT($L52, fail, 'AssignmentOp "^="');
|
|
1867
|
+
var AssignmentOp$12 = $EXPECT($L53, fail, 'AssignmentOp "||="');
|
|
1868
|
+
var AssignmentOp$13 = $EXPECT($L54, fail, 'AssignmentOp "|="');
|
|
1869
|
+
var AssignmentOp$14 = $EXPECT($L55, fail, 'AssignmentOp "??="');
|
|
1870
|
+
var AssignmentOp$15 = $EXPECT($L56, fail, 'AssignmentOp "="');
|
|
1815
1871
|
function AssignmentOp(state) {
|
|
1816
1872
|
if (state.tokenize) {
|
|
1817
1873
|
return $TOKEN("AssignmentOp", state, AssignmentOp$0(state) || AssignmentOp$1(state) || AssignmentOp$2(state) || AssignmentOp$3(state) || AssignmentOp$4(state) || AssignmentOp$5(state) || AssignmentOp$6(state) || AssignmentOp$7(state) || AssignmentOp$8(state) || AssignmentOp$9(state) || AssignmentOp$10(state) || AssignmentOp$11(state) || AssignmentOp$12(state) || AssignmentOp$13(state) || AssignmentOp$14(state) || AssignmentOp$15(state));
|
|
@@ -1819,48 +1875,48 @@ var Civet = (() => {
|
|
|
1819
1875
|
return AssignmentOp$0(state) || AssignmentOp$1(state) || AssignmentOp$2(state) || AssignmentOp$3(state) || AssignmentOp$4(state) || AssignmentOp$5(state) || AssignmentOp$6(state) || AssignmentOp$7(state) || AssignmentOp$8(state) || AssignmentOp$9(state) || AssignmentOp$10(state) || AssignmentOp$11(state) || AssignmentOp$12(state) || AssignmentOp$13(state) || AssignmentOp$14(state) || AssignmentOp$15(state);
|
|
1820
1876
|
}
|
|
1821
1877
|
}
|
|
1822
|
-
var BinaryOp$0 = $EXPECT($
|
|
1878
|
+
var BinaryOp$0 = $EXPECT($L57, fail, 'BinaryOp "**"');
|
|
1823
1879
|
var BinaryOp$1 = $EXPECT($L9, fail, 'BinaryOp "*"');
|
|
1824
|
-
var BinaryOp$2 = $EXPECT($
|
|
1825
|
-
var BinaryOp$3 = $EXPECT($
|
|
1826
|
-
var BinaryOp$4 = $EXPECT($
|
|
1827
|
-
var BinaryOp$5 = $EXPECT($
|
|
1828
|
-
var BinaryOp$6 = $EXPECT($
|
|
1829
|
-
var BinaryOp$7 = $EXPECT($
|
|
1830
|
-
var BinaryOp$8 = $EXPECT($
|
|
1880
|
+
var BinaryOp$2 = $EXPECT($L58, fail, 'BinaryOp "/"');
|
|
1881
|
+
var BinaryOp$3 = $EXPECT($L59, fail, 'BinaryOp "%"');
|
|
1882
|
+
var BinaryOp$4 = $EXPECT($L60, fail, 'BinaryOp "+"');
|
|
1883
|
+
var BinaryOp$5 = $EXPECT($L61, fail, 'BinaryOp "-"');
|
|
1884
|
+
var BinaryOp$6 = $EXPECT($L62, fail, 'BinaryOp "<="');
|
|
1885
|
+
var BinaryOp$7 = $EXPECT($L63, fail, 'BinaryOp ">="');
|
|
1886
|
+
var BinaryOp$8 = $EXPECT($L64, fail, 'BinaryOp "<<"');
|
|
1831
1887
|
var BinaryOp$9 = $EXPECT($L14, fail, 'BinaryOp "<"');
|
|
1832
|
-
var BinaryOp$10 = $EXPECT($
|
|
1833
|
-
var BinaryOp$11 = $EXPECT($
|
|
1834
|
-
var BinaryOp$12 = $EXPECT($
|
|
1835
|
-
var BinaryOp$13 = $EXPECT($
|
|
1836
|
-
var BinaryOp$14 = $TV($EXPECT($
|
|
1888
|
+
var BinaryOp$10 = $EXPECT($L65, fail, 'BinaryOp ">>>"');
|
|
1889
|
+
var BinaryOp$11 = $EXPECT($L66, fail, 'BinaryOp ">>"');
|
|
1890
|
+
var BinaryOp$12 = $EXPECT($L67, fail, 'BinaryOp ">"');
|
|
1891
|
+
var BinaryOp$13 = $EXPECT($L68, fail, 'BinaryOp "!=="');
|
|
1892
|
+
var BinaryOp$14 = $TV($EXPECT($L69, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
|
|
1837
1893
|
if (global.coffeeCompat)
|
|
1838
1894
|
return "!==";
|
|
1839
1895
|
return $1;
|
|
1840
1896
|
});
|
|
1841
|
-
var BinaryOp$15 = $T($S($EXPECT($
|
|
1897
|
+
var BinaryOp$15 = $T($S($EXPECT($L70, fail, 'BinaryOp "is"'), NonIdContinue), function(value) {
|
|
1842
1898
|
return "===";
|
|
1843
1899
|
});
|
|
1844
|
-
var BinaryOp$16 = $EXPECT($
|
|
1845
|
-
var BinaryOp$17 = $TV($EXPECT($
|
|
1900
|
+
var BinaryOp$16 = $EXPECT($L71, fail, 'BinaryOp "==="');
|
|
1901
|
+
var BinaryOp$17 = $TV($EXPECT($L72, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
|
|
1846
1902
|
if (global.coffeeCompat)
|
|
1847
1903
|
return "===";
|
|
1848
1904
|
return $1;
|
|
1849
1905
|
});
|
|
1850
|
-
var BinaryOp$18 = $T($S($EXPECT($
|
|
1906
|
+
var BinaryOp$18 = $T($S($EXPECT($L73, fail, 'BinaryOp "and"'), NonIdContinue), function(value) {
|
|
1851
1907
|
return "&&";
|
|
1852
1908
|
});
|
|
1853
|
-
var BinaryOp$19 = $EXPECT($
|
|
1854
|
-
var BinaryOp$20 = $T($S($EXPECT($
|
|
1909
|
+
var BinaryOp$19 = $EXPECT($L74, fail, 'BinaryOp "&&"');
|
|
1910
|
+
var BinaryOp$20 = $T($S($EXPECT($L75, fail, 'BinaryOp "or"'), NonIdContinue), function(value) {
|
|
1855
1911
|
return "||";
|
|
1856
1912
|
});
|
|
1857
|
-
var BinaryOp$21 = $EXPECT($
|
|
1858
|
-
var BinaryOp$22 = $EXPECT($
|
|
1859
|
-
var BinaryOp$23 = $S($EXPECT($
|
|
1860
|
-
var BinaryOp$24 = $S($EXPECT($
|
|
1861
|
-
var BinaryOp$25 = $EXPECT($
|
|
1862
|
-
var BinaryOp$26 = $EXPECT($
|
|
1863
|
-
var BinaryOp$27 = $EXPECT($
|
|
1913
|
+
var BinaryOp$21 = $EXPECT($L76, fail, 'BinaryOp "||"');
|
|
1914
|
+
var BinaryOp$22 = $EXPECT($L77, fail, 'BinaryOp "??"');
|
|
1915
|
+
var BinaryOp$23 = $S($EXPECT($L78, fail, 'BinaryOp "instanceof"'), NonIdContinue);
|
|
1916
|
+
var BinaryOp$24 = $S($EXPECT($L79, fail, 'BinaryOp "in"'), NonIdContinue);
|
|
1917
|
+
var BinaryOp$25 = $EXPECT($L80, fail, 'BinaryOp "&"');
|
|
1918
|
+
var BinaryOp$26 = $EXPECT($L81, fail, 'BinaryOp "^"');
|
|
1919
|
+
var BinaryOp$27 = $EXPECT($L82, fail, 'BinaryOp "|"');
|
|
1864
1920
|
function BinaryOp(state) {
|
|
1865
1921
|
if (state.tokenize) {
|
|
1866
1922
|
return $TOKEN("BinaryOp", state, BinaryOp$0(state) || BinaryOp$1(state) || BinaryOp$2(state) || BinaryOp$3(state) || BinaryOp$4(state) || BinaryOp$5(state) || BinaryOp$6(state) || BinaryOp$7(state) || BinaryOp$8(state) || BinaryOp$9(state) || BinaryOp$10(state) || BinaryOp$11(state) || BinaryOp$12(state) || BinaryOp$13(state) || BinaryOp$14(state) || BinaryOp$15(state) || BinaryOp$16(state) || BinaryOp$17(state) || BinaryOp$18(state) || BinaryOp$19(state) || BinaryOp$20(state) || BinaryOp$21(state) || BinaryOp$22(state) || BinaryOp$23(state) || BinaryOp$24(state) || BinaryOp$25(state) || BinaryOp$26(state) || BinaryOp$27(state));
|
|
@@ -1869,7 +1925,7 @@ var Civet = (() => {
|
|
|
1869
1925
|
}
|
|
1870
1926
|
}
|
|
1871
1927
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
1872
|
-
var UnaryOp$1 = $S($C($EXPECT($
|
|
1928
|
+
var UnaryOp$1 = $S($C($EXPECT($L83, fail, 'UnaryOp "delete"'), $EXPECT($L84, fail, 'UnaryOp "void"'), $EXPECT($L85, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
|
|
1873
1929
|
function UnaryOp(state) {
|
|
1874
1930
|
if (state.tokenize) {
|
|
1875
1931
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -1903,7 +1959,7 @@ var Civet = (() => {
|
|
|
1903
1959
|
return StatementListItem$0(state);
|
|
1904
1960
|
}
|
|
1905
1961
|
}
|
|
1906
|
-
var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($
|
|
1962
|
+
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) {
|
|
1907
1963
|
var ws = $1;
|
|
1908
1964
|
var cond = $2;
|
|
1909
1965
|
var exp = $4;
|
|
@@ -1936,7 +1992,7 @@ var Civet = (() => {
|
|
|
1936
1992
|
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);
|
|
1937
1993
|
}
|
|
1938
1994
|
}
|
|
1939
|
-
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($
|
|
1995
|
+
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L88, fail, 'EmptyStatement ";"')));
|
|
1940
1996
|
function EmptyStatement(state) {
|
|
1941
1997
|
if (state.verbose)
|
|
1942
1998
|
console.log("ENTER:", "EmptyStatement");
|
|
@@ -1956,8 +2012,8 @@ var Civet = (() => {
|
|
|
1956
2012
|
return BlockStatement$0(state);
|
|
1957
2013
|
}
|
|
1958
2014
|
}
|
|
1959
|
-
var IfStatement$0 = $S($EXPECT($
|
|
1960
|
-
var IfStatement$1 = $TS($S($EXPECT($
|
|
2015
|
+
var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L89, fail, 'IfStatement "else"'), Block)));
|
|
2016
|
+
var IfStatement$1 = $TS($S($EXPECT($L87, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
|
|
1961
2017
|
var condition = $2;
|
|
1962
2018
|
var block = $3;
|
|
1963
2019
|
return ["if", condition.map((c) => {
|
|
@@ -1987,7 +2043,7 @@ var Civet = (() => {
|
|
|
1987
2043
|
return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
|
|
1988
2044
|
}
|
|
1989
2045
|
}
|
|
1990
|
-
var LoopStatement$0 = $TS($S($EXPECT($
|
|
2046
|
+
var LoopStatement$0 = $TS($S($EXPECT($L90, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
|
|
1991
2047
|
var b = $3;
|
|
1992
2048
|
return ["while(true)", b];
|
|
1993
2049
|
});
|
|
@@ -2000,7 +2056,7 @@ var Civet = (() => {
|
|
|
2000
2056
|
return LoopStatement$0(state);
|
|
2001
2057
|
}
|
|
2002
2058
|
}
|
|
2003
|
-
var DoWhileStatement$0 = $S($EXPECT($
|
|
2059
|
+
var DoWhileStatement$0 = $S($EXPECT($L91, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
|
|
2004
2060
|
function DoWhileStatement(state) {
|
|
2005
2061
|
if (state.verbose)
|
|
2006
2062
|
console.log("ENTER:", "DoWhileStatement");
|
|
@@ -2010,7 +2066,7 @@ var Civet = (() => {
|
|
|
2010
2066
|
return DoWhileStatement$0(state);
|
|
2011
2067
|
}
|
|
2012
2068
|
}
|
|
2013
|
-
var WhileStatement$0 = $S(
|
|
2069
|
+
var WhileStatement$0 = $S(WhileClause, Block);
|
|
2014
2070
|
function WhileStatement(state) {
|
|
2015
2071
|
if (state.verbose)
|
|
2016
2072
|
console.log("ENTER:", "WhileStatement");
|
|
@@ -2020,7 +2076,26 @@ var Civet = (() => {
|
|
|
2020
2076
|
return WhileStatement$0(state);
|
|
2021
2077
|
}
|
|
2022
2078
|
}
|
|
2023
|
-
var
|
|
2079
|
+
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) {
|
|
2080
|
+
var kind = $1;
|
|
2081
|
+
var cond = $3;
|
|
2082
|
+
if (kind === "until") {
|
|
2083
|
+
cond[1] = "(!(";
|
|
2084
|
+
cond[5] = "))";
|
|
2085
|
+
return ["while", cond];
|
|
2086
|
+
}
|
|
2087
|
+
return $0;
|
|
2088
|
+
});
|
|
2089
|
+
function WhileClause(state) {
|
|
2090
|
+
if (state.verbose)
|
|
2091
|
+
console.log("ENTER:", "WhileClause");
|
|
2092
|
+
if (state.tokenize) {
|
|
2093
|
+
return $TOKEN("WhileClause", state, WhileClause$0(state));
|
|
2094
|
+
} else {
|
|
2095
|
+
return WhileClause$0(state);
|
|
2096
|
+
}
|
|
2097
|
+
}
|
|
2098
|
+
var ForStatement$0 = $S($EXPECT($L94, fail, 'ForStatement "for"'), NonIdContinue, __, $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);
|
|
2024
2099
|
function ForStatement(state) {
|
|
2025
2100
|
if (state.verbose)
|
|
2026
2101
|
console.log("ENTER:", "ForStatement");
|
|
@@ -2030,10 +2105,10 @@ var Civet = (() => {
|
|
|
2030
2105
|
return ForStatement$0(state);
|
|
2031
2106
|
}
|
|
2032
2107
|
}
|
|
2033
|
-
var ForInOfStatement$0 = $S($EXPECT($
|
|
2034
|
-
var ForInOfStatement$1 = $S($EXPECT($
|
|
2035
|
-
var ForInOfStatement$2 = $S($EXPECT($
|
|
2036
|
-
var ForInOfStatement$3 = $S($EXPECT($
|
|
2108
|
+
var ForInOfStatement$0 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
|
|
2109
|
+
var ForInOfStatement$1 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, __, InsertOpenParen, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
|
|
2110
|
+
var ForInOfStatement$2 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, $E($S(__, $EXPECT($L96, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L97, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
|
|
2111
|
+
var ForInOfStatement$3 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, $E($S(__, $EXPECT($L96, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L97, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
|
|
2037
2112
|
function ForInOfStatement(state) {
|
|
2038
2113
|
if (state.tokenize) {
|
|
2039
2114
|
return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
|
|
@@ -2041,7 +2116,7 @@ var Civet = (() => {
|
|
|
2041
2116
|
return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
|
|
2042
2117
|
}
|
|
2043
2118
|
}
|
|
2044
|
-
var ForDeclaration$0 = $S($C($EXPECT($
|
|
2119
|
+
var ForDeclaration$0 = $S($C($EXPECT($L98, fail, 'ForDeclaration "let"'), $EXPECT($L99, fail, 'ForDeclaration "const"')), NonIdContinue, __, ForBinding);
|
|
2045
2120
|
function ForDeclaration(state) {
|
|
2046
2121
|
if (state.verbose)
|
|
2047
2122
|
console.log("ENTER:", "ForDeclaration");
|
|
@@ -2060,7 +2135,7 @@ var Civet = (() => {
|
|
|
2060
2135
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
2061
2136
|
}
|
|
2062
2137
|
}
|
|
2063
|
-
var SwitchStatement$0 = $S($EXPECT($
|
|
2138
|
+
var SwitchStatement$0 = $S($EXPECT($L100, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
|
|
2064
2139
|
function SwitchStatement(state) {
|
|
2065
2140
|
if (state.verbose)
|
|
2066
2141
|
console.log("ENTER:", "SwitchStatement");
|
|
@@ -2104,9 +2179,9 @@ var Civet = (() => {
|
|
|
2104
2179
|
return NestedCaseClause$0(state);
|
|
2105
2180
|
}
|
|
2106
2181
|
}
|
|
2107
|
-
var CaseClause$0 = $S($EXPECT($
|
|
2182
|
+
var CaseClause$0 = $S($EXPECT($L101, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
|
|
2108
2183
|
var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
|
|
2109
|
-
var CaseClause$2 = $S($EXPECT($
|
|
2184
|
+
var CaseClause$2 = $S($EXPECT($L102, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
|
|
2110
2185
|
function CaseClause(state) {
|
|
2111
2186
|
if (state.tokenize) {
|
|
2112
2187
|
return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
|
|
@@ -2114,7 +2189,7 @@ var Civet = (() => {
|
|
|
2114
2189
|
return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
|
|
2115
2190
|
}
|
|
2116
2191
|
}
|
|
2117
|
-
var When$0 = $T($S($EXPECT($
|
|
2192
|
+
var When$0 = $T($S($EXPECT($L103, fail, 'When "when"'), NonIdContinue), function(value) {
|
|
2118
2193
|
return "case";
|
|
2119
2194
|
});
|
|
2120
2195
|
function When(state) {
|
|
@@ -2127,7 +2202,7 @@ var Civet = (() => {
|
|
|
2127
2202
|
}
|
|
2128
2203
|
}
|
|
2129
2204
|
var ImpliedColon$0 = $S(__, $EXPECT($L12, fail, 'ImpliedColon ":"'));
|
|
2130
|
-
var ImpliedColon$1 = $T($EXPECT($
|
|
2205
|
+
var ImpliedColon$1 = $T($EXPECT($L31, fail, 'ImpliedColon ""'), function(value) {
|
|
2131
2206
|
return ":";
|
|
2132
2207
|
});
|
|
2133
2208
|
function ImpliedColon(state) {
|
|
@@ -2137,7 +2212,7 @@ var Civet = (() => {
|
|
|
2137
2212
|
return ImpliedColon$0(state) || ImpliedColon$1(state);
|
|
2138
2213
|
}
|
|
2139
2214
|
}
|
|
2140
|
-
var TryStatement$0 = $TS($S($EXPECT($
|
|
2215
|
+
var TryStatement$0 = $TS($S($EXPECT($L104, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2141
2216
|
var c = $3;
|
|
2142
2217
|
var f = $4;
|
|
2143
2218
|
if (!c && !f) {
|
|
@@ -2154,7 +2229,7 @@ var Civet = (() => {
|
|
|
2154
2229
|
return TryStatement$0(state);
|
|
2155
2230
|
}
|
|
2156
2231
|
}
|
|
2157
|
-
var Catch$0 = $S(__, $EXPECT($
|
|
2232
|
+
var Catch$0 = $S(__, $EXPECT($L105, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
|
|
2158
2233
|
function Catch(state) {
|
|
2159
2234
|
if (state.verbose)
|
|
2160
2235
|
console.log("ENTER:", "Catch");
|
|
@@ -2173,7 +2248,7 @@ var Civet = (() => {
|
|
|
2173
2248
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2174
2249
|
}
|
|
2175
2250
|
}
|
|
2176
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2251
|
+
var Finally$0 = $S(__, $EXPECT($L106, fail, 'Finally "finally"'), BracedBlock);
|
|
2177
2252
|
function Finally(state) {
|
|
2178
2253
|
if (state.verbose)
|
|
2179
2254
|
console.log("ENTER:", "Finally");
|
|
@@ -2211,20 +2286,38 @@ var Civet = (() => {
|
|
|
2211
2286
|
return ExpressionStatement$0(state);
|
|
2212
2287
|
}
|
|
2213
2288
|
}
|
|
2214
|
-
var KeywordStatement$0 = $S($EXPECT($
|
|
2215
|
-
var KeywordStatement$1 = $S($EXPECT($
|
|
2216
|
-
var KeywordStatement$2 = $S($EXPECT($
|
|
2217
|
-
var KeywordStatement$3 = $S($
|
|
2218
|
-
var KeywordStatement$4 = $S($EXPECT($
|
|
2219
|
-
var KeywordStatement$5 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
|
|
2289
|
+
var KeywordStatement$0 = $S($EXPECT($L107, fail, 'KeywordStatement "break"'), NonIdContinue);
|
|
2290
|
+
var KeywordStatement$1 = $S($EXPECT($L108, fail, 'KeywordStatement "continue"'), NonIdContinue);
|
|
2291
|
+
var KeywordStatement$2 = $S($EXPECT($L109, fail, 'KeywordStatement "debugger"'), NonIdContinue);
|
|
2292
|
+
var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
|
|
2293
|
+
var KeywordStatement$4 = $S($EXPECT($L110, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
|
|
2220
2294
|
function KeywordStatement(state) {
|
|
2221
2295
|
if (state.tokenize) {
|
|
2222
|
-
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state)
|
|
2296
|
+
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
|
|
2297
|
+
} else {
|
|
2298
|
+
return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state);
|
|
2299
|
+
}
|
|
2300
|
+
}
|
|
2301
|
+
var MaybeNestedExpression$0 = $S($N(EOS), $Q(TrailingComment), Expression);
|
|
2302
|
+
var MaybeNestedExpression$1 = $S($Y(EOS), ObjectLiteral);
|
|
2303
|
+
function MaybeNestedExpression(state) {
|
|
2304
|
+
if (state.tokenize) {
|
|
2305
|
+
return $TOKEN("MaybeNestedExpression", state, MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state));
|
|
2223
2306
|
} else {
|
|
2224
|
-
return
|
|
2307
|
+
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2225
2308
|
}
|
|
2226
2309
|
}
|
|
2227
|
-
var
|
|
2310
|
+
var Return$0 = $S($EXPECT($L111, fail, 'Return "return"'), NonIdContinue);
|
|
2311
|
+
function Return(state) {
|
|
2312
|
+
if (state.verbose)
|
|
2313
|
+
console.log("ENTER:", "Return");
|
|
2314
|
+
if (state.tokenize) {
|
|
2315
|
+
return $TOKEN("Return", state, Return$0(state));
|
|
2316
|
+
} else {
|
|
2317
|
+
return Return$0(state);
|
|
2318
|
+
}
|
|
2319
|
+
}
|
|
2320
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L112, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2228
2321
|
return { "ts": true, "children": value };
|
|
2229
2322
|
});
|
|
2230
2323
|
var ImportDeclaration$1 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), NonIdContinue, __, ImportClause, __, FromClause);
|
|
@@ -2266,7 +2359,7 @@ var Civet = (() => {
|
|
|
2266
2359
|
return NamedImports$0(state);
|
|
2267
2360
|
}
|
|
2268
2361
|
}
|
|
2269
|
-
var FromClause$0 = $S($EXPECT($
|
|
2362
|
+
var FromClause$0 = $S($EXPECT($L113, fail, 'FromClause "from"'), NonIdContinue, __, ModuleSpecifier);
|
|
2270
2363
|
function FromClause(state) {
|
|
2271
2364
|
if (state.verbose)
|
|
2272
2365
|
console.log("ENTER:", "FromClause");
|
|
@@ -2314,7 +2407,7 @@ var Civet = (() => {
|
|
|
2314
2407
|
return ImportedBinding$0(state);
|
|
2315
2408
|
}
|
|
2316
2409
|
}
|
|
2317
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
2410
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L102, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2318
2411
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
2319
2412
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
2320
2413
|
function ExportDeclaration(state) {
|
|
@@ -2334,7 +2427,7 @@ var Civet = (() => {
|
|
|
2334
2427
|
return As$0(state);
|
|
2335
2428
|
}
|
|
2336
2429
|
}
|
|
2337
|
-
var Export$0 = $S($EXPECT($
|
|
2430
|
+
var Export$0 = $S($EXPECT($L114, fail, 'Export "export"'), NonIdContinue);
|
|
2338
2431
|
function Export(state) {
|
|
2339
2432
|
if (state.verbose)
|
|
2340
2433
|
console.log("ENTER:", "Export");
|
|
@@ -2394,13 +2487,22 @@ var Civet = (() => {
|
|
|
2394
2487
|
return HoistableDeclaration$0(state);
|
|
2395
2488
|
}
|
|
2396
2489
|
}
|
|
2397
|
-
var LexicalDeclaration$0 = $S($C($EXPECT($
|
|
2398
|
-
var LexicalDeclaration$1 = $
|
|
2399
|
-
var bind =
|
|
2400
|
-
var suffix =
|
|
2401
|
-
var ws =
|
|
2402
|
-
var
|
|
2403
|
-
|
|
2490
|
+
var LexicalDeclaration$0 = $S($C($EXPECT($L98, fail, 'LexicalDeclaration "let"'), $EXPECT($L99, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
|
|
2491
|
+
var LexicalDeclaration$1 = $TS($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
2492
|
+
var bind = $1;
|
|
2493
|
+
var suffix = $2;
|
|
2494
|
+
var ws = $3;
|
|
2495
|
+
var ca = $4;
|
|
2496
|
+
var exp = $5;
|
|
2497
|
+
return [
|
|
2498
|
+
{ token: "const", $loc: ca.$loc },
|
|
2499
|
+
" ",
|
|
2500
|
+
bind,
|
|
2501
|
+
suffix,
|
|
2502
|
+
ws,
|
|
2503
|
+
{ token: "=", $loc: ca.$loc },
|
|
2504
|
+
exp
|
|
2505
|
+
];
|
|
2404
2506
|
});
|
|
2405
2507
|
function LexicalDeclaration(state) {
|
|
2406
2508
|
if (state.tokenize) {
|
|
@@ -2409,6 +2511,18 @@ var Civet = (() => {
|
|
|
2409
2511
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
2410
2512
|
}
|
|
2411
2513
|
}
|
|
2514
|
+
var ConstAssignment$0 = $TV($EXPECT($L115, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
2515
|
+
return { $loc, token: $0 };
|
|
2516
|
+
});
|
|
2517
|
+
function ConstAssignment(state) {
|
|
2518
|
+
if (state.verbose)
|
|
2519
|
+
console.log("ENTER:", "ConstAssignment");
|
|
2520
|
+
if (state.tokenize) {
|
|
2521
|
+
return $TOKEN("ConstAssignment", state, ConstAssignment$0(state));
|
|
2522
|
+
} else {
|
|
2523
|
+
return ConstAssignment$0(state);
|
|
2524
|
+
}
|
|
2525
|
+
}
|
|
2412
2526
|
var LexicalBinding$0 = $S(BindingPattern, $E(TypeSuffix), Initializer);
|
|
2413
2527
|
var LexicalBinding$1 = $S(BindingIdentifier, $E(TypeSuffix), $E(Initializer));
|
|
2414
2528
|
function LexicalBinding(state) {
|
|
@@ -2418,7 +2532,7 @@ var Civet = (() => {
|
|
|
2418
2532
|
return LexicalBinding$0(state) || LexicalBinding$1(state);
|
|
2419
2533
|
}
|
|
2420
2534
|
}
|
|
2421
|
-
var Initializer$0 = $S(__, $EXPECT($
|
|
2535
|
+
var Initializer$0 = $S(__, $EXPECT($L56, fail, 'Initializer "="'), AssignmentExpression);
|
|
2422
2536
|
function Initializer(state) {
|
|
2423
2537
|
if (state.verbose)
|
|
2424
2538
|
console.log("ENTER:", "Initializer");
|
|
@@ -2428,7 +2542,7 @@ var Civet = (() => {
|
|
|
2428
2542
|
return Initializer$0(state);
|
|
2429
2543
|
}
|
|
2430
2544
|
}
|
|
2431
|
-
var VariableStatement$0 = $S($EXPECT($
|
|
2545
|
+
var VariableStatement$0 = $S($EXPECT($L95, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
|
|
2432
2546
|
function VariableStatement(state) {
|
|
2433
2547
|
if (state.verbose)
|
|
2434
2548
|
console.log("ENTER:", "VariableStatement");
|
|
@@ -2519,11 +2633,11 @@ var Civet = (() => {
|
|
|
2519
2633
|
return HexLiteral$0(state);
|
|
2520
2634
|
}
|
|
2521
2635
|
}
|
|
2522
|
-
var StringLiteral$0 = $T($S($EXPECT($
|
|
2636
|
+
var StringLiteral$0 = $T($S($EXPECT($L116, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L116, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function(value) {
|
|
2523
2637
|
return ["`", value[1], "`"];
|
|
2524
2638
|
});
|
|
2525
|
-
var StringLiteral$1 = $S($EXPECT($
|
|
2526
|
-
var StringLiteral$2 = $S($EXPECT($
|
|
2639
|
+
var StringLiteral$1 = $S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'));
|
|
2640
|
+
var StringLiteral$2 = $S($EXPECT($L118, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L118, fail, `StringLiteral "\\\\'"`));
|
|
2527
2641
|
function StringLiteral(state) {
|
|
2528
2642
|
if (state.tokenize) {
|
|
2529
2643
|
return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state));
|
|
@@ -2559,7 +2673,7 @@ var Civet = (() => {
|
|
|
2559
2673
|
return TripleDoubleStringCharacter$0(state);
|
|
2560
2674
|
}
|
|
2561
2675
|
}
|
|
2562
|
-
var EscapeSequence$0 = $TEXT($S($EXPECT($
|
|
2676
|
+
var EscapeSequence$0 = $TEXT($S($EXPECT($L119, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R11, fail, "EscapeSequence /./")));
|
|
2563
2677
|
function EscapeSequence(state) {
|
|
2564
2678
|
if (state.verbose)
|
|
2565
2679
|
console.log("ENTER:", "EscapeSequence");
|
|
@@ -2569,7 +2683,7 @@ var Civet = (() => {
|
|
|
2569
2683
|
return EscapeSequence$0(state);
|
|
2570
2684
|
}
|
|
2571
2685
|
}
|
|
2572
|
-
var RegularExpressionLiteral$0 = $S($EXPECT($
|
|
2686
|
+
var RegularExpressionLiteral$0 = $S($EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
|
|
2573
2687
|
function RegularExpressionLiteral(state) {
|
|
2574
2688
|
if (state.verbose)
|
|
2575
2689
|
console.log("ENTER:", "RegularExpressionLiteral");
|
|
@@ -2608,7 +2722,7 @@ var Civet = (() => {
|
|
|
2608
2722
|
return RegularExpressionFlags$0(state);
|
|
2609
2723
|
}
|
|
2610
2724
|
}
|
|
2611
|
-
var TemplateLiteral$0 = $S($EXPECT($
|
|
2725
|
+
var TemplateLiteral$0 = $S($EXPECT($L120, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L120, fail, 'TemplateLiteral "`"'));
|
|
2612
2726
|
function TemplateLiteral(state) {
|
|
2613
2727
|
if (state.verbose)
|
|
2614
2728
|
console.log("ENTER:", "TemplateLiteral");
|
|
@@ -2618,7 +2732,7 @@ var Civet = (() => {
|
|
|
2618
2732
|
return TemplateLiteral$0(state);
|
|
2619
2733
|
}
|
|
2620
2734
|
}
|
|
2621
|
-
var TemplateSubstitution$0 = $S($EXPECT($
|
|
2735
|
+
var TemplateSubstitution$0 = $S($EXPECT($L121, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
|
|
2622
2736
|
function TemplateSubstitution(state) {
|
|
2623
2737
|
if (state.verbose)
|
|
2624
2738
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -2675,7 +2789,7 @@ var Civet = (() => {
|
|
|
2675
2789
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
2676
2790
|
}
|
|
2677
2791
|
}
|
|
2678
|
-
var JSMultiLineComment$0 = $S($EXPECT($
|
|
2792
|
+
var JSMultiLineComment$0 = $S($EXPECT($L122, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'JSMultiLineComment "*/"')), $EXPECT($R11, fail, "JSMultiLineComment /./")))), $EXPECT($L123, fail, 'JSMultiLineComment "*/"'));
|
|
2679
2793
|
function JSMultiLineComment(state) {
|
|
2680
2794
|
if (state.verbose)
|
|
2681
2795
|
console.log("ENTER:", "JSMultiLineComment");
|
|
@@ -2699,7 +2813,7 @@ var Civet = (() => {
|
|
|
2699
2813
|
return CoffeeSingleLineComment$0(state);
|
|
2700
2814
|
}
|
|
2701
2815
|
}
|
|
2702
|
-
var CoffeeMultiLineComment$0 = $T($S($EXPECT($
|
|
2816
|
+
var CoffeeMultiLineComment$0 = $T($S($EXPECT($L124, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L124, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R11, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L124, fail, 'CoffeeMultiLineComment "###"')), function(value) {
|
|
2703
2817
|
return ["/*", value[1], "*/"];
|
|
2704
2818
|
});
|
|
2705
2819
|
function CoffeeMultiLineComment(state) {
|
|
@@ -2711,7 +2825,7 @@ var Civet = (() => {
|
|
|
2711
2825
|
return CoffeeMultiLineComment$0(state);
|
|
2712
2826
|
}
|
|
2713
2827
|
}
|
|
2714
|
-
var InlineComment$0 = $S($EXPECT($
|
|
2828
|
+
var InlineComment$0 = $S($EXPECT($L122, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'InlineComment "*/"')), $EXPECT($R19, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L123, fail, 'InlineComment "*/"'));
|
|
2715
2829
|
function InlineComment(state) {
|
|
2716
2830
|
if (state.verbose)
|
|
2717
2831
|
console.log("ENTER:", "InlineComment");
|
|
@@ -2761,7 +2875,7 @@ var Civet = (() => {
|
|
|
2761
2875
|
return __$0(state);
|
|
2762
2876
|
}
|
|
2763
2877
|
}
|
|
2764
|
-
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($
|
|
2878
|
+
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L88, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
|
|
2765
2879
|
var StatementDelimiter$1 = $T($Y(EOS), function(value) {
|
|
2766
2880
|
return [";", value];
|
|
2767
2881
|
});
|
|
@@ -2796,7 +2910,7 @@ var Civet = (() => {
|
|
|
2796
2910
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
2797
2911
|
}
|
|
2798
2912
|
}
|
|
2799
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
2913
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L125, fail, 'JSXSelfClosingElement "/>"'));
|
|
2800
2914
|
function JSXSelfClosingElement(state) {
|
|
2801
2915
|
if (state.verbose)
|
|
2802
2916
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -2806,7 +2920,7 @@ var Civet = (() => {
|
|
|
2806
2920
|
return JSXSelfClosingElement$0(state);
|
|
2807
2921
|
}
|
|
2808
2922
|
}
|
|
2809
|
-
var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
2923
|
+
var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L67, fail, 'JSXOpeningElement ">"'));
|
|
2810
2924
|
function JSXOpeningElement(state) {
|
|
2811
2925
|
if (state.verbose)
|
|
2812
2926
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -2816,7 +2930,7 @@ var Civet = (() => {
|
|
|
2816
2930
|
return JSXOpeningElement$0(state);
|
|
2817
2931
|
}
|
|
2818
2932
|
}
|
|
2819
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
2933
|
+
var JSXClosingElement$0 = $S($EXPECT($L126, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L67, fail, 'JSXClosingElement ">"'));
|
|
2820
2934
|
function JSXClosingElement(state) {
|
|
2821
2935
|
if (state.verbose)
|
|
2822
2936
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -2826,7 +2940,7 @@ var Civet = (() => {
|
|
|
2826
2940
|
return JSXClosingElement$0(state);
|
|
2827
2941
|
}
|
|
2828
2942
|
}
|
|
2829
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
2943
|
+
var JSXFragment$0 = $S($EXPECT($L127, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L128, fail, 'JSXFragment "</>"'));
|
|
2830
2944
|
function JSXFragment(state) {
|
|
2831
2945
|
if (state.verbose)
|
|
2832
2946
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -2836,7 +2950,7 @@ var Civet = (() => {
|
|
|
2836
2950
|
return JSXFragment$0(state);
|
|
2837
2951
|
}
|
|
2838
2952
|
}
|
|
2839
|
-
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($
|
|
2953
|
+
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L24, fail, 'JSXElementName "."'), JSXIdentifierName))));
|
|
2840
2954
|
function JSXElementName(state) {
|
|
2841
2955
|
if (state.verbose)
|
|
2842
2956
|
console.log("ENTER:", "JSXElementName");
|
|
@@ -2866,7 +2980,7 @@ var Civet = (() => {
|
|
|
2866
2980
|
return JSXAttributes$0(state);
|
|
2867
2981
|
}
|
|
2868
2982
|
}
|
|
2869
|
-
var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($
|
|
2983
|
+
var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($L32, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttribute "}"'));
|
|
2870
2984
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
2871
2985
|
function JSXAttribute(state) {
|
|
2872
2986
|
if (state.tokenize) {
|
|
@@ -2885,7 +2999,7 @@ var Civet = (() => {
|
|
|
2885
2999
|
return JSXAttributeName$0(state);
|
|
2886
3000
|
}
|
|
2887
3001
|
}
|
|
2888
|
-
var JSXAttributeInitializer$0 = $S(__, $EXPECT($
|
|
3002
|
+
var JSXAttributeInitializer$0 = $S(__, $EXPECT($L56, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
|
|
2889
3003
|
function JSXAttributeInitializer(state) {
|
|
2890
3004
|
if (state.verbose)
|
|
2891
3005
|
console.log("ENTER:", "JSXAttributeInitializer");
|
|
@@ -2938,7 +3052,7 @@ var Civet = (() => {
|
|
|
2938
3052
|
return JSXText$0(state);
|
|
2939
3053
|
}
|
|
2940
3054
|
}
|
|
2941
|
-
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($
|
|
3055
|
+
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L32, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
|
|
2942
3056
|
function JSXChildExpression(state) {
|
|
2943
3057
|
if (state.verbose)
|
|
2944
3058
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -2948,7 +3062,7 @@ var Civet = (() => {
|
|
|
2948
3062
|
return JSXChildExpression$0(state);
|
|
2949
3063
|
}
|
|
2950
3064
|
}
|
|
2951
|
-
var TypeDeclaration$0 = $T($S($EXPECT($R27, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($
|
|
3065
|
+
var TypeDeclaration$0 = $T($S($EXPECT($R27, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L56, fail, 'TypeDeclaration "="'), __, Type), function(value) {
|
|
2952
3066
|
return { "ts": true, "children": value };
|
|
2953
3067
|
});
|
|
2954
3068
|
var TypeDeclaration$1 = $T($S($EXPECT($R28, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
|
|
@@ -3006,7 +3120,7 @@ var Civet = (() => {
|
|
|
3006
3120
|
return InterfaceProperty$0(state);
|
|
3007
3121
|
}
|
|
3008
3122
|
}
|
|
3009
|
-
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($
|
|
3123
|
+
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L88, fail, 'InterfacePropertyDelimiter ";"'));
|
|
3010
3124
|
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
|
|
3011
3125
|
var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
|
|
3012
3126
|
return ";";
|
|
@@ -3021,7 +3135,7 @@ var Civet = (() => {
|
|
|
3021
3135
|
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
|
|
3022
3136
|
}
|
|
3023
3137
|
}
|
|
3024
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R29, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($
|
|
3138
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R29, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L129, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L25, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L26, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
|
|
3025
3139
|
function TypeIndexSignature(state) {
|
|
3026
3140
|
if (state.verbose)
|
|
3027
3141
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -3032,7 +3146,7 @@ var Civet = (() => {
|
|
|
3032
3146
|
}
|
|
3033
3147
|
}
|
|
3034
3148
|
var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
|
|
3035
|
-
var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($
|
|
3149
|
+
var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L79, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
|
|
3036
3150
|
function TypeIndex(state) {
|
|
3037
3151
|
if (state.tokenize) {
|
|
3038
3152
|
return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
|
|
@@ -3052,7 +3166,7 @@ var Civet = (() => {
|
|
|
3052
3166
|
return TypeSuffix$0(state);
|
|
3053
3167
|
}
|
|
3054
3168
|
}
|
|
3055
|
-
var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($
|
|
3169
|
+
var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L130, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
|
|
3056
3170
|
return { "ts": true, "children": value };
|
|
3057
3171
|
});
|
|
3058
3172
|
function ReturnTypeSuffix(state) {
|
|
@@ -3064,7 +3178,7 @@ var Civet = (() => {
|
|
|
3064
3178
|
return ReturnTypeSuffix$0(state);
|
|
3065
3179
|
}
|
|
3066
3180
|
}
|
|
3067
|
-
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($
|
|
3181
|
+
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L70, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
|
|
3068
3182
|
function TypePredicate(state) {
|
|
3069
3183
|
if (state.verbose)
|
|
3070
3184
|
console.log("ENTER:", "TypePredicate");
|
|
@@ -3114,9 +3228,9 @@ var Civet = (() => {
|
|
|
3114
3228
|
return TypeUnarySuffix$0(state);
|
|
3115
3229
|
}
|
|
3116
3230
|
}
|
|
3117
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
3118
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
3119
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
3231
|
+
var TypeUnaryOp$0 = $EXPECT($L131, fail, 'TypeUnaryOp "keyof"');
|
|
3232
|
+
var TypeUnaryOp$1 = $EXPECT($L85, fail, 'TypeUnaryOp "typeof"');
|
|
3233
|
+
var TypeUnaryOp$2 = $EXPECT($L132, fail, 'TypeUnaryOp "infer"');
|
|
3120
3234
|
function TypeUnaryOp(state) {
|
|
3121
3235
|
if (state.tokenize) {
|
|
3122
3236
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -3124,7 +3238,7 @@ var Civet = (() => {
|
|
|
3124
3238
|
return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
|
|
3125
3239
|
}
|
|
3126
3240
|
}
|
|
3127
|
-
var TypeIndexedAccess$0 = $S(__, $EXPECT($
|
|
3241
|
+
var TypeIndexedAccess$0 = $S(__, $EXPECT($L25, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L26, fail, 'TypeIndexedAccess "]"'));
|
|
3128
3242
|
function TypeIndexedAccess(state) {
|
|
3129
3243
|
if (state.verbose)
|
|
3130
3244
|
console.log("ENTER:", "TypeIndexedAccess");
|
|
@@ -3137,7 +3251,7 @@ var Civet = (() => {
|
|
|
3137
3251
|
var TypePrimary$0 = InterfaceBlock;
|
|
3138
3252
|
var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
|
|
3139
3253
|
var TypePrimary$2 = $S($Q(_), FunctionType);
|
|
3140
|
-
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($
|
|
3254
|
+
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L24, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
|
|
3141
3255
|
var TypePrimary$4 = $S($Q(_), TypeLiteral);
|
|
3142
3256
|
function TypePrimary(state) {
|
|
3143
3257
|
if (state.tokenize) {
|
|
@@ -3157,8 +3271,8 @@ var Civet = (() => {
|
|
|
3157
3271
|
}
|
|
3158
3272
|
}
|
|
3159
3273
|
var TypeLiteral$0 = Literal;
|
|
3160
|
-
var TypeLiteral$1 = $EXPECT($
|
|
3161
|
-
var TypeLiteral$2 = $EXPECT($
|
|
3274
|
+
var TypeLiteral$1 = $EXPECT($L84, fail, 'TypeLiteral "void"');
|
|
3275
|
+
var TypeLiteral$2 = $EXPECT($L133, fail, 'TypeLiteral "[]"');
|
|
3162
3276
|
function TypeLiteral(state) {
|
|
3163
3277
|
if (state.tokenize) {
|
|
3164
3278
|
return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
|
|
@@ -3166,8 +3280,8 @@ var Civet = (() => {
|
|
|
3166
3280
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
3167
3281
|
}
|
|
3168
3282
|
}
|
|
3169
|
-
var TypeBinaryOp$0 = $EXPECT($
|
|
3170
|
-
var TypeBinaryOp$1 = $EXPECT($
|
|
3283
|
+
var TypeBinaryOp$0 = $EXPECT($L82, fail, 'TypeBinaryOp "|"');
|
|
3284
|
+
var TypeBinaryOp$1 = $EXPECT($L80, fail, 'TypeBinaryOp "&"');
|
|
3171
3285
|
function TypeBinaryOp(state) {
|
|
3172
3286
|
if (state.tokenize) {
|
|
3173
3287
|
return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
|
|
@@ -3185,7 +3299,7 @@ var Civet = (() => {
|
|
|
3185
3299
|
return FunctionType$0(state);
|
|
3186
3300
|
}
|
|
3187
3301
|
}
|
|
3188
|
-
var TypeArguments$0 = $S(__, $EXPECT($L14, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($
|
|
3302
|
+
var TypeArguments$0 = $S(__, $EXPECT($L14, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L67, fail, 'TypeArguments ">"'));
|
|
3189
3303
|
function TypeArguments(state) {
|
|
3190
3304
|
if (state.verbose)
|
|
3191
3305
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -3195,7 +3309,7 @@ var Civet = (() => {
|
|
|
3195
3309
|
return TypeArguments$0(state);
|
|
3196
3310
|
}
|
|
3197
3311
|
}
|
|
3198
|
-
var TypeParameters$0 = $S(__, $EXPECT($L14, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($
|
|
3312
|
+
var TypeParameters$0 = $S(__, $EXPECT($L14, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L67, fail, 'TypeParameters ">"'));
|
|
3199
3313
|
function TypeParameters(state) {
|
|
3200
3314
|
if (state.verbose)
|
|
3201
3315
|
console.log("ENTER:", "TypeParameters");
|
|
@@ -3226,8 +3340,8 @@ var Civet = (() => {
|
|
|
3226
3340
|
}
|
|
3227
3341
|
}
|
|
3228
3342
|
var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
|
|
3229
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
3230
|
-
var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
3343
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L67, fail, 'TypeParameterDelimiter ">"')));
|
|
3344
|
+
var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L67, fail, 'TypeParameterDelimiter ">"'))), function(value) {
|
|
3231
3345
|
return ",";
|
|
3232
3346
|
});
|
|
3233
3347
|
var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -3292,7 +3406,19 @@ var Civet = (() => {
|
|
|
3292
3406
|
return EOF$0(state);
|
|
3293
3407
|
}
|
|
3294
3408
|
}
|
|
3295
|
-
var
|
|
3409
|
+
var Debugger$0 = $TV($EXPECT($L31, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
3410
|
+
debugger;
|
|
3411
|
+
});
|
|
3412
|
+
function Debugger(state) {
|
|
3413
|
+
if (state.verbose)
|
|
3414
|
+
console.log("ENTER:", "Debugger");
|
|
3415
|
+
if (state.tokenize) {
|
|
3416
|
+
return $TOKEN("Debugger", state, Debugger$0(state));
|
|
3417
|
+
} else {
|
|
3418
|
+
return Debugger$0(state);
|
|
3419
|
+
}
|
|
3420
|
+
}
|
|
3421
|
+
var InsertOpenParen$0 = $T($EXPECT($L31, fail, 'InsertOpenParen ""'), function(value) {
|
|
3296
3422
|
return "(";
|
|
3297
3423
|
});
|
|
3298
3424
|
function InsertOpenParen(state) {
|
|
@@ -3304,7 +3430,7 @@ var Civet = (() => {
|
|
|
3304
3430
|
return InsertOpenParen$0(state);
|
|
3305
3431
|
}
|
|
3306
3432
|
}
|
|
3307
|
-
var InsertCloseParen$0 = $T($EXPECT($
|
|
3433
|
+
var InsertCloseParen$0 = $T($EXPECT($L31, fail, 'InsertCloseParen ""'), function(value) {
|
|
3308
3434
|
return ")";
|
|
3309
3435
|
});
|
|
3310
3436
|
function InsertCloseParen(state) {
|
|
@@ -3316,7 +3442,7 @@ var Civet = (() => {
|
|
|
3316
3442
|
return InsertCloseParen$0(state);
|
|
3317
3443
|
}
|
|
3318
3444
|
}
|
|
3319
|
-
var InsertOpenBrace$0 = $T($EXPECT($
|
|
3445
|
+
var InsertOpenBrace$0 = $T($EXPECT($L31, fail, 'InsertOpenBrace ""'), function(value) {
|
|
3320
3446
|
return " {";
|
|
3321
3447
|
});
|
|
3322
3448
|
function InsertOpenBrace(state) {
|
|
@@ -3328,7 +3454,7 @@ var Civet = (() => {
|
|
|
3328
3454
|
return InsertOpenBrace$0(state);
|
|
3329
3455
|
}
|
|
3330
3456
|
}
|
|
3331
|
-
var InsertCloseBrace$0 = $T($EXPECT($
|
|
3457
|
+
var InsertCloseBrace$0 = $T($EXPECT($L31, fail, 'InsertCloseBrace ""'), function(value) {
|
|
3332
3458
|
return "}";
|
|
3333
3459
|
});
|
|
3334
3460
|
function InsertCloseBrace(state) {
|
|
@@ -3340,7 +3466,7 @@ var Civet = (() => {
|
|
|
3340
3466
|
return InsertCloseBrace$0(state);
|
|
3341
3467
|
}
|
|
3342
3468
|
}
|
|
3343
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
3469
|
+
var InsertNewline$0 = $TV($EXPECT($L31, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
3344
3470
|
return "\n";
|
|
3345
3471
|
});
|
|
3346
3472
|
function InsertNewline(state) {
|
|
@@ -3352,7 +3478,7 @@ var Civet = (() => {
|
|
|
3352
3478
|
return InsertNewline$0(state);
|
|
3353
3479
|
}
|
|
3354
3480
|
}
|
|
3355
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
3481
|
+
var InsertIndent$0 = $TV($EXPECT($L31, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
3356
3482
|
return "".padStart(global.currentIndent * 2);
|
|
3357
3483
|
});
|
|
3358
3484
|
function InsertIndent(state) {
|
|
@@ -3364,7 +3490,7 @@ var Civet = (() => {
|
|
|
3364
3490
|
return InsertIndent$0(state);
|
|
3365
3491
|
}
|
|
3366
3492
|
}
|
|
3367
|
-
var InsertSpace$0 = $T($EXPECT($
|
|
3493
|
+
var InsertSpace$0 = $T($EXPECT($L31, fail, 'InsertSpace ""'), function(value) {
|
|
3368
3494
|
return " ";
|
|
3369
3495
|
});
|
|
3370
3496
|
function InsertSpace(state) {
|
|
@@ -3376,7 +3502,7 @@ var Civet = (() => {
|
|
|
3376
3502
|
return InsertSpace$0(state);
|
|
3377
3503
|
}
|
|
3378
3504
|
}
|
|
3379
|
-
var InsertDot$0 = $T($EXPECT($
|
|
3505
|
+
var InsertDot$0 = $T($EXPECT($L31, fail, 'InsertDot ""'), function(value) {
|
|
3380
3506
|
return ".";
|
|
3381
3507
|
});
|
|
3382
3508
|
function InsertDot(state) {
|
|
@@ -3388,7 +3514,7 @@ var Civet = (() => {
|
|
|
3388
3514
|
return InsertDot$0(state);
|
|
3389
3515
|
}
|
|
3390
3516
|
}
|
|
3391
|
-
var InsertBreak$0 = $T($EXPECT($
|
|
3517
|
+
var InsertBreak$0 = $T($EXPECT($L31, fail, 'InsertBreak ""'), function(value) {
|
|
3392
3518
|
return "break;";
|
|
3393
3519
|
});
|
|
3394
3520
|
function InsertBreak(state) {
|
|
@@ -3400,7 +3526,7 @@ var Civet = (() => {
|
|
|
3400
3526
|
return InsertBreak$0(state);
|
|
3401
3527
|
}
|
|
3402
3528
|
}
|
|
3403
|
-
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($
|
|
3529
|
+
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L31, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3404
3530
|
var directives = $2;
|
|
3405
3531
|
global.currentIndent = 0;
|
|
3406
3532
|
global.indentLevels = [0];
|
|
@@ -3420,7 +3546,7 @@ var Civet = (() => {
|
|
|
3420
3546
|
return Init$0(state);
|
|
3421
3547
|
}
|
|
3422
3548
|
}
|
|
3423
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
3549
|
+
var Indent$0 = $TV($Q($C($EXPECT($L134, fail, 'Indent " "'), $EXPECT($L135, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
3424
3550
|
return $1.length;
|
|
3425
3551
|
});
|
|
3426
3552
|
function Indent(state) {
|
|
@@ -3432,7 +3558,7 @@ var Civet = (() => {
|
|
|
3432
3558
|
return Indent$0(state);
|
|
3433
3559
|
}
|
|
3434
3560
|
}
|
|
3435
|
-
var PushIndent$0 = $TV($EXPECT($
|
|
3561
|
+
var PushIndent$0 = $TV($EXPECT($L31, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
|
|
3436
3562
|
global.currentIndent++;
|
|
3437
3563
|
if (global.verbose) {
|
|
3438
3564
|
console.log("pushing indent", global.currentIndent);
|
|
@@ -3449,7 +3575,7 @@ var Civet = (() => {
|
|
|
3449
3575
|
return PushIndent$0(state);
|
|
3450
3576
|
}
|
|
3451
3577
|
}
|
|
3452
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
3578
|
+
var PopIndent$0 = $TV($EXPECT($L31, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
3453
3579
|
if (global.verbose) {
|
|
3454
3580
|
console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
|
|
3455
3581
|
}
|
|
@@ -3491,6 +3617,31 @@ var Civet = (() => {
|
|
|
3491
3617
|
return Nested$0(state);
|
|
3492
3618
|
}
|
|
3493
3619
|
}
|
|
3620
|
+
var NestedFurther$0 = $TS($S($E(EOS), Indent), function($skip, $loc, $0, $1, $2) {
|
|
3621
|
+
var eos = $1;
|
|
3622
|
+
var indent = $2;
|
|
3623
|
+
const currentIndent = global.indentLevels[global.indentLevels.length - 1];
|
|
3624
|
+
if (global.verbose) {
|
|
3625
|
+
console.log("global indent", global.currentIndent);
|
|
3626
|
+
console.log("Indented", indent, currentIndent);
|
|
3627
|
+
}
|
|
3628
|
+
if (indent !== currentIndent + 1) {
|
|
3629
|
+
if (global.verbose) {
|
|
3630
|
+
console.log("skipped nested");
|
|
3631
|
+
}
|
|
3632
|
+
return $skip;
|
|
3633
|
+
}
|
|
3634
|
+
return [eos, "".padStart(indent * 2)];
|
|
3635
|
+
});
|
|
3636
|
+
function NestedFurther(state) {
|
|
3637
|
+
if (state.verbose)
|
|
3638
|
+
console.log("ENTER:", "NestedFurther");
|
|
3639
|
+
if (state.tokenize) {
|
|
3640
|
+
return $TOKEN("NestedFurther", state, NestedFurther$0(state));
|
|
3641
|
+
} else {
|
|
3642
|
+
return NestedFurther$0(state);
|
|
3643
|
+
}
|
|
3644
|
+
}
|
|
3494
3645
|
module.exports = {
|
|
3495
3646
|
parse
|
|
3496
3647
|
};
|
|
@@ -3501,11 +3652,18 @@ var Civet = (() => {
|
|
|
3501
3652
|
var require_generate = __commonJS({
|
|
3502
3653
|
"source/generate.coffee"(exports, module) {
|
|
3503
3654
|
var gen;
|
|
3655
|
+
var prune;
|
|
3504
3656
|
gen = function(node, options) {
|
|
3657
|
+
var $loc, token;
|
|
3505
3658
|
if (node === null || node === void 0) {
|
|
3506
3659
|
return "";
|
|
3507
3660
|
}
|
|
3508
3661
|
if (typeof node === "string") {
|
|
3662
|
+
if (options != null) {
|
|
3663
|
+
if (typeof options.updateSourceMap === "function") {
|
|
3664
|
+
options.updateSourceMap(node);
|
|
3665
|
+
}
|
|
3666
|
+
}
|
|
3509
3667
|
return node;
|
|
3510
3668
|
}
|
|
3511
3669
|
if (Array.isArray(node)) {
|
|
@@ -3514,19 +3672,55 @@ var Civet = (() => {
|
|
|
3514
3672
|
}).join("");
|
|
3515
3673
|
}
|
|
3516
3674
|
if (typeof node === "object") {
|
|
3517
|
-
if (
|
|
3675
|
+
if (options.js && node.ts) {
|
|
3518
3676
|
return "";
|
|
3519
3677
|
}
|
|
3678
|
+
if (node.$loc != null) {
|
|
3679
|
+
({ token, $loc } = node);
|
|
3680
|
+
if (options != null) {
|
|
3681
|
+
if (typeof options.updateSourceMap === "function") {
|
|
3682
|
+
options.updateSourceMap(token, $loc.pos);
|
|
3683
|
+
}
|
|
3684
|
+
}
|
|
3685
|
+
return token;
|
|
3686
|
+
}
|
|
3520
3687
|
if (!node.children) {
|
|
3521
3688
|
throw new Error("Unknown node", JSON.stringify(node));
|
|
3522
3689
|
}
|
|
3523
|
-
return node.children
|
|
3524
|
-
return gen(child, options);
|
|
3525
|
-
}).join("");
|
|
3690
|
+
return gen(node.children, options);
|
|
3526
3691
|
}
|
|
3527
3692
|
throw new Error("Unknown node", JSON.stringify(node));
|
|
3528
3693
|
};
|
|
3529
3694
|
module.exports = gen;
|
|
3695
|
+
prune = function(node) {
|
|
3696
|
+
var a;
|
|
3697
|
+
if (node === null || node === void 0) {
|
|
3698
|
+
return;
|
|
3699
|
+
}
|
|
3700
|
+
if (node.length === 0) {
|
|
3701
|
+
return;
|
|
3702
|
+
}
|
|
3703
|
+
if (Array.isArray(node)) {
|
|
3704
|
+
a = node.map(function(n) {
|
|
3705
|
+
return prune(n);
|
|
3706
|
+
}).filter(function(n) {
|
|
3707
|
+
return !!n;
|
|
3708
|
+
});
|
|
3709
|
+
if (a.length > 1) {
|
|
3710
|
+
return a;
|
|
3711
|
+
}
|
|
3712
|
+
if (a.length === 1) {
|
|
3713
|
+
return a[0];
|
|
3714
|
+
}
|
|
3715
|
+
return;
|
|
3716
|
+
}
|
|
3717
|
+
if (node.children != null) {
|
|
3718
|
+
node.children = prune(node.children);
|
|
3719
|
+
return node;
|
|
3720
|
+
}
|
|
3721
|
+
return node;
|
|
3722
|
+
};
|
|
3723
|
+
gen.prune = prune;
|
|
3530
3724
|
}
|
|
3531
3725
|
});
|
|
3532
3726
|
|
|
@@ -3540,7 +3734,9 @@ var Civet = (() => {
|
|
|
3540
3734
|
module.exports = {
|
|
3541
3735
|
parse,
|
|
3542
3736
|
compile: function(src, options) {
|
|
3543
|
-
return gen(parse(src
|
|
3737
|
+
return gen(parse(src, {
|
|
3738
|
+
filename: options != null ? options.filename : void 0
|
|
3739
|
+
}), options);
|
|
3544
3740
|
},
|
|
3545
3741
|
generate: gen
|
|
3546
3742
|
};
|