@danielx/civet 0.2.13 → 0.2.16
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +4 -3
- package/dist/browser.js +866 -369
- package/dist/browser.js.map +3 -3
- package/dist/civet +10 -8
- package/dist/cli.js.map +4 -4
- package/dist/main.js +866 -369
- package/dist/types.d.ts +25 -5
- package/esbuild-plugin.js +16 -15
- package/package.json +4 -1
- package/register.mjs +7 -6
package/dist/browser.js
CHANGED
|
@@ -417,6 +417,7 @@ var Civet = (() => {
|
|
|
417
417
|
UnaryExpression,
|
|
418
418
|
UnaryPostfix,
|
|
419
419
|
UpdateExpression,
|
|
420
|
+
UpdateExpressionSymbol,
|
|
420
421
|
AssignmentExpression,
|
|
421
422
|
AssignmentExpressionRest,
|
|
422
423
|
YieldExpression,
|
|
@@ -428,14 +429,17 @@ var Civet = (() => {
|
|
|
428
429
|
PrimaryExpression,
|
|
429
430
|
ClassDeclaration,
|
|
430
431
|
ClassExpression,
|
|
432
|
+
Class,
|
|
431
433
|
ClassHeritage,
|
|
432
434
|
ExtendsToken,
|
|
433
435
|
ClassBody,
|
|
434
436
|
NestedClassElements,
|
|
435
437
|
NestedClassElement,
|
|
436
438
|
ClassElement,
|
|
439
|
+
Static,
|
|
437
440
|
FieldDefinition,
|
|
438
441
|
This,
|
|
442
|
+
AtAccessor,
|
|
439
443
|
LeftHandSideExpression,
|
|
440
444
|
NewExpression,
|
|
441
445
|
CallExpression,
|
|
@@ -445,6 +449,8 @@ var Civet = (() => {
|
|
|
445
449
|
ApplicationStart,
|
|
446
450
|
AdditionalReservedWords,
|
|
447
451
|
MemberExpression,
|
|
452
|
+
MemberExpressionRest,
|
|
453
|
+
PropertyAccess,
|
|
448
454
|
SuperProperty,
|
|
449
455
|
MetaProperty,
|
|
450
456
|
Parameters,
|
|
@@ -461,13 +467,17 @@ var Civet = (() => {
|
|
|
461
467
|
FunctionDeclaration,
|
|
462
468
|
FunctionExpression,
|
|
463
469
|
ThinArrowFunction,
|
|
470
|
+
Arrow,
|
|
464
471
|
Block,
|
|
472
|
+
BracedOrEmptyBlock,
|
|
465
473
|
BracedBlock,
|
|
466
474
|
SingleNestedExpression,
|
|
467
475
|
SingleNestedBlockStatement,
|
|
468
476
|
NestedBlockExpressions,
|
|
469
477
|
BlockExpression,
|
|
470
478
|
Literal,
|
|
479
|
+
NullLiteral,
|
|
480
|
+
BooleanLiteral,
|
|
471
481
|
Comma,
|
|
472
482
|
Identifier,
|
|
473
483
|
IdentifierName,
|
|
@@ -497,7 +507,9 @@ var Civet = (() => {
|
|
|
497
507
|
AsyncGeneratorMethod,
|
|
498
508
|
AsyncGeneratorBody,
|
|
499
509
|
AssignmentOp,
|
|
510
|
+
AssignmentOpSymbol,
|
|
500
511
|
BinaryOp,
|
|
512
|
+
BinaryOpSymbol,
|
|
501
513
|
UnaryOp,
|
|
502
514
|
ModuleItem,
|
|
503
515
|
StatementListItem,
|
|
@@ -513,7 +525,9 @@ var Civet = (() => {
|
|
|
513
525
|
WhileClause,
|
|
514
526
|
ForStatement,
|
|
515
527
|
ForInOfStatement,
|
|
528
|
+
For,
|
|
516
529
|
ForDeclaration,
|
|
530
|
+
LetOrConst,
|
|
517
531
|
ForBinding,
|
|
518
532
|
SwitchStatement,
|
|
519
533
|
CaseBlock,
|
|
@@ -533,10 +547,12 @@ var Civet = (() => {
|
|
|
533
547
|
MaybeNestedExpression,
|
|
534
548
|
Return,
|
|
535
549
|
ImportDeclaration,
|
|
550
|
+
Import,
|
|
536
551
|
ImportClause,
|
|
537
552
|
NameSpaceImport,
|
|
538
553
|
NamedImports,
|
|
539
554
|
FromClause,
|
|
555
|
+
From,
|
|
540
556
|
ImportSpecifier,
|
|
541
557
|
ModuleExportName,
|
|
542
558
|
ModuleSpecifier,
|
|
@@ -550,12 +566,14 @@ var Civet = (() => {
|
|
|
550
566
|
Declaration,
|
|
551
567
|
HoistableDeclaration,
|
|
552
568
|
LexicalDeclaration,
|
|
569
|
+
ConstAssignment,
|
|
553
570
|
LexicalBinding,
|
|
554
571
|
Initializer,
|
|
555
572
|
VariableStatement,
|
|
556
573
|
VariableDeclarationList,
|
|
557
574
|
VariableDeclaration,
|
|
558
575
|
NumericLiteral,
|
|
576
|
+
NumericLiteralKind,
|
|
559
577
|
DecimalBigIntegerLiteral,
|
|
560
578
|
DecimalLiteral,
|
|
561
579
|
BinaryIntegerLiteral,
|
|
@@ -565,7 +583,7 @@ var Civet = (() => {
|
|
|
565
583
|
DoubleStringCharacter,
|
|
566
584
|
SingleStringCharacter,
|
|
567
585
|
TripleDoubleStringCharacter,
|
|
568
|
-
|
|
586
|
+
TripleSingleStringCharacter,
|
|
569
587
|
RegularExpressionLiteral,
|
|
570
588
|
RegularExpressionBody,
|
|
571
589
|
RegExpCharacter,
|
|
@@ -635,6 +653,7 @@ var Civet = (() => {
|
|
|
635
653
|
EOS,
|
|
636
654
|
EOL,
|
|
637
655
|
EOF,
|
|
656
|
+
Debugger,
|
|
638
657
|
InsertOpenParen,
|
|
639
658
|
InsertCloseParen,
|
|
640
659
|
InsertOpenBrace,
|
|
@@ -648,7 +667,8 @@ var Civet = (() => {
|
|
|
648
667
|
Indent,
|
|
649
668
|
PushIndent,
|
|
650
669
|
PopIndent,
|
|
651
|
-
Nested
|
|
670
|
+
Nested,
|
|
671
|
+
NestedFurther
|
|
652
672
|
});
|
|
653
673
|
var $L0 = $L(",");
|
|
654
674
|
var $L1 = $L("(");
|
|
@@ -669,14 +689,14 @@ var Civet = (() => {
|
|
|
669
689
|
var $L16 = $L("}");
|
|
670
690
|
var $L17 = $L("static");
|
|
671
691
|
var $L18 = $L("this");
|
|
672
|
-
var $L19 = $L("
|
|
673
|
-
var $L20 = $L("
|
|
692
|
+
var $L19 = $L("#");
|
|
693
|
+
var $L20 = $L("@");
|
|
674
694
|
var $L21 = $L("new");
|
|
675
695
|
var $L22 = $L("super");
|
|
676
696
|
var $L23 = $L("import");
|
|
677
|
-
var $L24 = $L("
|
|
678
|
-
var $L25 = $L("
|
|
679
|
-
var $L26 = $L("
|
|
697
|
+
var $L24 = $L(".");
|
|
698
|
+
var $L25 = $L("[");
|
|
699
|
+
var $L26 = $L("]");
|
|
680
700
|
var $L27 = $L("::");
|
|
681
701
|
var $L28 = $L("super[");
|
|
682
702
|
var $L29 = $L("new.target");
|
|
@@ -685,107 +705,106 @@ var Civet = (() => {
|
|
|
685
705
|
var $L32 = $L("...");
|
|
686
706
|
var $L33 = $L("function");
|
|
687
707
|
var $L34 = $L("->");
|
|
688
|
-
var $L35 = $L("
|
|
689
|
-
var $L36 = $L("
|
|
690
|
-
var $L37 = $L("
|
|
691
|
-
var $L38 = $L("
|
|
692
|
-
var $L39 = $L("
|
|
693
|
-
var $L40 = $L("
|
|
694
|
-
var $L41 = $L("
|
|
695
|
-
var $L42 = $L("
|
|
696
|
-
var $L43 = $L("
|
|
697
|
-
var $L44 = $L("
|
|
698
|
-
var $L45 = $L("
|
|
699
|
-
var $L46 = $L("
|
|
700
|
-
var $L47 = $L("
|
|
701
|
-
var $L48 = $L("
|
|
702
|
-
var $L49 = $L("
|
|
703
|
-
var $L50 = $L("
|
|
704
|
-
var $L51 = $L("
|
|
705
|
-
var $L52 = $L("
|
|
706
|
-
var $L53 = $L("
|
|
707
|
-
var $L54 = $L("
|
|
708
|
-
var $L55 = $L("
|
|
709
|
-
var $L56 = $L("
|
|
710
|
-
var $L57 = $L("
|
|
711
|
-
var $L58 = $L("
|
|
712
|
-
var $L59 = $L("
|
|
713
|
-
var $L60 = $L("
|
|
714
|
-
var $L61 = $L("
|
|
715
|
-
var $L62 = $L("
|
|
716
|
-
var $L63 = $L("
|
|
717
|
-
var $L64 = $L("
|
|
718
|
-
var $L65 = $L("
|
|
719
|
-
var $L66 = $L("
|
|
720
|
-
var $L67 = $L("
|
|
721
|
-
var $L68 = $L("
|
|
722
|
-
var $L69 = $L("
|
|
723
|
-
var $L70 = $L("
|
|
724
|
-
var $L71 = $L("
|
|
725
|
-
var $L72 = $L("
|
|
726
|
-
var $L73 = $L("
|
|
727
|
-
var $L74 = $L("
|
|
728
|
-
var $L75 = $L("
|
|
729
|
-
var $L76 = $L("
|
|
730
|
-
var $L77 = $L("
|
|
731
|
-
var $L78 = $L("
|
|
732
|
-
var $L79 = $L("
|
|
733
|
-
var $L80 = $L("
|
|
734
|
-
var $L81 = $L("
|
|
735
|
-
var $L82 = $L("
|
|
736
|
-
var $L83 = $L("
|
|
737
|
-
var $L84 = $L("
|
|
738
|
-
var $L85 = $L("
|
|
739
|
-
var $L86 = $L("
|
|
740
|
-
var $L87 = $L("
|
|
741
|
-
var $L88 = $L("
|
|
742
|
-
var $L89 = $L("
|
|
743
|
-
var $L90 = $L("
|
|
744
|
-
var $L91 = $L("
|
|
745
|
-
var $L92 = $L("
|
|
746
|
-
var $L93 = $L("
|
|
747
|
-
var $L94 = $L("
|
|
748
|
-
var $L95 = $L("
|
|
749
|
-
var $L96 = $L("
|
|
750
|
-
var $L97 = $L("
|
|
751
|
-
var $L98 = $L("
|
|
752
|
-
var $L99 = $L("
|
|
753
|
-
var $L100 = $L("
|
|
754
|
-
var $L101 = $L("
|
|
755
|
-
var $L102 = $L("
|
|
756
|
-
var $L103 = $L("
|
|
757
|
-
var $L104 = $L("
|
|
758
|
-
var $L105 = $L("
|
|
759
|
-
var $L106 = $L("
|
|
760
|
-
var $L107 = $L("
|
|
761
|
-
var $L108 = $L("
|
|
762
|
-
var $L109 = $L("
|
|
763
|
-
var $L110 = $L("
|
|
764
|
-
var $L111 = $L("
|
|
765
|
-
var $L112 = $L("
|
|
766
|
-
var $L113 = $L("
|
|
767
|
-
var $L114 = $L("
|
|
768
|
-
var $L115 = $L("
|
|
769
|
-
var $L116 = $L('"
|
|
708
|
+
var $L35 = $L("null");
|
|
709
|
+
var $L36 = $L("true");
|
|
710
|
+
var $L37 = $L("false");
|
|
711
|
+
var $L38 = $L("get");
|
|
712
|
+
var $L39 = $L("set");
|
|
713
|
+
var $L40 = $L("**=");
|
|
714
|
+
var $L41 = $L("*=");
|
|
715
|
+
var $L42 = $L("/=");
|
|
716
|
+
var $L43 = $L("%=");
|
|
717
|
+
var $L44 = $L("+=");
|
|
718
|
+
var $L45 = $L("-=");
|
|
719
|
+
var $L46 = $L("<<=");
|
|
720
|
+
var $L47 = $L(">>>=");
|
|
721
|
+
var $L48 = $L(">>=");
|
|
722
|
+
var $L49 = $L("&&=");
|
|
723
|
+
var $L50 = $L("&=");
|
|
724
|
+
var $L51 = $L("^=");
|
|
725
|
+
var $L52 = $L("||=");
|
|
726
|
+
var $L53 = $L("|=");
|
|
727
|
+
var $L54 = $L("??=");
|
|
728
|
+
var $L55 = $L("=");
|
|
729
|
+
var $L56 = $L("**");
|
|
730
|
+
var $L57 = $L("/");
|
|
731
|
+
var $L58 = $L("%");
|
|
732
|
+
var $L59 = $L("+");
|
|
733
|
+
var $L60 = $L("-");
|
|
734
|
+
var $L61 = $L("<=");
|
|
735
|
+
var $L62 = $L(">=");
|
|
736
|
+
var $L63 = $L("<<");
|
|
737
|
+
var $L64 = $L(">>>");
|
|
738
|
+
var $L65 = $L(">>");
|
|
739
|
+
var $L66 = $L(">");
|
|
740
|
+
var $L67 = $L("!==");
|
|
741
|
+
var $L68 = $L("!=");
|
|
742
|
+
var $L69 = $L("is");
|
|
743
|
+
var $L70 = $L("===");
|
|
744
|
+
var $L71 = $L("==");
|
|
745
|
+
var $L72 = $L("and");
|
|
746
|
+
var $L73 = $L("&&");
|
|
747
|
+
var $L74 = $L("or");
|
|
748
|
+
var $L75 = $L("||");
|
|
749
|
+
var $L76 = $L("??");
|
|
750
|
+
var $L77 = $L("instanceof");
|
|
751
|
+
var $L78 = $L("in");
|
|
752
|
+
var $L79 = $L("&");
|
|
753
|
+
var $L80 = $L("^");
|
|
754
|
+
var $L81 = $L("|");
|
|
755
|
+
var $L82 = $L("delete");
|
|
756
|
+
var $L83 = $L("void");
|
|
757
|
+
var $L84 = $L("typeof");
|
|
758
|
+
var $L85 = $L("if");
|
|
759
|
+
var $L86 = $L("unless");
|
|
760
|
+
var $L87 = $L(";");
|
|
761
|
+
var $L88 = $L("else");
|
|
762
|
+
var $L89 = $L("loop");
|
|
763
|
+
var $L90 = $L("do");
|
|
764
|
+
var $L91 = $L("while");
|
|
765
|
+
var $L92 = $L("until");
|
|
766
|
+
var $L93 = $L("var");
|
|
767
|
+
var $L94 = $L("await");
|
|
768
|
+
var $L95 = $L("of");
|
|
769
|
+
var $L96 = $L("for");
|
|
770
|
+
var $L97 = $L("let");
|
|
771
|
+
var $L98 = $L("const");
|
|
772
|
+
var $L99 = $L("switch");
|
|
773
|
+
var $L100 = $L("case");
|
|
774
|
+
var $L101 = $L("default");
|
|
775
|
+
var $L102 = $L("when");
|
|
776
|
+
var $L103 = $L("try");
|
|
777
|
+
var $L104 = $L("catch");
|
|
778
|
+
var $L105 = $L("finally");
|
|
779
|
+
var $L106 = $L("break");
|
|
780
|
+
var $L107 = $L("continue");
|
|
781
|
+
var $L108 = $L("debugger");
|
|
782
|
+
var $L109 = $L("throw");
|
|
783
|
+
var $L110 = $L("return");
|
|
784
|
+
var $L111 = $L("import type");
|
|
785
|
+
var $L112 = $L("from");
|
|
786
|
+
var $L113 = $L("export");
|
|
787
|
+
var $L114 = $L(":=");
|
|
788
|
+
var $L115 = $L('"""');
|
|
789
|
+
var $L116 = $L("'''");
|
|
770
790
|
var $L117 = $L('"');
|
|
771
791
|
var $L118 = $L("'");
|
|
772
|
-
var $L119 = $L("
|
|
773
|
-
var $L120 = $L("
|
|
774
|
-
var $L121 = $L("
|
|
775
|
-
var $L122 = $L("
|
|
776
|
-
var $L123 = $L("
|
|
777
|
-
var $L124 = $L("
|
|
778
|
-
var $L125 = $L("
|
|
779
|
-
var $L126 = $L("
|
|
780
|
-
var $L127 = $L("
|
|
781
|
-
var $L128 = $L("
|
|
782
|
-
var $L129 = $L("
|
|
783
|
-
var $L130 = $L("
|
|
784
|
-
var $L131 = $L("
|
|
785
|
-
var $L132 = $L("
|
|
786
|
-
var $L133 = $L("
|
|
787
|
-
var $L134 = $L("
|
|
788
|
-
var $L135 = $L(" ");
|
|
792
|
+
var $L119 = $L("`");
|
|
793
|
+
var $L120 = $L("${");
|
|
794
|
+
var $L121 = $L("/*");
|
|
795
|
+
var $L122 = $L("*/");
|
|
796
|
+
var $L123 = $L("###");
|
|
797
|
+
var $L124 = $L("/>");
|
|
798
|
+
var $L125 = $L("</");
|
|
799
|
+
var $L126 = $L("<>");
|
|
800
|
+
var $L127 = $L("</>");
|
|
801
|
+
var $L128 = $L("readonly");
|
|
802
|
+
var $L129 = $L("asserts");
|
|
803
|
+
var $L130 = $L("keyof");
|
|
804
|
+
var $L131 = $L("infer");
|
|
805
|
+
var $L132 = $L("[]");
|
|
806
|
+
var $L133 = $L(" ");
|
|
807
|
+
var $L134 = $L(" ");
|
|
789
808
|
var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
790
809
|
var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
791
810
|
var $R2 = $R(new RegExp("[!~+-]", "suy"));
|
|
@@ -794,33 +813,34 @@ var Civet = (() => {
|
|
|
794
813
|
var $R5 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
|
|
795
814
|
var $R6 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
|
|
796
815
|
var $R7 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
|
|
797
|
-
var $R8 = $R(new RegExp('[^"
|
|
798
|
-
var $R9 = $R(new RegExp("[^'
|
|
816
|
+
var $R8 = $R(new RegExp('(?:\\\\.|[^"])+', "suy"));
|
|
817
|
+
var $R9 = $R(new RegExp("(?:\\\\.|[^'])+", "suy"));
|
|
799
818
|
var $R10 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
|
|
800
|
-
var $R11 = $R(new RegExp("
|
|
819
|
+
var $R11 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])+", "suy"));
|
|
801
820
|
var $R12 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
|
|
802
|
-
var $R13 = $R(new RegExp("[^\\/\\r\\n]+", "suy"));
|
|
803
|
-
var $R14 = $R(new RegExp("(
|
|
821
|
+
var $R13 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
|
|
822
|
+
var $R14 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
804
823
|
var $R15 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
805
824
|
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"));
|
|
806
825
|
var $R17 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
807
|
-
var $R18 = $R(new RegExp("
|
|
808
|
-
var $R19 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
809
|
-
var $R20 = $R(new RegExp("[\\
|
|
810
|
-
var $R21 = $R(new RegExp("[\\
|
|
811
|
-
var $R22 = $R(new RegExp("
|
|
812
|
-
var $R23 = $R(new RegExp("(
|
|
813
|
-
var $R24 = $R(new RegExp(
|
|
814
|
-
var $R25 = $R(new RegExp("
|
|
815
|
-
var $R26 = $R(new RegExp("[^
|
|
816
|
-
var $R27 = $R(new RegExp("
|
|
817
|
-
var $R28 = $R(new RegExp("
|
|
818
|
-
var $R29 = $R(new RegExp("
|
|
819
|
-
var $R30 = $R(new RegExp("[+-]", "suy"));
|
|
820
|
-
var $R31 = $R(new RegExp("
|
|
821
|
-
var $R32 = $R(new RegExp("[\\
|
|
822
|
-
var $R33 = $R(new RegExp("\\
|
|
823
|
-
var $R34 = $R(new RegExp("
|
|
826
|
+
var $R18 = $R(new RegExp(".", "suy"));
|
|
827
|
+
var $R19 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
828
|
+
var $R20 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
829
|
+
var $R21 = $R(new RegExp("[\\t ]+", "suy"));
|
|
830
|
+
var $R22 = $R(new RegExp("[\\s]+", "suy"));
|
|
831
|
+
var $R23 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
832
|
+
var $R24 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
833
|
+
var $R25 = $R(new RegExp('"[^"]*"', "suy"));
|
|
834
|
+
var $R26 = $R(new RegExp("'[^']*'", "suy"));
|
|
835
|
+
var $R27 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
836
|
+
var $R28 = $R(new RegExp("type(?!\\p{ID_Continue})", "suy"));
|
|
837
|
+
var $R29 = $R(new RegExp("interface(?!\\p{ID_Continue})", "suy"));
|
|
838
|
+
var $R30 = $R(new RegExp("[+-]?", "suy"));
|
|
839
|
+
var $R31 = $R(new RegExp("[+-]", "suy"));
|
|
840
|
+
var $R32 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
841
|
+
var $R33 = $R(new RegExp("[\\t ]*", "suy"));
|
|
842
|
+
var $R34 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
843
|
+
var $R35 = $R(new RegExp("$", "suy"));
|
|
824
844
|
var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
|
|
825
845
|
function Program(state) {
|
|
826
846
|
if (state.verbose)
|
|
@@ -934,7 +954,9 @@ var Civet = (() => {
|
|
|
934
954
|
}
|
|
935
955
|
}
|
|
936
956
|
var UnaryPostfix$0 = $EXPECT($L3, fail, 'UnaryPostfix "?"');
|
|
937
|
-
var UnaryPostfix$1 = $S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), NonIdContinue, Type)
|
|
957
|
+
var UnaryPostfix$1 = $T($S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), NonIdContinue, Type), function(value) {
|
|
958
|
+
return { "ts": true, "children": value };
|
|
959
|
+
});
|
|
938
960
|
function UnaryPostfix(state) {
|
|
939
961
|
if (state.tokenize) {
|
|
940
962
|
return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state));
|
|
@@ -942,8 +964,8 @@ var Civet = (() => {
|
|
|
942
964
|
return UnaryPostfix$0(state) || UnaryPostfix$1(state);
|
|
943
965
|
}
|
|
944
966
|
}
|
|
945
|
-
var UpdateExpression$0 = $S(
|
|
946
|
-
var UpdateExpression$1 = $S(LeftHandSideExpression, $E(
|
|
967
|
+
var UpdateExpression$0 = $S(UpdateExpressionSymbol, UnaryExpression);
|
|
968
|
+
var UpdateExpression$1 = $S(LeftHandSideExpression, $E(UpdateExpressionSymbol));
|
|
947
969
|
function UpdateExpression(state) {
|
|
948
970
|
if (state.tokenize) {
|
|
949
971
|
return $TOKEN("UpdateExpression", state, UpdateExpression$0(state) || UpdateExpression$1(state));
|
|
@@ -951,6 +973,18 @@ var Civet = (() => {
|
|
|
951
973
|
return UpdateExpression$0(state) || UpdateExpression$1(state);
|
|
952
974
|
}
|
|
953
975
|
}
|
|
976
|
+
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L5, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L6, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
|
|
977
|
+
return { $loc, token: $1 };
|
|
978
|
+
});
|
|
979
|
+
function UpdateExpressionSymbol(state) {
|
|
980
|
+
if (state.verbose)
|
|
981
|
+
console.log("ENTER:", "UpdateExpressionSymbol");
|
|
982
|
+
if (state.tokenize) {
|
|
983
|
+
return $TOKEN("UpdateExpressionSymbol", state, UpdateExpressionSymbol$0(state));
|
|
984
|
+
} else {
|
|
985
|
+
return UpdateExpressionSymbol$0(state);
|
|
986
|
+
}
|
|
987
|
+
}
|
|
954
988
|
var AssignmentExpression$0 = $S($Q(TrailingComment), AssignmentExpressionRest);
|
|
955
989
|
var AssignmentExpression$1 = $S(__, AssignmentExpressionRest);
|
|
956
990
|
function AssignmentExpression(state) {
|
|
@@ -1064,7 +1098,7 @@ var Civet = (() => {
|
|
|
1064
1098
|
return ClassDeclaration$0(state);
|
|
1065
1099
|
}
|
|
1066
1100
|
}
|
|
1067
|
-
var ClassExpression$0 = $S(
|
|
1101
|
+
var ClassExpression$0 = $S(Class, $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
|
|
1068
1102
|
function ClassExpression(state) {
|
|
1069
1103
|
if (state.verbose)
|
|
1070
1104
|
console.log("ENTER:", "ClassExpression");
|
|
@@ -1074,7 +1108,19 @@ var Civet = (() => {
|
|
|
1074
1108
|
return ClassExpression$0(state);
|
|
1075
1109
|
}
|
|
1076
1110
|
}
|
|
1077
|
-
var
|
|
1111
|
+
var Class$0 = $TV($EXPECT($L13, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
1112
|
+
return { $loc, token: $0 };
|
|
1113
|
+
});
|
|
1114
|
+
function Class(state) {
|
|
1115
|
+
if (state.verbose)
|
|
1116
|
+
console.log("ENTER:", "Class");
|
|
1117
|
+
if (state.tokenize) {
|
|
1118
|
+
return $TOKEN("Class", state, Class$0(state));
|
|
1119
|
+
} else {
|
|
1120
|
+
return Class$0(state);
|
|
1121
|
+
}
|
|
1122
|
+
}
|
|
1123
|
+
var ClassHeritage$0 = $S(ExtendsToken, __, MemberExpression);
|
|
1078
1124
|
function ClassHeritage(state) {
|
|
1079
1125
|
if (state.verbose)
|
|
1080
1126
|
console.log("ENTER:", "ClassHeritage");
|
|
@@ -1084,10 +1130,12 @@ var Civet = (() => {
|
|
|
1084
1130
|
return ClassHeritage$0(state);
|
|
1085
1131
|
}
|
|
1086
1132
|
}
|
|
1087
|
-
var ExtendsToken$0 = $
|
|
1088
|
-
return "extends";
|
|
1133
|
+
var ExtendsToken$0 = $TV($EXPECT($L14, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
|
|
1134
|
+
return { $loc, token: "extends" };
|
|
1135
|
+
});
|
|
1136
|
+
var ExtendsToken$1 = $TV($EXPECT($L15, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
|
|
1137
|
+
return { $loc, token: $1 };
|
|
1089
1138
|
});
|
|
1090
|
-
var ExtendsToken$1 = $EXPECT($L15, fail, 'ExtendsToken "extends"');
|
|
1091
1139
|
function ExtendsToken(state) {
|
|
1092
1140
|
if (state.tokenize) {
|
|
1093
1141
|
return $TOKEN("ExtendsToken", state, ExtendsToken$0(state) || ExtendsToken$1(state));
|
|
@@ -1129,8 +1177,8 @@ var Civet = (() => {
|
|
|
1129
1177
|
return NestedClassElement$0(state);
|
|
1130
1178
|
}
|
|
1131
1179
|
}
|
|
1132
|
-
var ClassElement$0 = $S(
|
|
1133
|
-
var ClassElement$1 = $S($E($S(
|
|
1180
|
+
var ClassElement$0 = $S(Static, BracedBlock);
|
|
1181
|
+
var ClassElement$1 = $S($E($S(Static, __)), $C(MethodDefinition, FieldDefinition));
|
|
1134
1182
|
function ClassElement(state) {
|
|
1135
1183
|
if (state.tokenize) {
|
|
1136
1184
|
return $TOKEN("ClassElement", state, ClassElement$0(state) || ClassElement$1(state));
|
|
@@ -1138,6 +1186,18 @@ var Civet = (() => {
|
|
|
1138
1186
|
return ClassElement$0(state) || ClassElement$1(state);
|
|
1139
1187
|
}
|
|
1140
1188
|
}
|
|
1189
|
+
var Static$0 = $TV($EXPECT($L17, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
1190
|
+
return { $loc, token: $0 };
|
|
1191
|
+
});
|
|
1192
|
+
function Static(state) {
|
|
1193
|
+
if (state.verbose)
|
|
1194
|
+
console.log("ENTER:", "Static");
|
|
1195
|
+
if (state.tokenize) {
|
|
1196
|
+
return $TOKEN("Static", state, Static$0(state));
|
|
1197
|
+
} else {
|
|
1198
|
+
return Static$0(state);
|
|
1199
|
+
}
|
|
1200
|
+
}
|
|
1141
1201
|
var FieldDefinition$0 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
|
|
1142
1202
|
function FieldDefinition(state) {
|
|
1143
1203
|
if (state.verbose)
|
|
@@ -1148,13 +1208,12 @@ var Civet = (() => {
|
|
|
1148
1208
|
return FieldDefinition$0(state);
|
|
1149
1209
|
}
|
|
1150
1210
|
}
|
|
1151
|
-
var This$0 = $EXPECT($L18, fail, 'This "this"')
|
|
1152
|
-
|
|
1153
|
-
var ref = value[1];
|
|
1154
|
-
return ["this.", ref];
|
|
1211
|
+
var This$0 = $TV($EXPECT($L18, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
1212
|
+
return { $loc, token: $0 };
|
|
1155
1213
|
});
|
|
1156
|
-
var This$
|
|
1157
|
-
|
|
1214
|
+
var This$1 = $S(AtAccessor, $S($E($EXPECT($L19, fail, 'This "#"')), IdentifierName));
|
|
1215
|
+
var This$2 = $TV($EXPECT($L20, fail, 'This "@"'), function($skip, $loc, $0, $1) {
|
|
1216
|
+
return { $loc, token: "this" };
|
|
1158
1217
|
});
|
|
1159
1218
|
function This(state) {
|
|
1160
1219
|
if (state.tokenize) {
|
|
@@ -1163,6 +1222,18 @@ var Civet = (() => {
|
|
|
1163
1222
|
return This$0(state) || This$1(state) || This$2(state);
|
|
1164
1223
|
}
|
|
1165
1224
|
}
|
|
1225
|
+
var AtAccessor$0 = $TV($EXPECT($L20, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
|
|
1226
|
+
return { $loc, token: "this." };
|
|
1227
|
+
});
|
|
1228
|
+
function AtAccessor(state) {
|
|
1229
|
+
if (state.verbose)
|
|
1230
|
+
console.log("ENTER:", "AtAccessor");
|
|
1231
|
+
if (state.tokenize) {
|
|
1232
|
+
return $TOKEN("AtAccessor", state, AtAccessor$0(state));
|
|
1233
|
+
} else {
|
|
1234
|
+
return AtAccessor$0(state);
|
|
1235
|
+
}
|
|
1236
|
+
}
|
|
1166
1237
|
var LeftHandSideExpression$0 = NewExpression;
|
|
1167
1238
|
var LeftHandSideExpression$1 = CallExpression;
|
|
1168
1239
|
function LeftHandSideExpression(state) {
|
|
@@ -1172,7 +1243,7 @@ var Civet = (() => {
|
|
|
1172
1243
|
return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
|
|
1173
1244
|
}
|
|
1174
1245
|
}
|
|
1175
|
-
var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)),
|
|
1246
|
+
var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)), CallExpression);
|
|
1176
1247
|
function NewExpression(state) {
|
|
1177
1248
|
if (state.verbose)
|
|
1178
1249
|
console.log("ENTER:", "NewExpression");
|
|
@@ -1184,7 +1255,7 @@ var Civet = (() => {
|
|
|
1184
1255
|
}
|
|
1185
1256
|
var CallExpression$0 = $S($EXPECT($L22, fail, 'CallExpression "super"'), __, Arguments);
|
|
1186
1257
|
var CallExpression$1 = $S($EXPECT($L23, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
|
|
1187
|
-
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest)
|
|
1258
|
+
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
|
|
1188
1259
|
function CallExpression(state) {
|
|
1189
1260
|
if (state.tokenize) {
|
|
1190
1261
|
return $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state));
|
|
@@ -1193,23 +1264,17 @@ var Civet = (() => {
|
|
|
1193
1264
|
}
|
|
1194
1265
|
}
|
|
1195
1266
|
var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
|
|
1196
|
-
var CallExpressionRest$1 =
|
|
1197
|
-
var CallExpressionRest$2 =
|
|
1198
|
-
var CallExpressionRest$3 =
|
|
1199
|
-
var id = $2;
|
|
1200
|
-
if (id)
|
|
1201
|
-
return [".prototype.", id];
|
|
1202
|
-
return ".prototype";
|
|
1203
|
-
});
|
|
1204
|
-
var CallExpressionRest$4 = TemplateLiteral;
|
|
1267
|
+
var CallExpressionRest$1 = MemberExpressionRest;
|
|
1268
|
+
var CallExpressionRest$2 = SpacedApplication;
|
|
1269
|
+
var CallExpressionRest$3 = TemplateLiteral;
|
|
1205
1270
|
function CallExpressionRest(state) {
|
|
1206
1271
|
if (state.tokenize) {
|
|
1207
|
-
return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state)
|
|
1272
|
+
return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state));
|
|
1208
1273
|
} else {
|
|
1209
|
-
return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state)
|
|
1274
|
+
return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
|
|
1210
1275
|
}
|
|
1211
1276
|
}
|
|
1212
|
-
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($
|
|
1277
|
+
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L24, fail, 'OptionalShorthand "."'), InsertDot));
|
|
1213
1278
|
function OptionalShorthand(state) {
|
|
1214
1279
|
if (state.verbose)
|
|
1215
1280
|
console.log("ENTER:", "OptionalShorthand");
|
|
@@ -1219,7 +1284,7 @@ var Civet = (() => {
|
|
|
1219
1284
|
return OptionalShorthand$0(state);
|
|
1220
1285
|
}
|
|
1221
1286
|
}
|
|
1222
|
-
var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen);
|
|
1287
|
+
var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen, $Q($S($Y(EOS), Nested, CallExpressionRest)));
|
|
1223
1288
|
function SpacedApplication(state) {
|
|
1224
1289
|
if (state.verbose)
|
|
1225
1290
|
console.log("ENTER:", "SpacedApplication");
|
|
@@ -1253,7 +1318,7 @@ var Civet = (() => {
|
|
|
1253
1318
|
return AdditionalReservedWords$0(state);
|
|
1254
1319
|
}
|
|
1255
1320
|
}
|
|
1256
|
-
var MemberExpression$0 = $S(PrimaryExpression, $Q(
|
|
1321
|
+
var MemberExpression$0 = $S(PrimaryExpression, $Q(MemberExpressionRest));
|
|
1257
1322
|
var MemberExpression$1 = $S($Q(TrailingComment), SuperProperty);
|
|
1258
1323
|
var MemberExpression$2 = $S($Q(TrailingComment), MetaProperty);
|
|
1259
1324
|
function MemberExpression(state) {
|
|
@@ -1263,7 +1328,32 @@ var Civet = (() => {
|
|
|
1263
1328
|
return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
|
|
1264
1329
|
}
|
|
1265
1330
|
}
|
|
1266
|
-
var
|
|
1331
|
+
var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L25, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L26, fail, 'MemberExpressionRest "]"'));
|
|
1332
|
+
var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
|
|
1333
|
+
var MemberExpressionRest$2 = $TS($S($EXPECT($L27, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
|
|
1334
|
+
var id = $2;
|
|
1335
|
+
if (id)
|
|
1336
|
+
return [".prototype.", id];
|
|
1337
|
+
return ".prototype";
|
|
1338
|
+
});
|
|
1339
|
+
function MemberExpressionRest(state) {
|
|
1340
|
+
if (state.tokenize) {
|
|
1341
|
+
return $TOKEN("MemberExpressionRest", state, MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state));
|
|
1342
|
+
} else {
|
|
1343
|
+
return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state);
|
|
1344
|
+
}
|
|
1345
|
+
}
|
|
1346
|
+
var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L24, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
|
|
1347
|
+
function PropertyAccess(state) {
|
|
1348
|
+
if (state.verbose)
|
|
1349
|
+
console.log("ENTER:", "PropertyAccess");
|
|
1350
|
+
if (state.tokenize) {
|
|
1351
|
+
return $TOKEN("PropertyAccess", state, PropertyAccess$0(state));
|
|
1352
|
+
} else {
|
|
1353
|
+
return PropertyAccess$0(state);
|
|
1354
|
+
}
|
|
1355
|
+
}
|
|
1356
|
+
var SuperProperty$0 = $S($EXPECT($L28, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L26, fail, 'SuperProperty "]"'));
|
|
1267
1357
|
function SuperProperty(state) {
|
|
1268
1358
|
if (state.verbose)
|
|
1269
1359
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1347,7 +1437,7 @@ var Civet = (() => {
|
|
|
1347
1437
|
return ObjectBindingPattern$0(state);
|
|
1348
1438
|
}
|
|
1349
1439
|
}
|
|
1350
|
-
var ArrayBindingPattern$0 = $S($EXPECT($
|
|
1440
|
+
var ArrayBindingPattern$0 = $S($EXPECT($L25, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L26, fail, 'ArrayBindingPattern "]"'));
|
|
1351
1441
|
function ArrayBindingPattern(state) {
|
|
1352
1442
|
if (state.verbose)
|
|
1353
1443
|
console.log("ENTER:", "ArrayBindingPattern");
|
|
@@ -1415,11 +1505,17 @@ var Civet = (() => {
|
|
|
1415
1505
|
return FunctionExpression$0(state) || FunctionExpression$1(state);
|
|
1416
1506
|
}
|
|
1417
1507
|
}
|
|
1418
|
-
var ThinArrowFunction$0 = $
|
|
1419
|
-
var params =
|
|
1420
|
-
var suffix =
|
|
1421
|
-
var
|
|
1422
|
-
|
|
1508
|
+
var ThinArrowFunction$0 = $TS($S(Parameters, $E(ReturnTypeSuffix), __, Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1509
|
+
var params = $1;
|
|
1510
|
+
var suffix = $2;
|
|
1511
|
+
var arrow = $4;
|
|
1512
|
+
var block = $5;
|
|
1513
|
+
return [
|
|
1514
|
+
{ $loc: arrow.$loc, token: "function" },
|
|
1515
|
+
params,
|
|
1516
|
+
suffix,
|
|
1517
|
+
block
|
|
1518
|
+
];
|
|
1423
1519
|
});
|
|
1424
1520
|
function ThinArrowFunction(state) {
|
|
1425
1521
|
if (state.verbose)
|
|
@@ -1430,6 +1526,18 @@ var Civet = (() => {
|
|
|
1430
1526
|
return ThinArrowFunction$0(state);
|
|
1431
1527
|
}
|
|
1432
1528
|
}
|
|
1529
|
+
var Arrow$0 = $TV($EXPECT($L34, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
1530
|
+
return { $loc, token: $1 };
|
|
1531
|
+
});
|
|
1532
|
+
function Arrow(state) {
|
|
1533
|
+
if (state.verbose)
|
|
1534
|
+
console.log("ENTER:", "Arrow");
|
|
1535
|
+
if (state.tokenize) {
|
|
1536
|
+
return $TOKEN("Arrow", state, Arrow$0(state));
|
|
1537
|
+
} else {
|
|
1538
|
+
return Arrow$0(state);
|
|
1539
|
+
}
|
|
1540
|
+
}
|
|
1433
1541
|
var Block$0 = $S(__, $EXPECT($L11, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'Block "}"'));
|
|
1434
1542
|
var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1435
1543
|
var Block$2 = Statement;
|
|
@@ -1441,6 +1549,15 @@ var Civet = (() => {
|
|
|
1441
1549
|
return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
|
|
1442
1550
|
}
|
|
1443
1551
|
}
|
|
1552
|
+
var BracedOrEmptyBlock$0 = BracedBlock;
|
|
1553
|
+
var BracedOrEmptyBlock$1 = $S(InsertOpenBrace, InsertCloseBrace);
|
|
1554
|
+
function BracedOrEmptyBlock(state) {
|
|
1555
|
+
if (state.tokenize) {
|
|
1556
|
+
return $TOKEN("BracedOrEmptyBlock", state, BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state));
|
|
1557
|
+
} else {
|
|
1558
|
+
return BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state);
|
|
1559
|
+
}
|
|
1560
|
+
}
|
|
1444
1561
|
var BracedBlock$0 = $S(__, $EXPECT($L11, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BracedBlock "}"'));
|
|
1445
1562
|
var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1446
1563
|
var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
|
|
@@ -1451,7 +1568,7 @@ var Civet = (() => {
|
|
|
1451
1568
|
return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state);
|
|
1452
1569
|
}
|
|
1453
1570
|
}
|
|
1454
|
-
var SingleNestedExpression$0 = $TS($S(PushIndent, $E($S(Nested, Expression, StatementDelimiter)), $C($S($N($S(Nested, Expression)), PopIndent),
|
|
1571
|
+
var SingleNestedExpression$0 = $TS($S(PushIndent, $E($S(Nested, Expression, StatementDelimiter)), $C($S($N($S(Nested, Expression)), PopIndent), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1455
1572
|
var exp = $2;
|
|
1456
1573
|
if (exp)
|
|
1457
1574
|
return exp;
|
|
@@ -1466,7 +1583,7 @@ var Civet = (() => {
|
|
|
1466
1583
|
return SingleNestedExpression$0(state);
|
|
1467
1584
|
}
|
|
1468
1585
|
}
|
|
1469
|
-
var SingleNestedBlockStatement$0 = $TS($S(PushIndent, $E($S(Nested, StatementListItem)), $C($C($N($S(Nested, StatementListItem)),
|
|
1586
|
+
var SingleNestedBlockStatement$0 = $TS($S(PushIndent, $E($S(Nested, StatementListItem)), $C($C($N($S(Nested, StatementListItem)), PopIndent), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1470
1587
|
var exp = $2;
|
|
1471
1588
|
if (exp)
|
|
1472
1589
|
return exp;
|
|
@@ -1506,17 +1623,39 @@ var Civet = (() => {
|
|
|
1506
1623
|
return BlockExpression$0(state);
|
|
1507
1624
|
}
|
|
1508
1625
|
}
|
|
1509
|
-
var Literal$0 =
|
|
1510
|
-
var Literal$1 =
|
|
1511
|
-
var Literal$2 =
|
|
1512
|
-
var Literal$3 =
|
|
1513
|
-
var Literal$4 = $EXPECT($L37, fail, 'Literal "null"');
|
|
1514
|
-
var Literal$5 = $EXPECT($L38, fail, 'Literal "undefined"');
|
|
1626
|
+
var Literal$0 = NullLiteral;
|
|
1627
|
+
var Literal$1 = BooleanLiteral;
|
|
1628
|
+
var Literal$2 = NumericLiteral;
|
|
1629
|
+
var Literal$3 = StringLiteral;
|
|
1515
1630
|
function Literal(state) {
|
|
1516
1631
|
if (state.tokenize) {
|
|
1517
|
-
return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state)
|
|
1632
|
+
return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state));
|
|
1518
1633
|
} else {
|
|
1519
|
-
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state)
|
|
1634
|
+
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
|
|
1635
|
+
}
|
|
1636
|
+
}
|
|
1637
|
+
var NullLiteral$0 = $TV($EXPECT($L35, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
1638
|
+
return { $loc, token: $1 };
|
|
1639
|
+
});
|
|
1640
|
+
function NullLiteral(state) {
|
|
1641
|
+
if (state.verbose)
|
|
1642
|
+
console.log("ENTER:", "NullLiteral");
|
|
1643
|
+
if (state.tokenize) {
|
|
1644
|
+
return $TOKEN("NullLiteral", state, NullLiteral$0(state));
|
|
1645
|
+
} else {
|
|
1646
|
+
return NullLiteral$0(state);
|
|
1647
|
+
}
|
|
1648
|
+
}
|
|
1649
|
+
var BooleanLiteral$0 = $TV($C($EXPECT($L36, fail, 'BooleanLiteral "true"'), $EXPECT($L37, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
|
|
1650
|
+
return { $loc, token: $1 };
|
|
1651
|
+
});
|
|
1652
|
+
function BooleanLiteral(state) {
|
|
1653
|
+
if (state.verbose)
|
|
1654
|
+
console.log("ENTER:", "BooleanLiteral");
|
|
1655
|
+
if (state.tokenize) {
|
|
1656
|
+
return $TOKEN("BooleanLiteral", state, BooleanLiteral$0(state));
|
|
1657
|
+
} else {
|
|
1658
|
+
return BooleanLiteral$0(state);
|
|
1520
1659
|
}
|
|
1521
1660
|
}
|
|
1522
1661
|
var Comma$0 = $S($Q(_), $EXPECT($L0, fail, 'Comma ","'), $Q(_));
|
|
@@ -1539,7 +1678,12 @@ var Civet = (() => {
|
|
|
1539
1678
|
return Identifier$0(state);
|
|
1540
1679
|
}
|
|
1541
1680
|
}
|
|
1542
|
-
var IdentifierName$0 = $
|
|
1681
|
+
var IdentifierName$0 = $TR($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
1682
|
+
return {
|
|
1683
|
+
$loc,
|
|
1684
|
+
token: $0
|
|
1685
|
+
};
|
|
1686
|
+
});
|
|
1543
1687
|
function IdentifierName(state) {
|
|
1544
1688
|
if (state.verbose)
|
|
1545
1689
|
console.log("ENTER:", "IdentifierName");
|
|
@@ -1559,8 +1703,8 @@ var Civet = (() => {
|
|
|
1559
1703
|
return IdentifierReference$0(state);
|
|
1560
1704
|
}
|
|
1561
1705
|
}
|
|
1562
|
-
var ArrayLiteral$0 = $S($EXPECT($
|
|
1563
|
-
var ArrayLiteral$1 = $S($EXPECT($
|
|
1706
|
+
var ArrayLiteral$0 = $S($EXPECT($L25, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L26, fail, 'ArrayLiteral "]"'));
|
|
1707
|
+
var ArrayLiteral$1 = $S($EXPECT($L25, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L26, fail, 'ArrayLiteral "]"'));
|
|
1564
1708
|
function ArrayLiteral(state) {
|
|
1565
1709
|
if (state.tokenize) {
|
|
1566
1710
|
return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
|
|
@@ -1594,8 +1738,8 @@ var Civet = (() => {
|
|
|
1594
1738
|
}
|
|
1595
1739
|
}
|
|
1596
1740
|
var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
|
|
1597
|
-
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1598
|
-
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
1741
|
+
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
|
|
1742
|
+
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"'))), function(value) {
|
|
1599
1743
|
return ",";
|
|
1600
1744
|
});
|
|
1601
1745
|
var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1723,7 +1867,7 @@ var Civet = (() => {
|
|
|
1723
1867
|
var PropertyName$0 = NumericLiteral;
|
|
1724
1868
|
var PropertyName$1 = StringLiteral;
|
|
1725
1869
|
var PropertyName$2 = IdentifierName;
|
|
1726
|
-
var PropertyName$3 = $S($EXPECT($
|
|
1870
|
+
var PropertyName$3 = $S($EXPECT($L25, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L26, fail, 'PropertyName "]"'));
|
|
1727
1871
|
function PropertyName(state) {
|
|
1728
1872
|
if (state.tokenize) {
|
|
1729
1873
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -1731,8 +1875,8 @@ var Civet = (() => {
|
|
|
1731
1875
|
return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
|
|
1732
1876
|
}
|
|
1733
1877
|
}
|
|
1734
|
-
var MethodDefinition$0 = $S($EXPECT($
|
|
1735
|
-
var MethodDefinition$1 = $S($EXPECT($
|
|
1878
|
+
var MethodDefinition$0 = $S($EXPECT($L38, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1879
|
+
var MethodDefinition$1 = $S($EXPECT($L39, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1736
1880
|
var MethodDefinition$2 = AsyncGeneratorMethod;
|
|
1737
1881
|
var MethodDefinition$3 = AsyncMethod;
|
|
1738
1882
|
var MethodDefinition$4 = GeneratorMethod;
|
|
@@ -1753,7 +1897,7 @@ var Civet = (() => {
|
|
|
1753
1897
|
return ClassElementName$0(state) || ClassElementName$1(state);
|
|
1754
1898
|
}
|
|
1755
1899
|
}
|
|
1756
|
-
var PrivateIdentifier$0 = $S($EXPECT($
|
|
1900
|
+
var PrivateIdentifier$0 = $S($EXPECT($L19, fail, 'PrivateIdentifier "#"'), IdentifierName);
|
|
1757
1901
|
function PrivateIdentifier(state) {
|
|
1758
1902
|
if (state.verbose)
|
|
1759
1903
|
console.log("ENTER:", "PrivateIdentifier");
|
|
@@ -1823,80 +1967,104 @@ var Civet = (() => {
|
|
|
1823
1967
|
return AsyncGeneratorBody$0(state);
|
|
1824
1968
|
}
|
|
1825
1969
|
}
|
|
1826
|
-
var AssignmentOp$0 = $
|
|
1827
|
-
|
|
1828
|
-
|
|
1829
|
-
var AssignmentOp$3 = $EXPECT($L44, fail, 'AssignmentOp "%="');
|
|
1830
|
-
var AssignmentOp$4 = $EXPECT($L45, fail, 'AssignmentOp "+="');
|
|
1831
|
-
var AssignmentOp$5 = $EXPECT($L46, fail, 'AssignmentOp "-="');
|
|
1832
|
-
var AssignmentOp$6 = $EXPECT($L47, fail, 'AssignmentOp "<<="');
|
|
1833
|
-
var AssignmentOp$7 = $EXPECT($L48, fail, 'AssignmentOp ">>>="');
|
|
1834
|
-
var AssignmentOp$8 = $EXPECT($L49, fail, 'AssignmentOp ">>="');
|
|
1835
|
-
var AssignmentOp$9 = $EXPECT($L50, fail, 'AssignmentOp "&&="');
|
|
1836
|
-
var AssignmentOp$10 = $EXPECT($L51, fail, 'AssignmentOp "&="');
|
|
1837
|
-
var AssignmentOp$11 = $EXPECT($L52, fail, 'AssignmentOp "^="');
|
|
1838
|
-
var AssignmentOp$12 = $EXPECT($L53, fail, 'AssignmentOp "||="');
|
|
1839
|
-
var AssignmentOp$13 = $EXPECT($L54, fail, 'AssignmentOp "|="');
|
|
1840
|
-
var AssignmentOp$14 = $EXPECT($L55, fail, 'AssignmentOp "??="');
|
|
1841
|
-
var AssignmentOp$15 = $EXPECT($L56, fail, 'AssignmentOp "="');
|
|
1970
|
+
var AssignmentOp$0 = $TS($S(AssignmentOpSymbol), function($skip, $loc, $0, $1) {
|
|
1971
|
+
return { $loc, token: $1 };
|
|
1972
|
+
});
|
|
1842
1973
|
function AssignmentOp(state) {
|
|
1974
|
+
if (state.verbose)
|
|
1975
|
+
console.log("ENTER:", "AssignmentOp");
|
|
1976
|
+
if (state.tokenize) {
|
|
1977
|
+
return $TOKEN("AssignmentOp", state, AssignmentOp$0(state));
|
|
1978
|
+
} else {
|
|
1979
|
+
return AssignmentOp$0(state);
|
|
1980
|
+
}
|
|
1981
|
+
}
|
|
1982
|
+
var AssignmentOpSymbol$0 = $EXPECT($L40, fail, 'AssignmentOpSymbol "**="');
|
|
1983
|
+
var AssignmentOpSymbol$1 = $EXPECT($L41, fail, 'AssignmentOpSymbol "*="');
|
|
1984
|
+
var AssignmentOpSymbol$2 = $EXPECT($L42, fail, 'AssignmentOpSymbol "/="');
|
|
1985
|
+
var AssignmentOpSymbol$3 = $EXPECT($L43, fail, 'AssignmentOpSymbol "%="');
|
|
1986
|
+
var AssignmentOpSymbol$4 = $EXPECT($L44, fail, 'AssignmentOpSymbol "+="');
|
|
1987
|
+
var AssignmentOpSymbol$5 = $EXPECT($L45, fail, 'AssignmentOpSymbol "-="');
|
|
1988
|
+
var AssignmentOpSymbol$6 = $EXPECT($L46, fail, 'AssignmentOpSymbol "<<="');
|
|
1989
|
+
var AssignmentOpSymbol$7 = $EXPECT($L47, fail, 'AssignmentOpSymbol ">>>="');
|
|
1990
|
+
var AssignmentOpSymbol$8 = $EXPECT($L48, fail, 'AssignmentOpSymbol ">>="');
|
|
1991
|
+
var AssignmentOpSymbol$9 = $EXPECT($L49, fail, 'AssignmentOpSymbol "&&="');
|
|
1992
|
+
var AssignmentOpSymbol$10 = $EXPECT($L50, fail, 'AssignmentOpSymbol "&="');
|
|
1993
|
+
var AssignmentOpSymbol$11 = $EXPECT($L51, fail, 'AssignmentOpSymbol "^="');
|
|
1994
|
+
var AssignmentOpSymbol$12 = $EXPECT($L52, fail, 'AssignmentOpSymbol "||="');
|
|
1995
|
+
var AssignmentOpSymbol$13 = $EXPECT($L53, fail, 'AssignmentOpSymbol "|="');
|
|
1996
|
+
var AssignmentOpSymbol$14 = $EXPECT($L54, fail, 'AssignmentOpSymbol "??="');
|
|
1997
|
+
var AssignmentOpSymbol$15 = $EXPECT($L55, fail, 'AssignmentOpSymbol "="');
|
|
1998
|
+
function AssignmentOpSymbol(state) {
|
|
1843
1999
|
if (state.tokenize) {
|
|
1844
|
-
return $TOKEN("
|
|
1845
|
-
} else {
|
|
1846
|
-
return
|
|
1847
|
-
}
|
|
1848
|
-
}
|
|
1849
|
-
var BinaryOp$0 = $
|
|
1850
|
-
|
|
1851
|
-
|
|
1852
|
-
|
|
1853
|
-
|
|
1854
|
-
|
|
1855
|
-
|
|
1856
|
-
|
|
1857
|
-
|
|
1858
|
-
|
|
1859
|
-
|
|
1860
|
-
|
|
1861
|
-
var
|
|
1862
|
-
var
|
|
1863
|
-
var
|
|
2000
|
+
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));
|
|
2001
|
+
} else {
|
|
2002
|
+
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);
|
|
2003
|
+
}
|
|
2004
|
+
}
|
|
2005
|
+
var BinaryOp$0 = $TS($S(BinaryOpSymbol), function($skip, $loc, $0, $1) {
|
|
2006
|
+
return { $loc, token: $1 };
|
|
2007
|
+
});
|
|
2008
|
+
function BinaryOp(state) {
|
|
2009
|
+
if (state.verbose)
|
|
2010
|
+
console.log("ENTER:", "BinaryOp");
|
|
2011
|
+
if (state.tokenize) {
|
|
2012
|
+
return $TOKEN("BinaryOp", state, BinaryOp$0(state));
|
|
2013
|
+
} else {
|
|
2014
|
+
return BinaryOp$0(state);
|
|
2015
|
+
}
|
|
2016
|
+
}
|
|
2017
|
+
var BinaryOpSymbol$0 = $EXPECT($L56, fail, 'BinaryOpSymbol "**"');
|
|
2018
|
+
var BinaryOpSymbol$1 = $EXPECT($L9, fail, 'BinaryOpSymbol "*"');
|
|
2019
|
+
var BinaryOpSymbol$2 = $EXPECT($L57, fail, 'BinaryOpSymbol "/"');
|
|
2020
|
+
var BinaryOpSymbol$3 = $EXPECT($L58, fail, 'BinaryOpSymbol "%"');
|
|
2021
|
+
var BinaryOpSymbol$4 = $EXPECT($L59, fail, 'BinaryOpSymbol "+"');
|
|
2022
|
+
var BinaryOpSymbol$5 = $EXPECT($L60, fail, 'BinaryOpSymbol "-"');
|
|
2023
|
+
var BinaryOpSymbol$6 = $EXPECT($L61, fail, 'BinaryOpSymbol "<="');
|
|
2024
|
+
var BinaryOpSymbol$7 = $EXPECT($L62, fail, 'BinaryOpSymbol ">="');
|
|
2025
|
+
var BinaryOpSymbol$8 = $EXPECT($L63, fail, 'BinaryOpSymbol "<<"');
|
|
2026
|
+
var BinaryOpSymbol$9 = $EXPECT($L14, fail, 'BinaryOpSymbol "<"');
|
|
2027
|
+
var BinaryOpSymbol$10 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>>"');
|
|
2028
|
+
var BinaryOpSymbol$11 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>"');
|
|
2029
|
+
var BinaryOpSymbol$12 = $EXPECT($L66, fail, 'BinaryOpSymbol ">"');
|
|
2030
|
+
var BinaryOpSymbol$13 = $EXPECT($L67, fail, 'BinaryOpSymbol "!=="');
|
|
2031
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L68, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
1864
2032
|
if (global.coffeeCompat)
|
|
1865
2033
|
return "!==";
|
|
1866
2034
|
return $1;
|
|
1867
2035
|
});
|
|
1868
|
-
var
|
|
2036
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L69, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
1869
2037
|
return "===";
|
|
1870
2038
|
});
|
|
1871
|
-
var
|
|
1872
|
-
var
|
|
2039
|
+
var BinaryOpSymbol$16 = $EXPECT($L70, fail, 'BinaryOpSymbol "==="');
|
|
2040
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L71, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
1873
2041
|
if (global.coffeeCompat)
|
|
1874
2042
|
return "===";
|
|
1875
2043
|
return $1;
|
|
1876
2044
|
});
|
|
1877
|
-
var
|
|
2045
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L72, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
1878
2046
|
return "&&";
|
|
1879
2047
|
});
|
|
1880
|
-
var
|
|
1881
|
-
var
|
|
2048
|
+
var BinaryOpSymbol$19 = $EXPECT($L73, fail, 'BinaryOpSymbol "&&"');
|
|
2049
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
1882
2050
|
return "||";
|
|
1883
2051
|
});
|
|
1884
|
-
var
|
|
1885
|
-
var
|
|
1886
|
-
var
|
|
1887
|
-
var
|
|
1888
|
-
var
|
|
1889
|
-
var
|
|
1890
|
-
var
|
|
1891
|
-
function
|
|
2052
|
+
var BinaryOpSymbol$21 = $EXPECT($L75, fail, 'BinaryOpSymbol "||"');
|
|
2053
|
+
var BinaryOpSymbol$22 = $EXPECT($L76, fail, 'BinaryOpSymbol "??"');
|
|
2054
|
+
var BinaryOpSymbol$23 = $S($EXPECT($L77, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue);
|
|
2055
|
+
var BinaryOpSymbol$24 = $S($EXPECT($L78, fail, 'BinaryOpSymbol "in"'), NonIdContinue);
|
|
2056
|
+
var BinaryOpSymbol$25 = $EXPECT($L79, fail, 'BinaryOpSymbol "&"');
|
|
2057
|
+
var BinaryOpSymbol$26 = $EXPECT($L80, fail, 'BinaryOpSymbol "^"');
|
|
2058
|
+
var BinaryOpSymbol$27 = $EXPECT($L81, fail, 'BinaryOpSymbol "|"');
|
|
2059
|
+
function BinaryOpSymbol(state) {
|
|
1892
2060
|
if (state.tokenize) {
|
|
1893
|
-
return $TOKEN("
|
|
2061
|
+
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));
|
|
1894
2062
|
} else {
|
|
1895
|
-
return
|
|
2063
|
+
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);
|
|
1896
2064
|
}
|
|
1897
2065
|
}
|
|
1898
2066
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
1899
|
-
var UnaryOp$1 = $S($C($EXPECT($
|
|
2067
|
+
var UnaryOp$1 = $S($C($EXPECT($L82, fail, 'UnaryOp "delete"'), $EXPECT($L83, fail, 'UnaryOp "void"'), $EXPECT($L84, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
|
|
1900
2068
|
function UnaryOp(state) {
|
|
1901
2069
|
if (state.tokenize) {
|
|
1902
2070
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -1930,7 +2098,7 @@ var Civet = (() => {
|
|
|
1930
2098
|
return StatementListItem$0(state);
|
|
1931
2099
|
}
|
|
1932
2100
|
}
|
|
1933
|
-
var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($
|
|
2101
|
+
var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($L85, fail, 'PostfixConditional "if"'), $EXPECT($L86, fail, 'PostfixConditional "unless"')), NonIdContinue, Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1934
2102
|
var ws = $1;
|
|
1935
2103
|
var cond = $2;
|
|
1936
2104
|
var exp = $4;
|
|
@@ -1963,7 +2131,7 @@ var Civet = (() => {
|
|
|
1963
2131
|
return Statement$0(state) || Statement$1(state) || Statement$2(state) || Statement$3(state) || Statement$4(state) || Statement$5(state) || Statement$6(state) || Statement$7(state) || Statement$8(state);
|
|
1964
2132
|
}
|
|
1965
2133
|
}
|
|
1966
|
-
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($
|
|
2134
|
+
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L87, fail, 'EmptyStatement ";"')));
|
|
1967
2135
|
function EmptyStatement(state) {
|
|
1968
2136
|
if (state.verbose)
|
|
1969
2137
|
console.log("ENTER:", "EmptyStatement");
|
|
@@ -1983,8 +2151,8 @@ var Civet = (() => {
|
|
|
1983
2151
|
return BlockStatement$0(state);
|
|
1984
2152
|
}
|
|
1985
2153
|
}
|
|
1986
|
-
var IfStatement$0 = $S($EXPECT($
|
|
1987
|
-
var IfStatement$1 = $TS($S($EXPECT($
|
|
2154
|
+
var IfStatement$0 = $S($EXPECT($L85, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L88, fail, 'IfStatement "else"'), Block)));
|
|
2155
|
+
var IfStatement$1 = $TS($S($EXPECT($L86, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
|
|
1988
2156
|
var condition = $2;
|
|
1989
2157
|
var block = $3;
|
|
1990
2158
|
return ["if", condition.map((c) => {
|
|
@@ -2014,7 +2182,7 @@ var Civet = (() => {
|
|
|
2014
2182
|
return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
|
|
2015
2183
|
}
|
|
2016
2184
|
}
|
|
2017
|
-
var LoopStatement$0 = $TS($S($EXPECT($
|
|
2185
|
+
var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
|
|
2018
2186
|
var b = $3;
|
|
2019
2187
|
return ["while(true)", b];
|
|
2020
2188
|
});
|
|
@@ -2027,7 +2195,7 @@ var Civet = (() => {
|
|
|
2027
2195
|
return LoopStatement$0(state);
|
|
2028
2196
|
}
|
|
2029
2197
|
}
|
|
2030
|
-
var DoWhileStatement$0 = $S($EXPECT($
|
|
2198
|
+
var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
|
|
2031
2199
|
function DoWhileStatement(state) {
|
|
2032
2200
|
if (state.verbose)
|
|
2033
2201
|
console.log("ENTER:", "DoWhileStatement");
|
|
@@ -2047,7 +2215,7 @@ var Civet = (() => {
|
|
|
2047
2215
|
return WhileStatement$0(state);
|
|
2048
2216
|
}
|
|
2049
2217
|
}
|
|
2050
|
-
var WhileClause$0 = $TS($S($C($EXPECT($
|
|
2218
|
+
var WhileClause$0 = $TS($S($C($EXPECT($L91, fail, 'WhileClause "while"'), $EXPECT($L92, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
|
|
2051
2219
|
var kind = $1;
|
|
2052
2220
|
var cond = $3;
|
|
2053
2221
|
if (kind === "until") {
|
|
@@ -2066,7 +2234,7 @@ var Civet = (() => {
|
|
|
2066
2234
|
return WhileClause$0(state);
|
|
2067
2235
|
}
|
|
2068
2236
|
}
|
|
2069
|
-
var ForStatement$0 = $S(
|
|
2237
|
+
var ForStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L87, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L87, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
|
|
2070
2238
|
function ForStatement(state) {
|
|
2071
2239
|
if (state.verbose)
|
|
2072
2240
|
console.log("ENTER:", "ForStatement");
|
|
@@ -2076,10 +2244,10 @@ var Civet = (() => {
|
|
|
2076
2244
|
return ForStatement$0(state);
|
|
2077
2245
|
}
|
|
2078
2246
|
}
|
|
2079
|
-
var ForInOfStatement$0 = $S(
|
|
2080
|
-
var ForInOfStatement$1 = $S(
|
|
2081
|
-
var ForInOfStatement$2 = $S(
|
|
2082
|
-
var ForInOfStatement$3 = $S(
|
|
2247
|
+
var ForInOfStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
|
|
2248
|
+
var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
|
|
2249
|
+
var ForInOfStatement$2 = $S(For, $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
|
|
2250
|
+
var ForInOfStatement$3 = $S(For, $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
|
|
2083
2251
|
function ForInOfStatement(state) {
|
|
2084
2252
|
if (state.tokenize) {
|
|
2085
2253
|
return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
|
|
@@ -2087,7 +2255,19 @@ var Civet = (() => {
|
|
|
2087
2255
|
return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
|
|
2088
2256
|
}
|
|
2089
2257
|
}
|
|
2090
|
-
var
|
|
2258
|
+
var For$0 = $TS($S($EXPECT($L96, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2259
|
+
return { $loc, token: $1 };
|
|
2260
|
+
});
|
|
2261
|
+
function For(state) {
|
|
2262
|
+
if (state.verbose)
|
|
2263
|
+
console.log("ENTER:", "For");
|
|
2264
|
+
if (state.tokenize) {
|
|
2265
|
+
return $TOKEN("For", state, For$0(state));
|
|
2266
|
+
} else {
|
|
2267
|
+
return For$0(state);
|
|
2268
|
+
}
|
|
2269
|
+
}
|
|
2270
|
+
var ForDeclaration$0 = $S(LetOrConst, NonIdContinue, __, ForBinding);
|
|
2091
2271
|
function ForDeclaration(state) {
|
|
2092
2272
|
if (state.verbose)
|
|
2093
2273
|
console.log("ENTER:", "ForDeclaration");
|
|
@@ -2097,6 +2277,18 @@ var Civet = (() => {
|
|
|
2097
2277
|
return ForDeclaration$0(state);
|
|
2098
2278
|
}
|
|
2099
2279
|
}
|
|
2280
|
+
var LetOrConst$0 = $TV($C($EXPECT($L97, fail, 'LetOrConst "let"'), $EXPECT($L98, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
2281
|
+
return { $loc, token: $1 };
|
|
2282
|
+
});
|
|
2283
|
+
function LetOrConst(state) {
|
|
2284
|
+
if (state.verbose)
|
|
2285
|
+
console.log("ENTER:", "LetOrConst");
|
|
2286
|
+
if (state.tokenize) {
|
|
2287
|
+
return $TOKEN("LetOrConst", state, LetOrConst$0(state));
|
|
2288
|
+
} else {
|
|
2289
|
+
return LetOrConst$0(state);
|
|
2290
|
+
}
|
|
2291
|
+
}
|
|
2100
2292
|
var ForBinding$0 = BindingIdentifier;
|
|
2101
2293
|
var ForBinding$1 = BindingPattern;
|
|
2102
2294
|
function ForBinding(state) {
|
|
@@ -2106,7 +2298,7 @@ var Civet = (() => {
|
|
|
2106
2298
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
2107
2299
|
}
|
|
2108
2300
|
}
|
|
2109
|
-
var SwitchStatement$0 = $S($EXPECT($
|
|
2301
|
+
var SwitchStatement$0 = $S($EXPECT($L99, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
|
|
2110
2302
|
function SwitchStatement(state) {
|
|
2111
2303
|
if (state.verbose)
|
|
2112
2304
|
console.log("ENTER:", "SwitchStatement");
|
|
@@ -2150,9 +2342,9 @@ var Civet = (() => {
|
|
|
2150
2342
|
return NestedCaseClause$0(state);
|
|
2151
2343
|
}
|
|
2152
2344
|
}
|
|
2153
|
-
var CaseClause$0 = $S($EXPECT($
|
|
2345
|
+
var CaseClause$0 = $S($EXPECT($L100, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
|
|
2154
2346
|
var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
|
|
2155
|
-
var CaseClause$2 = $S($EXPECT($
|
|
2347
|
+
var CaseClause$2 = $S($EXPECT($L101, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
|
|
2156
2348
|
function CaseClause(state) {
|
|
2157
2349
|
if (state.tokenize) {
|
|
2158
2350
|
return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
|
|
@@ -2160,7 +2352,7 @@ var Civet = (() => {
|
|
|
2160
2352
|
return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
|
|
2161
2353
|
}
|
|
2162
2354
|
}
|
|
2163
|
-
var When$0 = $T($S($EXPECT($
|
|
2355
|
+
var When$0 = $T($S($EXPECT($L102, fail, 'When "when"'), NonIdContinue), function(value) {
|
|
2164
2356
|
return "case";
|
|
2165
2357
|
});
|
|
2166
2358
|
function When(state) {
|
|
@@ -2183,7 +2375,7 @@ var Civet = (() => {
|
|
|
2183
2375
|
return ImpliedColon$0(state) || ImpliedColon$1(state);
|
|
2184
2376
|
}
|
|
2185
2377
|
}
|
|
2186
|
-
var TryStatement$0 = $TS($S($EXPECT($
|
|
2378
|
+
var TryStatement$0 = $TS($S($EXPECT($L103, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2187
2379
|
var c = $3;
|
|
2188
2380
|
var f = $4;
|
|
2189
2381
|
if (!c && !f) {
|
|
@@ -2200,7 +2392,7 @@ var Civet = (() => {
|
|
|
2200
2392
|
return TryStatement$0(state);
|
|
2201
2393
|
}
|
|
2202
2394
|
}
|
|
2203
|
-
var Catch$0 = $S(__, $EXPECT($
|
|
2395
|
+
var Catch$0 = $S(__, $EXPECT($L104, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
|
|
2204
2396
|
function Catch(state) {
|
|
2205
2397
|
if (state.verbose)
|
|
2206
2398
|
console.log("ENTER:", "Catch");
|
|
@@ -2219,7 +2411,7 @@ var Civet = (() => {
|
|
|
2219
2411
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2220
2412
|
}
|
|
2221
2413
|
}
|
|
2222
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2414
|
+
var Finally$0 = $S(__, $EXPECT($L105, fail, 'Finally "finally"'), BracedBlock);
|
|
2223
2415
|
function Finally(state) {
|
|
2224
2416
|
if (state.verbose)
|
|
2225
2417
|
console.log("ENTER:", "Finally");
|
|
@@ -2257,11 +2449,11 @@ var Civet = (() => {
|
|
|
2257
2449
|
return ExpressionStatement$0(state);
|
|
2258
2450
|
}
|
|
2259
2451
|
}
|
|
2260
|
-
var KeywordStatement$0 = $S($EXPECT($
|
|
2261
|
-
var KeywordStatement$1 = $S($EXPECT($
|
|
2262
|
-
var KeywordStatement$2 = $S($EXPECT($
|
|
2452
|
+
var KeywordStatement$0 = $S($EXPECT($L106, fail, 'KeywordStatement "break"'), NonIdContinue);
|
|
2453
|
+
var KeywordStatement$1 = $S($EXPECT($L107, fail, 'KeywordStatement "continue"'), NonIdContinue);
|
|
2454
|
+
var KeywordStatement$2 = $S($EXPECT($L108, fail, 'KeywordStatement "debugger"'), NonIdContinue);
|
|
2263
2455
|
var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
|
|
2264
|
-
var KeywordStatement$4 = $S($EXPECT($
|
|
2456
|
+
var KeywordStatement$4 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
|
|
2265
2457
|
function KeywordStatement(state) {
|
|
2266
2458
|
if (state.tokenize) {
|
|
2267
2459
|
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
|
|
@@ -2270,16 +2462,17 @@ var Civet = (() => {
|
|
|
2270
2462
|
}
|
|
2271
2463
|
}
|
|
2272
2464
|
var MaybeNestedExpression$0 = $S($N(EOS), $Q(TrailingComment), Expression);
|
|
2273
|
-
var MaybeNestedExpression$1 = $S($Y(EOS),
|
|
2274
|
-
var MaybeNestedExpression$2 = $S($Y(EOS), ObjectLiteral);
|
|
2465
|
+
var MaybeNestedExpression$1 = $S($Y(EOS), ObjectLiteral);
|
|
2275
2466
|
function MaybeNestedExpression(state) {
|
|
2276
2467
|
if (state.tokenize) {
|
|
2277
|
-
return $TOKEN("MaybeNestedExpression", state, MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state)
|
|
2468
|
+
return $TOKEN("MaybeNestedExpression", state, MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state));
|
|
2278
2469
|
} else {
|
|
2279
|
-
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state)
|
|
2470
|
+
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2280
2471
|
}
|
|
2281
2472
|
}
|
|
2282
|
-
var Return$0 = $S($EXPECT($
|
|
2473
|
+
var Return$0 = $TS($S($EXPECT($L110, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2474
|
+
return { $loc, token: $1 };
|
|
2475
|
+
});
|
|
2283
2476
|
function Return(state) {
|
|
2284
2477
|
if (state.verbose)
|
|
2285
2478
|
console.log("ENTER:", "Return");
|
|
@@ -2289,11 +2482,11 @@ var Civet = (() => {
|
|
|
2289
2482
|
return Return$0(state);
|
|
2290
2483
|
}
|
|
2291
2484
|
}
|
|
2292
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2485
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L111, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2293
2486
|
return { "ts": true, "children": value };
|
|
2294
2487
|
});
|
|
2295
|
-
var ImportDeclaration$1 = $S(
|
|
2296
|
-
var ImportDeclaration$2 = $S(
|
|
2488
|
+
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
2489
|
+
var ImportDeclaration$2 = $S(Import, __, ModuleSpecifier);
|
|
2297
2490
|
function ImportDeclaration(state) {
|
|
2298
2491
|
if (state.tokenize) {
|
|
2299
2492
|
return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
|
|
@@ -2301,6 +2494,18 @@ var Civet = (() => {
|
|
|
2301
2494
|
return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state);
|
|
2302
2495
|
}
|
|
2303
2496
|
}
|
|
2497
|
+
var Import$0 = $TS($S($EXPECT($L23, fail, 'Import "import"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2498
|
+
return { $loc, token: $1 };
|
|
2499
|
+
});
|
|
2500
|
+
function Import(state) {
|
|
2501
|
+
if (state.verbose)
|
|
2502
|
+
console.log("ENTER:", "Import");
|
|
2503
|
+
if (state.tokenize) {
|
|
2504
|
+
return $TOKEN("Import", state, Import$0(state));
|
|
2505
|
+
} else {
|
|
2506
|
+
return Import$0(state);
|
|
2507
|
+
}
|
|
2508
|
+
}
|
|
2304
2509
|
var ImportClause$0 = $S(ImportedBinding, $E($S(__, $EXPECT($L0, fail, 'ImportClause ","'), __, $C(NameSpaceImport, NamedImports))));
|
|
2305
2510
|
var ImportClause$1 = NameSpaceImport;
|
|
2306
2511
|
var ImportClause$2 = NamedImports;
|
|
@@ -2331,7 +2536,7 @@ var Civet = (() => {
|
|
|
2331
2536
|
return NamedImports$0(state);
|
|
2332
2537
|
}
|
|
2333
2538
|
}
|
|
2334
|
-
var FromClause$0 = $S(
|
|
2539
|
+
var FromClause$0 = $S(From, __, ModuleSpecifier);
|
|
2335
2540
|
function FromClause(state) {
|
|
2336
2541
|
if (state.verbose)
|
|
2337
2542
|
console.log("ENTER:", "FromClause");
|
|
@@ -2341,6 +2546,18 @@ var Civet = (() => {
|
|
|
2341
2546
|
return FromClause$0(state);
|
|
2342
2547
|
}
|
|
2343
2548
|
}
|
|
2549
|
+
var From$0 = $TS($S($EXPECT($L112, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2550
|
+
return { $loc, token: $1 };
|
|
2551
|
+
});
|
|
2552
|
+
function From(state) {
|
|
2553
|
+
if (state.verbose)
|
|
2554
|
+
console.log("ENTER:", "From");
|
|
2555
|
+
if (state.tokenize) {
|
|
2556
|
+
return $TOKEN("From", state, From$0(state));
|
|
2557
|
+
} else {
|
|
2558
|
+
return From$0(state);
|
|
2559
|
+
}
|
|
2560
|
+
}
|
|
2344
2561
|
var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
|
|
2345
2562
|
var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
|
|
2346
2563
|
function ImportSpecifier(state) {
|
|
@@ -2379,7 +2596,7 @@ var Civet = (() => {
|
|
|
2379
2596
|
return ImportedBinding$0(state);
|
|
2380
2597
|
}
|
|
2381
2598
|
}
|
|
2382
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
2599
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L101, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2383
2600
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
2384
2601
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
2385
2602
|
function ExportDeclaration(state) {
|
|
@@ -2399,7 +2616,7 @@ var Civet = (() => {
|
|
|
2399
2616
|
return As$0(state);
|
|
2400
2617
|
}
|
|
2401
2618
|
}
|
|
2402
|
-
var Export$0 = $S($EXPECT($
|
|
2619
|
+
var Export$0 = $S($EXPECT($L113, fail, 'Export "export"'), NonIdContinue);
|
|
2403
2620
|
function Export(state) {
|
|
2404
2621
|
if (state.verbose)
|
|
2405
2622
|
console.log("ENTER:", "Export");
|
|
@@ -2459,13 +2676,22 @@ var Civet = (() => {
|
|
|
2459
2676
|
return HoistableDeclaration$0(state);
|
|
2460
2677
|
}
|
|
2461
2678
|
}
|
|
2462
|
-
var LexicalDeclaration$0 = $S(
|
|
2463
|
-
var LexicalDeclaration$1 = $
|
|
2464
|
-
var bind =
|
|
2465
|
-
var suffix =
|
|
2466
|
-
var ws =
|
|
2467
|
-
var
|
|
2468
|
-
|
|
2679
|
+
var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
|
|
2680
|
+
var LexicalDeclaration$1 = $TS($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
2681
|
+
var bind = $1;
|
|
2682
|
+
var suffix = $2;
|
|
2683
|
+
var ws = $3;
|
|
2684
|
+
var ca = $4;
|
|
2685
|
+
var exp = $5;
|
|
2686
|
+
return [
|
|
2687
|
+
{ token: "const", $loc: ca.$loc },
|
|
2688
|
+
" ",
|
|
2689
|
+
bind,
|
|
2690
|
+
suffix,
|
|
2691
|
+
ws,
|
|
2692
|
+
{ token: "=", $loc: ca.$loc },
|
|
2693
|
+
exp
|
|
2694
|
+
];
|
|
2469
2695
|
});
|
|
2470
2696
|
function LexicalDeclaration(state) {
|
|
2471
2697
|
if (state.tokenize) {
|
|
@@ -2474,6 +2700,18 @@ var Civet = (() => {
|
|
|
2474
2700
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
2475
2701
|
}
|
|
2476
2702
|
}
|
|
2703
|
+
var ConstAssignment$0 = $TV($EXPECT($L114, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
2704
|
+
return { $loc, token: $0 };
|
|
2705
|
+
});
|
|
2706
|
+
function ConstAssignment(state) {
|
|
2707
|
+
if (state.verbose)
|
|
2708
|
+
console.log("ENTER:", "ConstAssignment");
|
|
2709
|
+
if (state.tokenize) {
|
|
2710
|
+
return $TOKEN("ConstAssignment", state, ConstAssignment$0(state));
|
|
2711
|
+
} else {
|
|
2712
|
+
return ConstAssignment$0(state);
|
|
2713
|
+
}
|
|
2714
|
+
}
|
|
2477
2715
|
var LexicalBinding$0 = $S(BindingPattern, $E(TypeSuffix), Initializer);
|
|
2478
2716
|
var LexicalBinding$1 = $S(BindingIdentifier, $E(TypeSuffix), $E(Initializer));
|
|
2479
2717
|
function LexicalBinding(state) {
|
|
@@ -2483,7 +2721,7 @@ var Civet = (() => {
|
|
|
2483
2721
|
return LexicalBinding$0(state) || LexicalBinding$1(state);
|
|
2484
2722
|
}
|
|
2485
2723
|
}
|
|
2486
|
-
var Initializer$0 = $S(__, $EXPECT($
|
|
2724
|
+
var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
|
|
2487
2725
|
function Initializer(state) {
|
|
2488
2726
|
if (state.verbose)
|
|
2489
2727
|
console.log("ENTER:", "Initializer");
|
|
@@ -2493,7 +2731,7 @@ var Civet = (() => {
|
|
|
2493
2731
|
return Initializer$0(state);
|
|
2494
2732
|
}
|
|
2495
2733
|
}
|
|
2496
|
-
var VariableStatement$0 = $S($EXPECT($
|
|
2734
|
+
var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
|
|
2497
2735
|
function VariableStatement(state) {
|
|
2498
2736
|
if (state.verbose)
|
|
2499
2737
|
console.log("ENTER:", "VariableStatement");
|
|
@@ -2522,16 +2760,28 @@ var Civet = (() => {
|
|
|
2522
2760
|
return VariableDeclaration$0(state) || VariableDeclaration$1(state);
|
|
2523
2761
|
}
|
|
2524
2762
|
}
|
|
2525
|
-
var NumericLiteral$0 =
|
|
2526
|
-
|
|
2527
|
-
|
|
2528
|
-
var NumericLiteral$3 = HexLiteral;
|
|
2529
|
-
var NumericLiteral$4 = DecimalLiteral;
|
|
2763
|
+
var NumericLiteral$0 = $TS($S(NumericLiteralKind), function($skip, $loc, $0, $1) {
|
|
2764
|
+
return { $loc, token: $1 };
|
|
2765
|
+
});
|
|
2530
2766
|
function NumericLiteral(state) {
|
|
2767
|
+
if (state.verbose)
|
|
2768
|
+
console.log("ENTER:", "NumericLiteral");
|
|
2769
|
+
if (state.tokenize) {
|
|
2770
|
+
return $TOKEN("NumericLiteral", state, NumericLiteral$0(state));
|
|
2771
|
+
} else {
|
|
2772
|
+
return NumericLiteral$0(state);
|
|
2773
|
+
}
|
|
2774
|
+
}
|
|
2775
|
+
var NumericLiteralKind$0 = DecimalBigIntegerLiteral;
|
|
2776
|
+
var NumericLiteralKind$1 = BinaryIntegerLiteral;
|
|
2777
|
+
var NumericLiteralKind$2 = OctalIntegerLiteral;
|
|
2778
|
+
var NumericLiteralKind$3 = HexLiteral;
|
|
2779
|
+
var NumericLiteralKind$4 = DecimalLiteral;
|
|
2780
|
+
function NumericLiteralKind(state) {
|
|
2531
2781
|
if (state.tokenize) {
|
|
2532
|
-
return $TOKEN("
|
|
2782
|
+
return $TOKEN("NumericLiteralKind", state, NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state));
|
|
2533
2783
|
} else {
|
|
2534
|
-
return
|
|
2784
|
+
return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
|
|
2535
2785
|
}
|
|
2536
2786
|
}
|
|
2537
2787
|
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R3, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
@@ -2584,34 +2834,45 @@ var Civet = (() => {
|
|
|
2584
2834
|
return HexLiteral$0(state);
|
|
2585
2835
|
}
|
|
2586
2836
|
}
|
|
2587
|
-
var StringLiteral$0 = $
|
|
2588
|
-
|
|
2837
|
+
var StringLiteral$0 = $TS($S($EXPECT($L115, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L115, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
2838
|
+
var str = $2;
|
|
2839
|
+
return { $loc, token: "`" + module.dedentBlockString(str) + "`" };
|
|
2840
|
+
});
|
|
2841
|
+
var StringLiteral$1 = $TS($S($EXPECT($L116, fail, `StringLiteral "'''"`), $TEXT($Q(TripleSingleStringCharacter)), $EXPECT($L116, fail, `StringLiteral "'''"`)), function($skip, $loc, $0, $1, $2, $3) {
|
|
2842
|
+
var str = $2;
|
|
2843
|
+
return { $loc, token: "`" + module.dedentBlockString(str) + "`" };
|
|
2844
|
+
});
|
|
2845
|
+
var StringLiteral$2 = $TV($TEXT($S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
|
|
2846
|
+
return { $loc, token: $1 };
|
|
2847
|
+
});
|
|
2848
|
+
var StringLiteral$3 = $TV($TEXT($S($EXPECT($L118, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L118, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
|
|
2849
|
+
return { $loc, token: $1 };
|
|
2589
2850
|
});
|
|
2590
|
-
var StringLiteral$1 = $S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'));
|
|
2591
|
-
var StringLiteral$2 = $S($EXPECT($L118, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L118, fail, `StringLiteral "\\\\'"`));
|
|
2592
2851
|
function StringLiteral(state) {
|
|
2593
2852
|
if (state.tokenize) {
|
|
2594
|
-
return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state));
|
|
2853
|
+
return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state));
|
|
2595
2854
|
} else {
|
|
2596
|
-
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
|
|
2855
|
+
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
|
|
2597
2856
|
}
|
|
2598
2857
|
}
|
|
2599
|
-
var DoubleStringCharacter$0 = $R$0($EXPECT($R8, fail, 'DoubleStringCharacter /[^"
|
|
2600
|
-
var DoubleStringCharacter$1 = EscapeSequence;
|
|
2858
|
+
var DoubleStringCharacter$0 = $R$0($EXPECT($R8, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
|
|
2601
2859
|
function DoubleStringCharacter(state) {
|
|
2860
|
+
if (state.verbose)
|
|
2861
|
+
console.log("ENTER:", "DoubleStringCharacter");
|
|
2602
2862
|
if (state.tokenize) {
|
|
2603
|
-
return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state)
|
|
2863
|
+
return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state));
|
|
2604
2864
|
} else {
|
|
2605
|
-
return DoubleStringCharacter$0(state)
|
|
2865
|
+
return DoubleStringCharacter$0(state);
|
|
2606
2866
|
}
|
|
2607
2867
|
}
|
|
2608
|
-
var SingleStringCharacter$0 = $R$0($EXPECT($R9, fail, "SingleStringCharacter /[^'
|
|
2609
|
-
var SingleStringCharacter$1 = EscapeSequence;
|
|
2868
|
+
var SingleStringCharacter$0 = $R$0($EXPECT($R9, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
|
|
2610
2869
|
function SingleStringCharacter(state) {
|
|
2870
|
+
if (state.verbose)
|
|
2871
|
+
console.log("ENTER:", "SingleStringCharacter");
|
|
2611
2872
|
if (state.tokenize) {
|
|
2612
|
-
return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state)
|
|
2873
|
+
return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state));
|
|
2613
2874
|
} else {
|
|
2614
|
-
return SingleStringCharacter$0(state)
|
|
2875
|
+
return SingleStringCharacter$0(state);
|
|
2615
2876
|
}
|
|
2616
2877
|
}
|
|
2617
2878
|
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
|
|
@@ -2624,17 +2885,19 @@ var Civet = (() => {
|
|
|
2624
2885
|
return TripleDoubleStringCharacter$0(state);
|
|
2625
2886
|
}
|
|
2626
2887
|
}
|
|
2627
|
-
var
|
|
2628
|
-
function
|
|
2888
|
+
var TripleSingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "TripleSingleStringCharacter /(?:'(?!'')|\\\\.|[^'])+/"));
|
|
2889
|
+
function TripleSingleStringCharacter(state) {
|
|
2629
2890
|
if (state.verbose)
|
|
2630
|
-
console.log("ENTER:", "
|
|
2891
|
+
console.log("ENTER:", "TripleSingleStringCharacter");
|
|
2631
2892
|
if (state.tokenize) {
|
|
2632
|
-
return $TOKEN("
|
|
2893
|
+
return $TOKEN("TripleSingleStringCharacter", state, TripleSingleStringCharacter$0(state));
|
|
2633
2894
|
} else {
|
|
2634
|
-
return
|
|
2895
|
+
return TripleSingleStringCharacter$0(state);
|
|
2635
2896
|
}
|
|
2636
2897
|
}
|
|
2637
|
-
var RegularExpressionLiteral$0 = $S($EXPECT($
|
|
2898
|
+
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
2899
|
+
return { $loc, token: $1 };
|
|
2900
|
+
});
|
|
2638
2901
|
function RegularExpressionLiteral(state) {
|
|
2639
2902
|
if (state.verbose)
|
|
2640
2903
|
console.log("ENTER:", "RegularExpressionLiteral");
|
|
@@ -2654,16 +2917,17 @@ var Civet = (() => {
|
|
|
2654
2917
|
return RegularExpressionBody$0(state);
|
|
2655
2918
|
}
|
|
2656
2919
|
}
|
|
2657
|
-
var RegExpCharacter$0 = $R$0($EXPECT($R13, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
|
|
2658
|
-
var RegExpCharacter$1 = EscapeSequence;
|
|
2920
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R13, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
2659
2921
|
function RegExpCharacter(state) {
|
|
2922
|
+
if (state.verbose)
|
|
2923
|
+
console.log("ENTER:", "RegExpCharacter");
|
|
2660
2924
|
if (state.tokenize) {
|
|
2661
|
-
return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state)
|
|
2925
|
+
return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state));
|
|
2662
2926
|
} else {
|
|
2663
|
-
return RegExpCharacter$0(state)
|
|
2927
|
+
return RegExpCharacter$0(state);
|
|
2664
2928
|
}
|
|
2665
2929
|
}
|
|
2666
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($R14, fail, "RegularExpressionFlags /(
|
|
2930
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R14, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
2667
2931
|
function RegularExpressionFlags(state) {
|
|
2668
2932
|
if (state.verbose)
|
|
2669
2933
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -2673,7 +2937,7 @@ var Civet = (() => {
|
|
|
2673
2937
|
return RegularExpressionFlags$0(state);
|
|
2674
2938
|
}
|
|
2675
2939
|
}
|
|
2676
|
-
var TemplateLiteral$0 = $S($EXPECT($
|
|
2940
|
+
var TemplateLiteral$0 = $S($EXPECT($L119, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L119, fail, 'TemplateLiteral "`"'));
|
|
2677
2941
|
function TemplateLiteral(state) {
|
|
2678
2942
|
if (state.verbose)
|
|
2679
2943
|
console.log("ENTER:", "TemplateLiteral");
|
|
@@ -2683,7 +2947,7 @@ var Civet = (() => {
|
|
|
2683
2947
|
return TemplateLiteral$0(state);
|
|
2684
2948
|
}
|
|
2685
2949
|
}
|
|
2686
|
-
var TemplateSubstitution$0 = $S($EXPECT($
|
|
2950
|
+
var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
|
|
2687
2951
|
function TemplateSubstitution(state) {
|
|
2688
2952
|
if (state.verbose)
|
|
2689
2953
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -2740,7 +3004,7 @@ var Civet = (() => {
|
|
|
2740
3004
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
2741
3005
|
}
|
|
2742
3006
|
}
|
|
2743
|
-
var JSMultiLineComment$0 = $S($EXPECT($
|
|
3007
|
+
var JSMultiLineComment$0 = $S($EXPECT($L121, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'JSMultiLineComment "*/"')), $EXPECT($R18, fail, "JSMultiLineComment /./")))), $EXPECT($L122, fail, 'JSMultiLineComment "*/"'));
|
|
2744
3008
|
function JSMultiLineComment(state) {
|
|
2745
3009
|
if (state.verbose)
|
|
2746
3010
|
console.log("ENTER:", "JSMultiLineComment");
|
|
@@ -2750,7 +3014,7 @@ var Civet = (() => {
|
|
|
2750
3014
|
return JSMultiLineComment$0(state);
|
|
2751
3015
|
}
|
|
2752
3016
|
}
|
|
2753
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
3017
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R19, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
2754
3018
|
if (!global.coffeeCompat)
|
|
2755
3019
|
return $skip;
|
|
2756
3020
|
return ["//", $1];
|
|
@@ -2764,7 +3028,7 @@ var Civet = (() => {
|
|
|
2764
3028
|
return CoffeeSingleLineComment$0(state);
|
|
2765
3029
|
}
|
|
2766
3030
|
}
|
|
2767
|
-
var CoffeeMultiLineComment$0 = $T($S($EXPECT($
|
|
3031
|
+
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) {
|
|
2768
3032
|
return ["/*", value[1], "*/"];
|
|
2769
3033
|
});
|
|
2770
3034
|
function CoffeeMultiLineComment(state) {
|
|
@@ -2776,7 +3040,7 @@ var Civet = (() => {
|
|
|
2776
3040
|
return CoffeeMultiLineComment$0(state);
|
|
2777
3041
|
}
|
|
2778
3042
|
}
|
|
2779
|
-
var InlineComment$0 = $S($EXPECT($
|
|
3043
|
+
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 "*/"'));
|
|
2780
3044
|
function InlineComment(state) {
|
|
2781
3045
|
if (state.verbose)
|
|
2782
3046
|
console.log("ENTER:", "InlineComment");
|
|
@@ -2796,7 +3060,7 @@ var Civet = (() => {
|
|
|
2796
3060
|
return RestOfLine$0(state);
|
|
2797
3061
|
}
|
|
2798
3062
|
}
|
|
2799
|
-
var TrailingComment$0 = $R$0($EXPECT($
|
|
3063
|
+
var TrailingComment$0 = $R$0($EXPECT($R21, fail, "TrailingComment /[\\t ]+/"));
|
|
2800
3064
|
var TrailingComment$1 = InlineComment;
|
|
2801
3065
|
var TrailingComment$2 = SingleLineComment;
|
|
2802
3066
|
function TrailingComment(state) {
|
|
@@ -2806,7 +3070,7 @@ var Civet = (() => {
|
|
|
2806
3070
|
return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
|
|
2807
3071
|
}
|
|
2808
3072
|
}
|
|
2809
|
-
var _$0 = $P($C($R$0($EXPECT($
|
|
3073
|
+
var _$0 = $P($C($R$0($EXPECT($R21, fail, "_ /[\\t ]+/")), Comment));
|
|
2810
3074
|
function _(state) {
|
|
2811
3075
|
if (state.verbose)
|
|
2812
3076
|
console.log("ENTER:", "_");
|
|
@@ -2816,7 +3080,7 @@ var Civet = (() => {
|
|
|
2816
3080
|
return _$0(state);
|
|
2817
3081
|
}
|
|
2818
3082
|
}
|
|
2819
|
-
var __$0 = $Q($C($R$0($EXPECT($
|
|
3083
|
+
var __$0 = $Q($C($R$0($EXPECT($R22, fail, "__ /[\\s]+/")), Comment));
|
|
2820
3084
|
function __(state) {
|
|
2821
3085
|
if (state.verbose)
|
|
2822
3086
|
console.log("ENTER:", "__");
|
|
@@ -2826,7 +3090,7 @@ var Civet = (() => {
|
|
|
2826
3090
|
return __$0(state);
|
|
2827
3091
|
}
|
|
2828
3092
|
}
|
|
2829
|
-
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($
|
|
3093
|
+
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L87, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
|
|
2830
3094
|
var StatementDelimiter$1 = $T($Y(EOS), function(value) {
|
|
2831
3095
|
return [";", value];
|
|
2832
3096
|
});
|
|
@@ -2837,7 +3101,7 @@ var Civet = (() => {
|
|
|
2837
3101
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
2838
3102
|
}
|
|
2839
3103
|
}
|
|
2840
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3104
|
+
var NonIdContinue$0 = $R$0($EXPECT($R23, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
2841
3105
|
function NonIdContinue(state) {
|
|
2842
3106
|
if (state.verbose)
|
|
2843
3107
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -2861,7 +3125,7 @@ var Civet = (() => {
|
|
|
2861
3125
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
2862
3126
|
}
|
|
2863
3127
|
}
|
|
2864
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
3128
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L124, fail, 'JSXSelfClosingElement "/>"'));
|
|
2865
3129
|
function JSXSelfClosingElement(state) {
|
|
2866
3130
|
if (state.verbose)
|
|
2867
3131
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -2871,7 +3135,7 @@ var Civet = (() => {
|
|
|
2871
3135
|
return JSXSelfClosingElement$0(state);
|
|
2872
3136
|
}
|
|
2873
3137
|
}
|
|
2874
|
-
var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
3138
|
+
var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L66, fail, 'JSXOpeningElement ">"'));
|
|
2875
3139
|
function JSXOpeningElement(state) {
|
|
2876
3140
|
if (state.verbose)
|
|
2877
3141
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -2881,7 +3145,7 @@ var Civet = (() => {
|
|
|
2881
3145
|
return JSXOpeningElement$0(state);
|
|
2882
3146
|
}
|
|
2883
3147
|
}
|
|
2884
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
3148
|
+
var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
|
|
2885
3149
|
function JSXClosingElement(state) {
|
|
2886
3150
|
if (state.verbose)
|
|
2887
3151
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -2891,7 +3155,7 @@ var Civet = (() => {
|
|
|
2891
3155
|
return JSXClosingElement$0(state);
|
|
2892
3156
|
}
|
|
2893
3157
|
}
|
|
2894
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
3158
|
+
var JSXFragment$0 = $S($EXPECT($L126, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L127, fail, 'JSXFragment "</>"'));
|
|
2895
3159
|
function JSXFragment(state) {
|
|
2896
3160
|
if (state.verbose)
|
|
2897
3161
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -2901,7 +3165,7 @@ var Civet = (() => {
|
|
|
2901
3165
|
return JSXFragment$0(state);
|
|
2902
3166
|
}
|
|
2903
3167
|
}
|
|
2904
|
-
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($
|
|
3168
|
+
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L24, fail, 'JSXElementName "."'), JSXIdentifierName))));
|
|
2905
3169
|
function JSXElementName(state) {
|
|
2906
3170
|
if (state.verbose)
|
|
2907
3171
|
console.log("ENTER:", "JSXElementName");
|
|
@@ -2911,7 +3175,7 @@ var Civet = (() => {
|
|
|
2911
3175
|
return JSXElementName$0(state);
|
|
2912
3176
|
}
|
|
2913
3177
|
}
|
|
2914
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
3178
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R24, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
2915
3179
|
function JSXIdentifierName(state) {
|
|
2916
3180
|
if (state.verbose)
|
|
2917
3181
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -2950,7 +3214,7 @@ var Civet = (() => {
|
|
|
2950
3214
|
return JSXAttributeName$0(state);
|
|
2951
3215
|
}
|
|
2952
3216
|
}
|
|
2953
|
-
var JSXAttributeInitializer$0 = $S(__, $EXPECT($
|
|
3217
|
+
var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
|
|
2954
3218
|
function JSXAttributeInitializer(state) {
|
|
2955
3219
|
if (state.verbose)
|
|
2956
3220
|
console.log("ENTER:", "JSXAttributeInitializer");
|
|
@@ -2960,8 +3224,8 @@ var Civet = (() => {
|
|
|
2960
3224
|
return JSXAttributeInitializer$0(state);
|
|
2961
3225
|
}
|
|
2962
3226
|
}
|
|
2963
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
2964
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
3227
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R25, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
3228
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R26, fail, "JSXAttributeValue /'[^']*'/"));
|
|
2965
3229
|
var JSXAttributeValue$2 = $S($EXPECT($L11, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttributeValue "}"'));
|
|
2966
3230
|
var JSXAttributeValue$3 = JSXElement;
|
|
2967
3231
|
var JSXAttributeValue$4 = JSXFragment;
|
|
@@ -2993,7 +3257,7 @@ var Civet = (() => {
|
|
|
2993
3257
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
2994
3258
|
}
|
|
2995
3259
|
}
|
|
2996
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
3260
|
+
var JSXText$0 = $R$0($EXPECT($R27, fail, "JSXText /[^{}<>]+/"));
|
|
2997
3261
|
function JSXText(state) {
|
|
2998
3262
|
if (state.verbose)
|
|
2999
3263
|
console.log("ENTER:", "JSXText");
|
|
@@ -3013,10 +3277,10 @@ var Civet = (() => {
|
|
|
3013
3277
|
return JSXChildExpression$0(state);
|
|
3014
3278
|
}
|
|
3015
3279
|
}
|
|
3016
|
-
var TypeDeclaration$0 = $T($S($EXPECT($
|
|
3280
|
+
var TypeDeclaration$0 = $T($S($EXPECT($R28, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L55, fail, 'TypeDeclaration "="'), __, Type), function(value) {
|
|
3017
3281
|
return { "ts": true, "children": value };
|
|
3018
3282
|
});
|
|
3019
|
-
var TypeDeclaration$1 = $T($S($EXPECT($
|
|
3283
|
+
var TypeDeclaration$1 = $T($S($EXPECT($R29, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
|
|
3020
3284
|
return { "ts": true, "children": value };
|
|
3021
3285
|
});
|
|
3022
3286
|
function TypeDeclaration(state) {
|
|
@@ -3071,7 +3335,7 @@ var Civet = (() => {
|
|
|
3071
3335
|
return InterfaceProperty$0(state);
|
|
3072
3336
|
}
|
|
3073
3337
|
}
|
|
3074
|
-
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($
|
|
3338
|
+
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L87, fail, 'InterfacePropertyDelimiter ";"'));
|
|
3075
3339
|
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
|
|
3076
3340
|
var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
|
|
3077
3341
|
return ";";
|
|
@@ -3086,7 +3350,7 @@ var Civet = (() => {
|
|
|
3086
3350
|
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
|
|
3087
3351
|
}
|
|
3088
3352
|
}
|
|
3089
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
3353
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L128, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L25, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L26, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
|
|
3090
3354
|
function TypeIndexSignature(state) {
|
|
3091
3355
|
if (state.verbose)
|
|
3092
3356
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -3097,7 +3361,7 @@ var Civet = (() => {
|
|
|
3097
3361
|
}
|
|
3098
3362
|
}
|
|
3099
3363
|
var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
|
|
3100
|
-
var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($
|
|
3364
|
+
var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L78, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
|
|
3101
3365
|
function TypeIndex(state) {
|
|
3102
3366
|
if (state.tokenize) {
|
|
3103
3367
|
return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
|
|
@@ -3117,7 +3381,7 @@ var Civet = (() => {
|
|
|
3117
3381
|
return TypeSuffix$0(state);
|
|
3118
3382
|
}
|
|
3119
3383
|
}
|
|
3120
|
-
var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($
|
|
3384
|
+
var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L129, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
|
|
3121
3385
|
return { "ts": true, "children": value };
|
|
3122
3386
|
});
|
|
3123
3387
|
function ReturnTypeSuffix(state) {
|
|
@@ -3129,7 +3393,7 @@ var Civet = (() => {
|
|
|
3129
3393
|
return ReturnTypeSuffix$0(state);
|
|
3130
3394
|
}
|
|
3131
3395
|
}
|
|
3132
|
-
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($
|
|
3396
|
+
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
|
|
3133
3397
|
function TypePredicate(state) {
|
|
3134
3398
|
if (state.verbose)
|
|
3135
3399
|
console.log("ENTER:", "TypePredicate");
|
|
@@ -3179,9 +3443,9 @@ var Civet = (() => {
|
|
|
3179
3443
|
return TypeUnarySuffix$0(state);
|
|
3180
3444
|
}
|
|
3181
3445
|
}
|
|
3182
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
3183
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
3184
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
3446
|
+
var TypeUnaryOp$0 = $EXPECT($L130, fail, 'TypeUnaryOp "keyof"');
|
|
3447
|
+
var TypeUnaryOp$1 = $EXPECT($L84, fail, 'TypeUnaryOp "typeof"');
|
|
3448
|
+
var TypeUnaryOp$2 = $EXPECT($L131, fail, 'TypeUnaryOp "infer"');
|
|
3185
3449
|
function TypeUnaryOp(state) {
|
|
3186
3450
|
if (state.tokenize) {
|
|
3187
3451
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -3189,7 +3453,7 @@ var Civet = (() => {
|
|
|
3189
3453
|
return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
|
|
3190
3454
|
}
|
|
3191
3455
|
}
|
|
3192
|
-
var TypeIndexedAccess$0 = $S(__, $EXPECT($
|
|
3456
|
+
var TypeIndexedAccess$0 = $S(__, $EXPECT($L25, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L26, fail, 'TypeIndexedAccess "]"'));
|
|
3193
3457
|
function TypeIndexedAccess(state) {
|
|
3194
3458
|
if (state.verbose)
|
|
3195
3459
|
console.log("ENTER:", "TypeIndexedAccess");
|
|
@@ -3202,7 +3466,7 @@ var Civet = (() => {
|
|
|
3202
3466
|
var TypePrimary$0 = InterfaceBlock;
|
|
3203
3467
|
var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
|
|
3204
3468
|
var TypePrimary$2 = $S($Q(_), FunctionType);
|
|
3205
|
-
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($
|
|
3469
|
+
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L24, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
|
|
3206
3470
|
var TypePrimary$4 = $S($Q(_), TypeLiteral);
|
|
3207
3471
|
function TypePrimary(state) {
|
|
3208
3472
|
if (state.tokenize) {
|
|
@@ -3222,8 +3486,8 @@ var Civet = (() => {
|
|
|
3222
3486
|
}
|
|
3223
3487
|
}
|
|
3224
3488
|
var TypeLiteral$0 = Literal;
|
|
3225
|
-
var TypeLiteral$1 = $EXPECT($
|
|
3226
|
-
var TypeLiteral$2 = $EXPECT($
|
|
3489
|
+
var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
|
|
3490
|
+
var TypeLiteral$2 = $EXPECT($L132, fail, 'TypeLiteral "[]"');
|
|
3227
3491
|
function TypeLiteral(state) {
|
|
3228
3492
|
if (state.tokenize) {
|
|
3229
3493
|
return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
|
|
@@ -3231,8 +3495,8 @@ var Civet = (() => {
|
|
|
3231
3495
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
3232
3496
|
}
|
|
3233
3497
|
}
|
|
3234
|
-
var TypeBinaryOp$0 = $EXPECT($
|
|
3235
|
-
var TypeBinaryOp$1 = $EXPECT($
|
|
3498
|
+
var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
|
|
3499
|
+
var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
|
|
3236
3500
|
function TypeBinaryOp(state) {
|
|
3237
3501
|
if (state.tokenize) {
|
|
3238
3502
|
return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
|
|
@@ -3250,7 +3514,7 @@ var Civet = (() => {
|
|
|
3250
3514
|
return FunctionType$0(state);
|
|
3251
3515
|
}
|
|
3252
3516
|
}
|
|
3253
|
-
var TypeArguments$0 = $S(__, $EXPECT($L14, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($
|
|
3517
|
+
var TypeArguments$0 = $S(__, $EXPECT($L14, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L66, fail, 'TypeArguments ">"'));
|
|
3254
3518
|
function TypeArguments(state) {
|
|
3255
3519
|
if (state.verbose)
|
|
3256
3520
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -3260,7 +3524,7 @@ var Civet = (() => {
|
|
|
3260
3524
|
return TypeArguments$0(state);
|
|
3261
3525
|
}
|
|
3262
3526
|
}
|
|
3263
|
-
var TypeParameters$0 = $S(__, $EXPECT($L14, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($
|
|
3527
|
+
var TypeParameters$0 = $S(__, $EXPECT($L14, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L66, fail, 'TypeParameters ">"'));
|
|
3264
3528
|
function TypeParameters(state) {
|
|
3265
3529
|
if (state.verbose)
|
|
3266
3530
|
console.log("ENTER:", "TypeParameters");
|
|
@@ -3291,8 +3555,8 @@ var Civet = (() => {
|
|
|
3291
3555
|
}
|
|
3292
3556
|
}
|
|
3293
3557
|
var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
|
|
3294
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
3295
|
-
var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
3558
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L66, fail, 'TypeParameterDelimiter ">"')));
|
|
3559
|
+
var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L66, fail, 'TypeParameterDelimiter ">"'))), function(value) {
|
|
3296
3560
|
return ",";
|
|
3297
3561
|
});
|
|
3298
3562
|
var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -3305,7 +3569,7 @@ var Civet = (() => {
|
|
|
3305
3569
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
3306
3570
|
}
|
|
3307
3571
|
}
|
|
3308
|
-
var Shebang$0 = $R$0($EXPECT($
|
|
3572
|
+
var Shebang$0 = $R$0($EXPECT($R32, fail, "Shebang /#![^\\r\\n]*/"));
|
|
3309
3573
|
function Shebang(state) {
|
|
3310
3574
|
if (state.verbose)
|
|
3311
3575
|
console.log("ENTER:", "Shebang");
|
|
@@ -3315,7 +3579,7 @@ var Civet = (() => {
|
|
|
3315
3579
|
return Shebang$0(state);
|
|
3316
3580
|
}
|
|
3317
3581
|
}
|
|
3318
|
-
var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($
|
|
3582
|
+
var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R33, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
|
|
3319
3583
|
return $0.map((p) => p.join(""));
|
|
3320
3584
|
});
|
|
3321
3585
|
function DirectivePrologue(state) {
|
|
@@ -3337,7 +3601,7 @@ var Civet = (() => {
|
|
|
3337
3601
|
return EOS$0(state);
|
|
3338
3602
|
}
|
|
3339
3603
|
}
|
|
3340
|
-
var EOL$0 = $R$0($EXPECT($
|
|
3604
|
+
var EOL$0 = $R$0($EXPECT($R34, fail, "EOL /\\r\\n|\\n|\\r|$/"));
|
|
3341
3605
|
function EOL(state) {
|
|
3342
3606
|
if (state.verbose)
|
|
3343
3607
|
console.log("ENTER:", "EOL");
|
|
@@ -3347,7 +3611,7 @@ var Civet = (() => {
|
|
|
3347
3611
|
return EOL$0(state);
|
|
3348
3612
|
}
|
|
3349
3613
|
}
|
|
3350
|
-
var EOF$0 = $R$0($EXPECT($
|
|
3614
|
+
var EOF$0 = $R$0($EXPECT($R35, fail, "EOF /$/"));
|
|
3351
3615
|
function EOF(state) {
|
|
3352
3616
|
if (state.verbose)
|
|
3353
3617
|
console.log("ENTER:", "EOF");
|
|
@@ -3357,6 +3621,18 @@ var Civet = (() => {
|
|
|
3357
3621
|
return EOF$0(state);
|
|
3358
3622
|
}
|
|
3359
3623
|
}
|
|
3624
|
+
var Debugger$0 = $TV($EXPECT($L31, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
3625
|
+
debugger;
|
|
3626
|
+
});
|
|
3627
|
+
function Debugger(state) {
|
|
3628
|
+
if (state.verbose)
|
|
3629
|
+
console.log("ENTER:", "Debugger");
|
|
3630
|
+
if (state.tokenize) {
|
|
3631
|
+
return $TOKEN("Debugger", state, Debugger$0(state));
|
|
3632
|
+
} else {
|
|
3633
|
+
return Debugger$0(state);
|
|
3634
|
+
}
|
|
3635
|
+
}
|
|
3360
3636
|
var InsertOpenParen$0 = $T($EXPECT($L31, fail, 'InsertOpenParen ""'), function(value) {
|
|
3361
3637
|
return "(";
|
|
3362
3638
|
});
|
|
@@ -3474,6 +3750,15 @@ var Civet = (() => {
|
|
|
3474
3750
|
const compatRe = /use coffee-compat/;
|
|
3475
3751
|
global.coffeeCompat = directives.some((d) => d.match(compatRe));
|
|
3476
3752
|
}
|
|
3753
|
+
module.dedentBlockString = function(str) {
|
|
3754
|
+
const spacing = str.match(/^(\r?\n|\n)\s+/);
|
|
3755
|
+
if (spacing) {
|
|
3756
|
+
str = str.replaceAll(spacing[0], "\n");
|
|
3757
|
+
}
|
|
3758
|
+
str = str.replace(/^(\r?\n|\n)/, "");
|
|
3759
|
+
str = str.replace(/(\r?\n|\n)$/, "");
|
|
3760
|
+
return str;
|
|
3761
|
+
};
|
|
3477
3762
|
return $0;
|
|
3478
3763
|
});
|
|
3479
3764
|
function Init(state) {
|
|
@@ -3485,7 +3770,7 @@ var Civet = (() => {
|
|
|
3485
3770
|
return Init$0(state);
|
|
3486
3771
|
}
|
|
3487
3772
|
}
|
|
3488
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
3773
|
+
var Indent$0 = $TV($Q($C($EXPECT($L133, fail, 'Indent " "'), $EXPECT($L134, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
3489
3774
|
return $1.length;
|
|
3490
3775
|
});
|
|
3491
3776
|
function Indent(state) {
|
|
@@ -3556,6 +3841,31 @@ var Civet = (() => {
|
|
|
3556
3841
|
return Nested$0(state);
|
|
3557
3842
|
}
|
|
3558
3843
|
}
|
|
3844
|
+
var NestedFurther$0 = $TS($S($E(EOS), Indent), function($skip, $loc, $0, $1, $2) {
|
|
3845
|
+
var eos = $1;
|
|
3846
|
+
var indent = $2;
|
|
3847
|
+
const currentIndent = global.indentLevels[global.indentLevels.length - 1];
|
|
3848
|
+
if (global.verbose) {
|
|
3849
|
+
console.log("global indent", global.currentIndent);
|
|
3850
|
+
console.log("Indented", indent, currentIndent);
|
|
3851
|
+
}
|
|
3852
|
+
if (indent !== currentIndent + 1) {
|
|
3853
|
+
if (global.verbose) {
|
|
3854
|
+
console.log("skipped nested");
|
|
3855
|
+
}
|
|
3856
|
+
return $skip;
|
|
3857
|
+
}
|
|
3858
|
+
return [eos, "".padStart(indent * 2)];
|
|
3859
|
+
});
|
|
3860
|
+
function NestedFurther(state) {
|
|
3861
|
+
if (state.verbose)
|
|
3862
|
+
console.log("ENTER:", "NestedFurther");
|
|
3863
|
+
if (state.tokenize) {
|
|
3864
|
+
return $TOKEN("NestedFurther", state, NestedFurther$0(state));
|
|
3865
|
+
} else {
|
|
3866
|
+
return NestedFurther$0(state);
|
|
3867
|
+
}
|
|
3868
|
+
}
|
|
3559
3869
|
module.exports = {
|
|
3560
3870
|
parse
|
|
3561
3871
|
};
|
|
@@ -3566,11 +3876,18 @@ var Civet = (() => {
|
|
|
3566
3876
|
var require_generate = __commonJS({
|
|
3567
3877
|
"source/generate.coffee"(exports, module) {
|
|
3568
3878
|
var gen;
|
|
3879
|
+
var prune;
|
|
3569
3880
|
gen = function(node, options) {
|
|
3881
|
+
var $loc, token;
|
|
3570
3882
|
if (node === null || node === void 0) {
|
|
3571
3883
|
return "";
|
|
3572
3884
|
}
|
|
3573
3885
|
if (typeof node === "string") {
|
|
3886
|
+
if (options != null) {
|
|
3887
|
+
if (typeof options.updateSourceMap === "function") {
|
|
3888
|
+
options.updateSourceMap(node);
|
|
3889
|
+
}
|
|
3890
|
+
}
|
|
3574
3891
|
return node;
|
|
3575
3892
|
}
|
|
3576
3893
|
if (Array.isArray(node)) {
|
|
@@ -3579,37 +3896,217 @@ var Civet = (() => {
|
|
|
3579
3896
|
}).join("");
|
|
3580
3897
|
}
|
|
3581
3898
|
if (typeof node === "object") {
|
|
3582
|
-
if (
|
|
3899
|
+
if (options.js && node.ts) {
|
|
3583
3900
|
return "";
|
|
3584
3901
|
}
|
|
3902
|
+
if (node.$loc != null) {
|
|
3903
|
+
({ token, $loc } = node);
|
|
3904
|
+
if (options != null) {
|
|
3905
|
+
if (typeof options.updateSourceMap === "function") {
|
|
3906
|
+
options.updateSourceMap(token, $loc.pos);
|
|
3907
|
+
}
|
|
3908
|
+
}
|
|
3909
|
+
return token;
|
|
3910
|
+
}
|
|
3585
3911
|
if (!node.children) {
|
|
3586
3912
|
throw new Error("Unknown node", JSON.stringify(node));
|
|
3587
3913
|
}
|
|
3588
|
-
return node.children
|
|
3589
|
-
return gen(child, options);
|
|
3590
|
-
}).join("");
|
|
3914
|
+
return gen(node.children, options);
|
|
3591
3915
|
}
|
|
3592
3916
|
throw new Error("Unknown node", JSON.stringify(node));
|
|
3593
3917
|
};
|
|
3594
3918
|
module.exports = gen;
|
|
3919
|
+
prune = function(node) {
|
|
3920
|
+
var a;
|
|
3921
|
+
if (node === null || node === void 0) {
|
|
3922
|
+
return;
|
|
3923
|
+
}
|
|
3924
|
+
if (node.length === 0) {
|
|
3925
|
+
return;
|
|
3926
|
+
}
|
|
3927
|
+
if (Array.isArray(node)) {
|
|
3928
|
+
a = node.map(function(n) {
|
|
3929
|
+
return prune(n);
|
|
3930
|
+
}).filter(function(n) {
|
|
3931
|
+
return !!n;
|
|
3932
|
+
});
|
|
3933
|
+
if (a.length > 1) {
|
|
3934
|
+
return a;
|
|
3935
|
+
}
|
|
3936
|
+
if (a.length === 1) {
|
|
3937
|
+
return a[0];
|
|
3938
|
+
}
|
|
3939
|
+
return;
|
|
3940
|
+
}
|
|
3941
|
+
if (node.children != null) {
|
|
3942
|
+
node.children = prune(node.children);
|
|
3943
|
+
return node;
|
|
3944
|
+
}
|
|
3945
|
+
return node;
|
|
3946
|
+
};
|
|
3947
|
+
gen.prune = prune;
|
|
3948
|
+
}
|
|
3949
|
+
});
|
|
3950
|
+
|
|
3951
|
+
// source/util.coffee
|
|
3952
|
+
var require_util = __commonJS({
|
|
3953
|
+
"source/util.coffee"(exports, module) {
|
|
3954
|
+
var BASE64_CHARS;
|
|
3955
|
+
var SourceMap;
|
|
3956
|
+
var VLQ_CONTINUATION_BIT;
|
|
3957
|
+
var VLQ_SHIFT;
|
|
3958
|
+
var VLQ_VALUE_MASK;
|
|
3959
|
+
var encodeBase64;
|
|
3960
|
+
var encodeVlq;
|
|
3961
|
+
var locationTable;
|
|
3962
|
+
var lookupLineColumn;
|
|
3963
|
+
locationTable = function(input) {
|
|
3964
|
+
var line, lines, linesRe, pos, result;
|
|
3965
|
+
linesRe = /([^\r\n]*)(\r\n|\r|\n|$)/y;
|
|
3966
|
+
lines = [];
|
|
3967
|
+
line = 0;
|
|
3968
|
+
pos = 0;
|
|
3969
|
+
while (result = linesRe.exec(input)) {
|
|
3970
|
+
pos += result[0].length;
|
|
3971
|
+
lines[line++] = pos;
|
|
3972
|
+
if (pos === input.length) {
|
|
3973
|
+
break;
|
|
3974
|
+
}
|
|
3975
|
+
}
|
|
3976
|
+
return lines;
|
|
3977
|
+
};
|
|
3978
|
+
lookupLineColumn = function(table, pos) {
|
|
3979
|
+
var l, prevEnd;
|
|
3980
|
+
l = 0;
|
|
3981
|
+
prevEnd = 0;
|
|
3982
|
+
while (table[l] <= pos) {
|
|
3983
|
+
prevEnd = table[l++];
|
|
3984
|
+
}
|
|
3985
|
+
return [l, pos - prevEnd];
|
|
3986
|
+
};
|
|
3987
|
+
SourceMap = function(sourceString) {
|
|
3988
|
+
var EOL, sm, srcTable;
|
|
3989
|
+
srcTable = locationTable(sourceString);
|
|
3990
|
+
sm = {
|
|
3991
|
+
lines: [[]],
|
|
3992
|
+
lineNum: 0,
|
|
3993
|
+
colOffset: 0,
|
|
3994
|
+
srcTable
|
|
3995
|
+
};
|
|
3996
|
+
EOL = /\r?\n|\r/;
|
|
3997
|
+
return {
|
|
3998
|
+
data: sm,
|
|
3999
|
+
renderMappings: function() {
|
|
4000
|
+
var lastSourceColumn, lastSourceLine;
|
|
4001
|
+
lastSourceLine = 0;
|
|
4002
|
+
lastSourceColumn = 0;
|
|
4003
|
+
return sm.lines.map(function(line) {
|
|
4004
|
+
return line.map(function(entry) {
|
|
4005
|
+
var colDelta, lineDelta, sourceFileIndex, srcCol, srcLine;
|
|
4006
|
+
if (entry.length === 4) {
|
|
4007
|
+
[colDelta, sourceFileIndex, srcLine, srcCol] = entry;
|
|
4008
|
+
lineDelta = srcLine - lastSourceLine;
|
|
4009
|
+
colDelta = srcCol - lastSourceColumn;
|
|
4010
|
+
lastSourceLine = srcLine;
|
|
4011
|
+
lastSourceColumn = srcCol;
|
|
4012
|
+
return `${encodeVlq(entry[0])}${encodeVlq(sourceFileIndex)}${encodeVlq(lineDelta)}${encodeVlq(colDelta)}`;
|
|
4013
|
+
} else {
|
|
4014
|
+
return encodeVlq(entry[0]);
|
|
4015
|
+
}
|
|
4016
|
+
}).join(",");
|
|
4017
|
+
}).join(";");
|
|
4018
|
+
},
|
|
4019
|
+
json: function(srcFileName, outFileName) {
|
|
4020
|
+
return {
|
|
4021
|
+
version: 3,
|
|
4022
|
+
file: outFileName,
|
|
4023
|
+
sources: [srcFileName],
|
|
4024
|
+
mappings: this.renderMappings(),
|
|
4025
|
+
names: [],
|
|
4026
|
+
sourcesContent: [sourceString]
|
|
4027
|
+
};
|
|
4028
|
+
},
|
|
4029
|
+
updateSourceMap: function(outputStr, inputPos) {
|
|
4030
|
+
var outLines;
|
|
4031
|
+
outLines = outputStr.split(EOL);
|
|
4032
|
+
outLines.forEach(function(line, i) {
|
|
4033
|
+
var l, srcCol, srcLine;
|
|
4034
|
+
if (i > 0) {
|
|
4035
|
+
sm.lineNum++;
|
|
4036
|
+
sm.colOffset = 0;
|
|
4037
|
+
sm.lines[sm.lineNum] = [];
|
|
4038
|
+
}
|
|
4039
|
+
l = sm.colOffset;
|
|
4040
|
+
sm.colOffset = line.length;
|
|
4041
|
+
if (inputPos != null) {
|
|
4042
|
+
[srcLine, srcCol] = lookupLineColumn(srcTable, inputPos);
|
|
4043
|
+
return sm.lines[sm.lineNum].push([l, 0, srcLine, srcCol]);
|
|
4044
|
+
} else if (l !== 0) {
|
|
4045
|
+
return sm.lines[sm.lineNum].push([l]);
|
|
4046
|
+
}
|
|
4047
|
+
});
|
|
4048
|
+
}
|
|
4049
|
+
};
|
|
4050
|
+
};
|
|
4051
|
+
VLQ_SHIFT = 5;
|
|
4052
|
+
VLQ_CONTINUATION_BIT = 1 << VLQ_SHIFT;
|
|
4053
|
+
VLQ_VALUE_MASK = VLQ_CONTINUATION_BIT - 1;
|
|
4054
|
+
encodeVlq = function(value) {
|
|
4055
|
+
var answer, nextChunk, signBit, valueToEncode;
|
|
4056
|
+
answer = "";
|
|
4057
|
+
signBit = value < 0 ? 1 : 0;
|
|
4058
|
+
valueToEncode = (Math.abs(value) << 1) + signBit;
|
|
4059
|
+
while (valueToEncode || !answer) {
|
|
4060
|
+
nextChunk = valueToEncode & VLQ_VALUE_MASK;
|
|
4061
|
+
valueToEncode = valueToEncode >> VLQ_SHIFT;
|
|
4062
|
+
if (valueToEncode) {
|
|
4063
|
+
nextChunk |= VLQ_CONTINUATION_BIT;
|
|
4064
|
+
}
|
|
4065
|
+
answer += encodeBase64(nextChunk);
|
|
4066
|
+
}
|
|
4067
|
+
return answer;
|
|
4068
|
+
};
|
|
4069
|
+
BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
4070
|
+
encodeBase64 = function(value) {
|
|
4071
|
+
return BASE64_CHARS[value] || function() {
|
|
4072
|
+
throw new Error(`Cannot Base64 encode value: ${value}`);
|
|
4073
|
+
}();
|
|
4074
|
+
};
|
|
4075
|
+
module.exports = { locationTable, lookupLineColumn, SourceMap };
|
|
3595
4076
|
}
|
|
3596
4077
|
});
|
|
3597
4078
|
|
|
3598
4079
|
// source/main.coffee
|
|
3599
4080
|
var require_main = __commonJS({
|
|
3600
4081
|
"source/main.coffee"(exports, module) {
|
|
4082
|
+
var SourceMap;
|
|
3601
4083
|
var gen;
|
|
3602
4084
|
var parse;
|
|
4085
|
+
var prune;
|
|
4086
|
+
var util;
|
|
3603
4087
|
({ parse } = require_parser());
|
|
3604
|
-
gen = require_generate();
|
|
4088
|
+
({ prune } = gen = require_generate());
|
|
4089
|
+
({ SourceMap } = util = require_util());
|
|
3605
4090
|
module.exports = {
|
|
3606
4091
|
parse,
|
|
3607
4092
|
compile: function(src, options) {
|
|
3608
|
-
|
|
4093
|
+
var ast, code, sm;
|
|
4094
|
+
ast = prune(parse(src, {
|
|
3609
4095
|
filename: options != null ? options.filename : void 0
|
|
3610
|
-
})
|
|
4096
|
+
}));
|
|
4097
|
+
if (options.sourceMap) {
|
|
4098
|
+
sm = SourceMap(src);
|
|
4099
|
+
options.updateSourceMap = sm.updateSourceMap;
|
|
4100
|
+
code = gen(ast, options);
|
|
4101
|
+
return {
|
|
4102
|
+
code,
|
|
4103
|
+
sourceMap: sm
|
|
4104
|
+
};
|
|
4105
|
+
}
|
|
4106
|
+
return gen(ast, options);
|
|
3611
4107
|
},
|
|
3612
|
-
generate: gen
|
|
4108
|
+
generate: gen,
|
|
4109
|
+
util
|
|
3613
4110
|
};
|
|
3614
4111
|
}
|
|
3615
4112
|
});
|