@danielx/civet 0.2.15 → 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 +686 -320
- package/dist/browser.js.map +3 -3
- package/dist/civet +14 -13
- package/dist/cli.js.map +4 -4
- package/dist/main.js +691 -325
- package/dist/types.d.ts +24 -5
- package/package.json +4 -1
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,
|
|
@@ -463,13 +467,17 @@ var Civet = (() => {
|
|
|
463
467
|
FunctionDeclaration,
|
|
464
468
|
FunctionExpression,
|
|
465
469
|
ThinArrowFunction,
|
|
470
|
+
Arrow,
|
|
466
471
|
Block,
|
|
472
|
+
BracedOrEmptyBlock,
|
|
467
473
|
BracedBlock,
|
|
468
474
|
SingleNestedExpression,
|
|
469
475
|
SingleNestedBlockStatement,
|
|
470
476
|
NestedBlockExpressions,
|
|
471
477
|
BlockExpression,
|
|
472
478
|
Literal,
|
|
479
|
+
NullLiteral,
|
|
480
|
+
BooleanLiteral,
|
|
473
481
|
Comma,
|
|
474
482
|
Identifier,
|
|
475
483
|
IdentifierName,
|
|
@@ -499,7 +507,9 @@ var Civet = (() => {
|
|
|
499
507
|
AsyncGeneratorMethod,
|
|
500
508
|
AsyncGeneratorBody,
|
|
501
509
|
AssignmentOp,
|
|
510
|
+
AssignmentOpSymbol,
|
|
502
511
|
BinaryOp,
|
|
512
|
+
BinaryOpSymbol,
|
|
503
513
|
UnaryOp,
|
|
504
514
|
ModuleItem,
|
|
505
515
|
StatementListItem,
|
|
@@ -515,7 +525,9 @@ var Civet = (() => {
|
|
|
515
525
|
WhileClause,
|
|
516
526
|
ForStatement,
|
|
517
527
|
ForInOfStatement,
|
|
528
|
+
For,
|
|
518
529
|
ForDeclaration,
|
|
530
|
+
LetOrConst,
|
|
519
531
|
ForBinding,
|
|
520
532
|
SwitchStatement,
|
|
521
533
|
CaseBlock,
|
|
@@ -535,10 +547,12 @@ var Civet = (() => {
|
|
|
535
547
|
MaybeNestedExpression,
|
|
536
548
|
Return,
|
|
537
549
|
ImportDeclaration,
|
|
550
|
+
Import,
|
|
538
551
|
ImportClause,
|
|
539
552
|
NameSpaceImport,
|
|
540
553
|
NamedImports,
|
|
541
554
|
FromClause,
|
|
555
|
+
From,
|
|
542
556
|
ImportSpecifier,
|
|
543
557
|
ModuleExportName,
|
|
544
558
|
ModuleSpecifier,
|
|
@@ -559,6 +573,7 @@ var Civet = (() => {
|
|
|
559
573
|
VariableDeclarationList,
|
|
560
574
|
VariableDeclaration,
|
|
561
575
|
NumericLiteral,
|
|
576
|
+
NumericLiteralKind,
|
|
562
577
|
DecimalBigIntegerLiteral,
|
|
563
578
|
DecimalLiteral,
|
|
564
579
|
BinaryIntegerLiteral,
|
|
@@ -568,7 +583,7 @@ var Civet = (() => {
|
|
|
568
583
|
DoubleStringCharacter,
|
|
569
584
|
SingleStringCharacter,
|
|
570
585
|
TripleDoubleStringCharacter,
|
|
571
|
-
|
|
586
|
+
TripleSingleStringCharacter,
|
|
572
587
|
RegularExpressionLiteral,
|
|
573
588
|
RegularExpressionBody,
|
|
574
589
|
RegExpCharacter,
|
|
@@ -674,8 +689,8 @@ var Civet = (() => {
|
|
|
674
689
|
var $L16 = $L("}");
|
|
675
690
|
var $L17 = $L("static");
|
|
676
691
|
var $L18 = $L("this");
|
|
677
|
-
var $L19 = $L("
|
|
678
|
-
var $L20 = $L("
|
|
692
|
+
var $L19 = $L("#");
|
|
693
|
+
var $L20 = $L("@");
|
|
679
694
|
var $L21 = $L("new");
|
|
680
695
|
var $L22 = $L("super");
|
|
681
696
|
var $L23 = $L("import");
|
|
@@ -690,107 +705,106 @@ var Civet = (() => {
|
|
|
690
705
|
var $L32 = $L("...");
|
|
691
706
|
var $L33 = $L("function");
|
|
692
707
|
var $L34 = $L("->");
|
|
693
|
-
var $L35 = $L("
|
|
694
|
-
var $L36 = $L("
|
|
695
|
-
var $L37 = $L("
|
|
696
|
-
var $L38 = $L("
|
|
697
|
-
var $L39 = $L("
|
|
698
|
-
var $L40 = $L("
|
|
699
|
-
var $L41 = $L("
|
|
700
|
-
var $L42 = $L("
|
|
701
|
-
var $L43 = $L("
|
|
702
|
-
var $L44 = $L("
|
|
703
|
-
var $L45 = $L("
|
|
704
|
-
var $L46 = $L("
|
|
705
|
-
var $L47 = $L("
|
|
706
|
-
var $L48 = $L("
|
|
707
|
-
var $L49 = $L("
|
|
708
|
-
var $L50 = $L("
|
|
709
|
-
var $L51 = $L("
|
|
710
|
-
var $L52 = $L("
|
|
711
|
-
var $L53 = $L("
|
|
712
|
-
var $L54 = $L("
|
|
713
|
-
var $L55 = $L("
|
|
714
|
-
var $L56 = $L("
|
|
715
|
-
var $L57 = $L("
|
|
716
|
-
var $L58 = $L("
|
|
717
|
-
var $L59 = $L("
|
|
718
|
-
var $L60 = $L("
|
|
719
|
-
var $L61 = $L("
|
|
720
|
-
var $L62 = $L("
|
|
721
|
-
var $L63 = $L("
|
|
722
|
-
var $L64 = $L("
|
|
723
|
-
var $L65 = $L("
|
|
724
|
-
var $L66 = $L("
|
|
725
|
-
var $L67 = $L("
|
|
726
|
-
var $L68 = $L("
|
|
727
|
-
var $L69 = $L("
|
|
728
|
-
var $L70 = $L("
|
|
729
|
-
var $L71 = $L("
|
|
730
|
-
var $L72 = $L("
|
|
731
|
-
var $L73 = $L("
|
|
732
|
-
var $L74 = $L("
|
|
733
|
-
var $L75 = $L("
|
|
734
|
-
var $L76 = $L("
|
|
735
|
-
var $L77 = $L("
|
|
736
|
-
var $L78 = $L("
|
|
737
|
-
var $L79 = $L("
|
|
738
|
-
var $L80 = $L("
|
|
739
|
-
var $L81 = $L("
|
|
740
|
-
var $L82 = $L("
|
|
741
|
-
var $L83 = $L("
|
|
742
|
-
var $L84 = $L("
|
|
743
|
-
var $L85 = $L("
|
|
744
|
-
var $L86 = $L("
|
|
745
|
-
var $L87 = $L("
|
|
746
|
-
var $L88 = $L("
|
|
747
|
-
var $L89 = $L("
|
|
748
|
-
var $L90 = $L("
|
|
749
|
-
var $L91 = $L("
|
|
750
|
-
var $L92 = $L("
|
|
751
|
-
var $L93 = $L("
|
|
752
|
-
var $L94 = $L("
|
|
753
|
-
var $L95 = $L("
|
|
754
|
-
var $L96 = $L("
|
|
755
|
-
var $L97 = $L("
|
|
756
|
-
var $L98 = $L("
|
|
757
|
-
var $L99 = $L("
|
|
758
|
-
var $L100 = $L("
|
|
759
|
-
var $L101 = $L("
|
|
760
|
-
var $L102 = $L("
|
|
761
|
-
var $L103 = $L("
|
|
762
|
-
var $L104 = $L("
|
|
763
|
-
var $L105 = $L("
|
|
764
|
-
var $L106 = $L("
|
|
765
|
-
var $L107 = $L("
|
|
766
|
-
var $L108 = $L("
|
|
767
|
-
var $L109 = $L("
|
|
768
|
-
var $L110 = $L("
|
|
769
|
-
var $L111 = $L("
|
|
770
|
-
var $L112 = $L("
|
|
771
|
-
var $L113 = $L("
|
|
772
|
-
var $L114 = $L("
|
|
773
|
-
var $L115 = $L("
|
|
774
|
-
var $L116 = $L('"
|
|
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("'''");
|
|
775
790
|
var $L117 = $L('"');
|
|
776
791
|
var $L118 = $L("'");
|
|
777
|
-
var $L119 = $L("
|
|
778
|
-
var $L120 = $L("
|
|
779
|
-
var $L121 = $L("
|
|
780
|
-
var $L122 = $L("
|
|
781
|
-
var $L123 = $L("
|
|
782
|
-
var $L124 = $L("
|
|
783
|
-
var $L125 = $L("
|
|
784
|
-
var $L126 = $L("
|
|
785
|
-
var $L127 = $L("
|
|
786
|
-
var $L128 = $L("
|
|
787
|
-
var $L129 = $L("
|
|
788
|
-
var $L130 = $L("
|
|
789
|
-
var $L131 = $L("
|
|
790
|
-
var $L132 = $L("
|
|
791
|
-
var $L133 = $L("
|
|
792
|
-
var $L134 = $L("
|
|
793
|
-
var $L135 = $L(" ");
|
|
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(" ");
|
|
794
808
|
var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
795
809
|
var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
796
810
|
var $R2 = $R(new RegExp("[!~+-]", "suy"));
|
|
@@ -799,33 +813,34 @@ var Civet = (() => {
|
|
|
799
813
|
var $R5 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
|
|
800
814
|
var $R6 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
|
|
801
815
|
var $R7 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
|
|
802
|
-
var $R8 = $R(new RegExp('[^"
|
|
803
|
-
var $R9 = $R(new RegExp("[^'
|
|
816
|
+
var $R8 = $R(new RegExp('(?:\\\\.|[^"])+', "suy"));
|
|
817
|
+
var $R9 = $R(new RegExp("(?:\\\\.|[^'])+", "suy"));
|
|
804
818
|
var $R10 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
|
|
805
|
-
var $R11 = $R(new RegExp("
|
|
819
|
+
var $R11 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])+", "suy"));
|
|
806
820
|
var $R12 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
|
|
807
|
-
var $R13 = $R(new RegExp("[^\\/\\r\\n]+", "suy"));
|
|
808
|
-
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"));
|
|
809
823
|
var $R15 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
810
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"));
|
|
811
825
|
var $R17 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
812
|
-
var $R18 = $R(new RegExp("
|
|
813
|
-
var $R19 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
814
|
-
var $R20 = $R(new RegExp("[\\
|
|
815
|
-
var $R21 = $R(new RegExp("[\\
|
|
816
|
-
var $R22 = $R(new RegExp("
|
|
817
|
-
var $R23 = $R(new RegExp("(
|
|
818
|
-
var $R24 = $R(new RegExp(
|
|
819
|
-
var $R25 = $R(new RegExp("
|
|
820
|
-
var $R26 = $R(new RegExp("[^
|
|
821
|
-
var $R27 = $R(new RegExp("
|
|
822
|
-
var $R28 = $R(new RegExp("
|
|
823
|
-
var $R29 = $R(new RegExp("
|
|
824
|
-
var $R30 = $R(new RegExp("[+-]", "suy"));
|
|
825
|
-
var $R31 = $R(new RegExp("
|
|
826
|
-
var $R32 = $R(new RegExp("[\\
|
|
827
|
-
var $R33 = $R(new RegExp("\\
|
|
828
|
-
var $R34 = $R(new RegExp("
|
|
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"));
|
|
829
844
|
var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
|
|
830
845
|
function Program(state) {
|
|
831
846
|
if (state.verbose)
|
|
@@ -949,8 +964,8 @@ var Civet = (() => {
|
|
|
949
964
|
return UnaryPostfix$0(state) || UnaryPostfix$1(state);
|
|
950
965
|
}
|
|
951
966
|
}
|
|
952
|
-
var UpdateExpression$0 = $S(
|
|
953
|
-
var UpdateExpression$1 = $S(LeftHandSideExpression, $E(
|
|
967
|
+
var UpdateExpression$0 = $S(UpdateExpressionSymbol, UnaryExpression);
|
|
968
|
+
var UpdateExpression$1 = $S(LeftHandSideExpression, $E(UpdateExpressionSymbol));
|
|
954
969
|
function UpdateExpression(state) {
|
|
955
970
|
if (state.tokenize) {
|
|
956
971
|
return $TOKEN("UpdateExpression", state, UpdateExpression$0(state) || UpdateExpression$1(state));
|
|
@@ -958,6 +973,18 @@ var Civet = (() => {
|
|
|
958
973
|
return UpdateExpression$0(state) || UpdateExpression$1(state);
|
|
959
974
|
}
|
|
960
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
|
+
}
|
|
961
988
|
var AssignmentExpression$0 = $S($Q(TrailingComment), AssignmentExpressionRest);
|
|
962
989
|
var AssignmentExpression$1 = $S(__, AssignmentExpressionRest);
|
|
963
990
|
function AssignmentExpression(state) {
|
|
@@ -1071,7 +1098,7 @@ var Civet = (() => {
|
|
|
1071
1098
|
return ClassDeclaration$0(state);
|
|
1072
1099
|
}
|
|
1073
1100
|
}
|
|
1074
|
-
var ClassExpression$0 = $S(
|
|
1101
|
+
var ClassExpression$0 = $S(Class, $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
|
|
1075
1102
|
function ClassExpression(state) {
|
|
1076
1103
|
if (state.verbose)
|
|
1077
1104
|
console.log("ENTER:", "ClassExpression");
|
|
@@ -1081,6 +1108,18 @@ var Civet = (() => {
|
|
|
1081
1108
|
return ClassExpression$0(state);
|
|
1082
1109
|
}
|
|
1083
1110
|
}
|
|
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
|
+
}
|
|
1084
1123
|
var ClassHeritage$0 = $S(ExtendsToken, __, MemberExpression);
|
|
1085
1124
|
function ClassHeritage(state) {
|
|
1086
1125
|
if (state.verbose)
|
|
@@ -1091,10 +1130,12 @@ var Civet = (() => {
|
|
|
1091
1130
|
return ClassHeritage$0(state);
|
|
1092
1131
|
}
|
|
1093
1132
|
}
|
|
1094
|
-
var ExtendsToken$0 = $
|
|
1095
|
-
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 };
|
|
1096
1138
|
});
|
|
1097
|
-
var ExtendsToken$1 = $EXPECT($L15, fail, 'ExtendsToken "extends"');
|
|
1098
1139
|
function ExtendsToken(state) {
|
|
1099
1140
|
if (state.tokenize) {
|
|
1100
1141
|
return $TOKEN("ExtendsToken", state, ExtendsToken$0(state) || ExtendsToken$1(state));
|
|
@@ -1136,8 +1177,8 @@ var Civet = (() => {
|
|
|
1136
1177
|
return NestedClassElement$0(state);
|
|
1137
1178
|
}
|
|
1138
1179
|
}
|
|
1139
|
-
var ClassElement$0 = $S(
|
|
1140
|
-
var ClassElement$1 = $S($E($S(
|
|
1180
|
+
var ClassElement$0 = $S(Static, BracedBlock);
|
|
1181
|
+
var ClassElement$1 = $S($E($S(Static, __)), $C(MethodDefinition, FieldDefinition));
|
|
1141
1182
|
function ClassElement(state) {
|
|
1142
1183
|
if (state.tokenize) {
|
|
1143
1184
|
return $TOKEN("ClassElement", state, ClassElement$0(state) || ClassElement$1(state));
|
|
@@ -1145,6 +1186,18 @@ var Civet = (() => {
|
|
|
1145
1186
|
return ClassElement$0(state) || ClassElement$1(state);
|
|
1146
1187
|
}
|
|
1147
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
|
+
}
|
|
1148
1201
|
var FieldDefinition$0 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
|
|
1149
1202
|
function FieldDefinition(state) {
|
|
1150
1203
|
if (state.verbose)
|
|
@@ -1155,12 +1208,11 @@ var Civet = (() => {
|
|
|
1155
1208
|
return FieldDefinition$0(state);
|
|
1156
1209
|
}
|
|
1157
1210
|
}
|
|
1158
|
-
var This$0 = $EXPECT($L18, fail, 'This "this"')
|
|
1159
|
-
|
|
1160
|
-
var ref = value[1];
|
|
1161
|
-
return ["this.", ref];
|
|
1211
|
+
var This$0 = $TV($EXPECT($L18, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
1212
|
+
return { $loc, token: $0 };
|
|
1162
1213
|
});
|
|
1163
|
-
var This$
|
|
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) {
|
|
1164
1216
|
return { $loc, token: "this" };
|
|
1165
1217
|
});
|
|
1166
1218
|
function This(state) {
|
|
@@ -1170,6 +1222,18 @@ var Civet = (() => {
|
|
|
1170
1222
|
return This$0(state) || This$1(state) || This$2(state);
|
|
1171
1223
|
}
|
|
1172
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
|
+
}
|
|
1173
1237
|
var LeftHandSideExpression$0 = NewExpression;
|
|
1174
1238
|
var LeftHandSideExpression$1 = CallExpression;
|
|
1175
1239
|
function LeftHandSideExpression(state) {
|
|
@@ -1441,11 +1505,17 @@ var Civet = (() => {
|
|
|
1441
1505
|
return FunctionExpression$0(state) || FunctionExpression$1(state);
|
|
1442
1506
|
}
|
|
1443
1507
|
}
|
|
1444
|
-
var ThinArrowFunction$0 = $
|
|
1445
|
-
var params =
|
|
1446
|
-
var suffix =
|
|
1447
|
-
var
|
|
1448
|
-
|
|
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
|
+
];
|
|
1449
1519
|
});
|
|
1450
1520
|
function ThinArrowFunction(state) {
|
|
1451
1521
|
if (state.verbose)
|
|
@@ -1456,6 +1526,18 @@ var Civet = (() => {
|
|
|
1456
1526
|
return ThinArrowFunction$0(state);
|
|
1457
1527
|
}
|
|
1458
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
|
+
}
|
|
1459
1541
|
var Block$0 = $S(__, $EXPECT($L11, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'Block "}"'));
|
|
1460
1542
|
var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1461
1543
|
var Block$2 = Statement;
|
|
@@ -1467,6 +1549,15 @@ var Civet = (() => {
|
|
|
1467
1549
|
return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
|
|
1468
1550
|
}
|
|
1469
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
|
+
}
|
|
1470
1561
|
var BracedBlock$0 = $S(__, $EXPECT($L11, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BracedBlock "}"'));
|
|
1471
1562
|
var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1472
1563
|
var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
|
|
@@ -1532,17 +1623,39 @@ var Civet = (() => {
|
|
|
1532
1623
|
return BlockExpression$0(state);
|
|
1533
1624
|
}
|
|
1534
1625
|
}
|
|
1535
|
-
var Literal$0 =
|
|
1536
|
-
var Literal$1 =
|
|
1537
|
-
var Literal$2 =
|
|
1538
|
-
var Literal$3 =
|
|
1539
|
-
var Literal$4 = $EXPECT($L37, fail, 'Literal "null"');
|
|
1540
|
-
var Literal$5 = $EXPECT($L38, fail, 'Literal "undefined"');
|
|
1626
|
+
var Literal$0 = NullLiteral;
|
|
1627
|
+
var Literal$1 = BooleanLiteral;
|
|
1628
|
+
var Literal$2 = NumericLiteral;
|
|
1629
|
+
var Literal$3 = StringLiteral;
|
|
1541
1630
|
function Literal(state) {
|
|
1542
1631
|
if (state.tokenize) {
|
|
1543
|
-
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));
|
|
1633
|
+
} else {
|
|
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));
|
|
1544
1657
|
} else {
|
|
1545
|
-
return
|
|
1658
|
+
return BooleanLiteral$0(state);
|
|
1546
1659
|
}
|
|
1547
1660
|
}
|
|
1548
1661
|
var Comma$0 = $S($Q(_), $EXPECT($L0, fail, 'Comma ","'), $Q(_));
|
|
@@ -1762,8 +1875,8 @@ var Civet = (() => {
|
|
|
1762
1875
|
return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
|
|
1763
1876
|
}
|
|
1764
1877
|
}
|
|
1765
|
-
var MethodDefinition$0 = $S($EXPECT($
|
|
1766
|
-
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);
|
|
1767
1880
|
var MethodDefinition$2 = AsyncGeneratorMethod;
|
|
1768
1881
|
var MethodDefinition$3 = AsyncMethod;
|
|
1769
1882
|
var MethodDefinition$4 = GeneratorMethod;
|
|
@@ -1784,7 +1897,7 @@ var Civet = (() => {
|
|
|
1784
1897
|
return ClassElementName$0(state) || ClassElementName$1(state);
|
|
1785
1898
|
}
|
|
1786
1899
|
}
|
|
1787
|
-
var PrivateIdentifier$0 = $S($EXPECT($
|
|
1900
|
+
var PrivateIdentifier$0 = $S($EXPECT($L19, fail, 'PrivateIdentifier "#"'), IdentifierName);
|
|
1788
1901
|
function PrivateIdentifier(state) {
|
|
1789
1902
|
if (state.verbose)
|
|
1790
1903
|
console.log("ENTER:", "PrivateIdentifier");
|
|
@@ -1854,80 +1967,104 @@ var Civet = (() => {
|
|
|
1854
1967
|
return AsyncGeneratorBody$0(state);
|
|
1855
1968
|
}
|
|
1856
1969
|
}
|
|
1857
|
-
var AssignmentOp$0 = $
|
|
1858
|
-
|
|
1859
|
-
|
|
1860
|
-
var AssignmentOp$3 = $EXPECT($L44, fail, 'AssignmentOp "%="');
|
|
1861
|
-
var AssignmentOp$4 = $EXPECT($L45, fail, 'AssignmentOp "+="');
|
|
1862
|
-
var AssignmentOp$5 = $EXPECT($L46, fail, 'AssignmentOp "-="');
|
|
1863
|
-
var AssignmentOp$6 = $EXPECT($L47, fail, 'AssignmentOp "<<="');
|
|
1864
|
-
var AssignmentOp$7 = $EXPECT($L48, fail, 'AssignmentOp ">>>="');
|
|
1865
|
-
var AssignmentOp$8 = $EXPECT($L49, fail, 'AssignmentOp ">>="');
|
|
1866
|
-
var AssignmentOp$9 = $EXPECT($L50, fail, 'AssignmentOp "&&="');
|
|
1867
|
-
var AssignmentOp$10 = $EXPECT($L51, fail, 'AssignmentOp "&="');
|
|
1868
|
-
var AssignmentOp$11 = $EXPECT($L52, fail, 'AssignmentOp "^="');
|
|
1869
|
-
var AssignmentOp$12 = $EXPECT($L53, fail, 'AssignmentOp "||="');
|
|
1870
|
-
var AssignmentOp$13 = $EXPECT($L54, fail, 'AssignmentOp "|="');
|
|
1871
|
-
var AssignmentOp$14 = $EXPECT($L55, fail, 'AssignmentOp "??="');
|
|
1872
|
-
var AssignmentOp$15 = $EXPECT($L56, fail, 'AssignmentOp "="');
|
|
1970
|
+
var AssignmentOp$0 = $TS($S(AssignmentOpSymbol), function($skip, $loc, $0, $1) {
|
|
1971
|
+
return { $loc, token: $1 };
|
|
1972
|
+
});
|
|
1873
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) {
|
|
1874
1999
|
if (state.tokenize) {
|
|
1875
|
-
return $TOKEN("
|
|
1876
|
-
} else {
|
|
1877
|
-
return
|
|
1878
|
-
}
|
|
1879
|
-
}
|
|
1880
|
-
var BinaryOp$0 = $
|
|
1881
|
-
|
|
1882
|
-
|
|
1883
|
-
|
|
1884
|
-
|
|
1885
|
-
|
|
1886
|
-
|
|
1887
|
-
|
|
1888
|
-
|
|
1889
|
-
|
|
1890
|
-
|
|
1891
|
-
|
|
1892
|
-
var
|
|
1893
|
-
var
|
|
1894
|
-
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) {
|
|
1895
2032
|
if (global.coffeeCompat)
|
|
1896
2033
|
return "!==";
|
|
1897
2034
|
return $1;
|
|
1898
2035
|
});
|
|
1899
|
-
var
|
|
2036
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L69, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
1900
2037
|
return "===";
|
|
1901
2038
|
});
|
|
1902
|
-
var
|
|
1903
|
-
var
|
|
2039
|
+
var BinaryOpSymbol$16 = $EXPECT($L70, fail, 'BinaryOpSymbol "==="');
|
|
2040
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L71, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
1904
2041
|
if (global.coffeeCompat)
|
|
1905
2042
|
return "===";
|
|
1906
2043
|
return $1;
|
|
1907
2044
|
});
|
|
1908
|
-
var
|
|
2045
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L72, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
1909
2046
|
return "&&";
|
|
1910
2047
|
});
|
|
1911
|
-
var
|
|
1912
|
-
var
|
|
2048
|
+
var BinaryOpSymbol$19 = $EXPECT($L73, fail, 'BinaryOpSymbol "&&"');
|
|
2049
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
1913
2050
|
return "||";
|
|
1914
2051
|
});
|
|
1915
|
-
var
|
|
1916
|
-
var
|
|
1917
|
-
var
|
|
1918
|
-
var
|
|
1919
|
-
var
|
|
1920
|
-
var
|
|
1921
|
-
var
|
|
1922
|
-
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) {
|
|
1923
2060
|
if (state.tokenize) {
|
|
1924
|
-
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));
|
|
1925
2062
|
} else {
|
|
1926
|
-
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);
|
|
1927
2064
|
}
|
|
1928
2065
|
}
|
|
1929
2066
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
1930
|
-
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, __);
|
|
1931
2068
|
function UnaryOp(state) {
|
|
1932
2069
|
if (state.tokenize) {
|
|
1933
2070
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -1961,7 +2098,7 @@ var Civet = (() => {
|
|
|
1961
2098
|
return StatementListItem$0(state);
|
|
1962
2099
|
}
|
|
1963
2100
|
}
|
|
1964
|
-
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) {
|
|
1965
2102
|
var ws = $1;
|
|
1966
2103
|
var cond = $2;
|
|
1967
2104
|
var exp = $4;
|
|
@@ -1994,7 +2131,7 @@ var Civet = (() => {
|
|
|
1994
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);
|
|
1995
2132
|
}
|
|
1996
2133
|
}
|
|
1997
|
-
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($
|
|
2134
|
+
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L87, fail, 'EmptyStatement ";"')));
|
|
1998
2135
|
function EmptyStatement(state) {
|
|
1999
2136
|
if (state.verbose)
|
|
2000
2137
|
console.log("ENTER:", "EmptyStatement");
|
|
@@ -2014,8 +2151,8 @@ var Civet = (() => {
|
|
|
2014
2151
|
return BlockStatement$0(state);
|
|
2015
2152
|
}
|
|
2016
2153
|
}
|
|
2017
|
-
var IfStatement$0 = $S($EXPECT($
|
|
2018
|
-
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) {
|
|
2019
2156
|
var condition = $2;
|
|
2020
2157
|
var block = $3;
|
|
2021
2158
|
return ["if", condition.map((c) => {
|
|
@@ -2045,7 +2182,7 @@ var Civet = (() => {
|
|
|
2045
2182
|
return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
|
|
2046
2183
|
}
|
|
2047
2184
|
}
|
|
2048
|
-
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) {
|
|
2049
2186
|
var b = $3;
|
|
2050
2187
|
return ["while(true)", b];
|
|
2051
2188
|
});
|
|
@@ -2058,7 +2195,7 @@ var Civet = (() => {
|
|
|
2058
2195
|
return LoopStatement$0(state);
|
|
2059
2196
|
}
|
|
2060
2197
|
}
|
|
2061
|
-
var DoWhileStatement$0 = $S($EXPECT($
|
|
2198
|
+
var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
|
|
2062
2199
|
function DoWhileStatement(state) {
|
|
2063
2200
|
if (state.verbose)
|
|
2064
2201
|
console.log("ENTER:", "DoWhileStatement");
|
|
@@ -2078,7 +2215,7 @@ var Civet = (() => {
|
|
|
2078
2215
|
return WhileStatement$0(state);
|
|
2079
2216
|
}
|
|
2080
2217
|
}
|
|
2081
|
-
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) {
|
|
2082
2219
|
var kind = $1;
|
|
2083
2220
|
var cond = $3;
|
|
2084
2221
|
if (kind === "until") {
|
|
@@ -2097,7 +2234,7 @@ var Civet = (() => {
|
|
|
2097
2234
|
return WhileClause$0(state);
|
|
2098
2235
|
}
|
|
2099
2236
|
}
|
|
2100
|
-
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);
|
|
2101
2238
|
function ForStatement(state) {
|
|
2102
2239
|
if (state.verbose)
|
|
2103
2240
|
console.log("ENTER:", "ForStatement");
|
|
@@ -2107,10 +2244,10 @@ var Civet = (() => {
|
|
|
2107
2244
|
return ForStatement$0(state);
|
|
2108
2245
|
}
|
|
2109
2246
|
}
|
|
2110
|
-
var ForInOfStatement$0 = $S(
|
|
2111
|
-
var ForInOfStatement$1 = $S(
|
|
2112
|
-
var ForInOfStatement$2 = $S(
|
|
2113
|
-
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);
|
|
2114
2251
|
function ForInOfStatement(state) {
|
|
2115
2252
|
if (state.tokenize) {
|
|
2116
2253
|
return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
|
|
@@ -2118,7 +2255,19 @@ var Civet = (() => {
|
|
|
2118
2255
|
return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
|
|
2119
2256
|
}
|
|
2120
2257
|
}
|
|
2121
|
-
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);
|
|
2122
2271
|
function ForDeclaration(state) {
|
|
2123
2272
|
if (state.verbose)
|
|
2124
2273
|
console.log("ENTER:", "ForDeclaration");
|
|
@@ -2128,6 +2277,18 @@ var Civet = (() => {
|
|
|
2128
2277
|
return ForDeclaration$0(state);
|
|
2129
2278
|
}
|
|
2130
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
|
+
}
|
|
2131
2292
|
var ForBinding$0 = BindingIdentifier;
|
|
2132
2293
|
var ForBinding$1 = BindingPattern;
|
|
2133
2294
|
function ForBinding(state) {
|
|
@@ -2137,7 +2298,7 @@ var Civet = (() => {
|
|
|
2137
2298
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
2138
2299
|
}
|
|
2139
2300
|
}
|
|
2140
|
-
var SwitchStatement$0 = $S($EXPECT($
|
|
2301
|
+
var SwitchStatement$0 = $S($EXPECT($L99, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
|
|
2141
2302
|
function SwitchStatement(state) {
|
|
2142
2303
|
if (state.verbose)
|
|
2143
2304
|
console.log("ENTER:", "SwitchStatement");
|
|
@@ -2181,9 +2342,9 @@ var Civet = (() => {
|
|
|
2181
2342
|
return NestedCaseClause$0(state);
|
|
2182
2343
|
}
|
|
2183
2344
|
}
|
|
2184
|
-
var CaseClause$0 = $S($EXPECT($
|
|
2345
|
+
var CaseClause$0 = $S($EXPECT($L100, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
|
|
2185
2346
|
var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
|
|
2186
|
-
var CaseClause$2 = $S($EXPECT($
|
|
2347
|
+
var CaseClause$2 = $S($EXPECT($L101, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
|
|
2187
2348
|
function CaseClause(state) {
|
|
2188
2349
|
if (state.tokenize) {
|
|
2189
2350
|
return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
|
|
@@ -2191,7 +2352,7 @@ var Civet = (() => {
|
|
|
2191
2352
|
return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
|
|
2192
2353
|
}
|
|
2193
2354
|
}
|
|
2194
|
-
var When$0 = $T($S($EXPECT($
|
|
2355
|
+
var When$0 = $T($S($EXPECT($L102, fail, 'When "when"'), NonIdContinue), function(value) {
|
|
2195
2356
|
return "case";
|
|
2196
2357
|
});
|
|
2197
2358
|
function When(state) {
|
|
@@ -2214,7 +2375,7 @@ var Civet = (() => {
|
|
|
2214
2375
|
return ImpliedColon$0(state) || ImpliedColon$1(state);
|
|
2215
2376
|
}
|
|
2216
2377
|
}
|
|
2217
|
-
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) {
|
|
2218
2379
|
var c = $3;
|
|
2219
2380
|
var f = $4;
|
|
2220
2381
|
if (!c && !f) {
|
|
@@ -2231,7 +2392,7 @@ var Civet = (() => {
|
|
|
2231
2392
|
return TryStatement$0(state);
|
|
2232
2393
|
}
|
|
2233
2394
|
}
|
|
2234
|
-
var Catch$0 = $S(__, $EXPECT($
|
|
2395
|
+
var Catch$0 = $S(__, $EXPECT($L104, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
|
|
2235
2396
|
function Catch(state) {
|
|
2236
2397
|
if (state.verbose)
|
|
2237
2398
|
console.log("ENTER:", "Catch");
|
|
@@ -2250,7 +2411,7 @@ var Civet = (() => {
|
|
|
2250
2411
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2251
2412
|
}
|
|
2252
2413
|
}
|
|
2253
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2414
|
+
var Finally$0 = $S(__, $EXPECT($L105, fail, 'Finally "finally"'), BracedBlock);
|
|
2254
2415
|
function Finally(state) {
|
|
2255
2416
|
if (state.verbose)
|
|
2256
2417
|
console.log("ENTER:", "Finally");
|
|
@@ -2288,11 +2449,11 @@ var Civet = (() => {
|
|
|
2288
2449
|
return ExpressionStatement$0(state);
|
|
2289
2450
|
}
|
|
2290
2451
|
}
|
|
2291
|
-
var KeywordStatement$0 = $S($EXPECT($
|
|
2292
|
-
var KeywordStatement$1 = $S($EXPECT($
|
|
2293
|
-
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);
|
|
2294
2455
|
var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
|
|
2295
|
-
var KeywordStatement$4 = $S($EXPECT($
|
|
2456
|
+
var KeywordStatement$4 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
|
|
2296
2457
|
function KeywordStatement(state) {
|
|
2297
2458
|
if (state.tokenize) {
|
|
2298
2459
|
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
|
|
@@ -2309,7 +2470,9 @@ var Civet = (() => {
|
|
|
2309
2470
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2310
2471
|
}
|
|
2311
2472
|
}
|
|
2312
|
-
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
|
+
});
|
|
2313
2476
|
function Return(state) {
|
|
2314
2477
|
if (state.verbose)
|
|
2315
2478
|
console.log("ENTER:", "Return");
|
|
@@ -2319,11 +2482,11 @@ var Civet = (() => {
|
|
|
2319
2482
|
return Return$0(state);
|
|
2320
2483
|
}
|
|
2321
2484
|
}
|
|
2322
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2485
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L111, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2323
2486
|
return { "ts": true, "children": value };
|
|
2324
2487
|
});
|
|
2325
|
-
var ImportDeclaration$1 = $S(
|
|
2326
|
-
var ImportDeclaration$2 = $S(
|
|
2488
|
+
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
2489
|
+
var ImportDeclaration$2 = $S(Import, __, ModuleSpecifier);
|
|
2327
2490
|
function ImportDeclaration(state) {
|
|
2328
2491
|
if (state.tokenize) {
|
|
2329
2492
|
return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
|
|
@@ -2331,6 +2494,18 @@ var Civet = (() => {
|
|
|
2331
2494
|
return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state);
|
|
2332
2495
|
}
|
|
2333
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
|
+
}
|
|
2334
2509
|
var ImportClause$0 = $S(ImportedBinding, $E($S(__, $EXPECT($L0, fail, 'ImportClause ","'), __, $C(NameSpaceImport, NamedImports))));
|
|
2335
2510
|
var ImportClause$1 = NameSpaceImport;
|
|
2336
2511
|
var ImportClause$2 = NamedImports;
|
|
@@ -2361,7 +2536,7 @@ var Civet = (() => {
|
|
|
2361
2536
|
return NamedImports$0(state);
|
|
2362
2537
|
}
|
|
2363
2538
|
}
|
|
2364
|
-
var FromClause$0 = $S(
|
|
2539
|
+
var FromClause$0 = $S(From, __, ModuleSpecifier);
|
|
2365
2540
|
function FromClause(state) {
|
|
2366
2541
|
if (state.verbose)
|
|
2367
2542
|
console.log("ENTER:", "FromClause");
|
|
@@ -2371,6 +2546,18 @@ var Civet = (() => {
|
|
|
2371
2546
|
return FromClause$0(state);
|
|
2372
2547
|
}
|
|
2373
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
|
+
}
|
|
2374
2561
|
var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
|
|
2375
2562
|
var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
|
|
2376
2563
|
function ImportSpecifier(state) {
|
|
@@ -2409,7 +2596,7 @@ var Civet = (() => {
|
|
|
2409
2596
|
return ImportedBinding$0(state);
|
|
2410
2597
|
}
|
|
2411
2598
|
}
|
|
2412
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
2599
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L101, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2413
2600
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
2414
2601
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
2415
2602
|
function ExportDeclaration(state) {
|
|
@@ -2429,7 +2616,7 @@ var Civet = (() => {
|
|
|
2429
2616
|
return As$0(state);
|
|
2430
2617
|
}
|
|
2431
2618
|
}
|
|
2432
|
-
var Export$0 = $S($EXPECT($
|
|
2619
|
+
var Export$0 = $S($EXPECT($L113, fail, 'Export "export"'), NonIdContinue);
|
|
2433
2620
|
function Export(state) {
|
|
2434
2621
|
if (state.verbose)
|
|
2435
2622
|
console.log("ENTER:", "Export");
|
|
@@ -2489,7 +2676,7 @@ var Civet = (() => {
|
|
|
2489
2676
|
return HoistableDeclaration$0(state);
|
|
2490
2677
|
}
|
|
2491
2678
|
}
|
|
2492
|
-
var LexicalDeclaration$0 = $S(
|
|
2679
|
+
var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
|
|
2493
2680
|
var LexicalDeclaration$1 = $TS($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
2494
2681
|
var bind = $1;
|
|
2495
2682
|
var suffix = $2;
|
|
@@ -2513,7 +2700,7 @@ var Civet = (() => {
|
|
|
2513
2700
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
2514
2701
|
}
|
|
2515
2702
|
}
|
|
2516
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
2703
|
+
var ConstAssignment$0 = $TV($EXPECT($L114, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
2517
2704
|
return { $loc, token: $0 };
|
|
2518
2705
|
});
|
|
2519
2706
|
function ConstAssignment(state) {
|
|
@@ -2534,7 +2721,7 @@ var Civet = (() => {
|
|
|
2534
2721
|
return LexicalBinding$0(state) || LexicalBinding$1(state);
|
|
2535
2722
|
}
|
|
2536
2723
|
}
|
|
2537
|
-
var Initializer$0 = $S(__, $EXPECT($
|
|
2724
|
+
var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
|
|
2538
2725
|
function Initializer(state) {
|
|
2539
2726
|
if (state.verbose)
|
|
2540
2727
|
console.log("ENTER:", "Initializer");
|
|
@@ -2544,7 +2731,7 @@ var Civet = (() => {
|
|
|
2544
2731
|
return Initializer$0(state);
|
|
2545
2732
|
}
|
|
2546
2733
|
}
|
|
2547
|
-
var VariableStatement$0 = $S($EXPECT($
|
|
2734
|
+
var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
|
|
2548
2735
|
function VariableStatement(state) {
|
|
2549
2736
|
if (state.verbose)
|
|
2550
2737
|
console.log("ENTER:", "VariableStatement");
|
|
@@ -2573,16 +2760,28 @@ var Civet = (() => {
|
|
|
2573
2760
|
return VariableDeclaration$0(state) || VariableDeclaration$1(state);
|
|
2574
2761
|
}
|
|
2575
2762
|
}
|
|
2576
|
-
var NumericLiteral$0 =
|
|
2577
|
-
|
|
2578
|
-
|
|
2579
|
-
var NumericLiteral$3 = HexLiteral;
|
|
2580
|
-
var NumericLiteral$4 = DecimalLiteral;
|
|
2763
|
+
var NumericLiteral$0 = $TS($S(NumericLiteralKind), function($skip, $loc, $0, $1) {
|
|
2764
|
+
return { $loc, token: $1 };
|
|
2765
|
+
});
|
|
2581
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) {
|
|
2582
2781
|
if (state.tokenize) {
|
|
2583
|
-
return $TOKEN("
|
|
2782
|
+
return $TOKEN("NumericLiteralKind", state, NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state));
|
|
2584
2783
|
} else {
|
|
2585
|
-
return
|
|
2784
|
+
return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
|
|
2586
2785
|
}
|
|
2587
2786
|
}
|
|
2588
2787
|
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R3, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
@@ -2635,34 +2834,45 @@ var Civet = (() => {
|
|
|
2635
2834
|
return HexLiteral$0(state);
|
|
2636
2835
|
}
|
|
2637
2836
|
}
|
|
2638
|
-
var StringLiteral$0 = $
|
|
2639
|
-
|
|
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 };
|
|
2640
2850
|
});
|
|
2641
|
-
var StringLiteral$1 = $S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'));
|
|
2642
|
-
var StringLiteral$2 = $S($EXPECT($L118, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L118, fail, `StringLiteral "\\\\'"`));
|
|
2643
2851
|
function StringLiteral(state) {
|
|
2644
2852
|
if (state.tokenize) {
|
|
2645
|
-
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));
|
|
2646
2854
|
} else {
|
|
2647
|
-
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
|
|
2855
|
+
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
|
|
2648
2856
|
}
|
|
2649
2857
|
}
|
|
2650
|
-
var DoubleStringCharacter$0 = $R$0($EXPECT($R8, fail, 'DoubleStringCharacter /[^"
|
|
2651
|
-
var DoubleStringCharacter$1 = EscapeSequence;
|
|
2858
|
+
var DoubleStringCharacter$0 = $R$0($EXPECT($R8, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
|
|
2652
2859
|
function DoubleStringCharacter(state) {
|
|
2860
|
+
if (state.verbose)
|
|
2861
|
+
console.log("ENTER:", "DoubleStringCharacter");
|
|
2653
2862
|
if (state.tokenize) {
|
|
2654
|
-
return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state)
|
|
2863
|
+
return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state));
|
|
2655
2864
|
} else {
|
|
2656
|
-
return DoubleStringCharacter$0(state)
|
|
2865
|
+
return DoubleStringCharacter$0(state);
|
|
2657
2866
|
}
|
|
2658
2867
|
}
|
|
2659
|
-
var SingleStringCharacter$0 = $R$0($EXPECT($R9, fail, "SingleStringCharacter /[^'
|
|
2660
|
-
var SingleStringCharacter$1 = EscapeSequence;
|
|
2868
|
+
var SingleStringCharacter$0 = $R$0($EXPECT($R9, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
|
|
2661
2869
|
function SingleStringCharacter(state) {
|
|
2870
|
+
if (state.verbose)
|
|
2871
|
+
console.log("ENTER:", "SingleStringCharacter");
|
|
2662
2872
|
if (state.tokenize) {
|
|
2663
|
-
return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state)
|
|
2873
|
+
return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state));
|
|
2664
2874
|
} else {
|
|
2665
|
-
return SingleStringCharacter$0(state)
|
|
2875
|
+
return SingleStringCharacter$0(state);
|
|
2666
2876
|
}
|
|
2667
2877
|
}
|
|
2668
2878
|
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
|
|
@@ -2675,17 +2885,19 @@ var Civet = (() => {
|
|
|
2675
2885
|
return TripleDoubleStringCharacter$0(state);
|
|
2676
2886
|
}
|
|
2677
2887
|
}
|
|
2678
|
-
var
|
|
2679
|
-
function
|
|
2888
|
+
var TripleSingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "TripleSingleStringCharacter /(?:'(?!'')|\\\\.|[^'])+/"));
|
|
2889
|
+
function TripleSingleStringCharacter(state) {
|
|
2680
2890
|
if (state.verbose)
|
|
2681
|
-
console.log("ENTER:", "
|
|
2891
|
+
console.log("ENTER:", "TripleSingleStringCharacter");
|
|
2682
2892
|
if (state.tokenize) {
|
|
2683
|
-
return $TOKEN("
|
|
2893
|
+
return $TOKEN("TripleSingleStringCharacter", state, TripleSingleStringCharacter$0(state));
|
|
2684
2894
|
} else {
|
|
2685
|
-
return
|
|
2895
|
+
return TripleSingleStringCharacter$0(state);
|
|
2686
2896
|
}
|
|
2687
2897
|
}
|
|
2688
|
-
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
|
+
});
|
|
2689
2901
|
function RegularExpressionLiteral(state) {
|
|
2690
2902
|
if (state.verbose)
|
|
2691
2903
|
console.log("ENTER:", "RegularExpressionLiteral");
|
|
@@ -2705,16 +2917,17 @@ var Civet = (() => {
|
|
|
2705
2917
|
return RegularExpressionBody$0(state);
|
|
2706
2918
|
}
|
|
2707
2919
|
}
|
|
2708
|
-
var RegExpCharacter$0 = $R$0($EXPECT($R13, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
|
|
2709
|
-
var RegExpCharacter$1 = EscapeSequence;
|
|
2920
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R13, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
2710
2921
|
function RegExpCharacter(state) {
|
|
2922
|
+
if (state.verbose)
|
|
2923
|
+
console.log("ENTER:", "RegExpCharacter");
|
|
2711
2924
|
if (state.tokenize) {
|
|
2712
|
-
return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state)
|
|
2925
|
+
return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state));
|
|
2713
2926
|
} else {
|
|
2714
|
-
return RegExpCharacter$0(state)
|
|
2927
|
+
return RegExpCharacter$0(state);
|
|
2715
2928
|
}
|
|
2716
2929
|
}
|
|
2717
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($R14, fail, "RegularExpressionFlags /(
|
|
2930
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R14, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
2718
2931
|
function RegularExpressionFlags(state) {
|
|
2719
2932
|
if (state.verbose)
|
|
2720
2933
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -2724,7 +2937,7 @@ var Civet = (() => {
|
|
|
2724
2937
|
return RegularExpressionFlags$0(state);
|
|
2725
2938
|
}
|
|
2726
2939
|
}
|
|
2727
|
-
var TemplateLiteral$0 = $S($EXPECT($
|
|
2940
|
+
var TemplateLiteral$0 = $S($EXPECT($L119, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L119, fail, 'TemplateLiteral "`"'));
|
|
2728
2941
|
function TemplateLiteral(state) {
|
|
2729
2942
|
if (state.verbose)
|
|
2730
2943
|
console.log("ENTER:", "TemplateLiteral");
|
|
@@ -2734,7 +2947,7 @@ var Civet = (() => {
|
|
|
2734
2947
|
return TemplateLiteral$0(state);
|
|
2735
2948
|
}
|
|
2736
2949
|
}
|
|
2737
|
-
var TemplateSubstitution$0 = $S($EXPECT($
|
|
2950
|
+
var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
|
|
2738
2951
|
function TemplateSubstitution(state) {
|
|
2739
2952
|
if (state.verbose)
|
|
2740
2953
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -2791,7 +3004,7 @@ var Civet = (() => {
|
|
|
2791
3004
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
2792
3005
|
}
|
|
2793
3006
|
}
|
|
2794
|
-
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 "*/"'));
|
|
2795
3008
|
function JSMultiLineComment(state) {
|
|
2796
3009
|
if (state.verbose)
|
|
2797
3010
|
console.log("ENTER:", "JSMultiLineComment");
|
|
@@ -2801,7 +3014,7 @@ var Civet = (() => {
|
|
|
2801
3014
|
return JSMultiLineComment$0(state);
|
|
2802
3015
|
}
|
|
2803
3016
|
}
|
|
2804
|
-
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) {
|
|
2805
3018
|
if (!global.coffeeCompat)
|
|
2806
3019
|
return $skip;
|
|
2807
3020
|
return ["//", $1];
|
|
@@ -2815,7 +3028,7 @@ var Civet = (() => {
|
|
|
2815
3028
|
return CoffeeSingleLineComment$0(state);
|
|
2816
3029
|
}
|
|
2817
3030
|
}
|
|
2818
|
-
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) {
|
|
2819
3032
|
return ["/*", value[1], "*/"];
|
|
2820
3033
|
});
|
|
2821
3034
|
function CoffeeMultiLineComment(state) {
|
|
@@ -2827,7 +3040,7 @@ var Civet = (() => {
|
|
|
2827
3040
|
return CoffeeMultiLineComment$0(state);
|
|
2828
3041
|
}
|
|
2829
3042
|
}
|
|
2830
|
-
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 "*/"'));
|
|
2831
3044
|
function InlineComment(state) {
|
|
2832
3045
|
if (state.verbose)
|
|
2833
3046
|
console.log("ENTER:", "InlineComment");
|
|
@@ -2847,7 +3060,7 @@ var Civet = (() => {
|
|
|
2847
3060
|
return RestOfLine$0(state);
|
|
2848
3061
|
}
|
|
2849
3062
|
}
|
|
2850
|
-
var TrailingComment$0 = $R$0($EXPECT($
|
|
3063
|
+
var TrailingComment$0 = $R$0($EXPECT($R21, fail, "TrailingComment /[\\t ]+/"));
|
|
2851
3064
|
var TrailingComment$1 = InlineComment;
|
|
2852
3065
|
var TrailingComment$2 = SingleLineComment;
|
|
2853
3066
|
function TrailingComment(state) {
|
|
@@ -2857,7 +3070,7 @@ var Civet = (() => {
|
|
|
2857
3070
|
return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
|
|
2858
3071
|
}
|
|
2859
3072
|
}
|
|
2860
|
-
var _$0 = $P($C($R$0($EXPECT($
|
|
3073
|
+
var _$0 = $P($C($R$0($EXPECT($R21, fail, "_ /[\\t ]+/")), Comment));
|
|
2861
3074
|
function _(state) {
|
|
2862
3075
|
if (state.verbose)
|
|
2863
3076
|
console.log("ENTER:", "_");
|
|
@@ -2867,7 +3080,7 @@ var Civet = (() => {
|
|
|
2867
3080
|
return _$0(state);
|
|
2868
3081
|
}
|
|
2869
3082
|
}
|
|
2870
|
-
var __$0 = $Q($C($R$0($EXPECT($
|
|
3083
|
+
var __$0 = $Q($C($R$0($EXPECT($R22, fail, "__ /[\\s]+/")), Comment));
|
|
2871
3084
|
function __(state) {
|
|
2872
3085
|
if (state.verbose)
|
|
2873
3086
|
console.log("ENTER:", "__");
|
|
@@ -2877,7 +3090,7 @@ var Civet = (() => {
|
|
|
2877
3090
|
return __$0(state);
|
|
2878
3091
|
}
|
|
2879
3092
|
}
|
|
2880
|
-
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($
|
|
3093
|
+
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L87, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
|
|
2881
3094
|
var StatementDelimiter$1 = $T($Y(EOS), function(value) {
|
|
2882
3095
|
return [";", value];
|
|
2883
3096
|
});
|
|
@@ -2888,7 +3101,7 @@ var Civet = (() => {
|
|
|
2888
3101
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
2889
3102
|
}
|
|
2890
3103
|
}
|
|
2891
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3104
|
+
var NonIdContinue$0 = $R$0($EXPECT($R23, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
2892
3105
|
function NonIdContinue(state) {
|
|
2893
3106
|
if (state.verbose)
|
|
2894
3107
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -2912,7 +3125,7 @@ var Civet = (() => {
|
|
|
2912
3125
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
2913
3126
|
}
|
|
2914
3127
|
}
|
|
2915
|
-
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 "/>"'));
|
|
2916
3129
|
function JSXSelfClosingElement(state) {
|
|
2917
3130
|
if (state.verbose)
|
|
2918
3131
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -2922,7 +3135,7 @@ var Civet = (() => {
|
|
|
2922
3135
|
return JSXSelfClosingElement$0(state);
|
|
2923
3136
|
}
|
|
2924
3137
|
}
|
|
2925
|
-
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 ">"'));
|
|
2926
3139
|
function JSXOpeningElement(state) {
|
|
2927
3140
|
if (state.verbose)
|
|
2928
3141
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -2932,7 +3145,7 @@ var Civet = (() => {
|
|
|
2932
3145
|
return JSXOpeningElement$0(state);
|
|
2933
3146
|
}
|
|
2934
3147
|
}
|
|
2935
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
3148
|
+
var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
|
|
2936
3149
|
function JSXClosingElement(state) {
|
|
2937
3150
|
if (state.verbose)
|
|
2938
3151
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -2942,7 +3155,7 @@ var Civet = (() => {
|
|
|
2942
3155
|
return JSXClosingElement$0(state);
|
|
2943
3156
|
}
|
|
2944
3157
|
}
|
|
2945
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
3158
|
+
var JSXFragment$0 = $S($EXPECT($L126, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L127, fail, 'JSXFragment "</>"'));
|
|
2946
3159
|
function JSXFragment(state) {
|
|
2947
3160
|
if (state.verbose)
|
|
2948
3161
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -2962,7 +3175,7 @@ var Civet = (() => {
|
|
|
2962
3175
|
return JSXElementName$0(state);
|
|
2963
3176
|
}
|
|
2964
3177
|
}
|
|
2965
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
3178
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R24, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
2966
3179
|
function JSXIdentifierName(state) {
|
|
2967
3180
|
if (state.verbose)
|
|
2968
3181
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -3001,7 +3214,7 @@ var Civet = (() => {
|
|
|
3001
3214
|
return JSXAttributeName$0(state);
|
|
3002
3215
|
}
|
|
3003
3216
|
}
|
|
3004
|
-
var JSXAttributeInitializer$0 = $S(__, $EXPECT($
|
|
3217
|
+
var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
|
|
3005
3218
|
function JSXAttributeInitializer(state) {
|
|
3006
3219
|
if (state.verbose)
|
|
3007
3220
|
console.log("ENTER:", "JSXAttributeInitializer");
|
|
@@ -3011,8 +3224,8 @@ var Civet = (() => {
|
|
|
3011
3224
|
return JSXAttributeInitializer$0(state);
|
|
3012
3225
|
}
|
|
3013
3226
|
}
|
|
3014
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
3015
|
-
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 /'[^']*'/"));
|
|
3016
3229
|
var JSXAttributeValue$2 = $S($EXPECT($L11, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttributeValue "}"'));
|
|
3017
3230
|
var JSXAttributeValue$3 = JSXElement;
|
|
3018
3231
|
var JSXAttributeValue$4 = JSXFragment;
|
|
@@ -3044,7 +3257,7 @@ var Civet = (() => {
|
|
|
3044
3257
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
3045
3258
|
}
|
|
3046
3259
|
}
|
|
3047
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
3260
|
+
var JSXText$0 = $R$0($EXPECT($R27, fail, "JSXText /[^{}<>]+/"));
|
|
3048
3261
|
function JSXText(state) {
|
|
3049
3262
|
if (state.verbose)
|
|
3050
3263
|
console.log("ENTER:", "JSXText");
|
|
@@ -3064,10 +3277,10 @@ var Civet = (() => {
|
|
|
3064
3277
|
return JSXChildExpression$0(state);
|
|
3065
3278
|
}
|
|
3066
3279
|
}
|
|
3067
|
-
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) {
|
|
3068
3281
|
return { "ts": true, "children": value };
|
|
3069
3282
|
});
|
|
3070
|
-
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) {
|
|
3071
3284
|
return { "ts": true, "children": value };
|
|
3072
3285
|
});
|
|
3073
3286
|
function TypeDeclaration(state) {
|
|
@@ -3122,7 +3335,7 @@ var Civet = (() => {
|
|
|
3122
3335
|
return InterfaceProperty$0(state);
|
|
3123
3336
|
}
|
|
3124
3337
|
}
|
|
3125
|
-
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($
|
|
3338
|
+
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L87, fail, 'InterfacePropertyDelimiter ";"'));
|
|
3126
3339
|
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
|
|
3127
3340
|
var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
|
|
3128
3341
|
return ";";
|
|
@@ -3137,7 +3350,7 @@ var Civet = (() => {
|
|
|
3137
3350
|
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
|
|
3138
3351
|
}
|
|
3139
3352
|
}
|
|
3140
|
-
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 "?"'))));
|
|
3141
3354
|
function TypeIndexSignature(state) {
|
|
3142
3355
|
if (state.verbose)
|
|
3143
3356
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -3148,7 +3361,7 @@ var Civet = (() => {
|
|
|
3148
3361
|
}
|
|
3149
3362
|
}
|
|
3150
3363
|
var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
|
|
3151
|
-
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)));
|
|
3152
3365
|
function TypeIndex(state) {
|
|
3153
3366
|
if (state.tokenize) {
|
|
3154
3367
|
return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
|
|
@@ -3168,7 +3381,7 @@ var Civet = (() => {
|
|
|
3168
3381
|
return TypeSuffix$0(state);
|
|
3169
3382
|
}
|
|
3170
3383
|
}
|
|
3171
|
-
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) {
|
|
3172
3385
|
return { "ts": true, "children": value };
|
|
3173
3386
|
});
|
|
3174
3387
|
function ReturnTypeSuffix(state) {
|
|
@@ -3180,7 +3393,7 @@ var Civet = (() => {
|
|
|
3180
3393
|
return ReturnTypeSuffix$0(state);
|
|
3181
3394
|
}
|
|
3182
3395
|
}
|
|
3183
|
-
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($
|
|
3396
|
+
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
|
|
3184
3397
|
function TypePredicate(state) {
|
|
3185
3398
|
if (state.verbose)
|
|
3186
3399
|
console.log("ENTER:", "TypePredicate");
|
|
@@ -3230,9 +3443,9 @@ var Civet = (() => {
|
|
|
3230
3443
|
return TypeUnarySuffix$0(state);
|
|
3231
3444
|
}
|
|
3232
3445
|
}
|
|
3233
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
3234
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
3235
|
-
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"');
|
|
3236
3449
|
function TypeUnaryOp(state) {
|
|
3237
3450
|
if (state.tokenize) {
|
|
3238
3451
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -3273,8 +3486,8 @@ var Civet = (() => {
|
|
|
3273
3486
|
}
|
|
3274
3487
|
}
|
|
3275
3488
|
var TypeLiteral$0 = Literal;
|
|
3276
|
-
var TypeLiteral$1 = $EXPECT($
|
|
3277
|
-
var TypeLiteral$2 = $EXPECT($
|
|
3489
|
+
var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
|
|
3490
|
+
var TypeLiteral$2 = $EXPECT($L132, fail, 'TypeLiteral "[]"');
|
|
3278
3491
|
function TypeLiteral(state) {
|
|
3279
3492
|
if (state.tokenize) {
|
|
3280
3493
|
return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
|
|
@@ -3282,8 +3495,8 @@ var Civet = (() => {
|
|
|
3282
3495
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
3283
3496
|
}
|
|
3284
3497
|
}
|
|
3285
|
-
var TypeBinaryOp$0 = $EXPECT($
|
|
3286
|
-
var TypeBinaryOp$1 = $EXPECT($
|
|
3498
|
+
var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
|
|
3499
|
+
var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
|
|
3287
3500
|
function TypeBinaryOp(state) {
|
|
3288
3501
|
if (state.tokenize) {
|
|
3289
3502
|
return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
|
|
@@ -3301,7 +3514,7 @@ var Civet = (() => {
|
|
|
3301
3514
|
return FunctionType$0(state);
|
|
3302
3515
|
}
|
|
3303
3516
|
}
|
|
3304
|
-
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 ">"'));
|
|
3305
3518
|
function TypeArguments(state) {
|
|
3306
3519
|
if (state.verbose)
|
|
3307
3520
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -3311,7 +3524,7 @@ var Civet = (() => {
|
|
|
3311
3524
|
return TypeArguments$0(state);
|
|
3312
3525
|
}
|
|
3313
3526
|
}
|
|
3314
|
-
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 ">"'));
|
|
3315
3528
|
function TypeParameters(state) {
|
|
3316
3529
|
if (state.verbose)
|
|
3317
3530
|
console.log("ENTER:", "TypeParameters");
|
|
@@ -3342,8 +3555,8 @@ var Civet = (() => {
|
|
|
3342
3555
|
}
|
|
3343
3556
|
}
|
|
3344
3557
|
var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
|
|
3345
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
3346
|
-
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) {
|
|
3347
3560
|
return ",";
|
|
3348
3561
|
});
|
|
3349
3562
|
var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -3356,7 +3569,7 @@ var Civet = (() => {
|
|
|
3356
3569
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
3357
3570
|
}
|
|
3358
3571
|
}
|
|
3359
|
-
var Shebang$0 = $R$0($EXPECT($
|
|
3572
|
+
var Shebang$0 = $R$0($EXPECT($R32, fail, "Shebang /#![^\\r\\n]*/"));
|
|
3360
3573
|
function Shebang(state) {
|
|
3361
3574
|
if (state.verbose)
|
|
3362
3575
|
console.log("ENTER:", "Shebang");
|
|
@@ -3366,7 +3579,7 @@ var Civet = (() => {
|
|
|
3366
3579
|
return Shebang$0(state);
|
|
3367
3580
|
}
|
|
3368
3581
|
}
|
|
3369
|
-
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) {
|
|
3370
3583
|
return $0.map((p) => p.join(""));
|
|
3371
3584
|
});
|
|
3372
3585
|
function DirectivePrologue(state) {
|
|
@@ -3388,7 +3601,7 @@ var Civet = (() => {
|
|
|
3388
3601
|
return EOS$0(state);
|
|
3389
3602
|
}
|
|
3390
3603
|
}
|
|
3391
|
-
var EOL$0 = $R$0($EXPECT($
|
|
3604
|
+
var EOL$0 = $R$0($EXPECT($R34, fail, "EOL /\\r\\n|\\n|\\r|$/"));
|
|
3392
3605
|
function EOL(state) {
|
|
3393
3606
|
if (state.verbose)
|
|
3394
3607
|
console.log("ENTER:", "EOL");
|
|
@@ -3398,7 +3611,7 @@ var Civet = (() => {
|
|
|
3398
3611
|
return EOL$0(state);
|
|
3399
3612
|
}
|
|
3400
3613
|
}
|
|
3401
|
-
var EOF$0 = $R$0($EXPECT($
|
|
3614
|
+
var EOF$0 = $R$0($EXPECT($R35, fail, "EOF /$/"));
|
|
3402
3615
|
function EOF(state) {
|
|
3403
3616
|
if (state.verbose)
|
|
3404
3617
|
console.log("ENTER:", "EOF");
|
|
@@ -3537,6 +3750,15 @@ var Civet = (() => {
|
|
|
3537
3750
|
const compatRe = /use coffee-compat/;
|
|
3538
3751
|
global.coffeeCompat = directives.some((d) => d.match(compatRe));
|
|
3539
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
|
+
};
|
|
3540
3762
|
return $0;
|
|
3541
3763
|
});
|
|
3542
3764
|
function Init(state) {
|
|
@@ -3548,7 +3770,7 @@ var Civet = (() => {
|
|
|
3548
3770
|
return Init$0(state);
|
|
3549
3771
|
}
|
|
3550
3772
|
}
|
|
3551
|
-
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) {
|
|
3552
3774
|
return $1.length;
|
|
3553
3775
|
});
|
|
3554
3776
|
function Indent(state) {
|
|
@@ -3726,21 +3948,165 @@ var Civet = (() => {
|
|
|
3726
3948
|
}
|
|
3727
3949
|
});
|
|
3728
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 };
|
|
4076
|
+
}
|
|
4077
|
+
});
|
|
4078
|
+
|
|
3729
4079
|
// source/main.coffee
|
|
3730
4080
|
var require_main = __commonJS({
|
|
3731
4081
|
"source/main.coffee"(exports, module) {
|
|
4082
|
+
var SourceMap;
|
|
3732
4083
|
var gen;
|
|
3733
4084
|
var parse;
|
|
4085
|
+
var prune;
|
|
4086
|
+
var util;
|
|
3734
4087
|
({ parse } = require_parser());
|
|
3735
|
-
gen = require_generate();
|
|
4088
|
+
({ prune } = gen = require_generate());
|
|
4089
|
+
({ SourceMap } = util = require_util());
|
|
3736
4090
|
module.exports = {
|
|
3737
4091
|
parse,
|
|
3738
4092
|
compile: function(src, options) {
|
|
3739
|
-
|
|
4093
|
+
var ast, code, sm;
|
|
4094
|
+
ast = prune(parse(src, {
|
|
3740
4095
|
filename: options != null ? options.filename : void 0
|
|
3741
|
-
})
|
|
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);
|
|
3742
4107
|
},
|
|
3743
|
-
generate: gen
|
|
4108
|
+
generate: gen,
|
|
4109
|
+
util
|
|
3744
4110
|
};
|
|
3745
4111
|
}
|
|
3746
4112
|
});
|