@danielx/civet 0.2.15 → 0.3.1
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 +9 -7
- package/dist/browser.js +730 -350
- package/dist/browser.js.map +3 -3
- package/dist/civet +14 -13
- package/dist/cli.js.map +4 -4
- package/dist/main.js +735 -355
- package/dist/types.d.ts +24 -5
- package/package.json +8 -1
- package/register.mjs +37 -10
package/dist/browser.js
CHANGED
|
@@ -417,8 +417,10 @@ var Civet = (() => {
|
|
|
417
417
|
UnaryExpression,
|
|
418
418
|
UnaryPostfix,
|
|
419
419
|
UpdateExpression,
|
|
420
|
+
UpdateExpressionSymbol,
|
|
420
421
|
AssignmentExpression,
|
|
421
422
|
AssignmentExpressionRest,
|
|
423
|
+
AwaitExpression,
|
|
422
424
|
YieldExpression,
|
|
423
425
|
ArrowFunction,
|
|
424
426
|
FatArrow,
|
|
@@ -428,14 +430,17 @@ var Civet = (() => {
|
|
|
428
430
|
PrimaryExpression,
|
|
429
431
|
ClassDeclaration,
|
|
430
432
|
ClassExpression,
|
|
433
|
+
Class,
|
|
431
434
|
ClassHeritage,
|
|
432
435
|
ExtendsToken,
|
|
433
436
|
ClassBody,
|
|
434
437
|
NestedClassElements,
|
|
435
438
|
NestedClassElement,
|
|
436
439
|
ClassElement,
|
|
440
|
+
Static,
|
|
437
441
|
FieldDefinition,
|
|
438
442
|
This,
|
|
443
|
+
AtAccessor,
|
|
439
444
|
LeftHandSideExpression,
|
|
440
445
|
NewExpression,
|
|
441
446
|
CallExpression,
|
|
@@ -463,13 +468,17 @@ var Civet = (() => {
|
|
|
463
468
|
FunctionDeclaration,
|
|
464
469
|
FunctionExpression,
|
|
465
470
|
ThinArrowFunction,
|
|
471
|
+
Arrow,
|
|
466
472
|
Block,
|
|
473
|
+
BracedOrEmptyBlock,
|
|
467
474
|
BracedBlock,
|
|
468
475
|
SingleNestedExpression,
|
|
469
476
|
SingleNestedBlockStatement,
|
|
470
477
|
NestedBlockExpressions,
|
|
471
478
|
BlockExpression,
|
|
472
479
|
Literal,
|
|
480
|
+
NullLiteral,
|
|
481
|
+
BooleanLiteral,
|
|
473
482
|
Comma,
|
|
474
483
|
Identifier,
|
|
475
484
|
IdentifierName,
|
|
@@ -499,7 +508,9 @@ var Civet = (() => {
|
|
|
499
508
|
AsyncGeneratorMethod,
|
|
500
509
|
AsyncGeneratorBody,
|
|
501
510
|
AssignmentOp,
|
|
511
|
+
AssignmentOpSymbol,
|
|
502
512
|
BinaryOp,
|
|
513
|
+
BinaryOpSymbol,
|
|
503
514
|
UnaryOp,
|
|
504
515
|
ModuleItem,
|
|
505
516
|
StatementListItem,
|
|
@@ -515,7 +526,9 @@ var Civet = (() => {
|
|
|
515
526
|
WhileClause,
|
|
516
527
|
ForStatement,
|
|
517
528
|
ForInOfStatement,
|
|
529
|
+
For,
|
|
518
530
|
ForDeclaration,
|
|
531
|
+
LetOrConst,
|
|
519
532
|
ForBinding,
|
|
520
533
|
SwitchStatement,
|
|
521
534
|
CaseBlock,
|
|
@@ -535,10 +548,12 @@ var Civet = (() => {
|
|
|
535
548
|
MaybeNestedExpression,
|
|
536
549
|
Return,
|
|
537
550
|
ImportDeclaration,
|
|
551
|
+
Import,
|
|
538
552
|
ImportClause,
|
|
539
553
|
NameSpaceImport,
|
|
540
554
|
NamedImports,
|
|
541
555
|
FromClause,
|
|
556
|
+
From,
|
|
542
557
|
ImportSpecifier,
|
|
543
558
|
ModuleExportName,
|
|
544
559
|
ModuleSpecifier,
|
|
@@ -559,6 +574,7 @@ var Civet = (() => {
|
|
|
559
574
|
VariableDeclarationList,
|
|
560
575
|
VariableDeclaration,
|
|
561
576
|
NumericLiteral,
|
|
577
|
+
NumericLiteralKind,
|
|
562
578
|
DecimalBigIntegerLiteral,
|
|
563
579
|
DecimalLiteral,
|
|
564
580
|
BinaryIntegerLiteral,
|
|
@@ -568,7 +584,7 @@ var Civet = (() => {
|
|
|
568
584
|
DoubleStringCharacter,
|
|
569
585
|
SingleStringCharacter,
|
|
570
586
|
TripleDoubleStringCharacter,
|
|
571
|
-
|
|
587
|
+
TripleSingleStringCharacter,
|
|
572
588
|
RegularExpressionLiteral,
|
|
573
589
|
RegularExpressionBody,
|
|
574
590
|
RegExpCharacter,
|
|
@@ -663,37 +679,37 @@ var Civet = (() => {
|
|
|
663
679
|
var $L5 = $L("++");
|
|
664
680
|
var $L6 = $L("--");
|
|
665
681
|
var $L7 = $L("async");
|
|
666
|
-
var $L8 = $L("
|
|
667
|
-
var $L9 = $L("
|
|
668
|
-
var $L10 = $L("
|
|
669
|
-
var $L11 = $L("
|
|
670
|
-
var $L12 = $L("
|
|
671
|
-
var $L13 = $L("
|
|
672
|
-
var $L14 = $L("
|
|
673
|
-
var $L15 = $L("
|
|
674
|
-
var $L16 = $L("
|
|
675
|
-
var $L17 = $L("
|
|
676
|
-
var $L18 = $L("
|
|
677
|
-
var $L19 = $L("
|
|
682
|
+
var $L8 = $L("await");
|
|
683
|
+
var $L9 = $L("yield");
|
|
684
|
+
var $L10 = $L("*");
|
|
685
|
+
var $L11 = $L("=>");
|
|
686
|
+
var $L12 = $L("{");
|
|
687
|
+
var $L13 = $L(":");
|
|
688
|
+
var $L14 = $L("class");
|
|
689
|
+
var $L15 = $L("<");
|
|
690
|
+
var $L16 = $L("extends");
|
|
691
|
+
var $L17 = $L("}");
|
|
692
|
+
var $L18 = $L("static");
|
|
693
|
+
var $L19 = $L("this");
|
|
678
694
|
var $L20 = $L("#");
|
|
679
|
-
var $L21 = $L("
|
|
680
|
-
var $L22 = $L("
|
|
681
|
-
var $L23 = $L("
|
|
682
|
-
var $L24 = $L("
|
|
683
|
-
var $L25 = $L("
|
|
684
|
-
var $L26 = $L("
|
|
685
|
-
var $L27 = $L("
|
|
686
|
-
var $L28 = $L("
|
|
687
|
-
var $L29 = $L("
|
|
688
|
-
var $L30 = $L("
|
|
689
|
-
var $L31 = $L("");
|
|
690
|
-
var $L32 = $L("
|
|
691
|
-
var $L33 = $L("
|
|
692
|
-
var $L34 = $L("
|
|
693
|
-
var $L35 = $L("
|
|
694
|
-
var $L36 = $L("
|
|
695
|
-
var $L37 = $L("
|
|
696
|
-
var $L38 = $L("
|
|
695
|
+
var $L21 = $L("@");
|
|
696
|
+
var $L22 = $L("new");
|
|
697
|
+
var $L23 = $L("super");
|
|
698
|
+
var $L24 = $L("import");
|
|
699
|
+
var $L25 = $L(".");
|
|
700
|
+
var $L26 = $L("[");
|
|
701
|
+
var $L27 = $L("]");
|
|
702
|
+
var $L28 = $L("::");
|
|
703
|
+
var $L29 = $L("super[");
|
|
704
|
+
var $L30 = $L("new.target");
|
|
705
|
+
var $L31 = $L("import.meta");
|
|
706
|
+
var $L32 = $L("");
|
|
707
|
+
var $L33 = $L("...");
|
|
708
|
+
var $L34 = $L("function");
|
|
709
|
+
var $L35 = $L("->");
|
|
710
|
+
var $L36 = $L("null");
|
|
711
|
+
var $L37 = $L("true");
|
|
712
|
+
var $L38 = $L("false");
|
|
697
713
|
var $L39 = $L("get");
|
|
698
714
|
var $L40 = $L("set");
|
|
699
715
|
var $L41 = $L("**=");
|
|
@@ -749,48 +765,47 @@ var Civet = (() => {
|
|
|
749
765
|
var $L91 = $L("do");
|
|
750
766
|
var $L92 = $L("while");
|
|
751
767
|
var $L93 = $L("until");
|
|
752
|
-
var $L94 = $L("
|
|
753
|
-
var $L95 = $L("
|
|
754
|
-
var $L96 = $L("
|
|
755
|
-
var $L97 = $L("
|
|
756
|
-
var $L98 = $L("
|
|
757
|
-
var $L99 = $L("
|
|
758
|
-
var $L100 = $L("
|
|
759
|
-
var $L101 = $L("
|
|
760
|
-
var $L102 = $L("
|
|
761
|
-
var $L103 = $L("
|
|
762
|
-
var $L104 = $L("
|
|
763
|
-
var $L105 = $L("
|
|
764
|
-
var $L106 = $L("
|
|
765
|
-
var $L107 = $L("
|
|
766
|
-
var $L108 = $L("
|
|
767
|
-
var $L109 = $L("
|
|
768
|
-
var $L110 = $L("
|
|
769
|
-
var $L111 = $L("
|
|
770
|
-
var $L112 = $L("
|
|
771
|
-
var $L113 = $L("
|
|
772
|
-
var $L114 = $L("
|
|
773
|
-
var $L115 = $L("
|
|
774
|
-
var $L116 = $L('"
|
|
768
|
+
var $L94 = $L("var");
|
|
769
|
+
var $L95 = $L("of");
|
|
770
|
+
var $L96 = $L("for");
|
|
771
|
+
var $L97 = $L("let");
|
|
772
|
+
var $L98 = $L("const");
|
|
773
|
+
var $L99 = $L("switch");
|
|
774
|
+
var $L100 = $L("case");
|
|
775
|
+
var $L101 = $L("default");
|
|
776
|
+
var $L102 = $L("when");
|
|
777
|
+
var $L103 = $L("try");
|
|
778
|
+
var $L104 = $L("catch");
|
|
779
|
+
var $L105 = $L("finally");
|
|
780
|
+
var $L106 = $L("break");
|
|
781
|
+
var $L107 = $L("continue");
|
|
782
|
+
var $L108 = $L("debugger");
|
|
783
|
+
var $L109 = $L("throw");
|
|
784
|
+
var $L110 = $L("return");
|
|
785
|
+
var $L111 = $L("import type");
|
|
786
|
+
var $L112 = $L("from");
|
|
787
|
+
var $L113 = $L("export");
|
|
788
|
+
var $L114 = $L(":=");
|
|
789
|
+
var $L115 = $L('"""');
|
|
790
|
+
var $L116 = $L("'''");
|
|
775
791
|
var $L117 = $L('"');
|
|
776
792
|
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("
|
|
788
|
-
var $L130 = $L("
|
|
789
|
-
var $L131 = $L("
|
|
790
|
-
var $L132 = $L("
|
|
791
|
-
var $L133 = $L("
|
|
792
|
-
var $L134 = $L("
|
|
793
|
-
var $L135 = $L(" ");
|
|
793
|
+
var $L119 = $L("`");
|
|
794
|
+
var $L120 = $L("${");
|
|
795
|
+
var $L121 = $L("/*");
|
|
796
|
+
var $L122 = $L("*/");
|
|
797
|
+
var $L123 = $L("###");
|
|
798
|
+
var $L124 = $L("/>");
|
|
799
|
+
var $L125 = $L("</");
|
|
800
|
+
var $L126 = $L("<>");
|
|
801
|
+
var $L127 = $L("</>");
|
|
802
|
+
var $L128 = $L("readonly");
|
|
803
|
+
var $L129 = $L("asserts");
|
|
804
|
+
var $L130 = $L("keyof");
|
|
805
|
+
var $L131 = $L("infer");
|
|
806
|
+
var $L132 = $L("[]");
|
|
807
|
+
var $L133 = $L(" ");
|
|
808
|
+
var $L134 = $L(" ");
|
|
794
809
|
var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
795
810
|
var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
796
811
|
var $R2 = $R(new RegExp("[!~+-]", "suy"));
|
|
@@ -799,33 +814,34 @@ var Civet = (() => {
|
|
|
799
814
|
var $R5 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
|
|
800
815
|
var $R6 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
|
|
801
816
|
var $R7 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
|
|
802
|
-
var $R8 = $R(new RegExp('[^"
|
|
803
|
-
var $R9 = $R(new RegExp("[^'
|
|
817
|
+
var $R8 = $R(new RegExp('(?:\\\\.|[^"])+', "suy"));
|
|
818
|
+
var $R9 = $R(new RegExp("(?:\\\\.|[^'])+", "suy"));
|
|
804
819
|
var $R10 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
|
|
805
|
-
var $R11 = $R(new RegExp("
|
|
820
|
+
var $R11 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])+", "suy"));
|
|
806
821
|
var $R12 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
|
|
807
|
-
var $R13 = $R(new RegExp("[^\\/\\r\\n]+", "suy"));
|
|
808
|
-
var $R14 = $R(new RegExp("(
|
|
822
|
+
var $R13 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
|
|
823
|
+
var $R14 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
809
824
|
var $R15 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
810
825
|
var $R16 = $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"));
|
|
811
826
|
var $R17 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
812
|
-
var $R18 = $R(new RegExp("
|
|
813
|
-
var $R19 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
814
|
-
var $R20 = $R(new RegExp("[\\
|
|
815
|
-
var $R21 = $R(new RegExp("[\\
|
|
816
|
-
var $R22 = $R(new RegExp("
|
|
817
|
-
var $R23 = $R(new RegExp("(
|
|
818
|
-
var $R24 = $R(new RegExp(
|
|
819
|
-
var $R25 = $R(new RegExp("
|
|
820
|
-
var $R26 = $R(new RegExp("[^
|
|
821
|
-
var $R27 = $R(new RegExp("
|
|
822
|
-
var $R28 = $R(new RegExp("
|
|
823
|
-
var $R29 = $R(new RegExp("
|
|
824
|
-
var $R30 = $R(new RegExp("[+-]", "suy"));
|
|
825
|
-
var $R31 = $R(new RegExp("
|
|
826
|
-
var $R32 = $R(new RegExp("[\\
|
|
827
|
-
var $R33 = $R(new RegExp("\\
|
|
828
|
-
var $R34 = $R(new RegExp("
|
|
827
|
+
var $R18 = $R(new RegExp(".", "suy"));
|
|
828
|
+
var $R19 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
829
|
+
var $R20 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
830
|
+
var $R21 = $R(new RegExp("[\\t ]+", "suy"));
|
|
831
|
+
var $R22 = $R(new RegExp("[\\s]+", "suy"));
|
|
832
|
+
var $R23 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
833
|
+
var $R24 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
834
|
+
var $R25 = $R(new RegExp('"[^"]*"', "suy"));
|
|
835
|
+
var $R26 = $R(new RegExp("'[^']*'", "suy"));
|
|
836
|
+
var $R27 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
837
|
+
var $R28 = $R(new RegExp("type(?!\\p{ID_Continue})", "suy"));
|
|
838
|
+
var $R29 = $R(new RegExp("interface(?!\\p{ID_Continue})", "suy"));
|
|
839
|
+
var $R30 = $R(new RegExp("[+-]?", "suy"));
|
|
840
|
+
var $R31 = $R(new RegExp("[+-]", "suy"));
|
|
841
|
+
var $R32 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
842
|
+
var $R33 = $R(new RegExp("[\\t ]*", "suy"));
|
|
843
|
+
var $R34 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
844
|
+
var $R35 = $R(new RegExp("$", "suy"));
|
|
829
845
|
var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
|
|
830
846
|
function Program(state) {
|
|
831
847
|
if (state.verbose)
|
|
@@ -949,8 +965,8 @@ var Civet = (() => {
|
|
|
949
965
|
return UnaryPostfix$0(state) || UnaryPostfix$1(state);
|
|
950
966
|
}
|
|
951
967
|
}
|
|
952
|
-
var UpdateExpression$0 = $S(
|
|
953
|
-
var UpdateExpression$1 = $S(LeftHandSideExpression, $E(
|
|
968
|
+
var UpdateExpression$0 = $S(UpdateExpressionSymbol, UnaryExpression);
|
|
969
|
+
var UpdateExpression$1 = $S(LeftHandSideExpression, $E(UpdateExpressionSymbol));
|
|
954
970
|
function UpdateExpression(state) {
|
|
955
971
|
if (state.tokenize) {
|
|
956
972
|
return $TOKEN("UpdateExpression", state, UpdateExpression$0(state) || UpdateExpression$1(state));
|
|
@@ -958,6 +974,18 @@ var Civet = (() => {
|
|
|
958
974
|
return UpdateExpression$0(state) || UpdateExpression$1(state);
|
|
959
975
|
}
|
|
960
976
|
}
|
|
977
|
+
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L5, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L6, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
|
|
978
|
+
return { $loc, token: $1 };
|
|
979
|
+
});
|
|
980
|
+
function UpdateExpressionSymbol(state) {
|
|
981
|
+
if (state.verbose)
|
|
982
|
+
console.log("ENTER:", "UpdateExpressionSymbol");
|
|
983
|
+
if (state.tokenize) {
|
|
984
|
+
return $TOKEN("UpdateExpressionSymbol", state, UpdateExpressionSymbol$0(state));
|
|
985
|
+
} else {
|
|
986
|
+
return UpdateExpressionSymbol$0(state);
|
|
987
|
+
}
|
|
988
|
+
}
|
|
961
989
|
var AssignmentExpression$0 = $S($Q(TrailingComment), AssignmentExpressionRest);
|
|
962
990
|
var AssignmentExpression$1 = $S(__, AssignmentExpressionRest);
|
|
963
991
|
function AssignmentExpression(state) {
|
|
@@ -967,18 +995,29 @@ var Civet = (() => {
|
|
|
967
995
|
return AssignmentExpression$0(state) || AssignmentExpression$1(state);
|
|
968
996
|
}
|
|
969
997
|
}
|
|
970
|
-
var AssignmentExpressionRest$0 =
|
|
971
|
-
var AssignmentExpressionRest$1 =
|
|
972
|
-
var AssignmentExpressionRest$2 = $S($
|
|
973
|
-
var AssignmentExpressionRest$3 =
|
|
998
|
+
var AssignmentExpressionRest$0 = AwaitExpression;
|
|
999
|
+
var AssignmentExpressionRest$1 = YieldExpression;
|
|
1000
|
+
var AssignmentExpressionRest$2 = $S($E($S($EXPECT($L7, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
|
|
1001
|
+
var AssignmentExpressionRest$3 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), Expression);
|
|
1002
|
+
var AssignmentExpressionRest$4 = ConditionalExpression;
|
|
974
1003
|
function AssignmentExpressionRest(state) {
|
|
975
1004
|
if (state.tokenize) {
|
|
976
|
-
return $TOKEN("AssignmentExpressionRest", state, AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state));
|
|
1005
|
+
return $TOKEN("AssignmentExpressionRest", state, AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state) || AssignmentExpressionRest$4(state));
|
|
1006
|
+
} else {
|
|
1007
|
+
return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state) || AssignmentExpressionRest$4(state);
|
|
1008
|
+
}
|
|
1009
|
+
}
|
|
1010
|
+
var AwaitExpression$0 = $S($EXPECT($L8, fail, 'AwaitExpression "await"'), NonIdContinue, $Q(TrailingComment), AssignmentExpression);
|
|
1011
|
+
function AwaitExpression(state) {
|
|
1012
|
+
if (state.verbose)
|
|
1013
|
+
console.log("ENTER:", "AwaitExpression");
|
|
1014
|
+
if (state.tokenize) {
|
|
1015
|
+
return $TOKEN("AwaitExpression", state, AwaitExpression$0(state));
|
|
977
1016
|
} else {
|
|
978
|
-
return
|
|
1017
|
+
return AwaitExpression$0(state);
|
|
979
1018
|
}
|
|
980
1019
|
}
|
|
981
|
-
var YieldExpression$0 = $S($EXPECT($
|
|
1020
|
+
var YieldExpression$0 = $S($EXPECT($L9, fail, 'YieldExpression "yield"'), NonIdContinue, $E($S($Q(TrailingComment), $EXPECT($L10, fail, 'YieldExpression "*"'))), AssignmentExpression);
|
|
982
1021
|
function YieldExpression(state) {
|
|
983
1022
|
if (state.verbose)
|
|
984
1023
|
console.log("ENTER:", "YieldExpression");
|
|
@@ -997,7 +1036,7 @@ var Civet = (() => {
|
|
|
997
1036
|
return ArrowFunction$0(state) || ArrowFunction$1(state);
|
|
998
1037
|
}
|
|
999
1038
|
}
|
|
1000
|
-
var FatArrow$0 = $TS($S(__, $EXPECT($
|
|
1039
|
+
var FatArrow$0 = $TS($S(__, $EXPECT($L11, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
|
|
1001
1040
|
var ws = $1;
|
|
1002
1041
|
if (!ws.length)
|
|
1003
1042
|
return " =>";
|
|
@@ -1013,7 +1052,7 @@ var Civet = (() => {
|
|
|
1013
1052
|
}
|
|
1014
1053
|
}
|
|
1015
1054
|
var ConciseBody$0 = $S(EOS, SingleNestedBlockStatement);
|
|
1016
|
-
var ConciseBody$1 = $S($N($S($Q(_), $EXPECT($
|
|
1055
|
+
var ConciseBody$1 = $S($N($S($Q(_), $EXPECT($L12, fail, 'ConciseBody "{"'))), AssignmentExpression);
|
|
1017
1056
|
var ConciseBody$2 = BracedBlock;
|
|
1018
1057
|
function ConciseBody(state) {
|
|
1019
1058
|
if (state.tokenize) {
|
|
@@ -1022,7 +1061,7 @@ var Civet = (() => {
|
|
|
1022
1061
|
return ConciseBody$0(state) || ConciseBody$1(state) || ConciseBody$2(state);
|
|
1023
1062
|
}
|
|
1024
1063
|
}
|
|
1025
|
-
var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($
|
|
1064
|
+
var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L13, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
|
|
1026
1065
|
function ConditionalExpression(state) {
|
|
1027
1066
|
if (state.verbose)
|
|
1028
1067
|
console.log("ENTER:", "ConditionalExpression");
|
|
@@ -1071,7 +1110,7 @@ var Civet = (() => {
|
|
|
1071
1110
|
return ClassDeclaration$0(state);
|
|
1072
1111
|
}
|
|
1073
1112
|
}
|
|
1074
|
-
var ClassExpression$0 = $S(
|
|
1113
|
+
var ClassExpression$0 = $S(Class, $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
|
|
1075
1114
|
function ClassExpression(state) {
|
|
1076
1115
|
if (state.verbose)
|
|
1077
1116
|
console.log("ENTER:", "ClassExpression");
|
|
@@ -1081,6 +1120,18 @@ var Civet = (() => {
|
|
|
1081
1120
|
return ClassExpression$0(state);
|
|
1082
1121
|
}
|
|
1083
1122
|
}
|
|
1123
|
+
var Class$0 = $TV($EXPECT($L14, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
1124
|
+
return { $loc, token: $0 };
|
|
1125
|
+
});
|
|
1126
|
+
function Class(state) {
|
|
1127
|
+
if (state.verbose)
|
|
1128
|
+
console.log("ENTER:", "Class");
|
|
1129
|
+
if (state.tokenize) {
|
|
1130
|
+
return $TOKEN("Class", state, Class$0(state));
|
|
1131
|
+
} else {
|
|
1132
|
+
return Class$0(state);
|
|
1133
|
+
}
|
|
1134
|
+
}
|
|
1084
1135
|
var ClassHeritage$0 = $S(ExtendsToken, __, MemberExpression);
|
|
1085
1136
|
function ClassHeritage(state) {
|
|
1086
1137
|
if (state.verbose)
|
|
@@ -1091,10 +1142,12 @@ var Civet = (() => {
|
|
|
1091
1142
|
return ClassHeritage$0(state);
|
|
1092
1143
|
}
|
|
1093
1144
|
}
|
|
1094
|
-
var ExtendsToken$0 = $
|
|
1095
|
-
return "extends";
|
|
1145
|
+
var ExtendsToken$0 = $TV($EXPECT($L15, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
|
|
1146
|
+
return { $loc, token: "extends" };
|
|
1147
|
+
});
|
|
1148
|
+
var ExtendsToken$1 = $TV($EXPECT($L16, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
|
|
1149
|
+
return { $loc, token: $1 };
|
|
1096
1150
|
});
|
|
1097
|
-
var ExtendsToken$1 = $EXPECT($L15, fail, 'ExtendsToken "extends"');
|
|
1098
1151
|
function ExtendsToken(state) {
|
|
1099
1152
|
if (state.tokenize) {
|
|
1100
1153
|
return $TOKEN("ExtendsToken", state, ExtendsToken$0(state) || ExtendsToken$1(state));
|
|
@@ -1102,7 +1155,7 @@ var Civet = (() => {
|
|
|
1102
1155
|
return ExtendsToken$0(state) || ExtendsToken$1(state);
|
|
1103
1156
|
}
|
|
1104
1157
|
}
|
|
1105
|
-
var ClassBody$0 = $S(__, $EXPECT($
|
|
1158
|
+
var ClassBody$0 = $S(__, $EXPECT($L12, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L17, fail, 'ClassBody "}"'));
|
|
1106
1159
|
var ClassBody$1 = $S(InsertOpenBrace, EOS, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1107
1160
|
function ClassBody(state) {
|
|
1108
1161
|
if (state.tokenize) {
|
|
@@ -1136,8 +1189,8 @@ var Civet = (() => {
|
|
|
1136
1189
|
return NestedClassElement$0(state);
|
|
1137
1190
|
}
|
|
1138
1191
|
}
|
|
1139
|
-
var ClassElement$0 = $S(
|
|
1140
|
-
var ClassElement$1 = $S($E($S(
|
|
1192
|
+
var ClassElement$0 = $S(Static, BracedBlock);
|
|
1193
|
+
var ClassElement$1 = $S($E($S(Static, __)), $C(MethodDefinition, FieldDefinition));
|
|
1141
1194
|
function ClassElement(state) {
|
|
1142
1195
|
if (state.tokenize) {
|
|
1143
1196
|
return $TOKEN("ClassElement", state, ClassElement$0(state) || ClassElement$1(state));
|
|
@@ -1145,6 +1198,18 @@ var Civet = (() => {
|
|
|
1145
1198
|
return ClassElement$0(state) || ClassElement$1(state);
|
|
1146
1199
|
}
|
|
1147
1200
|
}
|
|
1201
|
+
var Static$0 = $TV($EXPECT($L18, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
1202
|
+
return { $loc, token: $0 };
|
|
1203
|
+
});
|
|
1204
|
+
function Static(state) {
|
|
1205
|
+
if (state.verbose)
|
|
1206
|
+
console.log("ENTER:", "Static");
|
|
1207
|
+
if (state.tokenize) {
|
|
1208
|
+
return $TOKEN("Static", state, Static$0(state));
|
|
1209
|
+
} else {
|
|
1210
|
+
return Static$0(state);
|
|
1211
|
+
}
|
|
1212
|
+
}
|
|
1148
1213
|
var FieldDefinition$0 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
|
|
1149
1214
|
function FieldDefinition(state) {
|
|
1150
1215
|
if (state.verbose)
|
|
@@ -1155,12 +1220,11 @@ var Civet = (() => {
|
|
|
1155
1220
|
return FieldDefinition$0(state);
|
|
1156
1221
|
}
|
|
1157
1222
|
}
|
|
1158
|
-
var This$0 = $EXPECT($
|
|
1159
|
-
|
|
1160
|
-
var ref = value[1];
|
|
1161
|
-
return ["this.", ref];
|
|
1223
|
+
var This$0 = $TV($EXPECT($L19, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
1224
|
+
return { $loc, token: $0 };
|
|
1162
1225
|
});
|
|
1163
|
-
var This$
|
|
1226
|
+
var This$1 = $S(AtAccessor, $S($E($EXPECT($L20, fail, 'This "#"')), IdentifierName));
|
|
1227
|
+
var This$2 = $TV($EXPECT($L21, fail, 'This "@"'), function($skip, $loc, $0, $1) {
|
|
1164
1228
|
return { $loc, token: "this" };
|
|
1165
1229
|
});
|
|
1166
1230
|
function This(state) {
|
|
@@ -1170,6 +1234,18 @@ var Civet = (() => {
|
|
|
1170
1234
|
return This$0(state) || This$1(state) || This$2(state);
|
|
1171
1235
|
}
|
|
1172
1236
|
}
|
|
1237
|
+
var AtAccessor$0 = $TV($EXPECT($L21, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
|
|
1238
|
+
return { $loc, token: "this." };
|
|
1239
|
+
});
|
|
1240
|
+
function AtAccessor(state) {
|
|
1241
|
+
if (state.verbose)
|
|
1242
|
+
console.log("ENTER:", "AtAccessor");
|
|
1243
|
+
if (state.tokenize) {
|
|
1244
|
+
return $TOKEN("AtAccessor", state, AtAccessor$0(state));
|
|
1245
|
+
} else {
|
|
1246
|
+
return AtAccessor$0(state);
|
|
1247
|
+
}
|
|
1248
|
+
}
|
|
1173
1249
|
var LeftHandSideExpression$0 = NewExpression;
|
|
1174
1250
|
var LeftHandSideExpression$1 = CallExpression;
|
|
1175
1251
|
function LeftHandSideExpression(state) {
|
|
@@ -1179,7 +1255,7 @@ var Civet = (() => {
|
|
|
1179
1255
|
return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
|
|
1180
1256
|
}
|
|
1181
1257
|
}
|
|
1182
|
-
var NewExpression$0 = $S($P($S($EXPECT($
|
|
1258
|
+
var NewExpression$0 = $S($P($S($EXPECT($L22, fail, 'NewExpression "new"'), __)), CallExpression);
|
|
1183
1259
|
function NewExpression(state) {
|
|
1184
1260
|
if (state.verbose)
|
|
1185
1261
|
console.log("ENTER:", "NewExpression");
|
|
@@ -1189,8 +1265,8 @@ var Civet = (() => {
|
|
|
1189
1265
|
return NewExpression$0(state);
|
|
1190
1266
|
}
|
|
1191
1267
|
}
|
|
1192
|
-
var CallExpression$0 = $S($EXPECT($
|
|
1193
|
-
var CallExpression$1 = $S($EXPECT($
|
|
1268
|
+
var CallExpression$0 = $S($EXPECT($L23, fail, 'CallExpression "super"'), __, Arguments);
|
|
1269
|
+
var CallExpression$1 = $S($EXPECT($L24, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
|
|
1194
1270
|
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
|
|
1195
1271
|
function CallExpression(state) {
|
|
1196
1272
|
if (state.tokenize) {
|
|
@@ -1210,7 +1286,7 @@ var Civet = (() => {
|
|
|
1210
1286
|
return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
|
|
1211
1287
|
}
|
|
1212
1288
|
}
|
|
1213
|
-
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($
|
|
1289
|
+
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L25, fail, 'OptionalShorthand "."'), InsertDot));
|
|
1214
1290
|
function OptionalShorthand(state) {
|
|
1215
1291
|
if (state.verbose)
|
|
1216
1292
|
console.log("ENTER:", "OptionalShorthand");
|
|
@@ -1264,9 +1340,9 @@ var Civet = (() => {
|
|
|
1264
1340
|
return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
|
|
1265
1341
|
}
|
|
1266
1342
|
}
|
|
1267
|
-
var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($
|
|
1343
|
+
var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L26, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L27, fail, 'MemberExpressionRest "]"'));
|
|
1268
1344
|
var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
|
|
1269
|
-
var MemberExpressionRest$2 = $TS($S($EXPECT($
|
|
1345
|
+
var MemberExpressionRest$2 = $TS($S($EXPECT($L28, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
|
|
1270
1346
|
var id = $2;
|
|
1271
1347
|
if (id)
|
|
1272
1348
|
return [".prototype.", id];
|
|
@@ -1279,7 +1355,7 @@ var Civet = (() => {
|
|
|
1279
1355
|
return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state);
|
|
1280
1356
|
}
|
|
1281
1357
|
}
|
|
1282
|
-
var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($
|
|
1358
|
+
var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L25, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
|
|
1283
1359
|
function PropertyAccess(state) {
|
|
1284
1360
|
if (state.verbose)
|
|
1285
1361
|
console.log("ENTER:", "PropertyAccess");
|
|
@@ -1289,7 +1365,7 @@ var Civet = (() => {
|
|
|
1289
1365
|
return PropertyAccess$0(state);
|
|
1290
1366
|
}
|
|
1291
1367
|
}
|
|
1292
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
1368
|
+
var SuperProperty$0 = $S($EXPECT($L29, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L27, fail, 'SuperProperty "]"'));
|
|
1293
1369
|
function SuperProperty(state) {
|
|
1294
1370
|
if (state.verbose)
|
|
1295
1371
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1299,8 +1375,8 @@ var Civet = (() => {
|
|
|
1299
1375
|
return SuperProperty$0(state);
|
|
1300
1376
|
}
|
|
1301
1377
|
}
|
|
1302
|
-
var MetaProperty$0 = $EXPECT($
|
|
1303
|
-
var MetaProperty$1 = $EXPECT($
|
|
1378
|
+
var MetaProperty$0 = $EXPECT($L30, fail, 'MetaProperty "new.target"');
|
|
1379
|
+
var MetaProperty$1 = $EXPECT($L31, fail, 'MetaProperty "import.meta"');
|
|
1304
1380
|
function MetaProperty(state) {
|
|
1305
1381
|
if (state.tokenize) {
|
|
1306
1382
|
return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
|
|
@@ -1309,7 +1385,7 @@ var Civet = (() => {
|
|
|
1309
1385
|
}
|
|
1310
1386
|
}
|
|
1311
1387
|
var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
|
|
1312
|
-
var Parameters$1 = $T($EXPECT($
|
|
1388
|
+
var Parameters$1 = $T($EXPECT($L32, fail, 'Parameters ""'), function(value) {
|
|
1313
1389
|
return "()";
|
|
1314
1390
|
});
|
|
1315
1391
|
function Parameters(state) {
|
|
@@ -1363,7 +1439,7 @@ var Civet = (() => {
|
|
|
1363
1439
|
return BindingPattern$0(state) || BindingPattern$1(state);
|
|
1364
1440
|
}
|
|
1365
1441
|
}
|
|
1366
|
-
var ObjectBindingPattern$0 = $S($EXPECT($
|
|
1442
|
+
var ObjectBindingPattern$0 = $S($EXPECT($L12, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L17, fail, 'ObjectBindingPattern "}"'));
|
|
1367
1443
|
function ObjectBindingPattern(state) {
|
|
1368
1444
|
if (state.verbose)
|
|
1369
1445
|
console.log("ENTER:", "ObjectBindingPattern");
|
|
@@ -1373,7 +1449,7 @@ var Civet = (() => {
|
|
|
1373
1449
|
return ObjectBindingPattern$0(state);
|
|
1374
1450
|
}
|
|
1375
1451
|
}
|
|
1376
|
-
var ArrayBindingPattern$0 = $S($EXPECT($
|
|
1452
|
+
var ArrayBindingPattern$0 = $S($EXPECT($L26, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L27, fail, 'ArrayBindingPattern "]"'));
|
|
1377
1453
|
function ArrayBindingPattern(state) {
|
|
1378
1454
|
if (state.verbose)
|
|
1379
1455
|
console.log("ENTER:", "ArrayBindingPattern");
|
|
@@ -1383,7 +1459,7 @@ var Civet = (() => {
|
|
|
1383
1459
|
return ArrayBindingPattern$0(state);
|
|
1384
1460
|
}
|
|
1385
1461
|
}
|
|
1386
|
-
var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($
|
|
1462
|
+
var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L13, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
|
|
1387
1463
|
var BindingProperty$1 = $S(__, BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
|
|
1388
1464
|
function BindingProperty(state) {
|
|
1389
1465
|
if (state.tokenize) {
|
|
@@ -1392,7 +1468,7 @@ var Civet = (() => {
|
|
|
1392
1468
|
return BindingProperty$0(state) || BindingProperty$1(state);
|
|
1393
1469
|
}
|
|
1394
1470
|
}
|
|
1395
|
-
var BindingRestProperty$0 = $S($EXPECT($
|
|
1471
|
+
var BindingRestProperty$0 = $S($EXPECT($L33, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
|
|
1396
1472
|
function BindingRestProperty(state) {
|
|
1397
1473
|
if (state.verbose)
|
|
1398
1474
|
console.log("ENTER:", "BindingRestProperty");
|
|
@@ -1412,7 +1488,7 @@ var Civet = (() => {
|
|
|
1412
1488
|
return BindingElement$0(state);
|
|
1413
1489
|
}
|
|
1414
1490
|
}
|
|
1415
|
-
var BindingRestElement$0 = $S($EXPECT($
|
|
1491
|
+
var BindingRestElement$0 = $S($EXPECT($L33, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
|
|
1416
1492
|
function BindingRestElement(state) {
|
|
1417
1493
|
if (state.verbose)
|
|
1418
1494
|
console.log("ENTER:", "BindingRestElement");
|
|
@@ -1433,7 +1509,7 @@ var Civet = (() => {
|
|
|
1433
1509
|
}
|
|
1434
1510
|
}
|
|
1435
1511
|
var FunctionExpression$0 = ThinArrowFunction;
|
|
1436
|
-
var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($
|
|
1512
|
+
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);
|
|
1437
1513
|
function FunctionExpression(state) {
|
|
1438
1514
|
if (state.tokenize) {
|
|
1439
1515
|
return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
|
|
@@ -1441,11 +1517,17 @@ var Civet = (() => {
|
|
|
1441
1517
|
return FunctionExpression$0(state) || FunctionExpression$1(state);
|
|
1442
1518
|
}
|
|
1443
1519
|
}
|
|
1444
|
-
var ThinArrowFunction$0 = $
|
|
1445
|
-
var params =
|
|
1446
|
-
var suffix =
|
|
1447
|
-
var
|
|
1448
|
-
|
|
1520
|
+
var ThinArrowFunction$0 = $TS($S(Parameters, $E(ReturnTypeSuffix), __, Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1521
|
+
var params = $1;
|
|
1522
|
+
var suffix = $2;
|
|
1523
|
+
var arrow = $4;
|
|
1524
|
+
var block = $5;
|
|
1525
|
+
return [
|
|
1526
|
+
{ $loc: arrow.$loc, token: "function" },
|
|
1527
|
+
params,
|
|
1528
|
+
suffix,
|
|
1529
|
+
block
|
|
1530
|
+
];
|
|
1449
1531
|
});
|
|
1450
1532
|
function ThinArrowFunction(state) {
|
|
1451
1533
|
if (state.verbose)
|
|
@@ -1456,7 +1538,19 @@ var Civet = (() => {
|
|
|
1456
1538
|
return ThinArrowFunction$0(state);
|
|
1457
1539
|
}
|
|
1458
1540
|
}
|
|
1459
|
-
var
|
|
1541
|
+
var Arrow$0 = $TV($EXPECT($L35, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
1542
|
+
return { $loc, token: $1 };
|
|
1543
|
+
});
|
|
1544
|
+
function Arrow(state) {
|
|
1545
|
+
if (state.verbose)
|
|
1546
|
+
console.log("ENTER:", "Arrow");
|
|
1547
|
+
if (state.tokenize) {
|
|
1548
|
+
return $TOKEN("Arrow", state, Arrow$0(state));
|
|
1549
|
+
} else {
|
|
1550
|
+
return Arrow$0(state);
|
|
1551
|
+
}
|
|
1552
|
+
}
|
|
1553
|
+
var Block$0 = $S(__, $EXPECT($L12, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L17, fail, 'Block "}"'));
|
|
1460
1554
|
var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1461
1555
|
var Block$2 = Statement;
|
|
1462
1556
|
var Block$3 = $S(__, Statement);
|
|
@@ -1467,7 +1561,16 @@ var Civet = (() => {
|
|
|
1467
1561
|
return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
|
|
1468
1562
|
}
|
|
1469
1563
|
}
|
|
1470
|
-
var
|
|
1564
|
+
var BracedOrEmptyBlock$0 = BracedBlock;
|
|
1565
|
+
var BracedOrEmptyBlock$1 = $S(InsertOpenBrace, InsertCloseBrace);
|
|
1566
|
+
function BracedOrEmptyBlock(state) {
|
|
1567
|
+
if (state.tokenize) {
|
|
1568
|
+
return $TOKEN("BracedOrEmptyBlock", state, BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state));
|
|
1569
|
+
} else {
|
|
1570
|
+
return BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state);
|
|
1571
|
+
}
|
|
1572
|
+
}
|
|
1573
|
+
var BracedBlock$0 = $S(__, $EXPECT($L12, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L17, fail, 'BracedBlock "}"'));
|
|
1471
1574
|
var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1472
1575
|
var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
|
|
1473
1576
|
function BracedBlock(state) {
|
|
@@ -1532,17 +1635,39 @@ var Civet = (() => {
|
|
|
1532
1635
|
return BlockExpression$0(state);
|
|
1533
1636
|
}
|
|
1534
1637
|
}
|
|
1535
|
-
var Literal$0 =
|
|
1536
|
-
var Literal$1 =
|
|
1537
|
-
var Literal$2 =
|
|
1538
|
-
var Literal$3 =
|
|
1539
|
-
var Literal$4 = $EXPECT($L37, fail, 'Literal "null"');
|
|
1540
|
-
var Literal$5 = $EXPECT($L38, fail, 'Literal "undefined"');
|
|
1638
|
+
var Literal$0 = NullLiteral;
|
|
1639
|
+
var Literal$1 = BooleanLiteral;
|
|
1640
|
+
var Literal$2 = NumericLiteral;
|
|
1641
|
+
var Literal$3 = StringLiteral;
|
|
1541
1642
|
function Literal(state) {
|
|
1542
1643
|
if (state.tokenize) {
|
|
1543
|
-
return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state)
|
|
1644
|
+
return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state));
|
|
1544
1645
|
} else {
|
|
1545
|
-
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state)
|
|
1646
|
+
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
|
|
1647
|
+
}
|
|
1648
|
+
}
|
|
1649
|
+
var NullLiteral$0 = $TV($EXPECT($L36, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
1650
|
+
return { $loc, token: $1 };
|
|
1651
|
+
});
|
|
1652
|
+
function NullLiteral(state) {
|
|
1653
|
+
if (state.verbose)
|
|
1654
|
+
console.log("ENTER:", "NullLiteral");
|
|
1655
|
+
if (state.tokenize) {
|
|
1656
|
+
return $TOKEN("NullLiteral", state, NullLiteral$0(state));
|
|
1657
|
+
} else {
|
|
1658
|
+
return NullLiteral$0(state);
|
|
1659
|
+
}
|
|
1660
|
+
}
|
|
1661
|
+
var BooleanLiteral$0 = $TV($C($EXPECT($L37, fail, 'BooleanLiteral "true"'), $EXPECT($L38, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
|
|
1662
|
+
return { $loc, token: $1 };
|
|
1663
|
+
});
|
|
1664
|
+
function BooleanLiteral(state) {
|
|
1665
|
+
if (state.verbose)
|
|
1666
|
+
console.log("ENTER:", "BooleanLiteral");
|
|
1667
|
+
if (state.tokenize) {
|
|
1668
|
+
return $TOKEN("BooleanLiteral", state, BooleanLiteral$0(state));
|
|
1669
|
+
} else {
|
|
1670
|
+
return BooleanLiteral$0(state);
|
|
1546
1671
|
}
|
|
1547
1672
|
}
|
|
1548
1673
|
var Comma$0 = $S($Q(_), $EXPECT($L0, fail, 'Comma ","'), $Q(_));
|
|
@@ -1590,8 +1715,8 @@ var Civet = (() => {
|
|
|
1590
1715
|
return IdentifierReference$0(state);
|
|
1591
1716
|
}
|
|
1592
1717
|
}
|
|
1593
|
-
var ArrayLiteral$0 = $S($EXPECT($
|
|
1594
|
-
var ArrayLiteral$1 = $S($EXPECT($
|
|
1718
|
+
var ArrayLiteral$0 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
|
|
1719
|
+
var ArrayLiteral$1 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
|
|
1595
1720
|
function ArrayLiteral(state) {
|
|
1596
1721
|
if (state.tokenize) {
|
|
1597
1722
|
return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
|
|
@@ -1625,8 +1750,8 @@ var Civet = (() => {
|
|
|
1625
1750
|
}
|
|
1626
1751
|
}
|
|
1627
1752
|
var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
|
|
1628
|
-
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1629
|
-
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
1753
|
+
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L27, fail, 'ArrayElementDelimiter "]"')));
|
|
1754
|
+
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L27, fail, 'ArrayElementDelimiter "]"'))), function(value) {
|
|
1630
1755
|
return ",";
|
|
1631
1756
|
});
|
|
1632
1757
|
var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1659,7 +1784,7 @@ var Civet = (() => {
|
|
|
1659
1784
|
return InlineElementList$0(state);
|
|
1660
1785
|
}
|
|
1661
1786
|
}
|
|
1662
|
-
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($
|
|
1787
|
+
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L33, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
|
|
1663
1788
|
function ArrayElementExpression(state) {
|
|
1664
1789
|
if (state.verbose)
|
|
1665
1790
|
console.log("ENTER:", "ArrayElementExpression");
|
|
@@ -1679,9 +1804,9 @@ var Civet = (() => {
|
|
|
1679
1804
|
return Elision$0(state);
|
|
1680
1805
|
}
|
|
1681
1806
|
}
|
|
1682
|
-
var ObjectLiteral$0 = $S($EXPECT($
|
|
1683
|
-
var ObjectLiteral$1 = $S($EXPECT($
|
|
1684
|
-
var ObjectLiteral$2 = $S($EXPECT($
|
|
1807
|
+
var ObjectLiteral$0 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L17, fail, 'ObjectLiteral "}"'));
|
|
1808
|
+
var ObjectLiteral$1 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L17, fail, 'ObjectLiteral "}"'));
|
|
1809
|
+
var ObjectLiteral$2 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), __, $EXPECT($L17, fail, 'ObjectLiteral "}"'));
|
|
1685
1810
|
var ObjectLiteral$3 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1686
1811
|
function ObjectLiteral(state) {
|
|
1687
1812
|
if (state.tokenize) {
|
|
@@ -1716,8 +1841,8 @@ var Civet = (() => {
|
|
|
1716
1841
|
}
|
|
1717
1842
|
}
|
|
1718
1843
|
var ObjectPropertyDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ObjectPropertyDelimiter ","'));
|
|
1719
|
-
var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1720
|
-
var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
1844
|
+
var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L17, fail, 'ObjectPropertyDelimiter "}"')));
|
|
1845
|
+
var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L17, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
|
|
1721
1846
|
return ",";
|
|
1722
1847
|
});
|
|
1723
1848
|
var ObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1740,9 +1865,9 @@ var Civet = (() => {
|
|
|
1740
1865
|
return PropertyDefinitionList$0(state);
|
|
1741
1866
|
}
|
|
1742
1867
|
}
|
|
1743
|
-
var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($
|
|
1868
|
+
var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L13, fail, 'PropertyDefinition ":"'), AssignmentExpression);
|
|
1744
1869
|
var PropertyDefinition$1 = MethodDefinition;
|
|
1745
|
-
var PropertyDefinition$2 = $S($EXPECT($
|
|
1870
|
+
var PropertyDefinition$2 = $S($EXPECT($L33, fail, 'PropertyDefinition "..."'), AssignmentExpression);
|
|
1746
1871
|
var PropertyDefinition$3 = IdentifierReference;
|
|
1747
1872
|
function PropertyDefinition(state) {
|
|
1748
1873
|
if (state.tokenize) {
|
|
@@ -1754,7 +1879,7 @@ var Civet = (() => {
|
|
|
1754
1879
|
var PropertyName$0 = NumericLiteral;
|
|
1755
1880
|
var PropertyName$1 = StringLiteral;
|
|
1756
1881
|
var PropertyName$2 = IdentifierName;
|
|
1757
|
-
var PropertyName$3 = $S($EXPECT($
|
|
1882
|
+
var PropertyName$3 = $S($EXPECT($L26, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L27, fail, 'PropertyName "]"'));
|
|
1758
1883
|
function PropertyName(state) {
|
|
1759
1884
|
if (state.tokenize) {
|
|
1760
1885
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -1794,7 +1919,7 @@ var Civet = (() => {
|
|
|
1794
1919
|
return PrivateIdentifier$0(state);
|
|
1795
1920
|
}
|
|
1796
1921
|
}
|
|
1797
|
-
var GeneratorMethod$0 = $S($EXPECT($
|
|
1922
|
+
var GeneratorMethod$0 = $S($EXPECT($L10, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
|
|
1798
1923
|
function GeneratorMethod(state) {
|
|
1799
1924
|
if (state.verbose)
|
|
1800
1925
|
console.log("ENTER:", "GeneratorMethod");
|
|
@@ -1834,7 +1959,7 @@ var Civet = (() => {
|
|
|
1834
1959
|
return AsyncFunctionBody$0(state);
|
|
1835
1960
|
}
|
|
1836
1961
|
}
|
|
1837
|
-
var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($
|
|
1962
|
+
var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L10, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
|
|
1838
1963
|
function AsyncGeneratorMethod(state) {
|
|
1839
1964
|
if (state.verbose)
|
|
1840
1965
|
console.log("ENTER:", "AsyncGeneratorMethod");
|
|
@@ -1854,76 +1979,100 @@ var Civet = (() => {
|
|
|
1854
1979
|
return AsyncGeneratorBody$0(state);
|
|
1855
1980
|
}
|
|
1856
1981
|
}
|
|
1857
|
-
var AssignmentOp$0 = $
|
|
1858
|
-
|
|
1859
|
-
|
|
1860
|
-
var AssignmentOp$3 = $EXPECT($L44, fail, 'AssignmentOp "%="');
|
|
1861
|
-
var AssignmentOp$4 = $EXPECT($L45, fail, 'AssignmentOp "+="');
|
|
1862
|
-
var AssignmentOp$5 = $EXPECT($L46, fail, 'AssignmentOp "-="');
|
|
1863
|
-
var AssignmentOp$6 = $EXPECT($L47, fail, 'AssignmentOp "<<="');
|
|
1864
|
-
var AssignmentOp$7 = $EXPECT($L48, fail, 'AssignmentOp ">>>="');
|
|
1865
|
-
var AssignmentOp$8 = $EXPECT($L49, fail, 'AssignmentOp ">>="');
|
|
1866
|
-
var AssignmentOp$9 = $EXPECT($L50, fail, 'AssignmentOp "&&="');
|
|
1867
|
-
var AssignmentOp$10 = $EXPECT($L51, fail, 'AssignmentOp "&="');
|
|
1868
|
-
var AssignmentOp$11 = $EXPECT($L52, fail, 'AssignmentOp "^="');
|
|
1869
|
-
var AssignmentOp$12 = $EXPECT($L53, fail, 'AssignmentOp "||="');
|
|
1870
|
-
var AssignmentOp$13 = $EXPECT($L54, fail, 'AssignmentOp "|="');
|
|
1871
|
-
var AssignmentOp$14 = $EXPECT($L55, fail, 'AssignmentOp "??="');
|
|
1872
|
-
var AssignmentOp$15 = $EXPECT($L56, fail, 'AssignmentOp "="');
|
|
1982
|
+
var AssignmentOp$0 = $TS($S(AssignmentOpSymbol), function($skip, $loc, $0, $1) {
|
|
1983
|
+
return { $loc, token: $1 };
|
|
1984
|
+
});
|
|
1873
1985
|
function AssignmentOp(state) {
|
|
1986
|
+
if (state.verbose)
|
|
1987
|
+
console.log("ENTER:", "AssignmentOp");
|
|
1874
1988
|
if (state.tokenize) {
|
|
1875
|
-
return $TOKEN("AssignmentOp", state, AssignmentOp$0(state)
|
|
1876
|
-
} else {
|
|
1877
|
-
return AssignmentOp$0(state)
|
|
1878
|
-
}
|
|
1879
|
-
}
|
|
1880
|
-
var
|
|
1881
|
-
var
|
|
1882
|
-
var
|
|
1883
|
-
var
|
|
1884
|
-
var
|
|
1885
|
-
var
|
|
1886
|
-
var
|
|
1887
|
-
var
|
|
1888
|
-
var
|
|
1889
|
-
var
|
|
1890
|
-
var
|
|
1891
|
-
var
|
|
1892
|
-
var
|
|
1893
|
-
var
|
|
1894
|
-
var
|
|
1989
|
+
return $TOKEN("AssignmentOp", state, AssignmentOp$0(state));
|
|
1990
|
+
} else {
|
|
1991
|
+
return AssignmentOp$0(state);
|
|
1992
|
+
}
|
|
1993
|
+
}
|
|
1994
|
+
var AssignmentOpSymbol$0 = $EXPECT($L41, fail, 'AssignmentOpSymbol "**="');
|
|
1995
|
+
var AssignmentOpSymbol$1 = $EXPECT($L42, fail, 'AssignmentOpSymbol "*="');
|
|
1996
|
+
var AssignmentOpSymbol$2 = $EXPECT($L43, fail, 'AssignmentOpSymbol "/="');
|
|
1997
|
+
var AssignmentOpSymbol$3 = $EXPECT($L44, fail, 'AssignmentOpSymbol "%="');
|
|
1998
|
+
var AssignmentOpSymbol$4 = $EXPECT($L45, fail, 'AssignmentOpSymbol "+="');
|
|
1999
|
+
var AssignmentOpSymbol$5 = $EXPECT($L46, fail, 'AssignmentOpSymbol "-="');
|
|
2000
|
+
var AssignmentOpSymbol$6 = $EXPECT($L47, fail, 'AssignmentOpSymbol "<<="');
|
|
2001
|
+
var AssignmentOpSymbol$7 = $EXPECT($L48, fail, 'AssignmentOpSymbol ">>>="');
|
|
2002
|
+
var AssignmentOpSymbol$8 = $EXPECT($L49, fail, 'AssignmentOpSymbol ">>="');
|
|
2003
|
+
var AssignmentOpSymbol$9 = $EXPECT($L50, fail, 'AssignmentOpSymbol "&&="');
|
|
2004
|
+
var AssignmentOpSymbol$10 = $EXPECT($L51, fail, 'AssignmentOpSymbol "&="');
|
|
2005
|
+
var AssignmentOpSymbol$11 = $EXPECT($L52, fail, 'AssignmentOpSymbol "^="');
|
|
2006
|
+
var AssignmentOpSymbol$12 = $EXPECT($L53, fail, 'AssignmentOpSymbol "||="');
|
|
2007
|
+
var AssignmentOpSymbol$13 = $EXPECT($L54, fail, 'AssignmentOpSymbol "|="');
|
|
2008
|
+
var AssignmentOpSymbol$14 = $EXPECT($L55, fail, 'AssignmentOpSymbol "??="');
|
|
2009
|
+
var AssignmentOpSymbol$15 = $EXPECT($L56, fail, 'AssignmentOpSymbol "="');
|
|
2010
|
+
function AssignmentOpSymbol(state) {
|
|
2011
|
+
if (state.tokenize) {
|
|
2012
|
+
return $TOKEN("AssignmentOpSymbol", state, AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state));
|
|
2013
|
+
} else {
|
|
2014
|
+
return 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);
|
|
2015
|
+
}
|
|
2016
|
+
}
|
|
2017
|
+
var BinaryOp$0 = $TS($S(BinaryOpSymbol), function($skip, $loc, $0, $1) {
|
|
2018
|
+
return { $loc, token: $1 };
|
|
2019
|
+
});
|
|
2020
|
+
function BinaryOp(state) {
|
|
2021
|
+
if (state.verbose)
|
|
2022
|
+
console.log("ENTER:", "BinaryOp");
|
|
2023
|
+
if (state.tokenize) {
|
|
2024
|
+
return $TOKEN("BinaryOp", state, BinaryOp$0(state));
|
|
2025
|
+
} else {
|
|
2026
|
+
return BinaryOp$0(state);
|
|
2027
|
+
}
|
|
2028
|
+
}
|
|
2029
|
+
var BinaryOpSymbol$0 = $EXPECT($L57, fail, 'BinaryOpSymbol "**"');
|
|
2030
|
+
var BinaryOpSymbol$1 = $EXPECT($L10, fail, 'BinaryOpSymbol "*"');
|
|
2031
|
+
var BinaryOpSymbol$2 = $EXPECT($L58, fail, 'BinaryOpSymbol "/"');
|
|
2032
|
+
var BinaryOpSymbol$3 = $EXPECT($L59, fail, 'BinaryOpSymbol "%"');
|
|
2033
|
+
var BinaryOpSymbol$4 = $EXPECT($L60, fail, 'BinaryOpSymbol "+"');
|
|
2034
|
+
var BinaryOpSymbol$5 = $EXPECT($L61, fail, 'BinaryOpSymbol "-"');
|
|
2035
|
+
var BinaryOpSymbol$6 = $EXPECT($L62, fail, 'BinaryOpSymbol "<="');
|
|
2036
|
+
var BinaryOpSymbol$7 = $EXPECT($L63, fail, 'BinaryOpSymbol ">="');
|
|
2037
|
+
var BinaryOpSymbol$8 = $EXPECT($L64, fail, 'BinaryOpSymbol "<<"');
|
|
2038
|
+
var BinaryOpSymbol$9 = $EXPECT($L15, fail, 'BinaryOpSymbol "<"');
|
|
2039
|
+
var BinaryOpSymbol$10 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>>"');
|
|
2040
|
+
var BinaryOpSymbol$11 = $EXPECT($L66, fail, 'BinaryOpSymbol ">>"');
|
|
2041
|
+
var BinaryOpSymbol$12 = $EXPECT($L67, fail, 'BinaryOpSymbol ">"');
|
|
2042
|
+
var BinaryOpSymbol$13 = $EXPECT($L68, fail, 'BinaryOpSymbol "!=="');
|
|
2043
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L69, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
1895
2044
|
if (global.coffeeCompat)
|
|
1896
2045
|
return "!==";
|
|
1897
2046
|
return $1;
|
|
1898
2047
|
});
|
|
1899
|
-
var
|
|
2048
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L70, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
1900
2049
|
return "===";
|
|
1901
2050
|
});
|
|
1902
|
-
var
|
|
1903
|
-
var
|
|
2051
|
+
var BinaryOpSymbol$16 = $EXPECT($L71, fail, 'BinaryOpSymbol "==="');
|
|
2052
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L72, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
1904
2053
|
if (global.coffeeCompat)
|
|
1905
2054
|
return "===";
|
|
1906
2055
|
return $1;
|
|
1907
2056
|
});
|
|
1908
|
-
var
|
|
2057
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L73, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
1909
2058
|
return "&&";
|
|
1910
2059
|
});
|
|
1911
|
-
var
|
|
1912
|
-
var
|
|
2060
|
+
var BinaryOpSymbol$19 = $EXPECT($L74, fail, 'BinaryOpSymbol "&&"');
|
|
2061
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L75, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
1913
2062
|
return "||";
|
|
1914
2063
|
});
|
|
1915
|
-
var
|
|
1916
|
-
var
|
|
1917
|
-
var
|
|
1918
|
-
var
|
|
1919
|
-
var
|
|
1920
|
-
var
|
|
1921
|
-
var
|
|
1922
|
-
function
|
|
2064
|
+
var BinaryOpSymbol$21 = $EXPECT($L76, fail, 'BinaryOpSymbol "||"');
|
|
2065
|
+
var BinaryOpSymbol$22 = $EXPECT($L77, fail, 'BinaryOpSymbol "??"');
|
|
2066
|
+
var BinaryOpSymbol$23 = $S($EXPECT($L78, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue);
|
|
2067
|
+
var BinaryOpSymbol$24 = $S($EXPECT($L79, fail, 'BinaryOpSymbol "in"'), NonIdContinue);
|
|
2068
|
+
var BinaryOpSymbol$25 = $EXPECT($L80, fail, 'BinaryOpSymbol "&"');
|
|
2069
|
+
var BinaryOpSymbol$26 = $EXPECT($L81, fail, 'BinaryOpSymbol "^"');
|
|
2070
|
+
var BinaryOpSymbol$27 = $EXPECT($L82, fail, 'BinaryOpSymbol "|"');
|
|
2071
|
+
function BinaryOpSymbol(state) {
|
|
1923
2072
|
if (state.tokenize) {
|
|
1924
|
-
return $TOKEN("
|
|
2073
|
+
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));
|
|
1925
2074
|
} else {
|
|
1926
|
-
return
|
|
2075
|
+
return 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);
|
|
1927
2076
|
}
|
|
1928
2077
|
}
|
|
1929
2078
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
@@ -2004,7 +2153,7 @@ var Civet = (() => {
|
|
|
2004
2153
|
return EmptyStatement$0(state);
|
|
2005
2154
|
}
|
|
2006
2155
|
}
|
|
2007
|
-
var BlockStatement$0 = $S(__, $EXPECT($
|
|
2156
|
+
var BlockStatement$0 = $S(__, $EXPECT($L12, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L17, fail, 'BlockStatement "}"'));
|
|
2008
2157
|
function BlockStatement(state) {
|
|
2009
2158
|
if (state.verbose)
|
|
2010
2159
|
console.log("ENTER:", "BlockStatement");
|
|
@@ -2097,7 +2246,7 @@ var Civet = (() => {
|
|
|
2097
2246
|
return WhileClause$0(state);
|
|
2098
2247
|
}
|
|
2099
2248
|
}
|
|
2100
|
-
var ForStatement$0 = $S(
|
|
2249
|
+
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);
|
|
2101
2250
|
function ForStatement(state) {
|
|
2102
2251
|
if (state.verbose)
|
|
2103
2252
|
console.log("ENTER:", "ForStatement");
|
|
@@ -2107,10 +2256,10 @@ var Civet = (() => {
|
|
|
2107
2256
|
return ForStatement$0(state);
|
|
2108
2257
|
}
|
|
2109
2258
|
}
|
|
2110
|
-
var ForInOfStatement$0 = $S(
|
|
2111
|
-
var ForInOfStatement$1 = $S(
|
|
2112
|
-
var ForInOfStatement$2 = $S(
|
|
2113
|
-
var ForInOfStatement$3 = $S(
|
|
2259
|
+
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);
|
|
2260
|
+
var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
|
|
2261
|
+
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);
|
|
2262
|
+
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);
|
|
2114
2263
|
function ForInOfStatement(state) {
|
|
2115
2264
|
if (state.tokenize) {
|
|
2116
2265
|
return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
|
|
@@ -2118,7 +2267,19 @@ var Civet = (() => {
|
|
|
2118
2267
|
return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
|
|
2119
2268
|
}
|
|
2120
2269
|
}
|
|
2121
|
-
var
|
|
2270
|
+
var For$0 = $TS($S($EXPECT($L96, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2271
|
+
return { $loc, token: $1 };
|
|
2272
|
+
});
|
|
2273
|
+
function For(state) {
|
|
2274
|
+
if (state.verbose)
|
|
2275
|
+
console.log("ENTER:", "For");
|
|
2276
|
+
if (state.tokenize) {
|
|
2277
|
+
return $TOKEN("For", state, For$0(state));
|
|
2278
|
+
} else {
|
|
2279
|
+
return For$0(state);
|
|
2280
|
+
}
|
|
2281
|
+
}
|
|
2282
|
+
var ForDeclaration$0 = $S(LetOrConst, NonIdContinue, __, ForBinding);
|
|
2122
2283
|
function ForDeclaration(state) {
|
|
2123
2284
|
if (state.verbose)
|
|
2124
2285
|
console.log("ENTER:", "ForDeclaration");
|
|
@@ -2128,6 +2289,18 @@ var Civet = (() => {
|
|
|
2128
2289
|
return ForDeclaration$0(state);
|
|
2129
2290
|
}
|
|
2130
2291
|
}
|
|
2292
|
+
var LetOrConst$0 = $TV($C($EXPECT($L97, fail, 'LetOrConst "let"'), $EXPECT($L98, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
2293
|
+
return { $loc, token: $1 };
|
|
2294
|
+
});
|
|
2295
|
+
function LetOrConst(state) {
|
|
2296
|
+
if (state.verbose)
|
|
2297
|
+
console.log("ENTER:", "LetOrConst");
|
|
2298
|
+
if (state.tokenize) {
|
|
2299
|
+
return $TOKEN("LetOrConst", state, LetOrConst$0(state));
|
|
2300
|
+
} else {
|
|
2301
|
+
return LetOrConst$0(state);
|
|
2302
|
+
}
|
|
2303
|
+
}
|
|
2131
2304
|
var ForBinding$0 = BindingIdentifier;
|
|
2132
2305
|
var ForBinding$1 = BindingPattern;
|
|
2133
2306
|
function ForBinding(state) {
|
|
@@ -2137,7 +2310,7 @@ var Civet = (() => {
|
|
|
2137
2310
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
2138
2311
|
}
|
|
2139
2312
|
}
|
|
2140
|
-
var SwitchStatement$0 = $S($EXPECT($
|
|
2313
|
+
var SwitchStatement$0 = $S($EXPECT($L99, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
|
|
2141
2314
|
function SwitchStatement(state) {
|
|
2142
2315
|
if (state.verbose)
|
|
2143
2316
|
console.log("ENTER:", "SwitchStatement");
|
|
@@ -2147,7 +2320,7 @@ var Civet = (() => {
|
|
|
2147
2320
|
return SwitchStatement$0(state);
|
|
2148
2321
|
}
|
|
2149
2322
|
}
|
|
2150
|
-
var CaseBlock$0 = $S(__, $EXPECT($
|
|
2323
|
+
var CaseBlock$0 = $S(__, $EXPECT($L12, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L17, fail, 'CaseBlock "}"'));
|
|
2151
2324
|
var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
|
|
2152
2325
|
function CaseBlock(state) {
|
|
2153
2326
|
if (state.tokenize) {
|
|
@@ -2181,9 +2354,9 @@ var Civet = (() => {
|
|
|
2181
2354
|
return NestedCaseClause$0(state);
|
|
2182
2355
|
}
|
|
2183
2356
|
}
|
|
2184
|
-
var CaseClause$0 = $S($EXPECT($
|
|
2357
|
+
var CaseClause$0 = $S($EXPECT($L100, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
|
|
2185
2358
|
var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
|
|
2186
|
-
var CaseClause$2 = $S($EXPECT($
|
|
2359
|
+
var CaseClause$2 = $S($EXPECT($L101, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
|
|
2187
2360
|
function CaseClause(state) {
|
|
2188
2361
|
if (state.tokenize) {
|
|
2189
2362
|
return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
|
|
@@ -2191,7 +2364,7 @@ var Civet = (() => {
|
|
|
2191
2364
|
return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
|
|
2192
2365
|
}
|
|
2193
2366
|
}
|
|
2194
|
-
var When$0 = $T($S($EXPECT($
|
|
2367
|
+
var When$0 = $T($S($EXPECT($L102, fail, 'When "when"'), NonIdContinue), function(value) {
|
|
2195
2368
|
return "case";
|
|
2196
2369
|
});
|
|
2197
2370
|
function When(state) {
|
|
@@ -2203,8 +2376,8 @@ var Civet = (() => {
|
|
|
2203
2376
|
return When$0(state);
|
|
2204
2377
|
}
|
|
2205
2378
|
}
|
|
2206
|
-
var ImpliedColon$0 = $S(__, $EXPECT($
|
|
2207
|
-
var ImpliedColon$1 = $T($EXPECT($
|
|
2379
|
+
var ImpliedColon$0 = $S(__, $EXPECT($L13, fail, 'ImpliedColon ":"'));
|
|
2380
|
+
var ImpliedColon$1 = $T($EXPECT($L32, fail, 'ImpliedColon ""'), function(value) {
|
|
2208
2381
|
return ":";
|
|
2209
2382
|
});
|
|
2210
2383
|
function ImpliedColon(state) {
|
|
@@ -2214,7 +2387,7 @@ var Civet = (() => {
|
|
|
2214
2387
|
return ImpliedColon$0(state) || ImpliedColon$1(state);
|
|
2215
2388
|
}
|
|
2216
2389
|
}
|
|
2217
|
-
var TryStatement$0 = $TS($S($EXPECT($
|
|
2390
|
+
var TryStatement$0 = $TS($S($EXPECT($L103, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2218
2391
|
var c = $3;
|
|
2219
2392
|
var f = $4;
|
|
2220
2393
|
if (!c && !f) {
|
|
@@ -2231,7 +2404,7 @@ var Civet = (() => {
|
|
|
2231
2404
|
return TryStatement$0(state);
|
|
2232
2405
|
}
|
|
2233
2406
|
}
|
|
2234
|
-
var Catch$0 = $S(__, $EXPECT($
|
|
2407
|
+
var Catch$0 = $S(__, $EXPECT($L104, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
|
|
2235
2408
|
function Catch(state) {
|
|
2236
2409
|
if (state.verbose)
|
|
2237
2410
|
console.log("ENTER:", "Catch");
|
|
@@ -2250,7 +2423,7 @@ var Civet = (() => {
|
|
|
2250
2423
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2251
2424
|
}
|
|
2252
2425
|
}
|
|
2253
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2426
|
+
var Finally$0 = $S(__, $EXPECT($L105, fail, 'Finally "finally"'), BracedBlock);
|
|
2254
2427
|
function Finally(state) {
|
|
2255
2428
|
if (state.verbose)
|
|
2256
2429
|
console.log("ENTER:", "Finally");
|
|
@@ -2288,11 +2461,11 @@ var Civet = (() => {
|
|
|
2288
2461
|
return ExpressionStatement$0(state);
|
|
2289
2462
|
}
|
|
2290
2463
|
}
|
|
2291
|
-
var KeywordStatement$0 = $S($EXPECT($
|
|
2292
|
-
var KeywordStatement$1 = $S($EXPECT($
|
|
2293
|
-
var KeywordStatement$2 = $S($EXPECT($
|
|
2464
|
+
var KeywordStatement$0 = $S($EXPECT($L106, fail, 'KeywordStatement "break"'), NonIdContinue);
|
|
2465
|
+
var KeywordStatement$1 = $S($EXPECT($L107, fail, 'KeywordStatement "continue"'), NonIdContinue);
|
|
2466
|
+
var KeywordStatement$2 = $S($EXPECT($L108, fail, 'KeywordStatement "debugger"'), NonIdContinue);
|
|
2294
2467
|
var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
|
|
2295
|
-
var KeywordStatement$4 = $S($EXPECT($
|
|
2468
|
+
var KeywordStatement$4 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
|
|
2296
2469
|
function KeywordStatement(state) {
|
|
2297
2470
|
if (state.tokenize) {
|
|
2298
2471
|
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
|
|
@@ -2309,7 +2482,9 @@ var Civet = (() => {
|
|
|
2309
2482
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2310
2483
|
}
|
|
2311
2484
|
}
|
|
2312
|
-
var Return$0 = $S($EXPECT($
|
|
2485
|
+
var Return$0 = $TS($S($EXPECT($L110, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2486
|
+
return { $loc, token: $1 };
|
|
2487
|
+
});
|
|
2313
2488
|
function Return(state) {
|
|
2314
2489
|
if (state.verbose)
|
|
2315
2490
|
console.log("ENTER:", "Return");
|
|
@@ -2319,11 +2494,11 @@ var Civet = (() => {
|
|
|
2319
2494
|
return Return$0(state);
|
|
2320
2495
|
}
|
|
2321
2496
|
}
|
|
2322
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2497
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L111, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2323
2498
|
return { "ts": true, "children": value };
|
|
2324
2499
|
});
|
|
2325
|
-
var ImportDeclaration$1 = $S(
|
|
2326
|
-
var ImportDeclaration$2 = $S(
|
|
2500
|
+
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
2501
|
+
var ImportDeclaration$2 = $S(Import, __, ModuleSpecifier);
|
|
2327
2502
|
function ImportDeclaration(state) {
|
|
2328
2503
|
if (state.tokenize) {
|
|
2329
2504
|
return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
|
|
@@ -2331,6 +2506,18 @@ var Civet = (() => {
|
|
|
2331
2506
|
return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state);
|
|
2332
2507
|
}
|
|
2333
2508
|
}
|
|
2509
|
+
var Import$0 = $TS($S($EXPECT($L24, fail, 'Import "import"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2510
|
+
return { $loc, token: $1 };
|
|
2511
|
+
});
|
|
2512
|
+
function Import(state) {
|
|
2513
|
+
if (state.verbose)
|
|
2514
|
+
console.log("ENTER:", "Import");
|
|
2515
|
+
if (state.tokenize) {
|
|
2516
|
+
return $TOKEN("Import", state, Import$0(state));
|
|
2517
|
+
} else {
|
|
2518
|
+
return Import$0(state);
|
|
2519
|
+
}
|
|
2520
|
+
}
|
|
2334
2521
|
var ImportClause$0 = $S(ImportedBinding, $E($S(__, $EXPECT($L0, fail, 'ImportClause ","'), __, $C(NameSpaceImport, NamedImports))));
|
|
2335
2522
|
var ImportClause$1 = NameSpaceImport;
|
|
2336
2523
|
var ImportClause$2 = NamedImports;
|
|
@@ -2341,7 +2528,7 @@ var Civet = (() => {
|
|
|
2341
2528
|
return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
|
|
2342
2529
|
}
|
|
2343
2530
|
}
|
|
2344
|
-
var NameSpaceImport$0 = $S($EXPECT($
|
|
2531
|
+
var NameSpaceImport$0 = $S($EXPECT($L10, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), NonIdContinue, __, ImportedBinding);
|
|
2345
2532
|
function NameSpaceImport(state) {
|
|
2346
2533
|
if (state.verbose)
|
|
2347
2534
|
console.log("ENTER:", "NameSpaceImport");
|
|
@@ -2351,7 +2538,7 @@ var Civet = (() => {
|
|
|
2351
2538
|
return NameSpaceImport$0(state);
|
|
2352
2539
|
}
|
|
2353
2540
|
}
|
|
2354
|
-
var NamedImports$0 = $S($EXPECT($
|
|
2541
|
+
var NamedImports$0 = $S($EXPECT($L12, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L17, fail, 'NamedImports "}"'));
|
|
2355
2542
|
function NamedImports(state) {
|
|
2356
2543
|
if (state.verbose)
|
|
2357
2544
|
console.log("ENTER:", "NamedImports");
|
|
@@ -2361,7 +2548,7 @@ var Civet = (() => {
|
|
|
2361
2548
|
return NamedImports$0(state);
|
|
2362
2549
|
}
|
|
2363
2550
|
}
|
|
2364
|
-
var FromClause$0 = $S(
|
|
2551
|
+
var FromClause$0 = $S(From, __, ModuleSpecifier);
|
|
2365
2552
|
function FromClause(state) {
|
|
2366
2553
|
if (state.verbose)
|
|
2367
2554
|
console.log("ENTER:", "FromClause");
|
|
@@ -2371,6 +2558,18 @@ var Civet = (() => {
|
|
|
2371
2558
|
return FromClause$0(state);
|
|
2372
2559
|
}
|
|
2373
2560
|
}
|
|
2561
|
+
var From$0 = $TS($S($EXPECT($L112, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2562
|
+
return { $loc, token: $1 };
|
|
2563
|
+
});
|
|
2564
|
+
function From(state) {
|
|
2565
|
+
if (state.verbose)
|
|
2566
|
+
console.log("ENTER:", "From");
|
|
2567
|
+
if (state.tokenize) {
|
|
2568
|
+
return $TOKEN("From", state, From$0(state));
|
|
2569
|
+
} else {
|
|
2570
|
+
return From$0(state);
|
|
2571
|
+
}
|
|
2572
|
+
}
|
|
2374
2573
|
var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
|
|
2375
2574
|
var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
|
|
2376
2575
|
function ImportSpecifier(state) {
|
|
@@ -2409,7 +2608,7 @@ var Civet = (() => {
|
|
|
2409
2608
|
return ImportedBinding$0(state);
|
|
2410
2609
|
}
|
|
2411
2610
|
}
|
|
2412
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
2611
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L101, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2413
2612
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
2414
2613
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
2415
2614
|
function ExportDeclaration(state) {
|
|
@@ -2429,7 +2628,7 @@ var Civet = (() => {
|
|
|
2429
2628
|
return As$0(state);
|
|
2430
2629
|
}
|
|
2431
2630
|
}
|
|
2432
|
-
var Export$0 = $S($EXPECT($
|
|
2631
|
+
var Export$0 = $S($EXPECT($L113, fail, 'Export "export"'), NonIdContinue);
|
|
2433
2632
|
function Export(state) {
|
|
2434
2633
|
if (state.verbose)
|
|
2435
2634
|
console.log("ENTER:", "Export");
|
|
@@ -2439,7 +2638,7 @@ var Civet = (() => {
|
|
|
2439
2638
|
return Export$0(state);
|
|
2440
2639
|
}
|
|
2441
2640
|
}
|
|
2442
|
-
var ExportFromClause$0 = $S($EXPECT($
|
|
2641
|
+
var ExportFromClause$0 = $S($EXPECT($L10, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), NonIdContinue, __, ModuleExportName)));
|
|
2443
2642
|
var ExportFromClause$1 = NamedExports;
|
|
2444
2643
|
function ExportFromClause(state) {
|
|
2445
2644
|
if (state.tokenize) {
|
|
@@ -2448,7 +2647,7 @@ var Civet = (() => {
|
|
|
2448
2647
|
return ExportFromClause$0(state) || ExportFromClause$1(state);
|
|
2449
2648
|
}
|
|
2450
2649
|
}
|
|
2451
|
-
var NamedExports$0 = $S($EXPECT($
|
|
2650
|
+
var NamedExports$0 = $S($EXPECT($L12, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L17, fail, 'NamedExports "}"'));
|
|
2452
2651
|
function NamedExports(state) {
|
|
2453
2652
|
if (state.verbose)
|
|
2454
2653
|
console.log("ENTER:", "NamedExports");
|
|
@@ -2489,7 +2688,7 @@ var Civet = (() => {
|
|
|
2489
2688
|
return HoistableDeclaration$0(state);
|
|
2490
2689
|
}
|
|
2491
2690
|
}
|
|
2492
|
-
var LexicalDeclaration$0 = $S(
|
|
2691
|
+
var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
|
|
2493
2692
|
var LexicalDeclaration$1 = $TS($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
2494
2693
|
var bind = $1;
|
|
2495
2694
|
var suffix = $2;
|
|
@@ -2513,7 +2712,7 @@ var Civet = (() => {
|
|
|
2513
2712
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
2514
2713
|
}
|
|
2515
2714
|
}
|
|
2516
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
2715
|
+
var ConstAssignment$0 = $TV($EXPECT($L114, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
2517
2716
|
return { $loc, token: $0 };
|
|
2518
2717
|
});
|
|
2519
2718
|
function ConstAssignment(state) {
|
|
@@ -2544,7 +2743,7 @@ var Civet = (() => {
|
|
|
2544
2743
|
return Initializer$0(state);
|
|
2545
2744
|
}
|
|
2546
2745
|
}
|
|
2547
|
-
var VariableStatement$0 = $S($EXPECT($
|
|
2746
|
+
var VariableStatement$0 = $S($EXPECT($L94, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
|
|
2548
2747
|
function VariableStatement(state) {
|
|
2549
2748
|
if (state.verbose)
|
|
2550
2749
|
console.log("ENTER:", "VariableStatement");
|
|
@@ -2573,16 +2772,28 @@ var Civet = (() => {
|
|
|
2573
2772
|
return VariableDeclaration$0(state) || VariableDeclaration$1(state);
|
|
2574
2773
|
}
|
|
2575
2774
|
}
|
|
2576
|
-
var NumericLiteral$0 =
|
|
2577
|
-
|
|
2578
|
-
|
|
2579
|
-
var NumericLiteral$3 = HexLiteral;
|
|
2580
|
-
var NumericLiteral$4 = DecimalLiteral;
|
|
2775
|
+
var NumericLiteral$0 = $TS($S(NumericLiteralKind), function($skip, $loc, $0, $1) {
|
|
2776
|
+
return { $loc, token: $1 };
|
|
2777
|
+
});
|
|
2581
2778
|
function NumericLiteral(state) {
|
|
2779
|
+
if (state.verbose)
|
|
2780
|
+
console.log("ENTER:", "NumericLiteral");
|
|
2781
|
+
if (state.tokenize) {
|
|
2782
|
+
return $TOKEN("NumericLiteral", state, NumericLiteral$0(state));
|
|
2783
|
+
} else {
|
|
2784
|
+
return NumericLiteral$0(state);
|
|
2785
|
+
}
|
|
2786
|
+
}
|
|
2787
|
+
var NumericLiteralKind$0 = DecimalBigIntegerLiteral;
|
|
2788
|
+
var NumericLiteralKind$1 = BinaryIntegerLiteral;
|
|
2789
|
+
var NumericLiteralKind$2 = OctalIntegerLiteral;
|
|
2790
|
+
var NumericLiteralKind$3 = HexLiteral;
|
|
2791
|
+
var NumericLiteralKind$4 = DecimalLiteral;
|
|
2792
|
+
function NumericLiteralKind(state) {
|
|
2582
2793
|
if (state.tokenize) {
|
|
2583
|
-
return $TOKEN("
|
|
2794
|
+
return $TOKEN("NumericLiteralKind", state, NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state));
|
|
2584
2795
|
} else {
|
|
2585
|
-
return
|
|
2796
|
+
return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
|
|
2586
2797
|
}
|
|
2587
2798
|
}
|
|
2588
2799
|
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R3, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
@@ -2635,34 +2846,45 @@ var Civet = (() => {
|
|
|
2635
2846
|
return HexLiteral$0(state);
|
|
2636
2847
|
}
|
|
2637
2848
|
}
|
|
2638
|
-
var StringLiteral$0 = $
|
|
2639
|
-
|
|
2849
|
+
var StringLiteral$0 = $TS($S($EXPECT($L115, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L115, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
2850
|
+
var str = $2;
|
|
2851
|
+
return { $loc, token: "`" + module.dedentBlockString(str) + "`" };
|
|
2852
|
+
});
|
|
2853
|
+
var StringLiteral$1 = $TS($S($EXPECT($L116, fail, `StringLiteral "'''"`), $TEXT($Q(TripleSingleStringCharacter)), $EXPECT($L116, fail, `StringLiteral "'''"`)), function($skip, $loc, $0, $1, $2, $3) {
|
|
2854
|
+
var str = $2;
|
|
2855
|
+
return { $loc, token: "`" + module.dedentBlockString(str) + "`" };
|
|
2856
|
+
});
|
|
2857
|
+
var StringLiteral$2 = $TV($TEXT($S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
|
|
2858
|
+
return { $loc, token: $1 };
|
|
2859
|
+
});
|
|
2860
|
+
var StringLiteral$3 = $TV($TEXT($S($EXPECT($L118, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L118, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
|
|
2861
|
+
return { $loc, token: $1 };
|
|
2640
2862
|
});
|
|
2641
|
-
var StringLiteral$1 = $S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'));
|
|
2642
|
-
var StringLiteral$2 = $S($EXPECT($L118, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L118, fail, `StringLiteral "\\\\'"`));
|
|
2643
2863
|
function StringLiteral(state) {
|
|
2644
2864
|
if (state.tokenize) {
|
|
2645
|
-
return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state));
|
|
2865
|
+
return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state));
|
|
2646
2866
|
} else {
|
|
2647
|
-
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
|
|
2867
|
+
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
|
|
2648
2868
|
}
|
|
2649
2869
|
}
|
|
2650
|
-
var DoubleStringCharacter$0 = $R$0($EXPECT($R8, fail, 'DoubleStringCharacter /[^"
|
|
2651
|
-
var DoubleStringCharacter$1 = EscapeSequence;
|
|
2870
|
+
var DoubleStringCharacter$0 = $R$0($EXPECT($R8, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
|
|
2652
2871
|
function DoubleStringCharacter(state) {
|
|
2872
|
+
if (state.verbose)
|
|
2873
|
+
console.log("ENTER:", "DoubleStringCharacter");
|
|
2653
2874
|
if (state.tokenize) {
|
|
2654
|
-
return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state)
|
|
2875
|
+
return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state));
|
|
2655
2876
|
} else {
|
|
2656
|
-
return DoubleStringCharacter$0(state)
|
|
2877
|
+
return DoubleStringCharacter$0(state);
|
|
2657
2878
|
}
|
|
2658
2879
|
}
|
|
2659
|
-
var SingleStringCharacter$0 = $R$0($EXPECT($R9, fail, "SingleStringCharacter /[^'
|
|
2660
|
-
var SingleStringCharacter$1 = EscapeSequence;
|
|
2880
|
+
var SingleStringCharacter$0 = $R$0($EXPECT($R9, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
|
|
2661
2881
|
function SingleStringCharacter(state) {
|
|
2882
|
+
if (state.verbose)
|
|
2883
|
+
console.log("ENTER:", "SingleStringCharacter");
|
|
2662
2884
|
if (state.tokenize) {
|
|
2663
|
-
return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state)
|
|
2885
|
+
return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state));
|
|
2664
2886
|
} else {
|
|
2665
|
-
return SingleStringCharacter$0(state)
|
|
2887
|
+
return SingleStringCharacter$0(state);
|
|
2666
2888
|
}
|
|
2667
2889
|
}
|
|
2668
2890
|
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
|
|
@@ -2675,17 +2897,19 @@ var Civet = (() => {
|
|
|
2675
2897
|
return TripleDoubleStringCharacter$0(state);
|
|
2676
2898
|
}
|
|
2677
2899
|
}
|
|
2678
|
-
var
|
|
2679
|
-
function
|
|
2900
|
+
var TripleSingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "TripleSingleStringCharacter /(?:'(?!'')|\\\\.|[^'])+/"));
|
|
2901
|
+
function TripleSingleStringCharacter(state) {
|
|
2680
2902
|
if (state.verbose)
|
|
2681
|
-
console.log("ENTER:", "
|
|
2903
|
+
console.log("ENTER:", "TripleSingleStringCharacter");
|
|
2682
2904
|
if (state.tokenize) {
|
|
2683
|
-
return $TOKEN("
|
|
2905
|
+
return $TOKEN("TripleSingleStringCharacter", state, TripleSingleStringCharacter$0(state));
|
|
2684
2906
|
} else {
|
|
2685
|
-
return
|
|
2907
|
+
return TripleSingleStringCharacter$0(state);
|
|
2686
2908
|
}
|
|
2687
2909
|
}
|
|
2688
|
-
var RegularExpressionLiteral$0 = $S($EXPECT($L58, fail, 'RegularExpressionLiteral "/"'),
|
|
2910
|
+
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
2911
|
+
return { $loc, token: $1 };
|
|
2912
|
+
});
|
|
2689
2913
|
function RegularExpressionLiteral(state) {
|
|
2690
2914
|
if (state.verbose)
|
|
2691
2915
|
console.log("ENTER:", "RegularExpressionLiteral");
|
|
@@ -2705,16 +2929,17 @@ var Civet = (() => {
|
|
|
2705
2929
|
return RegularExpressionBody$0(state);
|
|
2706
2930
|
}
|
|
2707
2931
|
}
|
|
2708
|
-
var RegExpCharacter$0 = $R$0($EXPECT($R13, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
|
|
2709
|
-
var RegExpCharacter$1 = EscapeSequence;
|
|
2932
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R13, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
2710
2933
|
function RegExpCharacter(state) {
|
|
2934
|
+
if (state.verbose)
|
|
2935
|
+
console.log("ENTER:", "RegExpCharacter");
|
|
2711
2936
|
if (state.tokenize) {
|
|
2712
|
-
return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state)
|
|
2937
|
+
return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state));
|
|
2713
2938
|
} else {
|
|
2714
|
-
return RegExpCharacter$0(state)
|
|
2939
|
+
return RegExpCharacter$0(state);
|
|
2715
2940
|
}
|
|
2716
2941
|
}
|
|
2717
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($R14, fail, "RegularExpressionFlags /(
|
|
2942
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R14, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
2718
2943
|
function RegularExpressionFlags(state) {
|
|
2719
2944
|
if (state.verbose)
|
|
2720
2945
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -2724,7 +2949,7 @@ var Civet = (() => {
|
|
|
2724
2949
|
return RegularExpressionFlags$0(state);
|
|
2725
2950
|
}
|
|
2726
2951
|
}
|
|
2727
|
-
var TemplateLiteral$0 = $S($EXPECT($
|
|
2952
|
+
var TemplateLiteral$0 = $S($EXPECT($L119, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L119, fail, 'TemplateLiteral "`"'));
|
|
2728
2953
|
function TemplateLiteral(state) {
|
|
2729
2954
|
if (state.verbose)
|
|
2730
2955
|
console.log("ENTER:", "TemplateLiteral");
|
|
@@ -2734,7 +2959,7 @@ var Civet = (() => {
|
|
|
2734
2959
|
return TemplateLiteral$0(state);
|
|
2735
2960
|
}
|
|
2736
2961
|
}
|
|
2737
|
-
var TemplateSubstitution$0 = $S($EXPECT($
|
|
2962
|
+
var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L17, fail, 'TemplateSubstitution "}"'));
|
|
2738
2963
|
function TemplateSubstitution(state) {
|
|
2739
2964
|
if (state.verbose)
|
|
2740
2965
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -2791,7 +3016,7 @@ var Civet = (() => {
|
|
|
2791
3016
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
2792
3017
|
}
|
|
2793
3018
|
}
|
|
2794
|
-
var JSMultiLineComment$0 = $S($EXPECT($
|
|
3019
|
+
var JSMultiLineComment$0 = $S($EXPECT($L121, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'JSMultiLineComment "*/"')), $EXPECT($R18, fail, "JSMultiLineComment /./")))), $EXPECT($L122, fail, 'JSMultiLineComment "*/"'));
|
|
2795
3020
|
function JSMultiLineComment(state) {
|
|
2796
3021
|
if (state.verbose)
|
|
2797
3022
|
console.log("ENTER:", "JSMultiLineComment");
|
|
@@ -2801,7 +3026,7 @@ var Civet = (() => {
|
|
|
2801
3026
|
return JSMultiLineComment$0(state);
|
|
2802
3027
|
}
|
|
2803
3028
|
}
|
|
2804
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
3029
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R19, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
2805
3030
|
if (!global.coffeeCompat)
|
|
2806
3031
|
return $skip;
|
|
2807
3032
|
return ["//", $1];
|
|
@@ -2815,7 +3040,7 @@ var Civet = (() => {
|
|
|
2815
3040
|
return CoffeeSingleLineComment$0(state);
|
|
2816
3041
|
}
|
|
2817
3042
|
}
|
|
2818
|
-
var CoffeeMultiLineComment$0 = $T($S($EXPECT($
|
|
3043
|
+
var CoffeeMultiLineComment$0 = $T($S($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R18, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), function(value) {
|
|
2819
3044
|
return ["/*", value[1], "*/"];
|
|
2820
3045
|
});
|
|
2821
3046
|
function CoffeeMultiLineComment(state) {
|
|
@@ -2827,7 +3052,7 @@ var Civet = (() => {
|
|
|
2827
3052
|
return CoffeeMultiLineComment$0(state);
|
|
2828
3053
|
}
|
|
2829
3054
|
}
|
|
2830
|
-
var InlineComment$0 = $S($EXPECT($
|
|
3055
|
+
var InlineComment$0 = $S($EXPECT($L121, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'InlineComment "*/"')), $EXPECT($R20, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L122, fail, 'InlineComment "*/"'));
|
|
2831
3056
|
function InlineComment(state) {
|
|
2832
3057
|
if (state.verbose)
|
|
2833
3058
|
console.log("ENTER:", "InlineComment");
|
|
@@ -2847,7 +3072,7 @@ var Civet = (() => {
|
|
|
2847
3072
|
return RestOfLine$0(state);
|
|
2848
3073
|
}
|
|
2849
3074
|
}
|
|
2850
|
-
var TrailingComment$0 = $R$0($EXPECT($
|
|
3075
|
+
var TrailingComment$0 = $R$0($EXPECT($R21, fail, "TrailingComment /[\\t ]+/"));
|
|
2851
3076
|
var TrailingComment$1 = InlineComment;
|
|
2852
3077
|
var TrailingComment$2 = SingleLineComment;
|
|
2853
3078
|
function TrailingComment(state) {
|
|
@@ -2857,7 +3082,7 @@ var Civet = (() => {
|
|
|
2857
3082
|
return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
|
|
2858
3083
|
}
|
|
2859
3084
|
}
|
|
2860
|
-
var _$0 = $P($C($R$0($EXPECT($
|
|
3085
|
+
var _$0 = $P($C($R$0($EXPECT($R21, fail, "_ /[\\t ]+/")), Comment));
|
|
2861
3086
|
function _(state) {
|
|
2862
3087
|
if (state.verbose)
|
|
2863
3088
|
console.log("ENTER:", "_");
|
|
@@ -2867,7 +3092,7 @@ var Civet = (() => {
|
|
|
2867
3092
|
return _$0(state);
|
|
2868
3093
|
}
|
|
2869
3094
|
}
|
|
2870
|
-
var __$0 = $Q($C($R$0($EXPECT($
|
|
3095
|
+
var __$0 = $Q($C($R$0($EXPECT($R22, fail, "__ /[\\s]+/")), Comment));
|
|
2871
3096
|
function __(state) {
|
|
2872
3097
|
if (state.verbose)
|
|
2873
3098
|
console.log("ENTER:", "__");
|
|
@@ -2888,7 +3113,7 @@ var Civet = (() => {
|
|
|
2888
3113
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
2889
3114
|
}
|
|
2890
3115
|
}
|
|
2891
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3116
|
+
var NonIdContinue$0 = $R$0($EXPECT($R23, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
2892
3117
|
function NonIdContinue(state) {
|
|
2893
3118
|
if (state.verbose)
|
|
2894
3119
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -2912,7 +3137,7 @@ var Civet = (() => {
|
|
|
2912
3137
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
2913
3138
|
}
|
|
2914
3139
|
}
|
|
2915
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($
|
|
3140
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L15, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L124, fail, 'JSXSelfClosingElement "/>"'));
|
|
2916
3141
|
function JSXSelfClosingElement(state) {
|
|
2917
3142
|
if (state.verbose)
|
|
2918
3143
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -2922,7 +3147,7 @@ var Civet = (() => {
|
|
|
2922
3147
|
return JSXSelfClosingElement$0(state);
|
|
2923
3148
|
}
|
|
2924
3149
|
}
|
|
2925
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
3150
|
+
var JSXOpeningElement$0 = $S($EXPECT($L15, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L67, fail, 'JSXOpeningElement ">"'));
|
|
2926
3151
|
function JSXOpeningElement(state) {
|
|
2927
3152
|
if (state.verbose)
|
|
2928
3153
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -2932,7 +3157,7 @@ var Civet = (() => {
|
|
|
2932
3157
|
return JSXOpeningElement$0(state);
|
|
2933
3158
|
}
|
|
2934
3159
|
}
|
|
2935
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
3160
|
+
var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L67, fail, 'JSXClosingElement ">"'));
|
|
2936
3161
|
function JSXClosingElement(state) {
|
|
2937
3162
|
if (state.verbose)
|
|
2938
3163
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -2942,7 +3167,7 @@ var Civet = (() => {
|
|
|
2942
3167
|
return JSXClosingElement$0(state);
|
|
2943
3168
|
}
|
|
2944
3169
|
}
|
|
2945
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
3170
|
+
var JSXFragment$0 = $S($EXPECT($L126, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L127, fail, 'JSXFragment "</>"'));
|
|
2946
3171
|
function JSXFragment(state) {
|
|
2947
3172
|
if (state.verbose)
|
|
2948
3173
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -2952,7 +3177,7 @@ var Civet = (() => {
|
|
|
2952
3177
|
return JSXFragment$0(state);
|
|
2953
3178
|
}
|
|
2954
3179
|
}
|
|
2955
|
-
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($
|
|
3180
|
+
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L13, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L25, fail, 'JSXElementName "."'), JSXIdentifierName))));
|
|
2956
3181
|
function JSXElementName(state) {
|
|
2957
3182
|
if (state.verbose)
|
|
2958
3183
|
console.log("ENTER:", "JSXElementName");
|
|
@@ -2962,7 +3187,7 @@ var Civet = (() => {
|
|
|
2962
3187
|
return JSXElementName$0(state);
|
|
2963
3188
|
}
|
|
2964
3189
|
}
|
|
2965
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
3190
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R24, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
2966
3191
|
function JSXIdentifierName(state) {
|
|
2967
3192
|
if (state.verbose)
|
|
2968
3193
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -2982,7 +3207,7 @@ var Civet = (() => {
|
|
|
2982
3207
|
return JSXAttributes$0(state);
|
|
2983
3208
|
}
|
|
2984
3209
|
}
|
|
2985
|
-
var JSXAttribute$0 = $S($EXPECT($
|
|
3210
|
+
var JSXAttribute$0 = $S($EXPECT($L12, fail, 'JSXAttribute "{"'), __, $EXPECT($L33, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L17, fail, 'JSXAttribute "}"'));
|
|
2986
3211
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
2987
3212
|
function JSXAttribute(state) {
|
|
2988
3213
|
if (state.tokenize) {
|
|
@@ -2991,7 +3216,7 @@ var Civet = (() => {
|
|
|
2991
3216
|
return JSXAttribute$0(state) || JSXAttribute$1(state);
|
|
2992
3217
|
}
|
|
2993
3218
|
}
|
|
2994
|
-
var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($
|
|
3219
|
+
var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L13, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
|
|
2995
3220
|
function JSXAttributeName(state) {
|
|
2996
3221
|
if (state.verbose)
|
|
2997
3222
|
console.log("ENTER:", "JSXAttributeName");
|
|
@@ -3011,9 +3236,9 @@ var Civet = (() => {
|
|
|
3011
3236
|
return JSXAttributeInitializer$0(state);
|
|
3012
3237
|
}
|
|
3013
3238
|
}
|
|
3014
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
3015
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
3016
|
-
var JSXAttributeValue$2 = $S($EXPECT($
|
|
3239
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R25, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
3240
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R26, fail, "JSXAttributeValue /'[^']*'/"));
|
|
3241
|
+
var JSXAttributeValue$2 = $S($EXPECT($L12, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L17, fail, 'JSXAttributeValue "}"'));
|
|
3017
3242
|
var JSXAttributeValue$3 = JSXElement;
|
|
3018
3243
|
var JSXAttributeValue$4 = JSXFragment;
|
|
3019
3244
|
function JSXAttributeValue(state) {
|
|
@@ -3036,7 +3261,7 @@ var Civet = (() => {
|
|
|
3036
3261
|
var JSXChild$0 = JSXText;
|
|
3037
3262
|
var JSXChild$1 = JSXElement;
|
|
3038
3263
|
var JSXChild$2 = JSXFragment;
|
|
3039
|
-
var JSXChild$3 = $S($EXPECT($
|
|
3264
|
+
var JSXChild$3 = $S($EXPECT($L12, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L17, fail, 'JSXChild "}"'));
|
|
3040
3265
|
function JSXChild(state) {
|
|
3041
3266
|
if (state.tokenize) {
|
|
3042
3267
|
return $TOKEN("JSXChild", state, JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state));
|
|
@@ -3044,7 +3269,7 @@ var Civet = (() => {
|
|
|
3044
3269
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
3045
3270
|
}
|
|
3046
3271
|
}
|
|
3047
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
3272
|
+
var JSXText$0 = $R$0($EXPECT($R27, fail, "JSXText /[^{}<>]+/"));
|
|
3048
3273
|
function JSXText(state) {
|
|
3049
3274
|
if (state.verbose)
|
|
3050
3275
|
console.log("ENTER:", "JSXText");
|
|
@@ -3054,7 +3279,7 @@ var Civet = (() => {
|
|
|
3054
3279
|
return JSXText$0(state);
|
|
3055
3280
|
}
|
|
3056
3281
|
}
|
|
3057
|
-
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($
|
|
3282
|
+
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L33, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
|
|
3058
3283
|
function JSXChildExpression(state) {
|
|
3059
3284
|
if (state.verbose)
|
|
3060
3285
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -3064,10 +3289,10 @@ var Civet = (() => {
|
|
|
3064
3289
|
return JSXChildExpression$0(state);
|
|
3065
3290
|
}
|
|
3066
3291
|
}
|
|
3067
|
-
var TypeDeclaration$0 = $T($S($EXPECT($
|
|
3292
|
+
var TypeDeclaration$0 = $T($S($EXPECT($R28, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L56, fail, 'TypeDeclaration "="'), __, Type), function(value) {
|
|
3068
3293
|
return { "ts": true, "children": value };
|
|
3069
3294
|
});
|
|
3070
|
-
var TypeDeclaration$1 = $T($S($EXPECT($
|
|
3295
|
+
var TypeDeclaration$1 = $T($S($EXPECT($R29, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
|
|
3071
3296
|
return { "ts": true, "children": value };
|
|
3072
3297
|
});
|
|
3073
3298
|
function TypeDeclaration(state) {
|
|
@@ -3077,8 +3302,8 @@ var Civet = (() => {
|
|
|
3077
3302
|
return TypeDeclaration$0(state) || TypeDeclaration$1(state);
|
|
3078
3303
|
}
|
|
3079
3304
|
}
|
|
3080
|
-
var InterfaceBlock$0 = $S(__, $EXPECT($
|
|
3081
|
-
var InterfaceBlock$1 = $S(__, $EXPECT($
|
|
3305
|
+
var InterfaceBlock$0 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L17, fail, 'InterfaceBlock "}"'));
|
|
3306
|
+
var InterfaceBlock$1 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), $Q($S(__, InterfaceProperty)), __, $EXPECT($L17, fail, 'InterfaceBlock "}"'));
|
|
3082
3307
|
var InterfaceBlock$2 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
3083
3308
|
function InterfaceBlock(state) {
|
|
3084
3309
|
if (state.tokenize) {
|
|
@@ -3123,8 +3348,8 @@ var Civet = (() => {
|
|
|
3123
3348
|
}
|
|
3124
3349
|
}
|
|
3125
3350
|
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L88, fail, 'InterfacePropertyDelimiter ";"'));
|
|
3126
|
-
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
3127
|
-
var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
3351
|
+
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L17, fail, 'InterfacePropertyDelimiter "}"')));
|
|
3352
|
+
var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L17, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
|
|
3128
3353
|
return ";";
|
|
3129
3354
|
});
|
|
3130
3355
|
var InterfacePropertyDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -3137,7 +3362,7 @@ var Civet = (() => {
|
|
|
3137
3362
|
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
|
|
3138
3363
|
}
|
|
3139
3364
|
}
|
|
3140
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
3365
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L128, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L26, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L27, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
|
|
3141
3366
|
function TypeIndexSignature(state) {
|
|
3142
3367
|
if (state.verbose)
|
|
3143
3368
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -3156,7 +3381,7 @@ var Civet = (() => {
|
|
|
3156
3381
|
return TypeIndex$0(state) || TypeIndex$1(state);
|
|
3157
3382
|
}
|
|
3158
3383
|
}
|
|
3159
|
-
var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($
|
|
3384
|
+
var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L13, fail, 'TypeSuffix ":"'), Type), function(value) {
|
|
3160
3385
|
return { "ts": true, "children": value };
|
|
3161
3386
|
});
|
|
3162
3387
|
function TypeSuffix(state) {
|
|
@@ -3168,7 +3393,7 @@ var Civet = (() => {
|
|
|
3168
3393
|
return TypeSuffix$0(state);
|
|
3169
3394
|
}
|
|
3170
3395
|
}
|
|
3171
|
-
var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($
|
|
3396
|
+
var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L13, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L129, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
|
|
3172
3397
|
return { "ts": true, "children": value };
|
|
3173
3398
|
});
|
|
3174
3399
|
function ReturnTypeSuffix(state) {
|
|
@@ -3230,9 +3455,9 @@ var Civet = (() => {
|
|
|
3230
3455
|
return TypeUnarySuffix$0(state);
|
|
3231
3456
|
}
|
|
3232
3457
|
}
|
|
3233
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
3458
|
+
var TypeUnaryOp$0 = $EXPECT($L130, fail, 'TypeUnaryOp "keyof"');
|
|
3234
3459
|
var TypeUnaryOp$1 = $EXPECT($L85, fail, 'TypeUnaryOp "typeof"');
|
|
3235
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
3460
|
+
var TypeUnaryOp$2 = $EXPECT($L131, fail, 'TypeUnaryOp "infer"');
|
|
3236
3461
|
function TypeUnaryOp(state) {
|
|
3237
3462
|
if (state.tokenize) {
|
|
3238
3463
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -3240,7 +3465,7 @@ var Civet = (() => {
|
|
|
3240
3465
|
return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
|
|
3241
3466
|
}
|
|
3242
3467
|
}
|
|
3243
|
-
var TypeIndexedAccess$0 = $S(__, $EXPECT($
|
|
3468
|
+
var TypeIndexedAccess$0 = $S(__, $EXPECT($L26, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L27, fail, 'TypeIndexedAccess "]"'));
|
|
3244
3469
|
function TypeIndexedAccess(state) {
|
|
3245
3470
|
if (state.verbose)
|
|
3246
3471
|
console.log("ENTER:", "TypeIndexedAccess");
|
|
@@ -3253,7 +3478,7 @@ var Civet = (() => {
|
|
|
3253
3478
|
var TypePrimary$0 = InterfaceBlock;
|
|
3254
3479
|
var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
|
|
3255
3480
|
var TypePrimary$2 = $S($Q(_), FunctionType);
|
|
3256
|
-
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($
|
|
3481
|
+
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L25, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
|
|
3257
3482
|
var TypePrimary$4 = $S($Q(_), TypeLiteral);
|
|
3258
3483
|
function TypePrimary(state) {
|
|
3259
3484
|
if (state.tokenize) {
|
|
@@ -3262,7 +3487,7 @@ var Civet = (() => {
|
|
|
3262
3487
|
return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
|
|
3263
3488
|
}
|
|
3264
3489
|
}
|
|
3265
|
-
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($
|
|
3490
|
+
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L16, fail, 'TypeConditional "extends"'), Type, $E($S(__, $EXPECT($L3, fail, 'TypeConditional "?"'), Type, __, $EXPECT($L13, fail, 'TypeConditional ":"'), Type)))));
|
|
3266
3491
|
function TypeConditional(state) {
|
|
3267
3492
|
if (state.verbose)
|
|
3268
3493
|
console.log("ENTER:", "TypeConditional");
|
|
@@ -3274,7 +3499,7 @@ var Civet = (() => {
|
|
|
3274
3499
|
}
|
|
3275
3500
|
var TypeLiteral$0 = Literal;
|
|
3276
3501
|
var TypeLiteral$1 = $EXPECT($L84, fail, 'TypeLiteral "void"');
|
|
3277
|
-
var TypeLiteral$2 = $EXPECT($
|
|
3502
|
+
var TypeLiteral$2 = $EXPECT($L132, fail, 'TypeLiteral "[]"');
|
|
3278
3503
|
function TypeLiteral(state) {
|
|
3279
3504
|
if (state.tokenize) {
|
|
3280
3505
|
return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
|
|
@@ -3291,7 +3516,7 @@ var Civet = (() => {
|
|
|
3291
3516
|
return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
|
|
3292
3517
|
}
|
|
3293
3518
|
}
|
|
3294
|
-
var FunctionType$0 = $S(Parameters, __, $EXPECT($
|
|
3519
|
+
var FunctionType$0 = $S(Parameters, __, $EXPECT($L11, fail, 'FunctionType "=>"'), Type);
|
|
3295
3520
|
function FunctionType(state) {
|
|
3296
3521
|
if (state.verbose)
|
|
3297
3522
|
console.log("ENTER:", "FunctionType");
|
|
@@ -3301,7 +3526,7 @@ var Civet = (() => {
|
|
|
3301
3526
|
return FunctionType$0(state);
|
|
3302
3527
|
}
|
|
3303
3528
|
}
|
|
3304
|
-
var TypeArguments$0 = $S(__, $EXPECT($
|
|
3529
|
+
var TypeArguments$0 = $S(__, $EXPECT($L15, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L67, fail, 'TypeArguments ">"'));
|
|
3305
3530
|
function TypeArguments(state) {
|
|
3306
3531
|
if (state.verbose)
|
|
3307
3532
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -3311,7 +3536,7 @@ var Civet = (() => {
|
|
|
3311
3536
|
return TypeArguments$0(state);
|
|
3312
3537
|
}
|
|
3313
3538
|
}
|
|
3314
|
-
var TypeParameters$0 = $S(__, $EXPECT($
|
|
3539
|
+
var TypeParameters$0 = $S(__, $EXPECT($L15, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L67, fail, 'TypeParameters ">"'));
|
|
3315
3540
|
function TypeParameters(state) {
|
|
3316
3541
|
if (state.verbose)
|
|
3317
3542
|
console.log("ENTER:", "TypeParameters");
|
|
@@ -3331,7 +3556,7 @@ var Civet = (() => {
|
|
|
3331
3556
|
return TypeParameter$0(state);
|
|
3332
3557
|
}
|
|
3333
3558
|
}
|
|
3334
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
3559
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L16, fail, 'TypeConstraint "extends"'), Type);
|
|
3335
3560
|
function TypeConstraint(state) {
|
|
3336
3561
|
if (state.verbose)
|
|
3337
3562
|
console.log("ENTER:", "TypeConstraint");
|
|
@@ -3356,7 +3581,7 @@ var Civet = (() => {
|
|
|
3356
3581
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
3357
3582
|
}
|
|
3358
3583
|
}
|
|
3359
|
-
var Shebang$0 = $R$0($EXPECT($
|
|
3584
|
+
var Shebang$0 = $R$0($EXPECT($R32, fail, "Shebang /#![^\\r\\n]*/"));
|
|
3360
3585
|
function Shebang(state) {
|
|
3361
3586
|
if (state.verbose)
|
|
3362
3587
|
console.log("ENTER:", "Shebang");
|
|
@@ -3366,7 +3591,7 @@ var Civet = (() => {
|
|
|
3366
3591
|
return Shebang$0(state);
|
|
3367
3592
|
}
|
|
3368
3593
|
}
|
|
3369
|
-
var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($
|
|
3594
|
+
var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R33, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
|
|
3370
3595
|
return $0.map((p) => p.join(""));
|
|
3371
3596
|
});
|
|
3372
3597
|
function DirectivePrologue(state) {
|
|
@@ -3388,7 +3613,7 @@ var Civet = (() => {
|
|
|
3388
3613
|
return EOS$0(state);
|
|
3389
3614
|
}
|
|
3390
3615
|
}
|
|
3391
|
-
var EOL$0 = $R$0($EXPECT($
|
|
3616
|
+
var EOL$0 = $R$0($EXPECT($R34, fail, "EOL /\\r\\n|\\n|\\r|$/"));
|
|
3392
3617
|
function EOL(state) {
|
|
3393
3618
|
if (state.verbose)
|
|
3394
3619
|
console.log("ENTER:", "EOL");
|
|
@@ -3398,7 +3623,7 @@ var Civet = (() => {
|
|
|
3398
3623
|
return EOL$0(state);
|
|
3399
3624
|
}
|
|
3400
3625
|
}
|
|
3401
|
-
var EOF$0 = $R$0($EXPECT($
|
|
3626
|
+
var EOF$0 = $R$0($EXPECT($R35, fail, "EOF /$/"));
|
|
3402
3627
|
function EOF(state) {
|
|
3403
3628
|
if (state.verbose)
|
|
3404
3629
|
console.log("ENTER:", "EOF");
|
|
@@ -3408,7 +3633,7 @@ var Civet = (() => {
|
|
|
3408
3633
|
return EOF$0(state);
|
|
3409
3634
|
}
|
|
3410
3635
|
}
|
|
3411
|
-
var Debugger$0 = $TV($EXPECT($
|
|
3636
|
+
var Debugger$0 = $TV($EXPECT($L32, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
3412
3637
|
debugger;
|
|
3413
3638
|
});
|
|
3414
3639
|
function Debugger(state) {
|
|
@@ -3420,7 +3645,7 @@ var Civet = (() => {
|
|
|
3420
3645
|
return Debugger$0(state);
|
|
3421
3646
|
}
|
|
3422
3647
|
}
|
|
3423
|
-
var InsertOpenParen$0 = $T($EXPECT($
|
|
3648
|
+
var InsertOpenParen$0 = $T($EXPECT($L32, fail, 'InsertOpenParen ""'), function(value) {
|
|
3424
3649
|
return "(";
|
|
3425
3650
|
});
|
|
3426
3651
|
function InsertOpenParen(state) {
|
|
@@ -3432,7 +3657,7 @@ var Civet = (() => {
|
|
|
3432
3657
|
return InsertOpenParen$0(state);
|
|
3433
3658
|
}
|
|
3434
3659
|
}
|
|
3435
|
-
var InsertCloseParen$0 = $T($EXPECT($
|
|
3660
|
+
var InsertCloseParen$0 = $T($EXPECT($L32, fail, 'InsertCloseParen ""'), function(value) {
|
|
3436
3661
|
return ")";
|
|
3437
3662
|
});
|
|
3438
3663
|
function InsertCloseParen(state) {
|
|
@@ -3444,7 +3669,7 @@ var Civet = (() => {
|
|
|
3444
3669
|
return InsertCloseParen$0(state);
|
|
3445
3670
|
}
|
|
3446
3671
|
}
|
|
3447
|
-
var InsertOpenBrace$0 = $T($EXPECT($
|
|
3672
|
+
var InsertOpenBrace$0 = $T($EXPECT($L32, fail, 'InsertOpenBrace ""'), function(value) {
|
|
3448
3673
|
return " {";
|
|
3449
3674
|
});
|
|
3450
3675
|
function InsertOpenBrace(state) {
|
|
@@ -3456,7 +3681,7 @@ var Civet = (() => {
|
|
|
3456
3681
|
return InsertOpenBrace$0(state);
|
|
3457
3682
|
}
|
|
3458
3683
|
}
|
|
3459
|
-
var InsertCloseBrace$0 = $T($EXPECT($
|
|
3684
|
+
var InsertCloseBrace$0 = $T($EXPECT($L32, fail, 'InsertCloseBrace ""'), function(value) {
|
|
3460
3685
|
return "}";
|
|
3461
3686
|
});
|
|
3462
3687
|
function InsertCloseBrace(state) {
|
|
@@ -3468,7 +3693,7 @@ var Civet = (() => {
|
|
|
3468
3693
|
return InsertCloseBrace$0(state);
|
|
3469
3694
|
}
|
|
3470
3695
|
}
|
|
3471
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
3696
|
+
var InsertNewline$0 = $TV($EXPECT($L32, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
3472
3697
|
return "\n";
|
|
3473
3698
|
});
|
|
3474
3699
|
function InsertNewline(state) {
|
|
@@ -3480,7 +3705,7 @@ var Civet = (() => {
|
|
|
3480
3705
|
return InsertNewline$0(state);
|
|
3481
3706
|
}
|
|
3482
3707
|
}
|
|
3483
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
3708
|
+
var InsertIndent$0 = $TV($EXPECT($L32, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
3484
3709
|
return "".padStart(global.currentIndent * 2);
|
|
3485
3710
|
});
|
|
3486
3711
|
function InsertIndent(state) {
|
|
@@ -3492,7 +3717,7 @@ var Civet = (() => {
|
|
|
3492
3717
|
return InsertIndent$0(state);
|
|
3493
3718
|
}
|
|
3494
3719
|
}
|
|
3495
|
-
var InsertSpace$0 = $T($EXPECT($
|
|
3720
|
+
var InsertSpace$0 = $T($EXPECT($L32, fail, 'InsertSpace ""'), function(value) {
|
|
3496
3721
|
return " ";
|
|
3497
3722
|
});
|
|
3498
3723
|
function InsertSpace(state) {
|
|
@@ -3504,7 +3729,7 @@ var Civet = (() => {
|
|
|
3504
3729
|
return InsertSpace$0(state);
|
|
3505
3730
|
}
|
|
3506
3731
|
}
|
|
3507
|
-
var InsertDot$0 = $T($EXPECT($
|
|
3732
|
+
var InsertDot$0 = $T($EXPECT($L32, fail, 'InsertDot ""'), function(value) {
|
|
3508
3733
|
return ".";
|
|
3509
3734
|
});
|
|
3510
3735
|
function InsertDot(state) {
|
|
@@ -3516,7 +3741,7 @@ var Civet = (() => {
|
|
|
3516
3741
|
return InsertDot$0(state);
|
|
3517
3742
|
}
|
|
3518
3743
|
}
|
|
3519
|
-
var InsertBreak$0 = $T($EXPECT($
|
|
3744
|
+
var InsertBreak$0 = $T($EXPECT($L32, fail, 'InsertBreak ""'), function(value) {
|
|
3520
3745
|
return "break;";
|
|
3521
3746
|
});
|
|
3522
3747
|
function InsertBreak(state) {
|
|
@@ -3528,7 +3753,7 @@ var Civet = (() => {
|
|
|
3528
3753
|
return InsertBreak$0(state);
|
|
3529
3754
|
}
|
|
3530
3755
|
}
|
|
3531
|
-
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($
|
|
3756
|
+
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L32, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3532
3757
|
var directives = $2;
|
|
3533
3758
|
global.currentIndent = 0;
|
|
3534
3759
|
global.indentLevels = [0];
|
|
@@ -3537,6 +3762,15 @@ var Civet = (() => {
|
|
|
3537
3762
|
const compatRe = /use coffee-compat/;
|
|
3538
3763
|
global.coffeeCompat = directives.some((d) => d.match(compatRe));
|
|
3539
3764
|
}
|
|
3765
|
+
module.dedentBlockString = function(str) {
|
|
3766
|
+
const spacing = str.match(/^(\r?\n|\n)\s+/);
|
|
3767
|
+
if (spacing) {
|
|
3768
|
+
str = str.replaceAll(spacing[0], "\n");
|
|
3769
|
+
}
|
|
3770
|
+
str = str.replace(/^(\r?\n|\n)/, "");
|
|
3771
|
+
str = str.replace(/(\r?\n|\n)$/, "");
|
|
3772
|
+
return str;
|
|
3773
|
+
};
|
|
3540
3774
|
return $0;
|
|
3541
3775
|
});
|
|
3542
3776
|
function Init(state) {
|
|
@@ -3548,7 +3782,7 @@ var Civet = (() => {
|
|
|
3548
3782
|
return Init$0(state);
|
|
3549
3783
|
}
|
|
3550
3784
|
}
|
|
3551
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
3785
|
+
var Indent$0 = $TV($Q($C($EXPECT($L133, fail, 'Indent " "'), $EXPECT($L134, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
3552
3786
|
return $1.length;
|
|
3553
3787
|
});
|
|
3554
3788
|
function Indent(state) {
|
|
@@ -3560,7 +3794,7 @@ var Civet = (() => {
|
|
|
3560
3794
|
return Indent$0(state);
|
|
3561
3795
|
}
|
|
3562
3796
|
}
|
|
3563
|
-
var PushIndent$0 = $TV($EXPECT($
|
|
3797
|
+
var PushIndent$0 = $TV($EXPECT($L32, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
|
|
3564
3798
|
global.currentIndent++;
|
|
3565
3799
|
if (global.verbose) {
|
|
3566
3800
|
console.log("pushing indent", global.currentIndent);
|
|
@@ -3577,7 +3811,7 @@ var Civet = (() => {
|
|
|
3577
3811
|
return PushIndent$0(state);
|
|
3578
3812
|
}
|
|
3579
3813
|
}
|
|
3580
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
3814
|
+
var PopIndent$0 = $TV($EXPECT($L32, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
3581
3815
|
if (global.verbose) {
|
|
3582
3816
|
console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
|
|
3583
3817
|
}
|
|
@@ -3726,21 +3960,167 @@ var Civet = (() => {
|
|
|
3726
3960
|
}
|
|
3727
3961
|
});
|
|
3728
3962
|
|
|
3963
|
+
// source/util.coffee
|
|
3964
|
+
var require_util = __commonJS({
|
|
3965
|
+
"source/util.coffee"(exports, module) {
|
|
3966
|
+
var BASE64_CHARS;
|
|
3967
|
+
var SourceMap;
|
|
3968
|
+
var VLQ_CONTINUATION_BIT;
|
|
3969
|
+
var VLQ_SHIFT;
|
|
3970
|
+
var VLQ_VALUE_MASK;
|
|
3971
|
+
var encodeBase64;
|
|
3972
|
+
var encodeVlq;
|
|
3973
|
+
var locationTable;
|
|
3974
|
+
var lookupLineColumn;
|
|
3975
|
+
locationTable = function(input) {
|
|
3976
|
+
var line, lines, linesRe, pos, result;
|
|
3977
|
+
linesRe = /([^\r\n]*)(\r\n|\r|\n|$)/y;
|
|
3978
|
+
lines = [];
|
|
3979
|
+
line = 0;
|
|
3980
|
+
pos = 0;
|
|
3981
|
+
while (result = linesRe.exec(input)) {
|
|
3982
|
+
pos += result[0].length;
|
|
3983
|
+
lines[line++] = pos;
|
|
3984
|
+
if (pos === input.length) {
|
|
3985
|
+
break;
|
|
3986
|
+
}
|
|
3987
|
+
}
|
|
3988
|
+
return lines;
|
|
3989
|
+
};
|
|
3990
|
+
lookupLineColumn = function(table, pos) {
|
|
3991
|
+
var l, prevEnd;
|
|
3992
|
+
l = 0;
|
|
3993
|
+
prevEnd = 0;
|
|
3994
|
+
while (table[l] <= pos) {
|
|
3995
|
+
prevEnd = table[l++];
|
|
3996
|
+
}
|
|
3997
|
+
return [l, pos - prevEnd];
|
|
3998
|
+
};
|
|
3999
|
+
SourceMap = function(sourceString) {
|
|
4000
|
+
var EOL, sm, srcTable;
|
|
4001
|
+
srcTable = locationTable(sourceString);
|
|
4002
|
+
sm = {
|
|
4003
|
+
lines: [[]],
|
|
4004
|
+
lineNum: 0,
|
|
4005
|
+
colOffset: 0,
|
|
4006
|
+
srcTable
|
|
4007
|
+
};
|
|
4008
|
+
EOL = /\r?\n|\r/;
|
|
4009
|
+
return {
|
|
4010
|
+
data: sm,
|
|
4011
|
+
renderMappings: function() {
|
|
4012
|
+
var lastSourceColumn, lastSourceLine;
|
|
4013
|
+
lastSourceLine = 0;
|
|
4014
|
+
lastSourceColumn = 0;
|
|
4015
|
+
return sm.lines.map(function(line) {
|
|
4016
|
+
return line.map(function(entry) {
|
|
4017
|
+
var colDelta, lineDelta, sourceFileIndex, srcCol, srcLine;
|
|
4018
|
+
if (entry.length === 4) {
|
|
4019
|
+
[colDelta, sourceFileIndex, srcLine, srcCol] = entry;
|
|
4020
|
+
lineDelta = srcLine - lastSourceLine;
|
|
4021
|
+
colDelta = srcCol - lastSourceColumn;
|
|
4022
|
+
lastSourceLine = srcLine;
|
|
4023
|
+
lastSourceColumn = srcCol;
|
|
4024
|
+
return `${encodeVlq(entry[0])}${encodeVlq(sourceFileIndex)}${encodeVlq(lineDelta)}${encodeVlq(colDelta)}`;
|
|
4025
|
+
} else {
|
|
4026
|
+
return encodeVlq(entry[0]);
|
|
4027
|
+
}
|
|
4028
|
+
}).join(",");
|
|
4029
|
+
}).join(";");
|
|
4030
|
+
},
|
|
4031
|
+
json: function(srcFileName, outFileName) {
|
|
4032
|
+
return {
|
|
4033
|
+
version: 3,
|
|
4034
|
+
file: outFileName,
|
|
4035
|
+
sources: [srcFileName],
|
|
4036
|
+
mappings: this.renderMappings(),
|
|
4037
|
+
names: [],
|
|
4038
|
+
sourcesContent: [sourceString]
|
|
4039
|
+
};
|
|
4040
|
+
},
|
|
4041
|
+
updateSourceMap: function(outputStr, inputPos) {
|
|
4042
|
+
var outLines;
|
|
4043
|
+
outLines = outputStr.split(EOL);
|
|
4044
|
+
outLines.forEach(function(line, i) {
|
|
4045
|
+
var l, srcCol, srcLine;
|
|
4046
|
+
if (i > 0) {
|
|
4047
|
+
sm.lineNum++;
|
|
4048
|
+
sm.colOffset = 0;
|
|
4049
|
+
sm.lines[sm.lineNum] = [];
|
|
4050
|
+
}
|
|
4051
|
+
l = sm.colOffset;
|
|
4052
|
+
sm.colOffset = line.length;
|
|
4053
|
+
if (inputPos != null) {
|
|
4054
|
+
[srcLine, srcCol] = lookupLineColumn(srcTable, inputPos);
|
|
4055
|
+
return sm.lines[sm.lineNum].push([l, 0, srcLine, srcCol]);
|
|
4056
|
+
} else if (l !== 0) {
|
|
4057
|
+
return sm.lines[sm.lineNum].push([l]);
|
|
4058
|
+
}
|
|
4059
|
+
});
|
|
4060
|
+
}
|
|
4061
|
+
};
|
|
4062
|
+
};
|
|
4063
|
+
VLQ_SHIFT = 5;
|
|
4064
|
+
VLQ_CONTINUATION_BIT = 1 << VLQ_SHIFT;
|
|
4065
|
+
VLQ_VALUE_MASK = VLQ_CONTINUATION_BIT - 1;
|
|
4066
|
+
encodeVlq = function(value) {
|
|
4067
|
+
var answer, nextChunk, signBit, valueToEncode;
|
|
4068
|
+
answer = "";
|
|
4069
|
+
signBit = value < 0 ? 1 : 0;
|
|
4070
|
+
valueToEncode = (Math.abs(value) << 1) + signBit;
|
|
4071
|
+
while (valueToEncode || !answer) {
|
|
4072
|
+
nextChunk = valueToEncode & VLQ_VALUE_MASK;
|
|
4073
|
+
valueToEncode = valueToEncode >> VLQ_SHIFT;
|
|
4074
|
+
if (valueToEncode) {
|
|
4075
|
+
nextChunk |= VLQ_CONTINUATION_BIT;
|
|
4076
|
+
}
|
|
4077
|
+
answer += encodeBase64(nextChunk);
|
|
4078
|
+
}
|
|
4079
|
+
return answer;
|
|
4080
|
+
};
|
|
4081
|
+
BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
4082
|
+
encodeBase64 = function(value) {
|
|
4083
|
+
return BASE64_CHARS[value] || function() {
|
|
4084
|
+
throw new Error(`Cannot Base64 encode value: ${value}`);
|
|
4085
|
+
}();
|
|
4086
|
+
};
|
|
4087
|
+
module.exports = { locationTable, lookupLineColumn, SourceMap };
|
|
4088
|
+
}
|
|
4089
|
+
});
|
|
4090
|
+
|
|
3729
4091
|
// source/main.coffee
|
|
3730
4092
|
var require_main = __commonJS({
|
|
3731
4093
|
"source/main.coffee"(exports, module) {
|
|
4094
|
+
var SourceMap;
|
|
4095
|
+
var defaultOptions;
|
|
3732
4096
|
var gen;
|
|
3733
4097
|
var parse;
|
|
4098
|
+
var prune;
|
|
4099
|
+
var util;
|
|
3734
4100
|
({ parse } = require_parser());
|
|
3735
|
-
gen = require_generate();
|
|
4101
|
+
({ prune } = gen = require_generate());
|
|
4102
|
+
({ SourceMap } = util = require_util());
|
|
4103
|
+
defaultOptions = {};
|
|
3736
4104
|
module.exports = {
|
|
3737
4105
|
parse,
|
|
3738
|
-
compile: function(src, options) {
|
|
3739
|
-
|
|
3740
|
-
|
|
3741
|
-
|
|
4106
|
+
compile: function(src, options = defaultOptions) {
|
|
4107
|
+
var ast, code, sm;
|
|
4108
|
+
ast = prune(parse(src, {
|
|
4109
|
+
filename: options.filename
|
|
4110
|
+
}));
|
|
4111
|
+
if (options.sourceMap) {
|
|
4112
|
+
sm = SourceMap(src);
|
|
4113
|
+
options.updateSourceMap = sm.updateSourceMap;
|
|
4114
|
+
code = gen(ast, options);
|
|
4115
|
+
return {
|
|
4116
|
+
code,
|
|
4117
|
+
sourceMap: sm
|
|
4118
|
+
};
|
|
4119
|
+
}
|
|
4120
|
+
return gen(ast, options);
|
|
3742
4121
|
},
|
|
3743
|
-
generate: gen
|
|
4122
|
+
generate: gen,
|
|
4123
|
+
util
|
|
3744
4124
|
};
|
|
3745
4125
|
}
|
|
3746
4126
|
});
|