@danielx/civet 0.3.16 → 0.4.0
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 +106 -0
- package/dist/browser.js +1261 -594
- package/dist/esbuild-plugin.js +9 -8
- package/dist/esm.mjs +76 -11
- package/dist/main.js +1261 -594
- package/package.json +20 -2
package/dist/browser.js
CHANGED
|
@@ -430,14 +430,12 @@ var Civet = (() => {
|
|
|
430
430
|
PrimaryExpression,
|
|
431
431
|
ClassDeclaration,
|
|
432
432
|
ClassExpression,
|
|
433
|
-
Class,
|
|
434
433
|
ClassHeritage,
|
|
435
434
|
ExtendsToken,
|
|
436
435
|
ClassBody,
|
|
437
436
|
NestedClassElements,
|
|
438
437
|
NestedClassElement,
|
|
439
438
|
ClassElement,
|
|
440
|
-
Static,
|
|
441
439
|
FieldDefinition,
|
|
442
440
|
This,
|
|
443
441
|
AtAccessor,
|
|
@@ -528,7 +526,6 @@ var Civet = (() => {
|
|
|
528
526
|
WhileClause,
|
|
529
527
|
ForStatement,
|
|
530
528
|
ForInOfStatement,
|
|
531
|
-
For,
|
|
532
529
|
ForDeclaration,
|
|
533
530
|
LetOrConst,
|
|
534
531
|
ForBinding,
|
|
@@ -537,10 +534,9 @@ var Civet = (() => {
|
|
|
537
534
|
NestedCaseClauses,
|
|
538
535
|
NestedCaseClause,
|
|
539
536
|
CaseClause,
|
|
540
|
-
When,
|
|
541
537
|
ImpliedColon,
|
|
542
538
|
TryStatement,
|
|
543
|
-
|
|
539
|
+
CatchClause,
|
|
544
540
|
CatchBind,
|
|
545
541
|
Finally,
|
|
546
542
|
CatchParameter,
|
|
@@ -548,15 +544,12 @@ var Civet = (() => {
|
|
|
548
544
|
ExpressionStatement,
|
|
549
545
|
KeywordStatement,
|
|
550
546
|
MaybeNestedExpression,
|
|
551
|
-
Return,
|
|
552
547
|
ImportDeclaration,
|
|
553
548
|
ImpliedImport,
|
|
554
|
-
Import,
|
|
555
549
|
ImportClause,
|
|
556
550
|
NameSpaceImport,
|
|
557
551
|
NamedImports,
|
|
558
552
|
FromClause,
|
|
559
|
-
From,
|
|
560
553
|
ImportSpecifier,
|
|
561
554
|
ModuleExportName,
|
|
562
555
|
ModuleSpecifier,
|
|
@@ -564,8 +557,6 @@ var Civet = (() => {
|
|
|
564
557
|
UnquotedSpecifier,
|
|
565
558
|
ImportedBinding,
|
|
566
559
|
ExportDeclaration,
|
|
567
|
-
As,
|
|
568
|
-
Export,
|
|
569
560
|
ExportFromClause,
|
|
570
561
|
NamedExports,
|
|
571
562
|
ExportSpecifier,
|
|
@@ -588,8 +579,8 @@ var Civet = (() => {
|
|
|
588
579
|
StringLiteral,
|
|
589
580
|
DoubleStringCharacter,
|
|
590
581
|
SingleStringCharacter,
|
|
591
|
-
|
|
592
|
-
|
|
582
|
+
TripleDoubleStringCharacters,
|
|
583
|
+
TripleSingleStringCharacters,
|
|
593
584
|
RegularExpressionLiteral,
|
|
594
585
|
RegularExpressionBody,
|
|
595
586
|
RegExpCharacter,
|
|
@@ -608,9 +599,49 @@ var Civet = (() => {
|
|
|
608
599
|
RestOfLine,
|
|
609
600
|
TrailingComment,
|
|
610
601
|
_,
|
|
602
|
+
NonNewlineWhitespace,
|
|
611
603
|
__,
|
|
604
|
+
Whitespace,
|
|
612
605
|
StatementDelimiter,
|
|
613
606
|
NonIdContinue,
|
|
607
|
+
Loc,
|
|
608
|
+
As,
|
|
609
|
+
Async,
|
|
610
|
+
Await,
|
|
611
|
+
Catch,
|
|
612
|
+
Class,
|
|
613
|
+
CloseBrace,
|
|
614
|
+
CloseBracket,
|
|
615
|
+
CloseParen,
|
|
616
|
+
Colon,
|
|
617
|
+
Dot,
|
|
618
|
+
Else,
|
|
619
|
+
Equals,
|
|
620
|
+
Export,
|
|
621
|
+
For,
|
|
622
|
+
From,
|
|
623
|
+
Function,
|
|
624
|
+
If,
|
|
625
|
+
Import,
|
|
626
|
+
In,
|
|
627
|
+
Loop,
|
|
628
|
+
New,
|
|
629
|
+
Of,
|
|
630
|
+
OpenBrace,
|
|
631
|
+
OpenBracket,
|
|
632
|
+
OpenParen,
|
|
633
|
+
QuestionMark,
|
|
634
|
+
Return,
|
|
635
|
+
Semicolon,
|
|
636
|
+
Static,
|
|
637
|
+
Switch,
|
|
638
|
+
Target,
|
|
639
|
+
TripleDoubleQuote,
|
|
640
|
+
TripleSingleQuote,
|
|
641
|
+
Try,
|
|
642
|
+
Unless,
|
|
643
|
+
Var,
|
|
644
|
+
When,
|
|
614
645
|
JSXElement,
|
|
615
646
|
JSXSelfClosingElement,
|
|
616
647
|
JSXOpeningElement,
|
|
@@ -686,132 +717,132 @@ var Civet = (() => {
|
|
|
686
717
|
Nested,
|
|
687
718
|
NestedFurther
|
|
688
719
|
});
|
|
689
|
-
var $L0 = $L("
|
|
690
|
-
var $L1 = $L("
|
|
691
|
-
var $L2 = $L("
|
|
692
|
-
var $L3 = $L("
|
|
693
|
-
var $L4 = $L("
|
|
694
|
-
var $L5 = $L("
|
|
695
|
-
var $L6 = $L("
|
|
696
|
-
var $L7 = $L("
|
|
697
|
-
var $L8 = $L("
|
|
698
|
-
var $L9 = $L("
|
|
699
|
-
var $L10 = $L("
|
|
700
|
-
var $L11 = $L("
|
|
701
|
-
var $L12 = $L("
|
|
702
|
-
var $L13 = $L("
|
|
703
|
-
var $L14 = $L("
|
|
704
|
-
var $L15 = $L("
|
|
705
|
-
var $L16 = $L("
|
|
706
|
-
var $L17 = $L("
|
|
707
|
-
var $L18 = $L("
|
|
708
|
-
var $L19 = $L("
|
|
709
|
-
var $L20 = $L("
|
|
710
|
-
var $L21 = $L("
|
|
711
|
-
var $L22 = $L("
|
|
712
|
-
var $L23 = $L("
|
|
713
|
-
var $L24 = $L("
|
|
714
|
-
var $L25 = $L("
|
|
715
|
-
var $L26 = $L("
|
|
716
|
-
var $L27 = $L("
|
|
717
|
-
var $L28 = $L("
|
|
718
|
-
var $L29 = $L("
|
|
719
|
-
var $L30 = $L("
|
|
720
|
-
var $L31 = $L("
|
|
721
|
-
var $L32 = $L("
|
|
722
|
-
var $L33 = $L("");
|
|
723
|
-
var $L34 = $L("
|
|
724
|
-
var $L35 = $L("
|
|
725
|
-
var $L36 = $L("
|
|
726
|
-
var $L37 = $L("
|
|
727
|
-
var $L38 = $L("
|
|
728
|
-
var $L39 = $L("
|
|
729
|
-
var $L40 = $L("
|
|
730
|
-
var $L41 = $L("
|
|
731
|
-
var $L42 = $L("
|
|
732
|
-
var $L43 = $L("
|
|
733
|
-
var $L44 = $L("
|
|
734
|
-
var $L45 = $L("
|
|
735
|
-
var $L46 = $L("
|
|
736
|
-
var $L47 = $L("
|
|
737
|
-
var $L48 = $L("
|
|
738
|
-
var $L49 = $L("
|
|
739
|
-
var $L50 = $L("
|
|
740
|
-
var $L51 = $L("
|
|
741
|
-
var $L52 = $L("
|
|
742
|
-
var $L53 = $L("
|
|
743
|
-
var $L54 = $L("
|
|
744
|
-
var $L55 = $L("
|
|
745
|
-
var $L56 = $L("
|
|
746
|
-
var $L57 = $L("
|
|
747
|
-
var $L58 = $L("
|
|
748
|
-
var $L59 = $L("
|
|
749
|
-
var $L60 = $L("
|
|
750
|
-
var $L61 = $L("
|
|
751
|
-
var $L62 = $L("
|
|
752
|
-
var $L63 = $L("
|
|
753
|
-
var $L64 = $L("
|
|
754
|
-
var $L65 = $L("
|
|
755
|
-
var $L66 = $L("
|
|
756
|
-
var $L67 = $L("
|
|
757
|
-
var $L68 = $L("
|
|
758
|
-
var $L69 = $L("
|
|
759
|
-
var $L70 = $L("
|
|
760
|
-
var $L71 = $L("
|
|
761
|
-
var $L72 = $L("
|
|
762
|
-
var $L73 = $L("
|
|
763
|
-
var $L74 = $L("
|
|
764
|
-
var $L75 = $L("
|
|
765
|
-
var $L76 = $L("
|
|
766
|
-
var $L77 = $L("
|
|
767
|
-
var $L78 = $L("
|
|
768
|
-
var $L79 = $L("
|
|
769
|
-
var $L80 = $L("
|
|
770
|
-
var $L81 = $L("
|
|
771
|
-
var $L82 = $L("
|
|
772
|
-
var $L83 = $L("
|
|
773
|
-
var $L84 = $L("
|
|
774
|
-
var $L85 = $L("
|
|
775
|
-
var $L86 = $L("
|
|
776
|
-
var $L87 = $L("
|
|
777
|
-
var $L88 = $L("
|
|
778
|
-
var $L89 = $L("
|
|
779
|
-
var $L90 = $L("
|
|
780
|
-
var $L91 = $L("
|
|
781
|
-
var $L92 = $L("
|
|
782
|
-
var $L93 = $L("
|
|
783
|
-
var $L94 = $L("
|
|
784
|
-
var $L95 = $L("
|
|
785
|
-
var $L96 = $L("
|
|
786
|
-
var $L97 = $L("
|
|
787
|
-
var $L98 = $L("
|
|
788
|
-
var $L99 = $L("
|
|
789
|
-
var $L100 = $L("
|
|
790
|
-
var $L101 = $L("
|
|
791
|
-
var $L102 = $L("
|
|
792
|
-
var $L103 = $L("
|
|
793
|
-
var $L104 = $L("
|
|
794
|
-
var $L105 = $L("
|
|
795
|
-
var $L106 = $L("
|
|
796
|
-
var $L107 = $L("
|
|
797
|
-
var $L108 = $L("
|
|
798
|
-
var $L109 = $L("
|
|
799
|
-
var $L110 = $L("
|
|
800
|
-
var $L111 = $L("
|
|
801
|
-
var $L112 = $L("
|
|
802
|
-
var $L113 = $L("
|
|
803
|
-
var $L114 = $L("
|
|
804
|
-
var $L115 = $L("
|
|
805
|
-
var $L116 = $L("
|
|
806
|
-
var $L117 = $L(
|
|
807
|
-
var $L118 = $L("
|
|
808
|
-
var $L119 = $L(
|
|
809
|
-
var $L120 = $L("'
|
|
810
|
-
var $L121 = $L("
|
|
811
|
-
var $L122 = $L("
|
|
812
|
-
var $L123 = $L("
|
|
813
|
-
var $L124 = $L("
|
|
814
|
-
var $L125 = $L("
|
|
720
|
+
var $L0 = $L("++");
|
|
721
|
+
var $L1 = $L("--");
|
|
722
|
+
var $L2 = $L("yield");
|
|
723
|
+
var $L3 = $L("*");
|
|
724
|
+
var $L4 = $L("=>");
|
|
725
|
+
var $L5 = $L("<");
|
|
726
|
+
var $L6 = $L("extends");
|
|
727
|
+
var $L7 = $L("this");
|
|
728
|
+
var $L8 = $L("#");
|
|
729
|
+
var $L9 = $L("@");
|
|
730
|
+
var $L10 = $L("super");
|
|
731
|
+
var $L11 = $L("import");
|
|
732
|
+
var $L12 = $L("!");
|
|
733
|
+
var $L13 = $L("::");
|
|
734
|
+
var $L14 = $L("super[");
|
|
735
|
+
var $L15 = $L("import.meta");
|
|
736
|
+
var $L16 = $L("");
|
|
737
|
+
var $L17 = $L(")");
|
|
738
|
+
var $L18 = $L("...");
|
|
739
|
+
var $L19 = $L("->");
|
|
740
|
+
var $L20 = $L("null");
|
|
741
|
+
var $L21 = $L("true");
|
|
742
|
+
var $L22 = $L("false");
|
|
743
|
+
var $L23 = $L(",");
|
|
744
|
+
var $L24 = $L("]");
|
|
745
|
+
var $L25 = $L("get");
|
|
746
|
+
var $L26 = $L("set");
|
|
747
|
+
var $L27 = $L("**=");
|
|
748
|
+
var $L28 = $L("*=");
|
|
749
|
+
var $L29 = $L("/=");
|
|
750
|
+
var $L30 = $L("%=");
|
|
751
|
+
var $L31 = $L("+=");
|
|
752
|
+
var $L32 = $L("-=");
|
|
753
|
+
var $L33 = $L("<<=");
|
|
754
|
+
var $L34 = $L(">>>=");
|
|
755
|
+
var $L35 = $L(">>=");
|
|
756
|
+
var $L36 = $L("&&=");
|
|
757
|
+
var $L37 = $L("&=");
|
|
758
|
+
var $L38 = $L("^=");
|
|
759
|
+
var $L39 = $L("||=");
|
|
760
|
+
var $L40 = $L("|=");
|
|
761
|
+
var $L41 = $L("??=");
|
|
762
|
+
var $L42 = $L("?=");
|
|
763
|
+
var $L43 = $L("=");
|
|
764
|
+
var $L44 = $L("**");
|
|
765
|
+
var $L45 = $L("/");
|
|
766
|
+
var $L46 = $L("%");
|
|
767
|
+
var $L47 = $L("+");
|
|
768
|
+
var $L48 = $L("-");
|
|
769
|
+
var $L49 = $L("<=");
|
|
770
|
+
var $L50 = $L(">=");
|
|
771
|
+
var $L51 = $L("<<");
|
|
772
|
+
var $L52 = $L(">>>");
|
|
773
|
+
var $L53 = $L(">>");
|
|
774
|
+
var $L54 = $L(">");
|
|
775
|
+
var $L55 = $L("!==");
|
|
776
|
+
var $L56 = $L("!=");
|
|
777
|
+
var $L57 = $L("is");
|
|
778
|
+
var $L58 = $L("===");
|
|
779
|
+
var $L59 = $L("==");
|
|
780
|
+
var $L60 = $L("and");
|
|
781
|
+
var $L61 = $L("&&");
|
|
782
|
+
var $L62 = $L("or");
|
|
783
|
+
var $L63 = $L("||");
|
|
784
|
+
var $L64 = $L("??");
|
|
785
|
+
var $L65 = $L("instanceof");
|
|
786
|
+
var $L66 = $L("in");
|
|
787
|
+
var $L67 = $L("&");
|
|
788
|
+
var $L68 = $L("^");
|
|
789
|
+
var $L69 = $L("|");
|
|
790
|
+
var $L70 = $L("delete");
|
|
791
|
+
var $L71 = $L("void");
|
|
792
|
+
var $L72 = $L("typeof");
|
|
793
|
+
var $L73 = $L(";");
|
|
794
|
+
var $L74 = $L("do");
|
|
795
|
+
var $L75 = $L("while");
|
|
796
|
+
var $L76 = $L("until");
|
|
797
|
+
var $L77 = $L("let");
|
|
798
|
+
var $L78 = $L("const");
|
|
799
|
+
var $L79 = $L("case");
|
|
800
|
+
var $L80 = $L("default");
|
|
801
|
+
var $L81 = $L("finally");
|
|
802
|
+
var $L82 = $L("break");
|
|
803
|
+
var $L83 = $L("continue");
|
|
804
|
+
var $L84 = $L("debugger");
|
|
805
|
+
var $L85 = $L("throw");
|
|
806
|
+
var $L86 = $L("import type");
|
|
807
|
+
var $L87 = $L(":=");
|
|
808
|
+
var $L88 = $L('"');
|
|
809
|
+
var $L89 = $L("'");
|
|
810
|
+
var $L90 = $L("`");
|
|
811
|
+
var $L91 = $L("${");
|
|
812
|
+
var $L92 = $L("/*");
|
|
813
|
+
var $L93 = $L("*/");
|
|
814
|
+
var $L94 = $L("###");
|
|
815
|
+
var $L95 = $L("as");
|
|
816
|
+
var $L96 = $L("async");
|
|
817
|
+
var $L97 = $L("await");
|
|
818
|
+
var $L98 = $L("catch");
|
|
819
|
+
var $L99 = $L("class");
|
|
820
|
+
var $L100 = $L("}");
|
|
821
|
+
var $L101 = $L(":");
|
|
822
|
+
var $L102 = $L(".");
|
|
823
|
+
var $L103 = $L("else");
|
|
824
|
+
var $L104 = $L("export");
|
|
825
|
+
var $L105 = $L("for");
|
|
826
|
+
var $L106 = $L("from");
|
|
827
|
+
var $L107 = $L("function");
|
|
828
|
+
var $L108 = $L("if");
|
|
829
|
+
var $L109 = $L("loop");
|
|
830
|
+
var $L110 = $L("new");
|
|
831
|
+
var $L111 = $L("of");
|
|
832
|
+
var $L112 = $L("{");
|
|
833
|
+
var $L113 = $L("[");
|
|
834
|
+
var $L114 = $L("(");
|
|
835
|
+
var $L115 = $L("?");
|
|
836
|
+
var $L116 = $L("return");
|
|
837
|
+
var $L117 = $L("static");
|
|
838
|
+
var $L118 = $L("switch");
|
|
839
|
+
var $L119 = $L("target");
|
|
840
|
+
var $L120 = $L('"""');
|
|
841
|
+
var $L121 = $L("'''");
|
|
842
|
+
var $L122 = $L("try");
|
|
843
|
+
var $L123 = $L("unless");
|
|
844
|
+
var $L124 = $L("var");
|
|
845
|
+
var $L125 = $L("when");
|
|
815
846
|
var $L126 = $L("/>");
|
|
816
847
|
var $L127 = $L("</");
|
|
817
848
|
var $L128 = $L("<>");
|
|
@@ -830,30 +861,30 @@ var Civet = (() => {
|
|
|
830
861
|
var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
831
862
|
var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
832
863
|
var $R2 = $R(new RegExp("[!~+-]", "suy"));
|
|
833
|
-
var $R3 = $R(new RegExp("\\s
|
|
834
|
-
var $R4 = $R(new RegExp(
|
|
835
|
-
var $R5 = $R(new RegExp("(
|
|
836
|
-
var $R6 = $R(new RegExp("
|
|
837
|
-
var $R7 = $R(new RegExp("0[
|
|
838
|
-
var $R8 = $R(new RegExp("0[
|
|
839
|
-
var $R9 = $R(new RegExp(
|
|
840
|
-
var $R10 = $R(new RegExp(
|
|
841
|
-
var $R11 = $R(new RegExp("(
|
|
842
|
-
var $R12 = $R(new RegExp(
|
|
843
|
-
var $R13 = $R(new RegExp("
|
|
844
|
-
var $R14 = $R(new RegExp("[
|
|
845
|
-
var $R15 = $R(new RegExp("(
|
|
846
|
-
var $R16 = $R(new RegExp("(
|
|
847
|
-
var $R17 = $R(new RegExp("(
|
|
848
|
-
var $R18 = $R(new RegExp("
|
|
849
|
-
var $R19 = $R(new RegExp("
|
|
850
|
-
var $R20 = $R(new RegExp("
|
|
851
|
-
var $R21 = $R(new RegExp("
|
|
852
|
-
var $R22 = $R(new RegExp("[
|
|
853
|
-
var $R23 = $R(new RegExp("[
|
|
854
|
-
var $R24 = $R(new RegExp("[\\
|
|
855
|
-
var $R25 = $R(new RegExp("
|
|
856
|
-
var $R26 = $R(new RegExp("
|
|
864
|
+
var $R3 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
865
|
+
var $R4 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
866
|
+
var $R5 = $R(new RegExp("\\d+(?:\\.\\d*)?", "suy"));
|
|
867
|
+
var $R6 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
|
|
868
|
+
var $R7 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
|
|
869
|
+
var $R8 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
|
|
870
|
+
var $R9 = $R(new RegExp('(?:\\\\.|[^"])+', "suy"));
|
|
871
|
+
var $R10 = $R(new RegExp("(?:\\\\.|[^'])+", "suy"));
|
|
872
|
+
var $R11 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])*', "suy"));
|
|
873
|
+
var $R12 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
|
|
874
|
+
var $R13 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
|
|
875
|
+
var $R14 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
|
|
876
|
+
var $R15 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
877
|
+
var $R16 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
878
|
+
var $R17 = $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|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
879
|
+
var $R18 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
880
|
+
var $R19 = $R(new RegExp(".", "suy"));
|
|
881
|
+
var $R20 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
882
|
+
var $R21 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
883
|
+
var $R22 = $R(new RegExp("[ \\t]+", "suy"));
|
|
884
|
+
var $R23 = $R(new RegExp("[\\t ]+", "suy"));
|
|
885
|
+
var $R24 = $R(new RegExp("[\\s]+", "suy"));
|
|
886
|
+
var $R25 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
887
|
+
var $R26 = $R(new RegExp("\\s", "suy"));
|
|
857
888
|
var $R27 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
858
889
|
var $R28 = $R(new RegExp('"[^"]*"', "suy"));
|
|
859
890
|
var $R29 = $R(new RegExp("'[^']*'", "suy"));
|
|
@@ -884,7 +915,7 @@ var Civet = (() => {
|
|
|
884
915
|
return TopLevelStatement$0(state);
|
|
885
916
|
}
|
|
886
917
|
}
|
|
887
|
-
var Expression$0 = $S(AssignmentExpression, $Q($S(__,
|
|
918
|
+
var Expression$0 = $S(AssignmentExpression, $Q($S(__, Comma, AssignmentExpression)));
|
|
888
919
|
function Expression(state) {
|
|
889
920
|
if (state.verbose)
|
|
890
921
|
console.log("ENTER:", "Expression");
|
|
@@ -894,7 +925,7 @@ var Civet = (() => {
|
|
|
894
925
|
return Expression$0(state);
|
|
895
926
|
}
|
|
896
927
|
}
|
|
897
|
-
var Arguments$0 = $S(
|
|
928
|
+
var Arguments$0 = $S(OpenParen, $E(ArgumentList), $E($S(__, Comma)), __, CloseParen);
|
|
898
929
|
function Arguments(state) {
|
|
899
930
|
if (state.verbose)
|
|
900
931
|
console.log("ENTER:", "Arguments");
|
|
@@ -938,7 +969,7 @@ var Civet = (() => {
|
|
|
938
969
|
return NestedArgument$0(state);
|
|
939
970
|
}
|
|
940
971
|
}
|
|
941
|
-
var CommaExpression$0 = $S(__,
|
|
972
|
+
var CommaExpression$0 = $S(__, Comma, __, Expression);
|
|
942
973
|
function CommaExpression(state) {
|
|
943
974
|
if (state.verbose)
|
|
944
975
|
console.log("ENTER:", "CommaExpression");
|
|
@@ -962,7 +993,7 @@ var Civet = (() => {
|
|
|
962
993
|
var pre = $1;
|
|
963
994
|
var exp = $2;
|
|
964
995
|
var post = $3;
|
|
965
|
-
if (post === "?") {
|
|
996
|
+
if (post?.token === "?") {
|
|
966
997
|
return ["(", pre, , "(", exp, ") != null)"];
|
|
967
998
|
}
|
|
968
999
|
return [pre, exp, post];
|
|
@@ -976,8 +1007,8 @@ var Civet = (() => {
|
|
|
976
1007
|
return UnaryExpression$0(state);
|
|
977
1008
|
}
|
|
978
1009
|
}
|
|
979
|
-
var UnaryPostfix$0 =
|
|
980
|
-
var UnaryPostfix$1 = $T($S(__,
|
|
1010
|
+
var UnaryPostfix$0 = QuestionMark;
|
|
1011
|
+
var UnaryPostfix$1 = $T($S(__, As, NonIdContinue, Type), function(value) {
|
|
981
1012
|
return { "ts": true, "children": value };
|
|
982
1013
|
});
|
|
983
1014
|
function UnaryPostfix(state) {
|
|
@@ -996,7 +1027,7 @@ var Civet = (() => {
|
|
|
996
1027
|
return UpdateExpression$0(state) || UpdateExpression$1(state);
|
|
997
1028
|
}
|
|
998
1029
|
}
|
|
999
|
-
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($
|
|
1030
|
+
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L0, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L1, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
|
|
1000
1031
|
return { $loc, token: $1 };
|
|
1001
1032
|
});
|
|
1002
1033
|
function UpdateExpressionSymbol(state) {
|
|
@@ -1019,7 +1050,7 @@ var Civet = (() => {
|
|
|
1019
1050
|
}
|
|
1020
1051
|
var AssignmentExpressionRest$0 = AwaitExpression;
|
|
1021
1052
|
var AssignmentExpressionRest$1 = YieldExpression;
|
|
1022
|
-
var AssignmentExpressionRest$2 = $S($E($S(
|
|
1053
|
+
var AssignmentExpressionRest$2 = $S($E($S(Async, __)), ArrowFunction);
|
|
1023
1054
|
var AssignmentExpressionRest$3 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), Expression);
|
|
1024
1055
|
var AssignmentExpressionRest$4 = ConditionalExpression;
|
|
1025
1056
|
function AssignmentExpressionRest(state) {
|
|
@@ -1029,7 +1060,7 @@ var Civet = (() => {
|
|
|
1029
1060
|
return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state) || AssignmentExpressionRest$4(state);
|
|
1030
1061
|
}
|
|
1031
1062
|
}
|
|
1032
|
-
var AwaitExpression$0 = $S(
|
|
1063
|
+
var AwaitExpression$0 = $S(Await, $Q(TrailingComment), AssignmentExpression);
|
|
1033
1064
|
function AwaitExpression(state) {
|
|
1034
1065
|
if (state.verbose)
|
|
1035
1066
|
console.log("ENTER:", "AwaitExpression");
|
|
@@ -1039,7 +1070,7 @@ var Civet = (() => {
|
|
|
1039
1070
|
return AwaitExpression$0(state);
|
|
1040
1071
|
}
|
|
1041
1072
|
}
|
|
1042
|
-
var YieldExpression$0 = $S($EXPECT($
|
|
1073
|
+
var YieldExpression$0 = $S($EXPECT($L2, fail, 'YieldExpression "yield"'), NonIdContinue, $E($S($Q(TrailingComment), $EXPECT($L3, fail, 'YieldExpression "*"'))), AssignmentExpression);
|
|
1043
1074
|
function YieldExpression(state) {
|
|
1044
1075
|
if (state.verbose)
|
|
1045
1076
|
console.log("ENTER:", "YieldExpression");
|
|
@@ -1058,7 +1089,7 @@ var Civet = (() => {
|
|
|
1058
1089
|
return ArrowFunction$0(state) || ArrowFunction$1(state);
|
|
1059
1090
|
}
|
|
1060
1091
|
}
|
|
1061
|
-
var FatArrow$0 = $TS($S(__, $EXPECT($
|
|
1092
|
+
var FatArrow$0 = $TS($S(__, $EXPECT($L4, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
|
|
1062
1093
|
var ws = $1;
|
|
1063
1094
|
if (!ws.length)
|
|
1064
1095
|
return " =>";
|
|
@@ -1073,7 +1104,7 @@ var Civet = (() => {
|
|
|
1073
1104
|
return FatArrow$0(state);
|
|
1074
1105
|
}
|
|
1075
1106
|
}
|
|
1076
|
-
var FatArrowBody$0 = $S(__,
|
|
1107
|
+
var FatArrowBody$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
|
|
1077
1108
|
var FatArrowBody$1 = $TS($S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
1078
1109
|
var eos = $2;
|
|
1079
1110
|
var exps = $3;
|
|
@@ -1093,7 +1124,7 @@ var Civet = (() => {
|
|
|
1093
1124
|
return FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state) || FatArrowBody$4(state);
|
|
1094
1125
|
}
|
|
1095
1126
|
}
|
|
1096
|
-
var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__,
|
|
1127
|
+
var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, QuestionMark, AssignmentExpression, __, Colon, AssignmentExpression)));
|
|
1097
1128
|
function ConditionalExpression(state) {
|
|
1098
1129
|
if (state.verbose)
|
|
1099
1130
|
console.log("ENTER:", "ConditionalExpression");
|
|
@@ -1122,7 +1153,7 @@ var Civet = (() => {
|
|
|
1122
1153
|
var PrimaryExpression$6 = ClassExpression;
|
|
1123
1154
|
var PrimaryExpression$7 = RegularExpressionLiteral;
|
|
1124
1155
|
var PrimaryExpression$8 = TemplateLiteral;
|
|
1125
|
-
var PrimaryExpression$9 = $S(
|
|
1156
|
+
var PrimaryExpression$9 = $S(OpenParen, __, Expression, __, CloseParen);
|
|
1126
1157
|
var PrimaryExpression$10 = JSXElement;
|
|
1127
1158
|
var PrimaryExpression$11 = JSXFragment;
|
|
1128
1159
|
function PrimaryExpression(state) {
|
|
@@ -1152,18 +1183,6 @@ var Civet = (() => {
|
|
|
1152
1183
|
return ClassExpression$0(state);
|
|
1153
1184
|
}
|
|
1154
1185
|
}
|
|
1155
|
-
var Class$0 = $TV($EXPECT($L15, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
1156
|
-
return { $loc, token: $1 };
|
|
1157
|
-
});
|
|
1158
|
-
function Class(state) {
|
|
1159
|
-
if (state.verbose)
|
|
1160
|
-
console.log("ENTER:", "Class");
|
|
1161
|
-
if (state.tokenize) {
|
|
1162
|
-
return $TOKEN("Class", state, Class$0(state));
|
|
1163
|
-
} else {
|
|
1164
|
-
return Class$0(state);
|
|
1165
|
-
}
|
|
1166
|
-
}
|
|
1167
1186
|
var ClassHeritage$0 = $S(ExtendsToken, __, MemberExpression);
|
|
1168
1187
|
function ClassHeritage(state) {
|
|
1169
1188
|
if (state.verbose)
|
|
@@ -1174,10 +1193,10 @@ var Civet = (() => {
|
|
|
1174
1193
|
return ClassHeritage$0(state);
|
|
1175
1194
|
}
|
|
1176
1195
|
}
|
|
1177
|
-
var ExtendsToken$0 = $TV($EXPECT($
|
|
1196
|
+
var ExtendsToken$0 = $TV($EXPECT($L5, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
|
|
1178
1197
|
return { $loc, token: "extends" };
|
|
1179
1198
|
});
|
|
1180
|
-
var ExtendsToken$1 = $TV($EXPECT($
|
|
1199
|
+
var ExtendsToken$1 = $TV($EXPECT($L6, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
|
|
1181
1200
|
return { $loc, token: $1 };
|
|
1182
1201
|
});
|
|
1183
1202
|
function ExtendsToken(state) {
|
|
@@ -1187,7 +1206,7 @@ var Civet = (() => {
|
|
|
1187
1206
|
return ExtendsToken$0(state) || ExtendsToken$1(state);
|
|
1188
1207
|
}
|
|
1189
1208
|
}
|
|
1190
|
-
var ClassBody$0 = $S(__,
|
|
1209
|
+
var ClassBody$0 = $S(__, OpenBrace, $E($S(EOS, NestedClassElements)), __, CloseBrace);
|
|
1191
1210
|
var ClassBody$1 = $S(InsertOpenBrace, EOS, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1192
1211
|
function ClassBody(state) {
|
|
1193
1212
|
if (state.tokenize) {
|
|
@@ -1230,19 +1249,15 @@ var Civet = (() => {
|
|
|
1230
1249
|
return ClassElement$0(state) || ClassElement$1(state);
|
|
1231
1250
|
}
|
|
1232
1251
|
}
|
|
1233
|
-
var
|
|
1234
|
-
|
|
1252
|
+
var FieldDefinition$0 = $TS($S(InsertReadonly, ClassElementName, $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
1253
|
+
var r = $1;
|
|
1254
|
+
var ca = $5;
|
|
1255
|
+
r.children[0].$loc = {
|
|
1256
|
+
pos: ca.$loc.pos - 1,
|
|
1257
|
+
length: ca.$loc.length + 1
|
|
1258
|
+
};
|
|
1259
|
+
return $0;
|
|
1235
1260
|
});
|
|
1236
|
-
function Static(state) {
|
|
1237
|
-
if (state.verbose)
|
|
1238
|
-
console.log("ENTER:", "Static");
|
|
1239
|
-
if (state.tokenize) {
|
|
1240
|
-
return $TOKEN("Static", state, Static$0(state));
|
|
1241
|
-
} else {
|
|
1242
|
-
return Static$0(state);
|
|
1243
|
-
}
|
|
1244
|
-
}
|
|
1245
|
-
var FieldDefinition$0 = $S(InsertReadonly, ClassElementName, $E(TypeSuffix), __, ConstAssignment, AssignmentExpression);
|
|
1246
1261
|
var FieldDefinition$1 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
|
|
1247
1262
|
function FieldDefinition(state) {
|
|
1248
1263
|
if (state.tokenize) {
|
|
@@ -1251,11 +1266,11 @@ var Civet = (() => {
|
|
|
1251
1266
|
return FieldDefinition$0(state) || FieldDefinition$1(state);
|
|
1252
1267
|
}
|
|
1253
1268
|
}
|
|
1254
|
-
var This$0 = $TV($EXPECT($
|
|
1269
|
+
var This$0 = $TV($EXPECT($L7, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
1255
1270
|
return { $loc, token: $1 };
|
|
1256
1271
|
});
|
|
1257
|
-
var This$1 = $S(AtAccessor, $S($E($EXPECT($
|
|
1258
|
-
var This$2 = $TV($EXPECT($
|
|
1272
|
+
var This$1 = $S(AtAccessor, $S($E($EXPECT($L8, fail, 'This "#"')), IdentifierName));
|
|
1273
|
+
var This$2 = $TV($EXPECT($L9, fail, 'This "@"'), function($skip, $loc, $0, $1) {
|
|
1259
1274
|
return { $loc, token: "this" };
|
|
1260
1275
|
});
|
|
1261
1276
|
function This(state) {
|
|
@@ -1265,7 +1280,7 @@ var Civet = (() => {
|
|
|
1265
1280
|
return This$0(state) || This$1(state) || This$2(state);
|
|
1266
1281
|
}
|
|
1267
1282
|
}
|
|
1268
|
-
var AtAccessor$0 = $TV($EXPECT($
|
|
1283
|
+
var AtAccessor$0 = $TV($EXPECT($L9, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
|
|
1269
1284
|
return { $loc, token: "this." };
|
|
1270
1285
|
});
|
|
1271
1286
|
function AtAccessor(state) {
|
|
@@ -1286,7 +1301,7 @@ var Civet = (() => {
|
|
|
1286
1301
|
return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
|
|
1287
1302
|
}
|
|
1288
1303
|
}
|
|
1289
|
-
var NewExpression$0 = $S($P($S(
|
|
1304
|
+
var NewExpression$0 = $S($P($S(New, __)), CallExpression);
|
|
1290
1305
|
function NewExpression(state) {
|
|
1291
1306
|
if (state.verbose)
|
|
1292
1307
|
console.log("ENTER:", "NewExpression");
|
|
@@ -1296,8 +1311,8 @@ var Civet = (() => {
|
|
|
1296
1311
|
return NewExpression$0(state);
|
|
1297
1312
|
}
|
|
1298
1313
|
}
|
|
1299
|
-
var CallExpression$0 = $S($EXPECT($
|
|
1300
|
-
var CallExpression$1 = $S($EXPECT($
|
|
1314
|
+
var CallExpression$0 = $S($EXPECT($L10, fail, 'CallExpression "super"'), __, Arguments);
|
|
1315
|
+
var CallExpression$1 = $S($EXPECT($L11, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
|
|
1301
1316
|
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
|
|
1302
1317
|
function CallExpression(state) {
|
|
1303
1318
|
if (state.tokenize) {
|
|
@@ -1317,7 +1332,7 @@ var Civet = (() => {
|
|
|
1317
1332
|
return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
|
|
1318
1333
|
}
|
|
1319
1334
|
}
|
|
1320
|
-
var OptionalShorthand$0 = $S(
|
|
1335
|
+
var OptionalShorthand$0 = $S(QuestionMark, $C(Dot, InsertDot));
|
|
1321
1336
|
function OptionalShorthand(state) {
|
|
1322
1337
|
if (state.verbose)
|
|
1323
1338
|
console.log("ENTER:", "OptionalShorthand");
|
|
@@ -1327,7 +1342,7 @@ var Civet = (() => {
|
|
|
1327
1342
|
return OptionalShorthand$0(state);
|
|
1328
1343
|
}
|
|
1329
1344
|
}
|
|
1330
|
-
var NonNullAssertion$0 = $T($EXPECT($
|
|
1345
|
+
var NonNullAssertion$0 = $T($EXPECT($L12, fail, 'NonNullAssertion "!"'), function(value) {
|
|
1331
1346
|
return { "ts": true, "children": value };
|
|
1332
1347
|
});
|
|
1333
1348
|
function NonNullAssertion(state) {
|
|
@@ -1349,10 +1364,11 @@ var Civet = (() => {
|
|
|
1349
1364
|
return SpacedApplication$0(state);
|
|
1350
1365
|
}
|
|
1351
1366
|
}
|
|
1352
|
-
var ApplicationStart$0 = $TS($S($E(OptionalShorthand), $N(EOS),
|
|
1367
|
+
var ApplicationStart$0 = $TS($S($E(OptionalShorthand), $N(EOS), _, $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1353
1368
|
var opt = $1;
|
|
1354
1369
|
var spacing = $3;
|
|
1355
|
-
|
|
1370
|
+
spacing[0].token = spacing[0].token.replace(/^ ?/, "(");
|
|
1371
|
+
return [opt, spacing];
|
|
1356
1372
|
});
|
|
1357
1373
|
function ApplicationStart(state) {
|
|
1358
1374
|
if (state.verbose)
|
|
@@ -1383,9 +1399,9 @@ var Civet = (() => {
|
|
|
1383
1399
|
return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
|
|
1384
1400
|
}
|
|
1385
1401
|
}
|
|
1386
|
-
var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)),
|
|
1402
|
+
var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), OpenBracket, __, Expression, __, CloseBracket);
|
|
1387
1403
|
var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
|
|
1388
|
-
var MemberExpressionRest$2 = $TS($S($EXPECT($
|
|
1404
|
+
var MemberExpressionRest$2 = $TS($S($EXPECT($L13, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
|
|
1389
1405
|
var id = $2;
|
|
1390
1406
|
if (id)
|
|
1391
1407
|
return [".prototype.", id];
|
|
@@ -1399,7 +1415,7 @@ var Civet = (() => {
|
|
|
1399
1415
|
return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state);
|
|
1400
1416
|
}
|
|
1401
1417
|
}
|
|
1402
|
-
var PropertyAccess$0 = $S($E($C(
|
|
1418
|
+
var PropertyAccess$0 = $S($E($C(QuestionMark, NonNullAssertion)), Dot, $C(IdentifierName, PrivateIdentifier));
|
|
1403
1419
|
function PropertyAccess(state) {
|
|
1404
1420
|
if (state.verbose)
|
|
1405
1421
|
console.log("ENTER:", "PropertyAccess");
|
|
@@ -1409,7 +1425,7 @@ var Civet = (() => {
|
|
|
1409
1425
|
return PropertyAccess$0(state);
|
|
1410
1426
|
}
|
|
1411
1427
|
}
|
|
1412
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
1428
|
+
var SuperProperty$0 = $S($EXPECT($L14, fail, 'SuperProperty "super["'), __, Expression, __, CloseBracket);
|
|
1413
1429
|
function SuperProperty(state) {
|
|
1414
1430
|
if (state.verbose)
|
|
1415
1431
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1419,8 +1435,10 @@ var Civet = (() => {
|
|
|
1419
1435
|
return SuperProperty$0(state);
|
|
1420
1436
|
}
|
|
1421
1437
|
}
|
|
1422
|
-
var MetaProperty$0 = $
|
|
1423
|
-
var MetaProperty$1 = $EXPECT($
|
|
1438
|
+
var MetaProperty$0 = $S(New, Dot, Target);
|
|
1439
|
+
var MetaProperty$1 = $TV($EXPECT($L15, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
|
|
1440
|
+
return { $loc, token: $1 };
|
|
1441
|
+
});
|
|
1424
1442
|
function MetaProperty(state) {
|
|
1425
1443
|
if (state.tokenize) {
|
|
1426
1444
|
return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
|
|
@@ -1428,9 +1446,9 @@ var Civet = (() => {
|
|
|
1428
1446
|
return MetaProperty$0(state) || MetaProperty$1(state);
|
|
1429
1447
|
}
|
|
1430
1448
|
}
|
|
1431
|
-
var Parameters$0 = $S($E(TypeParameters),
|
|
1432
|
-
var Parameters$1 = $
|
|
1433
|
-
return "()";
|
|
1449
|
+
var Parameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), __, CloseParen);
|
|
1450
|
+
var Parameters$1 = $TV($EXPECT($L16, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
1451
|
+
return { $loc, token: "()" };
|
|
1434
1452
|
});
|
|
1435
1453
|
function Parameters(state) {
|
|
1436
1454
|
if (state.tokenize) {
|
|
@@ -1449,13 +1467,13 @@ var Civet = (() => {
|
|
|
1449
1467
|
return ParameterElement$0(state);
|
|
1450
1468
|
}
|
|
1451
1469
|
}
|
|
1452
|
-
var ParameterElementDelimiter$0 = $S($Q(_),
|
|
1453
|
-
var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1454
|
-
var ParameterElementDelimiter$2 = $
|
|
1455
|
-
return ",";
|
|
1470
|
+
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
1471
|
+
var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L17, fail, 'ParameterElementDelimiter ")"')));
|
|
1472
|
+
var ParameterElementDelimiter$2 = $TV($Y($S(__, $EXPECT($L17, fail, 'ParameterElementDelimiter ")"'))), function($skip, $loc, $0, $1) {
|
|
1473
|
+
return { $loc, token: "," };
|
|
1456
1474
|
});
|
|
1457
|
-
var ParameterElementDelimiter$3 = $
|
|
1458
|
-
return ",";
|
|
1475
|
+
var ParameterElementDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1476
|
+
return { $loc, token: "," };
|
|
1459
1477
|
});
|
|
1460
1478
|
function ParameterElementDelimiter(state) {
|
|
1461
1479
|
if (state.tokenize) {
|
|
@@ -1483,7 +1501,7 @@ var Civet = (() => {
|
|
|
1483
1501
|
return BindingPattern$0(state) || BindingPattern$1(state);
|
|
1484
1502
|
}
|
|
1485
1503
|
}
|
|
1486
|
-
var ObjectBindingPattern$0 = $S(
|
|
1504
|
+
var ObjectBindingPattern$0 = $S(OpenBrace, $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, CloseBrace);
|
|
1487
1505
|
function ObjectBindingPattern(state) {
|
|
1488
1506
|
if (state.verbose)
|
|
1489
1507
|
console.log("ENTER:", "ObjectBindingPattern");
|
|
@@ -1493,7 +1511,7 @@ var Civet = (() => {
|
|
|
1493
1511
|
return ObjectBindingPattern$0(state);
|
|
1494
1512
|
}
|
|
1495
1513
|
}
|
|
1496
|
-
var ArrayBindingPattern$0 = $S(
|
|
1514
|
+
var ArrayBindingPattern$0 = $S(OpenBracket, $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, CloseBracket);
|
|
1497
1515
|
function ArrayBindingPattern(state) {
|
|
1498
1516
|
if (state.verbose)
|
|
1499
1517
|
console.log("ENTER:", "ArrayBindingPattern");
|
|
@@ -1503,7 +1521,7 @@ var Civet = (() => {
|
|
|
1503
1521
|
return ArrayBindingPattern$0(state);
|
|
1504
1522
|
}
|
|
1505
1523
|
}
|
|
1506
|
-
var BindingProperty$0 = $S(__, PropertyName, __,
|
|
1524
|
+
var BindingProperty$0 = $S(__, PropertyName, __, Colon, __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
|
|
1507
1525
|
var BindingProperty$1 = $S(__, BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
|
|
1508
1526
|
function BindingProperty(state) {
|
|
1509
1527
|
if (state.tokenize) {
|
|
@@ -1512,7 +1530,7 @@ var Civet = (() => {
|
|
|
1512
1530
|
return BindingProperty$0(state) || BindingProperty$1(state);
|
|
1513
1531
|
}
|
|
1514
1532
|
}
|
|
1515
|
-
var BindingRestProperty$0 = $S($EXPECT($
|
|
1533
|
+
var BindingRestProperty$0 = $S($EXPECT($L18, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
|
|
1516
1534
|
function BindingRestProperty(state) {
|
|
1517
1535
|
if (state.verbose)
|
|
1518
1536
|
console.log("ENTER:", "BindingRestProperty");
|
|
@@ -1532,7 +1550,7 @@ var Civet = (() => {
|
|
|
1532
1550
|
return BindingElement$0(state);
|
|
1533
1551
|
}
|
|
1534
1552
|
}
|
|
1535
|
-
var BindingRestElement$0 = $S($EXPECT($
|
|
1553
|
+
var BindingRestElement$0 = $S($EXPECT($L18, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
|
|
1536
1554
|
function BindingRestElement(state) {
|
|
1537
1555
|
if (state.verbose)
|
|
1538
1556
|
console.log("ENTER:", "BindingRestElement");
|
|
@@ -1553,7 +1571,7 @@ var Civet = (() => {
|
|
|
1553
1571
|
}
|
|
1554
1572
|
}
|
|
1555
1573
|
var FunctionExpression$0 = ThinArrowFunction;
|
|
1556
|
-
var FunctionExpression$1 = $S($E($S(
|
|
1574
|
+
var FunctionExpression$1 = $S($E($S(Async, __)), Function, $E($S($EXPECT($L3, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
|
|
1557
1575
|
function FunctionExpression(state) {
|
|
1558
1576
|
if (state.tokenize) {
|
|
1559
1577
|
return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
|
|
@@ -1582,7 +1600,7 @@ var Civet = (() => {
|
|
|
1582
1600
|
return ThinArrowFunction$0(state);
|
|
1583
1601
|
}
|
|
1584
1602
|
}
|
|
1585
|
-
var Arrow$0 = $TV($EXPECT($
|
|
1603
|
+
var Arrow$0 = $TV($EXPECT($L19, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
1586
1604
|
return { $loc, token: $1 };
|
|
1587
1605
|
});
|
|
1588
1606
|
function Arrow(state) {
|
|
@@ -1594,7 +1612,7 @@ var Civet = (() => {
|
|
|
1594
1612
|
return Arrow$0(state);
|
|
1595
1613
|
}
|
|
1596
1614
|
}
|
|
1597
|
-
var Block$0 = $S(__,
|
|
1615
|
+
var Block$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
|
|
1598
1616
|
var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1599
1617
|
var Block$2 = Statement;
|
|
1600
1618
|
var Block$3 = $S(__, Statement);
|
|
@@ -1614,7 +1632,7 @@ var Civet = (() => {
|
|
|
1614
1632
|
return BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state);
|
|
1615
1633
|
}
|
|
1616
1634
|
}
|
|
1617
|
-
var BracedBlock$0 = $S(__,
|
|
1635
|
+
var BracedBlock$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
|
|
1618
1636
|
var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1619
1637
|
var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
|
|
1620
1638
|
function BracedBlock(state) {
|
|
@@ -1675,7 +1693,7 @@ var Civet = (() => {
|
|
|
1675
1693
|
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
|
|
1676
1694
|
}
|
|
1677
1695
|
}
|
|
1678
|
-
var NullLiteral$0 = $TV($EXPECT($
|
|
1696
|
+
var NullLiteral$0 = $TV($EXPECT($L20, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
1679
1697
|
return { $loc, token: $1 };
|
|
1680
1698
|
});
|
|
1681
1699
|
function NullLiteral(state) {
|
|
@@ -1687,7 +1705,7 @@ var Civet = (() => {
|
|
|
1687
1705
|
return NullLiteral$0(state);
|
|
1688
1706
|
}
|
|
1689
1707
|
}
|
|
1690
|
-
var BooleanLiteral$0 = $TV($C($EXPECT($
|
|
1708
|
+
var BooleanLiteral$0 = $TV($C($EXPECT($L21, fail, 'BooleanLiteral "true"'), $EXPECT($L22, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
|
|
1691
1709
|
return { $loc, token: $1 };
|
|
1692
1710
|
});
|
|
1693
1711
|
function BooleanLiteral(state) {
|
|
@@ -1699,7 +1717,9 @@ var Civet = (() => {
|
|
|
1699
1717
|
return BooleanLiteral$0(state);
|
|
1700
1718
|
}
|
|
1701
1719
|
}
|
|
1702
|
-
var Comma$0 = $
|
|
1720
|
+
var Comma$0 = $TV($EXPECT($L23, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
1721
|
+
return { $loc, token: $1 };
|
|
1722
|
+
});
|
|
1703
1723
|
function Comma(state) {
|
|
1704
1724
|
if (state.verbose)
|
|
1705
1725
|
console.log("ENTER:", "Comma");
|
|
@@ -1744,8 +1764,8 @@ var Civet = (() => {
|
|
|
1744
1764
|
return IdentifierReference$0(state);
|
|
1745
1765
|
}
|
|
1746
1766
|
}
|
|
1747
|
-
var ArrayLiteral$0 = $S(
|
|
1748
|
-
var ArrayLiteral$1 = $S(
|
|
1767
|
+
var ArrayLiteral$0 = $S(OpenBracket, NestedElementList, __, CloseBracket);
|
|
1768
|
+
var ArrayLiteral$1 = $S(OpenBracket, ElementList, __, CloseBracket);
|
|
1749
1769
|
function ArrayLiteral(state) {
|
|
1750
1770
|
if (state.tokenize) {
|
|
1751
1771
|
return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
|
|
@@ -1778,10 +1798,10 @@ var Civet = (() => {
|
|
|
1778
1798
|
return NestedElement$0(state);
|
|
1779
1799
|
}
|
|
1780
1800
|
}
|
|
1781
|
-
var ArrayElementDelimiter$0 = $S($Q(_),
|
|
1782
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
1783
|
-
var ArrayElementDelimiter$2 = $
|
|
1784
|
-
return ",";
|
|
1801
|
+
var ArrayElementDelimiter$0 = $S($Q(_), Comma);
|
|
1802
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L24, fail, 'ArrayElementDelimiter "]"')));
|
|
1803
|
+
var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1804
|
+
return { $loc, token: "," };
|
|
1785
1805
|
});
|
|
1786
1806
|
function ArrayElementDelimiter(state) {
|
|
1787
1807
|
if (state.tokenize) {
|
|
@@ -1790,7 +1810,7 @@ var Civet = (() => {
|
|
|
1790
1810
|
return ArrayElementDelimiter$0(state) || ArrayElementDelimiter$1(state) || ArrayElementDelimiter$2(state);
|
|
1791
1811
|
}
|
|
1792
1812
|
}
|
|
1793
|
-
var ElementList$0 = $S(ArrayElementExpression, $Q($S(__,
|
|
1813
|
+
var ElementList$0 = $S(ArrayElementExpression, $Q($S(__, Comma, __, ArrayElementExpression)));
|
|
1794
1814
|
function ElementList(state) {
|
|
1795
1815
|
if (state.verbose)
|
|
1796
1816
|
console.log("ENTER:", "ElementList");
|
|
@@ -1800,7 +1820,7 @@ var Civet = (() => {
|
|
|
1800
1820
|
return ElementList$0(state);
|
|
1801
1821
|
}
|
|
1802
1822
|
}
|
|
1803
|
-
var InlineElementList$0 = $S(ArrayElementExpression, $Q($S($Q(_),
|
|
1823
|
+
var InlineElementList$0 = $S(ArrayElementExpression, $Q($S($Q(_), Comma, $Q(_), ArrayElementExpression)));
|
|
1804
1824
|
function InlineElementList(state) {
|
|
1805
1825
|
if (state.verbose)
|
|
1806
1826
|
console.log("ENTER:", "InlineElementList");
|
|
@@ -1810,7 +1830,7 @@ var Civet = (() => {
|
|
|
1810
1830
|
return InlineElementList$0(state);
|
|
1811
1831
|
}
|
|
1812
1832
|
}
|
|
1813
|
-
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($
|
|
1833
|
+
var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L18, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
|
|
1814
1834
|
function ArrayElementExpression(state) {
|
|
1815
1835
|
if (state.verbose)
|
|
1816
1836
|
console.log("ENTER:", "ArrayElementExpression");
|
|
@@ -1820,7 +1840,7 @@ var Civet = (() => {
|
|
|
1820
1840
|
return ArrayElementExpression$0(state);
|
|
1821
1841
|
}
|
|
1822
1842
|
}
|
|
1823
|
-
var Elision$0 = $S(__,
|
|
1843
|
+
var Elision$0 = $S(__, Comma);
|
|
1824
1844
|
function Elision(state) {
|
|
1825
1845
|
if (state.verbose)
|
|
1826
1846
|
console.log("ENTER:", "Elision");
|
|
@@ -1830,9 +1850,9 @@ var Civet = (() => {
|
|
|
1830
1850
|
return Elision$0(state);
|
|
1831
1851
|
}
|
|
1832
1852
|
}
|
|
1833
|
-
var ObjectLiteral$0 = $S(
|
|
1834
|
-
var ObjectLiteral$1 = $S(
|
|
1835
|
-
var ObjectLiteral$2 = $S(
|
|
1853
|
+
var ObjectLiteral$0 = $S(OpenBrace, $Y(EOS), NestedPropertyDefinitions, __, CloseBrace);
|
|
1854
|
+
var ObjectLiteral$1 = $S(OpenBrace, __, PropertyDefinitionList, __, $E($S(Comma, __)), CloseBrace);
|
|
1855
|
+
var ObjectLiteral$2 = $S(OpenBrace, __, CloseBrace);
|
|
1836
1856
|
var ObjectLiteral$3 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1837
1857
|
function ObjectLiteral(state) {
|
|
1838
1858
|
if (state.tokenize) {
|
|
@@ -1866,13 +1886,13 @@ var Civet = (() => {
|
|
|
1866
1886
|
return NestedPropertyDefinition$0(state);
|
|
1867
1887
|
}
|
|
1868
1888
|
}
|
|
1869
|
-
var ObjectPropertyDelimiter$0 = $S($Q(_),
|
|
1870
|
-
var ObjectPropertyDelimiter$1 = $Y($S($Q(_),
|
|
1871
|
-
var ObjectPropertyDelimiter$2 = $
|
|
1872
|
-
return ",";
|
|
1889
|
+
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
1890
|
+
var ObjectPropertyDelimiter$1 = $Y($S($Q(_), CloseBrace));
|
|
1891
|
+
var ObjectPropertyDelimiter$2 = $TV($Y($S(__, CloseBrace)), function($skip, $loc, $0, $1) {
|
|
1892
|
+
return { $loc, token: "," };
|
|
1873
1893
|
});
|
|
1874
|
-
var ObjectPropertyDelimiter$3 = $
|
|
1875
|
-
return ",";
|
|
1894
|
+
var ObjectPropertyDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1895
|
+
return { $loc, token: "," };
|
|
1876
1896
|
});
|
|
1877
1897
|
function ObjectPropertyDelimiter(state) {
|
|
1878
1898
|
if (state.tokenize) {
|
|
@@ -1881,7 +1901,7 @@ var Civet = (() => {
|
|
|
1881
1901
|
return ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state) || ObjectPropertyDelimiter$3(state);
|
|
1882
1902
|
}
|
|
1883
1903
|
}
|
|
1884
|
-
var PropertyDefinitionList$0 = $S(PropertyDefinition, $Q($S(__,
|
|
1904
|
+
var PropertyDefinitionList$0 = $S(PropertyDefinition, $Q($S(__, Comma, __, PropertyDefinition)));
|
|
1885
1905
|
function PropertyDefinitionList(state) {
|
|
1886
1906
|
if (state.verbose)
|
|
1887
1907
|
console.log("ENTER:", "PropertyDefinitionList");
|
|
@@ -1891,9 +1911,9 @@ var Civet = (() => {
|
|
|
1891
1911
|
return PropertyDefinitionList$0(state);
|
|
1892
1912
|
}
|
|
1893
1913
|
}
|
|
1894
|
-
var PropertyDefinition$0 = $S(PropertyName, __,
|
|
1914
|
+
var PropertyDefinition$0 = $S(PropertyName, __, Colon, AssignmentExpression);
|
|
1895
1915
|
var PropertyDefinition$1 = MethodDefinition;
|
|
1896
|
-
var PropertyDefinition$2 = $S($EXPECT($
|
|
1916
|
+
var PropertyDefinition$2 = $S($EXPECT($L18, fail, 'PropertyDefinition "..."'), AssignmentExpression);
|
|
1897
1917
|
var PropertyDefinition$3 = IdentifierReference;
|
|
1898
1918
|
function PropertyDefinition(state) {
|
|
1899
1919
|
if (state.tokenize) {
|
|
@@ -1905,7 +1925,7 @@ var Civet = (() => {
|
|
|
1905
1925
|
var PropertyName$0 = NumericLiteral;
|
|
1906
1926
|
var PropertyName$1 = StringLiteral;
|
|
1907
1927
|
var PropertyName$2 = IdentifierName;
|
|
1908
|
-
var PropertyName$3 = $S(
|
|
1928
|
+
var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L24, fail, 'PropertyName "]"'));
|
|
1909
1929
|
function PropertyName(state) {
|
|
1910
1930
|
if (state.tokenize) {
|
|
1911
1931
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -1913,8 +1933,8 @@ var Civet = (() => {
|
|
|
1913
1933
|
return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
|
|
1914
1934
|
}
|
|
1915
1935
|
}
|
|
1916
|
-
var MethodDefinition$0 = $S($EXPECT($
|
|
1917
|
-
var MethodDefinition$1 = $S($EXPECT($
|
|
1936
|
+
var MethodDefinition$0 = $S($EXPECT($L25, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1937
|
+
var MethodDefinition$1 = $S($EXPECT($L26, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1918
1938
|
var MethodDefinition$2 = AsyncGeneratorMethod;
|
|
1919
1939
|
var MethodDefinition$3 = AsyncMethod;
|
|
1920
1940
|
var MethodDefinition$4 = GeneratorMethod;
|
|
@@ -1926,7 +1946,7 @@ var Civet = (() => {
|
|
|
1926
1946
|
return MethodDefinition$0(state) || MethodDefinition$1(state) || MethodDefinition$2(state) || MethodDefinition$3(state) || MethodDefinition$4(state) || MethodDefinition$5(state);
|
|
1927
1947
|
}
|
|
1928
1948
|
}
|
|
1929
|
-
var MethodModifier$0 = $S($C($EXPECT($
|
|
1949
|
+
var MethodModifier$0 = $S($C($EXPECT($L25, fail, 'MethodModifier "get"'), $EXPECT($L26, fail, 'MethodModifier "set"')), NonIdContinue, $Q(TrailingComment));
|
|
1930
1950
|
function MethodModifier(state) {
|
|
1931
1951
|
if (state.verbose)
|
|
1932
1952
|
console.log("ENTER:", "MethodModifier");
|
|
@@ -1955,7 +1975,7 @@ var Civet = (() => {
|
|
|
1955
1975
|
return ClassElementName$0(state) || ClassElementName$1(state);
|
|
1956
1976
|
}
|
|
1957
1977
|
}
|
|
1958
|
-
var PrivateIdentifier$0 = $S($EXPECT($
|
|
1978
|
+
var PrivateIdentifier$0 = $S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName);
|
|
1959
1979
|
function PrivateIdentifier(state) {
|
|
1960
1980
|
if (state.verbose)
|
|
1961
1981
|
console.log("ENTER:", "PrivateIdentifier");
|
|
@@ -1965,7 +1985,7 @@ var Civet = (() => {
|
|
|
1965
1985
|
return PrivateIdentifier$0(state);
|
|
1966
1986
|
}
|
|
1967
1987
|
}
|
|
1968
|
-
var GeneratorMethod$0 = $S($EXPECT($
|
|
1988
|
+
var GeneratorMethod$0 = $S($EXPECT($L3, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
|
|
1969
1989
|
function GeneratorMethod(state) {
|
|
1970
1990
|
if (state.verbose)
|
|
1971
1991
|
console.log("ENTER:", "GeneratorMethod");
|
|
@@ -1985,7 +2005,7 @@ var Civet = (() => {
|
|
|
1985
2005
|
return GeneratorBody$0(state);
|
|
1986
2006
|
}
|
|
1987
2007
|
}
|
|
1988
|
-
var AsyncMethod$0 = $S(
|
|
2008
|
+
var AsyncMethod$0 = $S(Async, $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
|
|
1989
2009
|
function AsyncMethod(state) {
|
|
1990
2010
|
if (state.verbose)
|
|
1991
2011
|
console.log("ENTER:", "AsyncMethod");
|
|
@@ -2005,7 +2025,7 @@ var Civet = (() => {
|
|
|
2005
2025
|
return AsyncFunctionBody$0(state);
|
|
2006
2026
|
}
|
|
2007
2027
|
}
|
|
2008
|
-
var AsyncGeneratorMethod$0 = $S(
|
|
2028
|
+
var AsyncGeneratorMethod$0 = $S(Async, $N(EOS), __, $EXPECT($L3, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
|
|
2009
2029
|
function AsyncGeneratorMethod(state) {
|
|
2010
2030
|
if (state.verbose)
|
|
2011
2031
|
console.log("ENTER:", "AsyncGeneratorMethod");
|
|
@@ -2037,25 +2057,25 @@ var Civet = (() => {
|
|
|
2037
2057
|
return AssignmentOp$0(state);
|
|
2038
2058
|
}
|
|
2039
2059
|
}
|
|
2040
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
2041
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
2042
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
2043
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
2044
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
2045
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
2046
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
2047
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
2048
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
2049
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
2050
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
2051
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
2052
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
2053
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
2054
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
2055
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
2060
|
+
var AssignmentOpSymbol$0 = $EXPECT($L27, fail, 'AssignmentOpSymbol "**="');
|
|
2061
|
+
var AssignmentOpSymbol$1 = $EXPECT($L28, fail, 'AssignmentOpSymbol "*="');
|
|
2062
|
+
var AssignmentOpSymbol$2 = $EXPECT($L29, fail, 'AssignmentOpSymbol "/="');
|
|
2063
|
+
var AssignmentOpSymbol$3 = $EXPECT($L30, fail, 'AssignmentOpSymbol "%="');
|
|
2064
|
+
var AssignmentOpSymbol$4 = $EXPECT($L31, fail, 'AssignmentOpSymbol "+="');
|
|
2065
|
+
var AssignmentOpSymbol$5 = $EXPECT($L32, fail, 'AssignmentOpSymbol "-="');
|
|
2066
|
+
var AssignmentOpSymbol$6 = $EXPECT($L33, fail, 'AssignmentOpSymbol "<<="');
|
|
2067
|
+
var AssignmentOpSymbol$7 = $EXPECT($L34, fail, 'AssignmentOpSymbol ">>>="');
|
|
2068
|
+
var AssignmentOpSymbol$8 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>="');
|
|
2069
|
+
var AssignmentOpSymbol$9 = $EXPECT($L36, fail, 'AssignmentOpSymbol "&&="');
|
|
2070
|
+
var AssignmentOpSymbol$10 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&="');
|
|
2071
|
+
var AssignmentOpSymbol$11 = $EXPECT($L38, fail, 'AssignmentOpSymbol "^="');
|
|
2072
|
+
var AssignmentOpSymbol$12 = $EXPECT($L39, fail, 'AssignmentOpSymbol "||="');
|
|
2073
|
+
var AssignmentOpSymbol$13 = $EXPECT($L40, fail, 'AssignmentOpSymbol "|="');
|
|
2074
|
+
var AssignmentOpSymbol$14 = $EXPECT($L41, fail, 'AssignmentOpSymbol "??="');
|
|
2075
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L42, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
2056
2076
|
return "??=";
|
|
2057
2077
|
});
|
|
2058
|
-
var AssignmentOpSymbol$16 = $EXPECT($
|
|
2078
|
+
var AssignmentOpSymbol$16 = $EXPECT($L43, fail, 'AssignmentOpSymbol "="');
|
|
2059
2079
|
function AssignmentOpSymbol(state) {
|
|
2060
2080
|
if (state.tokenize) {
|
|
2061
2081
|
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) || AssignmentOpSymbol$16(state));
|
|
@@ -2075,52 +2095,52 @@ var Civet = (() => {
|
|
|
2075
2095
|
return BinaryOp$0(state);
|
|
2076
2096
|
}
|
|
2077
2097
|
}
|
|
2078
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
2079
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
2080
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
2081
|
-
var BinaryOpSymbol$3 = $EXPECT($
|
|
2082
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
2083
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
2084
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
2085
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
2086
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
2087
|
-
var BinaryOpSymbol$9 = $EXPECT($
|
|
2088
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
2089
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
2090
|
-
var BinaryOpSymbol$12 = $EXPECT($
|
|
2091
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
2092
|
-
var BinaryOpSymbol$14 = $TV($EXPECT($
|
|
2098
|
+
var BinaryOpSymbol$0 = $EXPECT($L44, fail, 'BinaryOpSymbol "**"');
|
|
2099
|
+
var BinaryOpSymbol$1 = $EXPECT($L3, fail, 'BinaryOpSymbol "*"');
|
|
2100
|
+
var BinaryOpSymbol$2 = $EXPECT($L45, fail, 'BinaryOpSymbol "/"');
|
|
2101
|
+
var BinaryOpSymbol$3 = $EXPECT($L46, fail, 'BinaryOpSymbol "%"');
|
|
2102
|
+
var BinaryOpSymbol$4 = $EXPECT($L47, fail, 'BinaryOpSymbol "+"');
|
|
2103
|
+
var BinaryOpSymbol$5 = $EXPECT($L48, fail, 'BinaryOpSymbol "-"');
|
|
2104
|
+
var BinaryOpSymbol$6 = $EXPECT($L49, fail, 'BinaryOpSymbol "<="');
|
|
2105
|
+
var BinaryOpSymbol$7 = $EXPECT($L50, fail, 'BinaryOpSymbol ">="');
|
|
2106
|
+
var BinaryOpSymbol$8 = $EXPECT($L51, fail, 'BinaryOpSymbol "<<"');
|
|
2107
|
+
var BinaryOpSymbol$9 = $EXPECT($L5, fail, 'BinaryOpSymbol "<"');
|
|
2108
|
+
var BinaryOpSymbol$10 = $EXPECT($L52, fail, 'BinaryOpSymbol ">>>"');
|
|
2109
|
+
var BinaryOpSymbol$11 = $EXPECT($L53, fail, 'BinaryOpSymbol ">>"');
|
|
2110
|
+
var BinaryOpSymbol$12 = $EXPECT($L54, fail, 'BinaryOpSymbol ">"');
|
|
2111
|
+
var BinaryOpSymbol$13 = $EXPECT($L55, fail, 'BinaryOpSymbol "!=="');
|
|
2112
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L56, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
2093
2113
|
if (module.coffeeCompat)
|
|
2094
2114
|
return "!==";
|
|
2095
2115
|
return $1;
|
|
2096
2116
|
});
|
|
2097
|
-
var BinaryOpSymbol$15 = $T($S($EXPECT($
|
|
2117
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L57, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
2098
2118
|
return "===";
|
|
2099
2119
|
});
|
|
2100
|
-
var BinaryOpSymbol$16 = $EXPECT($
|
|
2101
|
-
var BinaryOpSymbol$17 = $TV($EXPECT($
|
|
2120
|
+
var BinaryOpSymbol$16 = $EXPECT($L58, fail, 'BinaryOpSymbol "==="');
|
|
2121
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L59, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
2102
2122
|
if (module.coffeeCompat)
|
|
2103
2123
|
return "===";
|
|
2104
2124
|
return $1;
|
|
2105
2125
|
});
|
|
2106
|
-
var BinaryOpSymbol$18 = $T($S($EXPECT($
|
|
2126
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L60, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
2107
2127
|
return "&&";
|
|
2108
2128
|
});
|
|
2109
|
-
var BinaryOpSymbol$19 = $EXPECT($
|
|
2110
|
-
var BinaryOpSymbol$20 = $T($S($EXPECT($
|
|
2129
|
+
var BinaryOpSymbol$19 = $EXPECT($L61, fail, 'BinaryOpSymbol "&&"');
|
|
2130
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
2111
2131
|
return "||";
|
|
2112
2132
|
});
|
|
2113
|
-
var BinaryOpSymbol$21 = $EXPECT($
|
|
2114
|
-
var BinaryOpSymbol$22 = $EXPECT($
|
|
2115
|
-
var BinaryOpSymbol$23 = $TS($S($EXPECT($
|
|
2133
|
+
var BinaryOpSymbol$21 = $EXPECT($L63, fail, 'BinaryOpSymbol "||"');
|
|
2134
|
+
var BinaryOpSymbol$22 = $EXPECT($L64, fail, 'BinaryOpSymbol "??"');
|
|
2135
|
+
var BinaryOpSymbol$23 = $TS($S($EXPECT($L65, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2116
2136
|
return $1;
|
|
2117
2137
|
});
|
|
2118
|
-
var BinaryOpSymbol$24 = $TS($S($EXPECT($
|
|
2138
|
+
var BinaryOpSymbol$24 = $TS($S($EXPECT($L66, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2119
2139
|
return $1;
|
|
2120
2140
|
});
|
|
2121
|
-
var BinaryOpSymbol$25 = $EXPECT($
|
|
2122
|
-
var BinaryOpSymbol$26 = $EXPECT($
|
|
2123
|
-
var BinaryOpSymbol$27 = $EXPECT($
|
|
2141
|
+
var BinaryOpSymbol$25 = $EXPECT($L67, fail, 'BinaryOpSymbol "&"');
|
|
2142
|
+
var BinaryOpSymbol$26 = $EXPECT($L68, fail, 'BinaryOpSymbol "^"');
|
|
2143
|
+
var BinaryOpSymbol$27 = $EXPECT($L69, fail, 'BinaryOpSymbol "|"');
|
|
2124
2144
|
function BinaryOpSymbol(state) {
|
|
2125
2145
|
if (state.tokenize) {
|
|
2126
2146
|
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));
|
|
@@ -2129,7 +2149,7 @@ var Civet = (() => {
|
|
|
2129
2149
|
}
|
|
2130
2150
|
}
|
|
2131
2151
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
2132
|
-
var UnaryOp$1 = $S($C($EXPECT($
|
|
2152
|
+
var UnaryOp$1 = $S($C($EXPECT($L70, fail, 'UnaryOp "delete"'), $EXPECT($L71, fail, 'UnaryOp "void"'), $EXPECT($L72, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
|
|
2133
2153
|
function UnaryOp(state) {
|
|
2134
2154
|
if (state.tokenize) {
|
|
2135
2155
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -2147,11 +2167,13 @@ var Civet = (() => {
|
|
|
2147
2167
|
return ModuleItem$0(state) || ModuleItem$1(state) || ModuleItem$2(state);
|
|
2148
2168
|
}
|
|
2149
2169
|
}
|
|
2150
|
-
var StatementListItem$0 = $TS($S($C(Declaration, Statement), $E(PostfixConditional)), function($skip, $loc, $0, $1, $2) {
|
|
2170
|
+
var StatementListItem$0 = $TS($S($C(Declaration, Statement), $E(PostfixConditional), Loc), function($skip, $loc, $0, $1, $2, $3) {
|
|
2151
2171
|
var statement = $1;
|
|
2152
2172
|
var cond = $2;
|
|
2173
|
+
var l = $3;
|
|
2153
2174
|
if (cond)
|
|
2154
|
-
return [cond, statement, "}"];
|
|
2175
|
+
return [cond, statement, { $loc: l.$loc, token: "}" }];
|
|
2176
|
+
$0.pop();
|
|
2155
2177
|
return $0;
|
|
2156
2178
|
});
|
|
2157
2179
|
function StatementListItem(state) {
|
|
@@ -2163,13 +2185,24 @@ var Civet = (() => {
|
|
|
2163
2185
|
return StatementListItem$0(state);
|
|
2164
2186
|
}
|
|
2165
2187
|
}
|
|
2166
|
-
var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C(
|
|
2188
|
+
var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C(If, Unless), NonIdContinue, Loc, Expression, Loc), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
2167
2189
|
var ws = $1;
|
|
2168
2190
|
var cond = $2;
|
|
2169
|
-
var
|
|
2170
|
-
|
|
2171
|
-
|
|
2172
|
-
|
|
2191
|
+
var l1 = $4;
|
|
2192
|
+
var exp = $5;
|
|
2193
|
+
var l2 = $6;
|
|
2194
|
+
let openParens = { $loc: l1.$loc, token: "(!(" };
|
|
2195
|
+
let closingParens = { $loc: l2.$loc, token: "))" };
|
|
2196
|
+
let space = { $loc: l2.$loc, token: " " };
|
|
2197
|
+
let openingBrace = { $loc: l2.$loc, token: "{" };
|
|
2198
|
+
if (cond.token === "if") {
|
|
2199
|
+
cond.token = "if";
|
|
2200
|
+
closingParens.token = ")";
|
|
2201
|
+
openParens.token = "(";
|
|
2202
|
+
} else {
|
|
2203
|
+
cond.token = "if";
|
|
2204
|
+
}
|
|
2205
|
+
return [ws, cond, openParens, exp, closingParens, space, openingBrace];
|
|
2173
2206
|
});
|
|
2174
2207
|
function PostfixConditional(state) {
|
|
2175
2208
|
if (state.verbose)
|
|
@@ -2196,7 +2229,7 @@ var Civet = (() => {
|
|
|
2196
2229
|
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);
|
|
2197
2230
|
}
|
|
2198
2231
|
}
|
|
2199
|
-
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($
|
|
2232
|
+
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L73, fail, 'EmptyStatement ";"')));
|
|
2200
2233
|
function EmptyStatement(state) {
|
|
2201
2234
|
if (state.verbose)
|
|
2202
2235
|
console.log("ENTER:", "EmptyStatement");
|
|
@@ -2206,7 +2239,7 @@ var Civet = (() => {
|
|
|
2206
2239
|
return EmptyStatement$0(state);
|
|
2207
2240
|
}
|
|
2208
2241
|
}
|
|
2209
|
-
var BlockStatement$0 = $S(__,
|
|
2242
|
+
var BlockStatement$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
|
|
2210
2243
|
function BlockStatement(state) {
|
|
2211
2244
|
if (state.verbose)
|
|
2212
2245
|
console.log("ENTER:", "BlockStatement");
|
|
@@ -2216,17 +2249,21 @@ var Civet = (() => {
|
|
|
2216
2249
|
return BlockStatement$0(state);
|
|
2217
2250
|
}
|
|
2218
2251
|
}
|
|
2219
|
-
var IfStatement$0 = $S(
|
|
2220
|
-
var IfStatement$1 = $TS($S(
|
|
2252
|
+
var IfStatement$0 = $S(If, Condition, Block, $E($S(__, Else, Block)));
|
|
2253
|
+
var IfStatement$1 = $TS($S(Unless, Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
|
|
2254
|
+
var kind = $1;
|
|
2221
2255
|
var condition = $2;
|
|
2222
2256
|
var block = $3;
|
|
2223
|
-
|
|
2224
|
-
if (c
|
|
2225
|
-
return
|
|
2226
|
-
if (c === "
|
|
2227
|
-
|
|
2228
|
-
|
|
2229
|
-
|
|
2257
|
+
condition.forEach((c) => {
|
|
2258
|
+
if (!c)
|
|
2259
|
+
return;
|
|
2260
|
+
if (c.token === "(")
|
|
2261
|
+
c.token = "(!(";
|
|
2262
|
+
if (c.token === ")")
|
|
2263
|
+
c.token = "))";
|
|
2264
|
+
});
|
|
2265
|
+
kind.token = "if";
|
|
2266
|
+
return [kind, condition, block];
|
|
2230
2267
|
});
|
|
2231
2268
|
function IfStatement(state) {
|
|
2232
2269
|
if (state.tokenize) {
|
|
@@ -2247,10 +2284,7 @@ var Civet = (() => {
|
|
|
2247
2284
|
return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
|
|
2248
2285
|
}
|
|
2249
2286
|
}
|
|
2250
|
-
var LoopStatement$0 = $
|
|
2251
|
-
var b = $3;
|
|
2252
|
-
return ["while(true)", b];
|
|
2253
|
-
});
|
|
2287
|
+
var LoopStatement$0 = $S(Loop, Block);
|
|
2254
2288
|
function LoopStatement(state) {
|
|
2255
2289
|
if (state.verbose)
|
|
2256
2290
|
console.log("ENTER:", "LoopStatement");
|
|
@@ -2260,7 +2294,7 @@ var Civet = (() => {
|
|
|
2260
2294
|
return LoopStatement$0(state);
|
|
2261
2295
|
}
|
|
2262
2296
|
}
|
|
2263
|
-
var DoWhileStatement$0 = $S($EXPECT($
|
|
2297
|
+
var DoWhileStatement$0 = $S($EXPECT($L74, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
|
|
2264
2298
|
function DoWhileStatement(state) {
|
|
2265
2299
|
if (state.verbose)
|
|
2266
2300
|
console.log("ENTER:", "DoWhileStatement");
|
|
@@ -2280,7 +2314,7 @@ var Civet = (() => {
|
|
|
2280
2314
|
return WhileStatement$0(state);
|
|
2281
2315
|
}
|
|
2282
2316
|
}
|
|
2283
|
-
var WhileClause$0 = $TS($S($C($EXPECT($
|
|
2317
|
+
var WhileClause$0 = $TS($S($C($EXPECT($L75, fail, 'WhileClause "while"'), $EXPECT($L76, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
|
|
2284
2318
|
var kind = $1;
|
|
2285
2319
|
var cond = $3;
|
|
2286
2320
|
if (kind === "until") {
|
|
@@ -2299,7 +2333,7 @@ var Civet = (() => {
|
|
|
2299
2333
|
return WhileClause$0(state);
|
|
2300
2334
|
}
|
|
2301
2335
|
}
|
|
2302
|
-
var ForStatement$0 = $S(For, __,
|
|
2336
|
+
var ForStatement$0 = $S(For, __, OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, __, $E(Expression), Semicolon, __, $E(Expression), CloseParen, Block);
|
|
2303
2337
|
function ForStatement(state) {
|
|
2304
2338
|
if (state.verbose)
|
|
2305
2339
|
console.log("ENTER:", "ForStatement");
|
|
@@ -2309,10 +2343,10 @@ var Civet = (() => {
|
|
|
2309
2343
|
return ForStatement$0(state);
|
|
2310
2344
|
}
|
|
2311
2345
|
}
|
|
2312
|
-
var ForInOfStatement$0 = $S(For, __,
|
|
2313
|
-
var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S(
|
|
2314
|
-
var ForInOfStatement$2 = $S(For, $E($S(__,
|
|
2315
|
-
var ForInOfStatement$3 = $S(For, $E($S(__,
|
|
2346
|
+
var ForInOfStatement$0 = $S(For, __, OpenParen, __, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, In, __, Expression, __, CloseParen, Block);
|
|
2347
|
+
var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, In, __, Expression, InsertCloseParen, Block);
|
|
2348
|
+
var ForInOfStatement$2 = $S(For, $E($S(__, Await)), __, OpenParen, __, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, Of, AssignmentExpression, __, CloseParen, Block);
|
|
2349
|
+
var ForInOfStatement$3 = $S(For, $E($S(__, Await)), __, InsertOpenParen, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, Of, AssignmentExpression, InsertCloseParen, Block);
|
|
2316
2350
|
function ForInOfStatement(state) {
|
|
2317
2351
|
if (state.tokenize) {
|
|
2318
2352
|
return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
|
|
@@ -2320,18 +2354,6 @@ var Civet = (() => {
|
|
|
2320
2354
|
return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
|
|
2321
2355
|
}
|
|
2322
2356
|
}
|
|
2323
|
-
var For$0 = $TS($S($EXPECT($L98, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2324
|
-
return { $loc, token: $1 };
|
|
2325
|
-
});
|
|
2326
|
-
function For(state) {
|
|
2327
|
-
if (state.verbose)
|
|
2328
|
-
console.log("ENTER:", "For");
|
|
2329
|
-
if (state.tokenize) {
|
|
2330
|
-
return $TOKEN("For", state, For$0(state));
|
|
2331
|
-
} else {
|
|
2332
|
-
return For$0(state);
|
|
2333
|
-
}
|
|
2334
|
-
}
|
|
2335
2357
|
var ForDeclaration$0 = $S(LetOrConst, NonIdContinue, __, ForBinding);
|
|
2336
2358
|
function ForDeclaration(state) {
|
|
2337
2359
|
if (state.verbose)
|
|
@@ -2342,7 +2364,7 @@ var Civet = (() => {
|
|
|
2342
2364
|
return ForDeclaration$0(state);
|
|
2343
2365
|
}
|
|
2344
2366
|
}
|
|
2345
|
-
var LetOrConst$0 = $TV($C($EXPECT($
|
|
2367
|
+
var LetOrConst$0 = $TV($C($EXPECT($L77, fail, 'LetOrConst "let"'), $EXPECT($L78, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
2346
2368
|
return { $loc, token: $1 };
|
|
2347
2369
|
});
|
|
2348
2370
|
function LetOrConst(state) {
|
|
@@ -2363,7 +2385,7 @@ var Civet = (() => {
|
|
|
2363
2385
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
2364
2386
|
}
|
|
2365
2387
|
}
|
|
2366
|
-
var SwitchStatement$0 = $S(
|
|
2388
|
+
var SwitchStatement$0 = $S(Switch, NonIdContinue, Condition, CaseBlock);
|
|
2367
2389
|
function SwitchStatement(state) {
|
|
2368
2390
|
if (state.verbose)
|
|
2369
2391
|
console.log("ENTER:", "SwitchStatement");
|
|
@@ -2373,7 +2395,7 @@ var Civet = (() => {
|
|
|
2373
2395
|
return SwitchStatement$0(state);
|
|
2374
2396
|
}
|
|
2375
2397
|
}
|
|
2376
|
-
var CaseBlock$0 = $S(__,
|
|
2398
|
+
var CaseBlock$0 = $S(__, OpenBrace, $Y(EOS), NestedCaseClauses, __, CloseBrace);
|
|
2377
2399
|
var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
|
|
2378
2400
|
function CaseBlock(state) {
|
|
2379
2401
|
if (state.tokenize) {
|
|
@@ -2407,9 +2429,9 @@ var Civet = (() => {
|
|
|
2407
2429
|
return NestedCaseClause$0(state);
|
|
2408
2430
|
}
|
|
2409
2431
|
}
|
|
2410
|
-
var CaseClause$0 = $S($EXPECT($
|
|
2432
|
+
var CaseClause$0 = $S($EXPECT($L79, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
|
|
2411
2433
|
var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
|
|
2412
|
-
var CaseClause$2 = $S($EXPECT($
|
|
2434
|
+
var CaseClause$2 = $S($EXPECT($L80, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
|
|
2413
2435
|
function CaseClause(state) {
|
|
2414
2436
|
if (state.tokenize) {
|
|
2415
2437
|
return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
|
|
@@ -2417,21 +2439,9 @@ var Civet = (() => {
|
|
|
2417
2439
|
return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
|
|
2418
2440
|
}
|
|
2419
2441
|
}
|
|
2420
|
-
var
|
|
2421
|
-
|
|
2422
|
-
|
|
2423
|
-
function When(state) {
|
|
2424
|
-
if (state.verbose)
|
|
2425
|
-
console.log("ENTER:", "When");
|
|
2426
|
-
if (state.tokenize) {
|
|
2427
|
-
return $TOKEN("When", state, When$0(state));
|
|
2428
|
-
} else {
|
|
2429
|
-
return When$0(state);
|
|
2430
|
-
}
|
|
2431
|
-
}
|
|
2432
|
-
var ImpliedColon$0 = $S(__, $EXPECT($L14, fail, 'ImpliedColon ":"'));
|
|
2433
|
-
var ImpliedColon$1 = $T($EXPECT($L33, fail, 'ImpliedColon ""'), function(value) {
|
|
2434
|
-
return ":";
|
|
2442
|
+
var ImpliedColon$0 = $S(__, Colon);
|
|
2443
|
+
var ImpliedColon$1 = $TV($EXPECT($L16, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
|
|
2444
|
+
return { $loc, token: ":" };
|
|
2435
2445
|
});
|
|
2436
2446
|
function ImpliedColon(state) {
|
|
2437
2447
|
if (state.tokenize) {
|
|
@@ -2440,7 +2450,7 @@ var Civet = (() => {
|
|
|
2440
2450
|
return ImpliedColon$0(state) || ImpliedColon$1(state);
|
|
2441
2451
|
}
|
|
2442
2452
|
}
|
|
2443
|
-
var TryStatement$0 = $TS($S(
|
|
2453
|
+
var TryStatement$0 = $TS($S(Try, BracedBlock, $E(CatchClause), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2444
2454
|
var c = $3;
|
|
2445
2455
|
var f = $4;
|
|
2446
2456
|
if (!c && !f) {
|
|
@@ -2457,17 +2467,17 @@ var Civet = (() => {
|
|
|
2457
2467
|
return TryStatement$0(state);
|
|
2458
2468
|
}
|
|
2459
2469
|
}
|
|
2460
|
-
var
|
|
2461
|
-
function
|
|
2470
|
+
var CatchClause$0 = $S(__, Catch, $E(CatchBind), BracedBlock);
|
|
2471
|
+
function CatchClause(state) {
|
|
2462
2472
|
if (state.verbose)
|
|
2463
|
-
console.log("ENTER:", "
|
|
2473
|
+
console.log("ENTER:", "CatchClause");
|
|
2464
2474
|
if (state.tokenize) {
|
|
2465
|
-
return $TOKEN("
|
|
2475
|
+
return $TOKEN("CatchClause", state, CatchClause$0(state));
|
|
2466
2476
|
} else {
|
|
2467
|
-
return
|
|
2477
|
+
return CatchClause$0(state);
|
|
2468
2478
|
}
|
|
2469
2479
|
}
|
|
2470
|
-
var CatchBind$0 = $S(__,
|
|
2480
|
+
var CatchBind$0 = $S(__, OpenParen, __, CatchParameter, __, CloseParen);
|
|
2471
2481
|
var CatchBind$1 = $S(__, InsertOpenParen, CatchParameter, InsertCloseParen);
|
|
2472
2482
|
function CatchBind(state) {
|
|
2473
2483
|
if (state.tokenize) {
|
|
@@ -2476,7 +2486,7 @@ var Civet = (() => {
|
|
|
2476
2486
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2477
2487
|
}
|
|
2478
2488
|
}
|
|
2479
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2489
|
+
var Finally$0 = $S(__, $EXPECT($L81, fail, 'Finally "finally"'), BracedBlock);
|
|
2480
2490
|
function Finally(state) {
|
|
2481
2491
|
if (state.verbose)
|
|
2482
2492
|
console.log("ENTER:", "Finally");
|
|
@@ -2495,7 +2505,7 @@ var Civet = (() => {
|
|
|
2495
2505
|
return CatchParameter$0(state) || CatchParameter$1(state);
|
|
2496
2506
|
}
|
|
2497
2507
|
}
|
|
2498
|
-
var Condition$0 = $S(__,
|
|
2508
|
+
var Condition$0 = $S(__, OpenParen, __, Expression, __, CloseParen);
|
|
2499
2509
|
var Condition$1 = $S($N(EOS), __, InsertOpenParen, Expression, InsertCloseParen);
|
|
2500
2510
|
function Condition(state) {
|
|
2501
2511
|
if (state.tokenize) {
|
|
@@ -2514,11 +2524,11 @@ var Civet = (() => {
|
|
|
2514
2524
|
return ExpressionStatement$0(state);
|
|
2515
2525
|
}
|
|
2516
2526
|
}
|
|
2517
|
-
var KeywordStatement$0 = $S($EXPECT($
|
|
2518
|
-
var KeywordStatement$1 = $S($EXPECT($
|
|
2519
|
-
var KeywordStatement$2 = $S($EXPECT($
|
|
2527
|
+
var KeywordStatement$0 = $S($EXPECT($L82, fail, 'KeywordStatement "break"'), NonIdContinue);
|
|
2528
|
+
var KeywordStatement$1 = $S($EXPECT($L83, fail, 'KeywordStatement "continue"'), NonIdContinue);
|
|
2529
|
+
var KeywordStatement$2 = $S($EXPECT($L84, fail, 'KeywordStatement "debugger"'), NonIdContinue);
|
|
2520
2530
|
var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
|
|
2521
|
-
var KeywordStatement$4 = $S($EXPECT($
|
|
2531
|
+
var KeywordStatement$4 = $S($EXPECT($L85, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
|
|
2522
2532
|
function KeywordStatement(state) {
|
|
2523
2533
|
if (state.tokenize) {
|
|
2524
2534
|
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
|
|
@@ -2535,24 +2545,22 @@ var Civet = (() => {
|
|
|
2535
2545
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2536
2546
|
}
|
|
2537
2547
|
}
|
|
2538
|
-
var
|
|
2539
|
-
return { $loc, token: $1 };
|
|
2540
|
-
});
|
|
2541
|
-
function Return(state) {
|
|
2542
|
-
if (state.verbose)
|
|
2543
|
-
console.log("ENTER:", "Return");
|
|
2544
|
-
if (state.tokenize) {
|
|
2545
|
-
return $TOKEN("Return", state, Return$0(state));
|
|
2546
|
-
} else {
|
|
2547
|
-
return Return$0(state);
|
|
2548
|
-
}
|
|
2549
|
-
}
|
|
2550
|
-
var ImportDeclaration$0 = $T($S($EXPECT($L113, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2548
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L86, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2551
2549
|
return { "ts": true, "children": value };
|
|
2552
2550
|
});
|
|
2553
2551
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
2554
2552
|
var ImportDeclaration$2 = $S(Import, __, ModuleSpecifier);
|
|
2555
|
-
var ImportDeclaration$3 = $S(ImpliedImport, ImportClause, __, FromClause)
|
|
2553
|
+
var ImportDeclaration$3 = $TS($S(ImpliedImport, ImportClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2554
|
+
var i = $1;
|
|
2555
|
+
var c = $2;
|
|
2556
|
+
var w = $3;
|
|
2557
|
+
var f = $4;
|
|
2558
|
+
i.$loc = {
|
|
2559
|
+
pos: f[0].$loc.pos - 1,
|
|
2560
|
+
length: f[0].$loc.length + 1
|
|
2561
|
+
};
|
|
2562
|
+
return [i, c, w, f];
|
|
2563
|
+
});
|
|
2556
2564
|
function ImportDeclaration(state) {
|
|
2557
2565
|
if (state.tokenize) {
|
|
2558
2566
|
return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state));
|
|
@@ -2560,8 +2568,8 @@ var Civet = (() => {
|
|
|
2560
2568
|
return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state);
|
|
2561
2569
|
}
|
|
2562
2570
|
}
|
|
2563
|
-
var ImpliedImport$0 = $
|
|
2564
|
-
return "import ";
|
|
2571
|
+
var ImpliedImport$0 = $TV($EXPECT($L16, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
|
|
2572
|
+
return { $loc, token: "import " };
|
|
2565
2573
|
});
|
|
2566
2574
|
function ImpliedImport(state) {
|
|
2567
2575
|
if (state.verbose)
|
|
@@ -2572,19 +2580,7 @@ var Civet = (() => {
|
|
|
2572
2580
|
return ImpliedImport$0(state);
|
|
2573
2581
|
}
|
|
2574
2582
|
}
|
|
2575
|
-
var
|
|
2576
|
-
return { $loc, token: $1 };
|
|
2577
|
-
});
|
|
2578
|
-
function Import(state) {
|
|
2579
|
-
if (state.verbose)
|
|
2580
|
-
console.log("ENTER:", "Import");
|
|
2581
|
-
if (state.tokenize) {
|
|
2582
|
-
return $TOKEN("Import", state, Import$0(state));
|
|
2583
|
-
} else {
|
|
2584
|
-
return Import$0(state);
|
|
2585
|
-
}
|
|
2586
|
-
}
|
|
2587
|
-
var ImportClause$0 = $S(ImportedBinding, $E($S(__, $EXPECT($L0, fail, 'ImportClause ","'), __, $C(NameSpaceImport, NamedImports))));
|
|
2583
|
+
var ImportClause$0 = $S(ImportedBinding, $E($S(__, Comma, __, $C(NameSpaceImport, NamedImports))));
|
|
2588
2584
|
var ImportClause$1 = NameSpaceImport;
|
|
2589
2585
|
var ImportClause$2 = NamedImports;
|
|
2590
2586
|
function ImportClause(state) {
|
|
@@ -2594,7 +2590,7 @@ var Civet = (() => {
|
|
|
2594
2590
|
return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
|
|
2595
2591
|
}
|
|
2596
2592
|
}
|
|
2597
|
-
var NameSpaceImport$0 = $S($EXPECT($
|
|
2593
|
+
var NameSpaceImport$0 = $S($EXPECT($L3, fail, 'NameSpaceImport "*"'), __, As, NonIdContinue, __, ImportedBinding);
|
|
2598
2594
|
function NameSpaceImport(state) {
|
|
2599
2595
|
if (state.verbose)
|
|
2600
2596
|
console.log("ENTER:", "NameSpaceImport");
|
|
@@ -2604,7 +2600,7 @@ var Civet = (() => {
|
|
|
2604
2600
|
return NameSpaceImport$0(state);
|
|
2605
2601
|
}
|
|
2606
2602
|
}
|
|
2607
|
-
var NamedImports$0 = $S(
|
|
2603
|
+
var NamedImports$0 = $S(OpenBrace, $Q(ImportSpecifier), $E($S(__, Comma)), __, CloseBrace);
|
|
2608
2604
|
function NamedImports(state) {
|
|
2609
2605
|
if (state.verbose)
|
|
2610
2606
|
console.log("ENTER:", "NamedImports");
|
|
@@ -2624,19 +2620,7 @@ var Civet = (() => {
|
|
|
2624
2620
|
return FromClause$0(state);
|
|
2625
2621
|
}
|
|
2626
2622
|
}
|
|
2627
|
-
var
|
|
2628
|
-
return { $loc, token: $1 };
|
|
2629
|
-
});
|
|
2630
|
-
function From(state) {
|
|
2631
|
-
if (state.verbose)
|
|
2632
|
-
console.log("ENTER:", "From");
|
|
2633
|
-
if (state.tokenize) {
|
|
2634
|
-
return $TOKEN("From", state, From$0(state));
|
|
2635
|
-
} else {
|
|
2636
|
-
return From$0(state);
|
|
2637
|
-
}
|
|
2638
|
-
}
|
|
2639
|
-
var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
|
|
2623
|
+
var ImportSpecifier$0 = $S(__, ModuleExportName, __, As, NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
|
|
2640
2624
|
var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
|
|
2641
2625
|
function ImportSpecifier(state) {
|
|
2642
2626
|
if (state.tokenize) {
|
|
@@ -2676,7 +2660,7 @@ var Civet = (() => {
|
|
|
2676
2660
|
return UnprocessedModuleSpecifier$0(state) || UnprocessedModuleSpecifier$1(state);
|
|
2677
2661
|
}
|
|
2678
2662
|
}
|
|
2679
|
-
var UnquotedSpecifier$0 = $TV($EXPECT($
|
|
2663
|
+
var UnquotedSpecifier$0 = $TV($EXPECT($R3, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
|
|
2680
2664
|
var spec = $0;
|
|
2681
2665
|
return { $loc, token: `"${spec}"` };
|
|
2682
2666
|
});
|
|
@@ -2699,7 +2683,7 @@ var Civet = (() => {
|
|
|
2699
2683
|
return ImportedBinding$0(state);
|
|
2700
2684
|
}
|
|
2701
2685
|
}
|
|
2702
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
2686
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L80, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2703
2687
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
2704
2688
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
2705
2689
|
function ExportDeclaration(state) {
|
|
@@ -2709,27 +2693,7 @@ var Civet = (() => {
|
|
|
2709
2693
|
return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
|
|
2710
2694
|
}
|
|
2711
2695
|
}
|
|
2712
|
-
var
|
|
2713
|
-
function As(state) {
|
|
2714
|
-
if (state.verbose)
|
|
2715
|
-
console.log("ENTER:", "As");
|
|
2716
|
-
if (state.tokenize) {
|
|
2717
|
-
return $TOKEN("As", state, As$0(state));
|
|
2718
|
-
} else {
|
|
2719
|
-
return As$0(state);
|
|
2720
|
-
}
|
|
2721
|
-
}
|
|
2722
|
-
var Export$0 = $S($EXPECT($L115, fail, 'Export "export"'), NonIdContinue);
|
|
2723
|
-
function Export(state) {
|
|
2724
|
-
if (state.verbose)
|
|
2725
|
-
console.log("ENTER:", "Export");
|
|
2726
|
-
if (state.tokenize) {
|
|
2727
|
-
return $TOKEN("Export", state, Export$0(state));
|
|
2728
|
-
} else {
|
|
2729
|
-
return Export$0(state);
|
|
2730
|
-
}
|
|
2731
|
-
}
|
|
2732
|
-
var ExportFromClause$0 = $S($EXPECT($L10, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), NonIdContinue, __, ModuleExportName)));
|
|
2696
|
+
var ExportFromClause$0 = $S($EXPECT($L3, fail, 'ExportFromClause "*"'), $E($S(__, As, NonIdContinue, __, ModuleExportName)));
|
|
2733
2697
|
var ExportFromClause$1 = NamedExports;
|
|
2734
2698
|
function ExportFromClause(state) {
|
|
2735
2699
|
if (state.tokenize) {
|
|
@@ -2738,7 +2702,7 @@ var Civet = (() => {
|
|
|
2738
2702
|
return ExportFromClause$0(state) || ExportFromClause$1(state);
|
|
2739
2703
|
}
|
|
2740
2704
|
}
|
|
2741
|
-
var NamedExports$0 = $S(
|
|
2705
|
+
var NamedExports$0 = $S(OpenBrace, $Q(ExportSpecifier), $E($S(__, Comma)), __, CloseBrace);
|
|
2742
2706
|
function NamedExports(state) {
|
|
2743
2707
|
if (state.verbose)
|
|
2744
2708
|
console.log("ENTER:", "NamedExports");
|
|
@@ -2748,7 +2712,7 @@ var Civet = (() => {
|
|
|
2748
2712
|
return NamedExports$0(state);
|
|
2749
2713
|
}
|
|
2750
2714
|
}
|
|
2751
|
-
var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__,
|
|
2715
|
+
var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, As, __, ModuleExportName)), ObjectPropertyDelimiter);
|
|
2752
2716
|
function ExportSpecifier(state) {
|
|
2753
2717
|
if (state.verbose)
|
|
2754
2718
|
console.log("ENTER:", "ExportSpecifier");
|
|
@@ -2779,8 +2743,16 @@ var Civet = (() => {
|
|
|
2779
2743
|
return HoistableDeclaration$0(state);
|
|
2780
2744
|
}
|
|
2781
2745
|
}
|
|
2782
|
-
var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__,
|
|
2783
|
-
var LexicalDeclaration$1 = $S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression)
|
|
2746
|
+
var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__, Comma, __, LexicalBinding)));
|
|
2747
|
+
var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
2748
|
+
var c = $1;
|
|
2749
|
+
var ca = $5;
|
|
2750
|
+
c.$loc = {
|
|
2751
|
+
pos: ca.$loc.pos - 1,
|
|
2752
|
+
length: ca.$loc.length + 1
|
|
2753
|
+
};
|
|
2754
|
+
return $0;
|
|
2755
|
+
});
|
|
2784
2756
|
function LexicalDeclaration(state) {
|
|
2785
2757
|
if (state.tokenize) {
|
|
2786
2758
|
return $TOKEN("LexicalDeclaration", state, LexicalDeclaration$0(state) || LexicalDeclaration$1(state));
|
|
@@ -2788,7 +2760,7 @@ var Civet = (() => {
|
|
|
2788
2760
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
2789
2761
|
}
|
|
2790
2762
|
}
|
|
2791
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
2763
|
+
var ConstAssignment$0 = $TV($EXPECT($L87, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
2792
2764
|
return { $loc, token: "=" };
|
|
2793
2765
|
});
|
|
2794
2766
|
function ConstAssignment(state) {
|
|
@@ -2809,7 +2781,7 @@ var Civet = (() => {
|
|
|
2809
2781
|
return LexicalBinding$0(state) || LexicalBinding$1(state);
|
|
2810
2782
|
}
|
|
2811
2783
|
}
|
|
2812
|
-
var Initializer$0 = $S(__,
|
|
2784
|
+
var Initializer$0 = $S(__, Equals, AssignmentExpression);
|
|
2813
2785
|
function Initializer(state) {
|
|
2814
2786
|
if (state.verbose)
|
|
2815
2787
|
console.log("ENTER:", "Initializer");
|
|
@@ -2819,7 +2791,7 @@ var Civet = (() => {
|
|
|
2819
2791
|
return Initializer$0(state);
|
|
2820
2792
|
}
|
|
2821
2793
|
}
|
|
2822
|
-
var VariableStatement$0 = $S(
|
|
2794
|
+
var VariableStatement$0 = $S(Var, __, VariableDeclarationList);
|
|
2823
2795
|
function VariableStatement(state) {
|
|
2824
2796
|
if (state.verbose)
|
|
2825
2797
|
console.log("ENTER:", "VariableStatement");
|
|
@@ -2829,7 +2801,7 @@ var Civet = (() => {
|
|
|
2829
2801
|
return VariableStatement$0(state);
|
|
2830
2802
|
}
|
|
2831
2803
|
}
|
|
2832
|
-
var VariableDeclarationList$0 = $S(VariableDeclaration, $Q($S(__,
|
|
2804
|
+
var VariableDeclarationList$0 = $S(VariableDeclaration, $Q($S(__, Comma, __, VariableDeclaration)));
|
|
2833
2805
|
function VariableDeclarationList(state) {
|
|
2834
2806
|
if (state.verbose)
|
|
2835
2807
|
console.log("ENTER:", "VariableDeclarationList");
|
|
@@ -2872,7 +2844,7 @@ var Civet = (() => {
|
|
|
2872
2844
|
return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
|
|
2873
2845
|
}
|
|
2874
2846
|
}
|
|
2875
|
-
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($
|
|
2847
|
+
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R4, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
2876
2848
|
function DecimalBigIntegerLiteral(state) {
|
|
2877
2849
|
if (state.verbose)
|
|
2878
2850
|
console.log("ENTER:", "DecimalBigIntegerLiteral");
|
|
@@ -2882,7 +2854,7 @@ var Civet = (() => {
|
|
|
2882
2854
|
return DecimalBigIntegerLiteral$0(state);
|
|
2883
2855
|
}
|
|
2884
2856
|
}
|
|
2885
|
-
var DecimalLiteral$0 = $R$0($EXPECT($
|
|
2857
|
+
var DecimalLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
|
|
2886
2858
|
function DecimalLiteral(state) {
|
|
2887
2859
|
if (state.verbose)
|
|
2888
2860
|
console.log("ENTER:", "DecimalLiteral");
|
|
@@ -2892,7 +2864,7 @@ var Civet = (() => {
|
|
|
2892
2864
|
return DecimalLiteral$0(state);
|
|
2893
2865
|
}
|
|
2894
2866
|
}
|
|
2895
|
-
var BinaryIntegerLiteral$0 = $R$0($EXPECT($
|
|
2867
|
+
var BinaryIntegerLiteral$0 = $R$0($EXPECT($R6, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
|
|
2896
2868
|
function BinaryIntegerLiteral(state) {
|
|
2897
2869
|
if (state.verbose)
|
|
2898
2870
|
console.log("ENTER:", "BinaryIntegerLiteral");
|
|
@@ -2902,7 +2874,7 @@ var Civet = (() => {
|
|
|
2902
2874
|
return BinaryIntegerLiteral$0(state);
|
|
2903
2875
|
}
|
|
2904
2876
|
}
|
|
2905
|
-
var OctalIntegerLiteral$0 = $R$0($EXPECT($
|
|
2877
|
+
var OctalIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*/"));
|
|
2906
2878
|
function OctalIntegerLiteral(state) {
|
|
2907
2879
|
if (state.verbose)
|
|
2908
2880
|
console.log("ENTER:", "OctalIntegerLiteral");
|
|
@@ -2912,7 +2884,7 @@ var Civet = (() => {
|
|
|
2912
2884
|
return OctalIntegerLiteral$0(state);
|
|
2913
2885
|
}
|
|
2914
2886
|
}
|
|
2915
|
-
var HexLiteral$0 = $R$0($EXPECT($
|
|
2887
|
+
var HexLiteral$0 = $R$0($EXPECT($R8, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*/"));
|
|
2916
2888
|
function HexLiteral(state) {
|
|
2917
2889
|
if (state.verbose)
|
|
2918
2890
|
console.log("ENTER:", "HexLiteral");
|
|
@@ -2922,18 +2894,22 @@ var Civet = (() => {
|
|
|
2922
2894
|
return HexLiteral$0(state);
|
|
2923
2895
|
}
|
|
2924
2896
|
}
|
|
2925
|
-
var StringLiteral$0 = $TS($S(
|
|
2897
|
+
var StringLiteral$0 = $TS($S(TripleDoubleQuote, TripleDoubleStringCharacters, TripleDoubleQuote), function($skip, $loc, $0, $1, $2, $3) {
|
|
2898
|
+
var s = $1;
|
|
2926
2899
|
var str = $2;
|
|
2927
|
-
|
|
2900
|
+
var e = $3;
|
|
2901
|
+
return [s, module.dedentBlockString(str), e];
|
|
2928
2902
|
});
|
|
2929
|
-
var StringLiteral$1 = $TS($S(
|
|
2903
|
+
var StringLiteral$1 = $TS($S(TripleSingleQuote, TripleSingleStringCharacters, TripleSingleQuote), function($skip, $loc, $0, $1, $2, $3) {
|
|
2904
|
+
var s = $1;
|
|
2930
2905
|
var str = $2;
|
|
2931
|
-
|
|
2906
|
+
var e = $3;
|
|
2907
|
+
return [s, module.dedentBlockString(str), e];
|
|
2932
2908
|
});
|
|
2933
|
-
var StringLiteral$2 = $TV($TEXT($S($EXPECT($
|
|
2909
|
+
var StringLiteral$2 = $TV($TEXT($S($EXPECT($L88, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L88, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
|
|
2934
2910
|
return { $loc, token: $1 };
|
|
2935
2911
|
});
|
|
2936
|
-
var StringLiteral$3 = $TV($TEXT($S($EXPECT($
|
|
2912
|
+
var StringLiteral$3 = $TV($TEXT($S($EXPECT($L89, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L89, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
|
|
2937
2913
|
return { $loc, token: $1 };
|
|
2938
2914
|
});
|
|
2939
2915
|
function StringLiteral(state) {
|
|
@@ -2943,7 +2919,7 @@ var Civet = (() => {
|
|
|
2943
2919
|
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
|
|
2944
2920
|
}
|
|
2945
2921
|
}
|
|
2946
|
-
var DoubleStringCharacter$0 = $R$0($EXPECT($
|
|
2922
|
+
var DoubleStringCharacter$0 = $R$0($EXPECT($R9, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
|
|
2947
2923
|
function DoubleStringCharacter(state) {
|
|
2948
2924
|
if (state.verbose)
|
|
2949
2925
|
console.log("ENTER:", "DoubleStringCharacter");
|
|
@@ -2953,7 +2929,7 @@ var Civet = (() => {
|
|
|
2953
2929
|
return DoubleStringCharacter$0(state);
|
|
2954
2930
|
}
|
|
2955
2931
|
}
|
|
2956
|
-
var SingleStringCharacter$0 = $R$0($EXPECT($
|
|
2932
|
+
var SingleStringCharacter$0 = $R$0($EXPECT($R10, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
|
|
2957
2933
|
function SingleStringCharacter(state) {
|
|
2958
2934
|
if (state.verbose)
|
|
2959
2935
|
console.log("ENTER:", "SingleStringCharacter");
|
|
@@ -2963,27 +2939,31 @@ var Civet = (() => {
|
|
|
2963
2939
|
return SingleStringCharacter$0(state);
|
|
2964
2940
|
}
|
|
2965
2941
|
}
|
|
2966
|
-
var
|
|
2967
|
-
|
|
2942
|
+
var TripleDoubleStringCharacters$0 = $TR($EXPECT($R11, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
2943
|
+
return { $loc, token: $0 };
|
|
2944
|
+
});
|
|
2945
|
+
function TripleDoubleStringCharacters(state) {
|
|
2968
2946
|
if (state.verbose)
|
|
2969
|
-
console.log("ENTER:", "
|
|
2947
|
+
console.log("ENTER:", "TripleDoubleStringCharacters");
|
|
2970
2948
|
if (state.tokenize) {
|
|
2971
|
-
return $TOKEN("
|
|
2949
|
+
return $TOKEN("TripleDoubleStringCharacters", state, TripleDoubleStringCharacters$0(state));
|
|
2972
2950
|
} else {
|
|
2973
|
-
return
|
|
2951
|
+
return TripleDoubleStringCharacters$0(state);
|
|
2974
2952
|
}
|
|
2975
2953
|
}
|
|
2976
|
-
var
|
|
2977
|
-
|
|
2954
|
+
var TripleSingleStringCharacters$0 = $TR($EXPECT($R12, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
2955
|
+
return { $loc, token: $0 };
|
|
2956
|
+
});
|
|
2957
|
+
function TripleSingleStringCharacters(state) {
|
|
2978
2958
|
if (state.verbose)
|
|
2979
|
-
console.log("ENTER:", "
|
|
2959
|
+
console.log("ENTER:", "TripleSingleStringCharacters");
|
|
2980
2960
|
if (state.tokenize) {
|
|
2981
|
-
return $TOKEN("
|
|
2961
|
+
return $TOKEN("TripleSingleStringCharacters", state, TripleSingleStringCharacters$0(state));
|
|
2982
2962
|
} else {
|
|
2983
|
-
return
|
|
2963
|
+
return TripleSingleStringCharacters$0(state);
|
|
2984
2964
|
}
|
|
2985
2965
|
}
|
|
2986
|
-
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($
|
|
2966
|
+
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L45, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L45, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
2987
2967
|
return { $loc, token: $1 };
|
|
2988
2968
|
});
|
|
2989
2969
|
function RegularExpressionLiteral(state) {
|
|
@@ -2995,7 +2975,7 @@ var Civet = (() => {
|
|
|
2995
2975
|
return RegularExpressionLiteral$0(state);
|
|
2996
2976
|
}
|
|
2997
2977
|
}
|
|
2998
|
-
var RegularExpressionBody$0 = $S($R$0($EXPECT($
|
|
2978
|
+
var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R13, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
|
|
2999
2979
|
function RegularExpressionBody(state) {
|
|
3000
2980
|
if (state.verbose)
|
|
3001
2981
|
console.log("ENTER:", "RegularExpressionBody");
|
|
@@ -3005,7 +2985,7 @@ var Civet = (() => {
|
|
|
3005
2985
|
return RegularExpressionBody$0(state);
|
|
3006
2986
|
}
|
|
3007
2987
|
}
|
|
3008
|
-
var RegExpCharacter$0 = $R$0($EXPECT($
|
|
2988
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R14, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
3009
2989
|
function RegExpCharacter(state) {
|
|
3010
2990
|
if (state.verbose)
|
|
3011
2991
|
console.log("ENTER:", "RegExpCharacter");
|
|
@@ -3015,7 +2995,7 @@ var Civet = (() => {
|
|
|
3015
2995
|
return RegExpCharacter$0(state);
|
|
3016
2996
|
}
|
|
3017
2997
|
}
|
|
3018
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($
|
|
2998
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R15, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
3019
2999
|
function RegularExpressionFlags(state) {
|
|
3020
3000
|
if (state.verbose)
|
|
3021
3001
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -3025,7 +3005,7 @@ var Civet = (() => {
|
|
|
3025
3005
|
return RegularExpressionFlags$0(state);
|
|
3026
3006
|
}
|
|
3027
3007
|
}
|
|
3028
|
-
var TemplateLiteral$0 = $S($EXPECT($
|
|
3008
|
+
var TemplateLiteral$0 = $S($EXPECT($L90, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L90, fail, 'TemplateLiteral "`"'));
|
|
3029
3009
|
function TemplateLiteral(state) {
|
|
3030
3010
|
if (state.verbose)
|
|
3031
3011
|
console.log("ENTER:", "TemplateLiteral");
|
|
@@ -3035,7 +3015,7 @@ var Civet = (() => {
|
|
|
3035
3015
|
return TemplateLiteral$0(state);
|
|
3036
3016
|
}
|
|
3037
3017
|
}
|
|
3038
|
-
var TemplateSubstitution$0 = $S($EXPECT($
|
|
3018
|
+
var TemplateSubstitution$0 = $S($EXPECT($L91, fail, 'TemplateSubstitution "${"'), __, Expression, __, CloseBrace);
|
|
3039
3019
|
function TemplateSubstitution(state) {
|
|
3040
3020
|
if (state.verbose)
|
|
3041
3021
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -3045,7 +3025,7 @@ var Civet = (() => {
|
|
|
3045
3025
|
return TemplateSubstitution$0(state);
|
|
3046
3026
|
}
|
|
3047
3027
|
}
|
|
3048
|
-
var TemplateCharacters$0 = $R$0($EXPECT($
|
|
3028
|
+
var TemplateCharacters$0 = $R$0($EXPECT($R16, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
|
|
3049
3029
|
function TemplateCharacters(state) {
|
|
3050
3030
|
if (state.verbose)
|
|
3051
3031
|
console.log("ENTER:", "TemplateCharacters");
|
|
@@ -3055,7 +3035,7 @@ var Civet = (() => {
|
|
|
3055
3035
|
return TemplateCharacters$0(state);
|
|
3056
3036
|
}
|
|
3057
3037
|
}
|
|
3058
|
-
var ReservedWord$0 = $R$0($EXPECT($
|
|
3038
|
+
var ReservedWord$0 = $R$0($EXPECT($R17, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
3059
3039
|
function ReservedWord(state) {
|
|
3060
3040
|
if (state.verbose)
|
|
3061
3041
|
console.log("ENTER:", "ReservedWord");
|
|
@@ -3074,7 +3054,9 @@ var Civet = (() => {
|
|
|
3074
3054
|
return Comment$0(state) || Comment$1(state);
|
|
3075
3055
|
}
|
|
3076
3056
|
}
|
|
3077
|
-
var SingleLineComment$0 = $
|
|
3057
|
+
var SingleLineComment$0 = $TR($EXPECT($R18, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3058
|
+
return { $loc, token: $0 };
|
|
3059
|
+
});
|
|
3078
3060
|
var SingleLineComment$1 = CoffeeSingleLineComment;
|
|
3079
3061
|
function SingleLineComment(state) {
|
|
3080
3062
|
if (state.tokenize) {
|
|
@@ -3092,7 +3074,9 @@ var Civet = (() => {
|
|
|
3092
3074
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
3093
3075
|
}
|
|
3094
3076
|
}
|
|
3095
|
-
var JSMultiLineComment$0 = $S($EXPECT($
|
|
3077
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L92, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L93, fail, 'JSMultiLineComment "*/"')), $EXPECT($R19, fail, "JSMultiLineComment /./"))), $EXPECT($L93, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
3078
|
+
return { $loc, token: $1 };
|
|
3079
|
+
});
|
|
3096
3080
|
function JSMultiLineComment(state) {
|
|
3097
3081
|
if (state.verbose)
|
|
3098
3082
|
console.log("ENTER:", "JSMultiLineComment");
|
|
@@ -3102,10 +3086,10 @@ var Civet = (() => {
|
|
|
3102
3086
|
return JSMultiLineComment$0(state);
|
|
3103
3087
|
}
|
|
3104
3088
|
}
|
|
3105
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
3089
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R20, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3106
3090
|
if (!module.coffeeCompat)
|
|
3107
3091
|
return $skip;
|
|
3108
|
-
return
|
|
3092
|
+
return { $loc, token: `//${$1}` };
|
|
3109
3093
|
});
|
|
3110
3094
|
function CoffeeSingleLineComment(state) {
|
|
3111
3095
|
if (state.verbose)
|
|
@@ -3116,8 +3100,8 @@ var Civet = (() => {
|
|
|
3116
3100
|
return CoffeeSingleLineComment$0(state);
|
|
3117
3101
|
}
|
|
3118
3102
|
}
|
|
3119
|
-
var CoffeeMultiLineComment$0 = $
|
|
3120
|
-
return
|
|
3103
|
+
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L94, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L94, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L93, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R19, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L94, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3104
|
+
return { $loc, token: `/*${$2}*/` };
|
|
3121
3105
|
});
|
|
3122
3106
|
function CoffeeMultiLineComment(state) {
|
|
3123
3107
|
if (state.verbose)
|
|
@@ -3128,7 +3112,9 @@ var Civet = (() => {
|
|
|
3128
3112
|
return CoffeeMultiLineComment$0(state);
|
|
3129
3113
|
}
|
|
3130
3114
|
}
|
|
3131
|
-
var InlineComment$0 = $S($EXPECT($
|
|
3115
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L92, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L93, fail, 'InlineComment "*/"')), $EXPECT($R21, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L93, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
3116
|
+
return { $loc, token: $1 };
|
|
3117
|
+
});
|
|
3132
3118
|
function InlineComment(state) {
|
|
3133
3119
|
if (state.verbose)
|
|
3134
3120
|
console.log("ENTER:", "InlineComment");
|
|
@@ -3138,7 +3124,7 @@ var Civet = (() => {
|
|
|
3138
3124
|
return InlineComment$0(state);
|
|
3139
3125
|
}
|
|
3140
3126
|
}
|
|
3141
|
-
var RestOfLine$0 = $S($Q($C($R$0($EXPECT($
|
|
3127
|
+
var RestOfLine$0 = $S($Q($C($R$0($EXPECT($R22, fail, "RestOfLine /[ \\t]+/")), SingleLineComment, MultiLineComment)), EOL);
|
|
3142
3128
|
function RestOfLine(state) {
|
|
3143
3129
|
if (state.verbose)
|
|
3144
3130
|
console.log("ENTER:", "RestOfLine");
|
|
@@ -3148,7 +3134,7 @@ var Civet = (() => {
|
|
|
3148
3134
|
return RestOfLine$0(state);
|
|
3149
3135
|
}
|
|
3150
3136
|
}
|
|
3151
|
-
var TrailingComment$0 = $R$0($EXPECT($
|
|
3137
|
+
var TrailingComment$0 = $R$0($EXPECT($R23, fail, "TrailingComment /[\\t ]+/"));
|
|
3152
3138
|
var TrailingComment$1 = InlineComment;
|
|
3153
3139
|
var TrailingComment$2 = SingleLineComment;
|
|
3154
3140
|
function TrailingComment(state) {
|
|
@@ -3158,7 +3144,7 @@ var Civet = (() => {
|
|
|
3158
3144
|
return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
|
|
3159
3145
|
}
|
|
3160
3146
|
}
|
|
3161
|
-
var _$0 = $P($C(
|
|
3147
|
+
var _$0 = $P($C(NonNewlineWhitespace, Comment));
|
|
3162
3148
|
function _(state) {
|
|
3163
3149
|
if (state.verbose)
|
|
3164
3150
|
console.log("ENTER:", "_");
|
|
@@ -3168,7 +3154,19 @@ var Civet = (() => {
|
|
|
3168
3154
|
return _$0(state);
|
|
3169
3155
|
}
|
|
3170
3156
|
}
|
|
3171
|
-
var
|
|
3157
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R22, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3158
|
+
return { $loc, token: $0 };
|
|
3159
|
+
});
|
|
3160
|
+
function NonNewlineWhitespace(state) {
|
|
3161
|
+
if (state.verbose)
|
|
3162
|
+
console.log("ENTER:", "NonNewlineWhitespace");
|
|
3163
|
+
if (state.tokenize) {
|
|
3164
|
+
return $TOKEN("NonNewlineWhitespace", state, NonNewlineWhitespace$0(state));
|
|
3165
|
+
} else {
|
|
3166
|
+
return NonNewlineWhitespace$0(state);
|
|
3167
|
+
}
|
|
3168
|
+
}
|
|
3169
|
+
var __$0 = $Q($C(Whitespace, Comment));
|
|
3172
3170
|
function __(state) {
|
|
3173
3171
|
if (state.verbose)
|
|
3174
3172
|
console.log("ENTER:", "__");
|
|
@@ -3178,9 +3176,21 @@ var Civet = (() => {
|
|
|
3178
3176
|
return __$0(state);
|
|
3179
3177
|
}
|
|
3180
3178
|
}
|
|
3181
|
-
var
|
|
3182
|
-
|
|
3183
|
-
|
|
3179
|
+
var Whitespace$0 = $TR($EXPECT($R24, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3180
|
+
return { $loc, token: $0 };
|
|
3181
|
+
});
|
|
3182
|
+
function Whitespace(state) {
|
|
3183
|
+
if (state.verbose)
|
|
3184
|
+
console.log("ENTER:", "Whitespace");
|
|
3185
|
+
if (state.tokenize) {
|
|
3186
|
+
return $TOKEN("Whitespace", state, Whitespace$0(state));
|
|
3187
|
+
} else {
|
|
3188
|
+
return Whitespace$0(state);
|
|
3189
|
+
}
|
|
3190
|
+
}
|
|
3191
|
+
var StatementDelimiter$0 = $S($Q(TrailingComment), Semicolon, $Q(TrailingComment));
|
|
3192
|
+
var StatementDelimiter$1 = $TS($S($EXPECT($L16, fail, 'StatementDelimiter ""'), $Y(EOS)), function($skip, $loc, $0, $1, $2) {
|
|
3193
|
+
return { $loc, token: ";" };
|
|
3184
3194
|
});
|
|
3185
3195
|
function StatementDelimiter(state) {
|
|
3186
3196
|
if (state.tokenize) {
|
|
@@ -3189,7 +3199,7 @@ var Civet = (() => {
|
|
|
3189
3199
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
3190
3200
|
}
|
|
3191
3201
|
}
|
|
3192
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3202
|
+
var NonIdContinue$0 = $R$0($EXPECT($R25, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
3193
3203
|
function NonIdContinue(state) {
|
|
3194
3204
|
if (state.verbose)
|
|
3195
3205
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -3199,6 +3209,462 @@ var Civet = (() => {
|
|
|
3199
3209
|
return NonIdContinue$0(state);
|
|
3200
3210
|
}
|
|
3201
3211
|
}
|
|
3212
|
+
var Loc$0 = $TV($EXPECT($L16, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
|
|
3213
|
+
return { $loc, token: "" };
|
|
3214
|
+
});
|
|
3215
|
+
function Loc(state) {
|
|
3216
|
+
if (state.verbose)
|
|
3217
|
+
console.log("ENTER:", "Loc");
|
|
3218
|
+
if (state.tokenize) {
|
|
3219
|
+
return $TOKEN("Loc", state, Loc$0(state));
|
|
3220
|
+
} else {
|
|
3221
|
+
return Loc$0(state);
|
|
3222
|
+
}
|
|
3223
|
+
}
|
|
3224
|
+
var As$0 = $TS($S($EXPECT($L95, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3225
|
+
return { $loc, token: $1 };
|
|
3226
|
+
});
|
|
3227
|
+
function As(state) {
|
|
3228
|
+
if (state.verbose)
|
|
3229
|
+
console.log("ENTER:", "As");
|
|
3230
|
+
if (state.tokenize) {
|
|
3231
|
+
return $TOKEN("As", state, As$0(state));
|
|
3232
|
+
} else {
|
|
3233
|
+
return As$0(state);
|
|
3234
|
+
}
|
|
3235
|
+
}
|
|
3236
|
+
var Async$0 = $TV($EXPECT($L96, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
|
|
3237
|
+
return { $loc, token: $1 };
|
|
3238
|
+
});
|
|
3239
|
+
function Async(state) {
|
|
3240
|
+
if (state.verbose)
|
|
3241
|
+
console.log("ENTER:", "Async");
|
|
3242
|
+
if (state.tokenize) {
|
|
3243
|
+
return $TOKEN("Async", state, Async$0(state));
|
|
3244
|
+
} else {
|
|
3245
|
+
return Async$0(state);
|
|
3246
|
+
}
|
|
3247
|
+
}
|
|
3248
|
+
var Await$0 = $TS($S($EXPECT($L97, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3249
|
+
return { $loc, token: $1 };
|
|
3250
|
+
});
|
|
3251
|
+
function Await(state) {
|
|
3252
|
+
if (state.verbose)
|
|
3253
|
+
console.log("ENTER:", "Await");
|
|
3254
|
+
if (state.tokenize) {
|
|
3255
|
+
return $TOKEN("Await", state, Await$0(state));
|
|
3256
|
+
} else {
|
|
3257
|
+
return Await$0(state);
|
|
3258
|
+
}
|
|
3259
|
+
}
|
|
3260
|
+
var Catch$0 = $TV($EXPECT($L98, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
3261
|
+
return { $loc, token: $1 };
|
|
3262
|
+
});
|
|
3263
|
+
function Catch(state) {
|
|
3264
|
+
if (state.verbose)
|
|
3265
|
+
console.log("ENTER:", "Catch");
|
|
3266
|
+
if (state.tokenize) {
|
|
3267
|
+
return $TOKEN("Catch", state, Catch$0(state));
|
|
3268
|
+
} else {
|
|
3269
|
+
return Catch$0(state);
|
|
3270
|
+
}
|
|
3271
|
+
}
|
|
3272
|
+
var Class$0 = $TV($EXPECT($L99, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
3273
|
+
return { $loc, token: $1 };
|
|
3274
|
+
});
|
|
3275
|
+
function Class(state) {
|
|
3276
|
+
if (state.verbose)
|
|
3277
|
+
console.log("ENTER:", "Class");
|
|
3278
|
+
if (state.tokenize) {
|
|
3279
|
+
return $TOKEN("Class", state, Class$0(state));
|
|
3280
|
+
} else {
|
|
3281
|
+
return Class$0(state);
|
|
3282
|
+
}
|
|
3283
|
+
}
|
|
3284
|
+
var CloseBrace$0 = $TV($EXPECT($L100, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
3285
|
+
return { $loc, token: $1 };
|
|
3286
|
+
});
|
|
3287
|
+
function CloseBrace(state) {
|
|
3288
|
+
if (state.verbose)
|
|
3289
|
+
console.log("ENTER:", "CloseBrace");
|
|
3290
|
+
if (state.tokenize) {
|
|
3291
|
+
return $TOKEN("CloseBrace", state, CloseBrace$0(state));
|
|
3292
|
+
} else {
|
|
3293
|
+
return CloseBrace$0(state);
|
|
3294
|
+
}
|
|
3295
|
+
}
|
|
3296
|
+
var CloseBracket$0 = $TV($EXPECT($L24, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
3297
|
+
return { $loc, token: $1 };
|
|
3298
|
+
});
|
|
3299
|
+
function CloseBracket(state) {
|
|
3300
|
+
if (state.verbose)
|
|
3301
|
+
console.log("ENTER:", "CloseBracket");
|
|
3302
|
+
if (state.tokenize) {
|
|
3303
|
+
return $TOKEN("CloseBracket", state, CloseBracket$0(state));
|
|
3304
|
+
} else {
|
|
3305
|
+
return CloseBracket$0(state);
|
|
3306
|
+
}
|
|
3307
|
+
}
|
|
3308
|
+
var CloseParen$0 = $TV($EXPECT($L17, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
3309
|
+
return { $loc, token: $1 };
|
|
3310
|
+
});
|
|
3311
|
+
function CloseParen(state) {
|
|
3312
|
+
if (state.verbose)
|
|
3313
|
+
console.log("ENTER:", "CloseParen");
|
|
3314
|
+
if (state.tokenize) {
|
|
3315
|
+
return $TOKEN("CloseParen", state, CloseParen$0(state));
|
|
3316
|
+
} else {
|
|
3317
|
+
return CloseParen$0(state);
|
|
3318
|
+
}
|
|
3319
|
+
}
|
|
3320
|
+
var Colon$0 = $TV($EXPECT($L101, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
3321
|
+
return { $loc, token: $1 };
|
|
3322
|
+
});
|
|
3323
|
+
function Colon(state) {
|
|
3324
|
+
if (state.verbose)
|
|
3325
|
+
console.log("ENTER:", "Colon");
|
|
3326
|
+
if (state.tokenize) {
|
|
3327
|
+
return $TOKEN("Colon", state, Colon$0(state));
|
|
3328
|
+
} else {
|
|
3329
|
+
return Colon$0(state);
|
|
3330
|
+
}
|
|
3331
|
+
}
|
|
3332
|
+
var Dot$0 = $TV($EXPECT($L102, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
3333
|
+
return { $loc, token: $1 };
|
|
3334
|
+
});
|
|
3335
|
+
function Dot(state) {
|
|
3336
|
+
if (state.verbose)
|
|
3337
|
+
console.log("ENTER:", "Dot");
|
|
3338
|
+
if (state.tokenize) {
|
|
3339
|
+
return $TOKEN("Dot", state, Dot$0(state));
|
|
3340
|
+
} else {
|
|
3341
|
+
return Dot$0(state);
|
|
3342
|
+
}
|
|
3343
|
+
}
|
|
3344
|
+
var Else$0 = $TV($EXPECT($L103, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
3345
|
+
return { $loc, token: $1 };
|
|
3346
|
+
});
|
|
3347
|
+
function Else(state) {
|
|
3348
|
+
if (state.verbose)
|
|
3349
|
+
console.log("ENTER:", "Else");
|
|
3350
|
+
if (state.tokenize) {
|
|
3351
|
+
return $TOKEN("Else", state, Else$0(state));
|
|
3352
|
+
} else {
|
|
3353
|
+
return Else$0(state);
|
|
3354
|
+
}
|
|
3355
|
+
}
|
|
3356
|
+
var Equals$0 = $TV($EXPECT($L43, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
3357
|
+
return { $loc, token: $1 };
|
|
3358
|
+
});
|
|
3359
|
+
function Equals(state) {
|
|
3360
|
+
if (state.verbose)
|
|
3361
|
+
console.log("ENTER:", "Equals");
|
|
3362
|
+
if (state.tokenize) {
|
|
3363
|
+
return $TOKEN("Equals", state, Equals$0(state));
|
|
3364
|
+
} else {
|
|
3365
|
+
return Equals$0(state);
|
|
3366
|
+
}
|
|
3367
|
+
}
|
|
3368
|
+
var Export$0 = $TS($S($EXPECT($L104, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3369
|
+
return { $loc, token: $1 };
|
|
3370
|
+
});
|
|
3371
|
+
function Export(state) {
|
|
3372
|
+
if (state.verbose)
|
|
3373
|
+
console.log("ENTER:", "Export");
|
|
3374
|
+
if (state.tokenize) {
|
|
3375
|
+
return $TOKEN("Export", state, Export$0(state));
|
|
3376
|
+
} else {
|
|
3377
|
+
return Export$0(state);
|
|
3378
|
+
}
|
|
3379
|
+
}
|
|
3380
|
+
var For$0 = $TS($S($EXPECT($L105, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3381
|
+
return { $loc, token: $1 };
|
|
3382
|
+
});
|
|
3383
|
+
function For(state) {
|
|
3384
|
+
if (state.verbose)
|
|
3385
|
+
console.log("ENTER:", "For");
|
|
3386
|
+
if (state.tokenize) {
|
|
3387
|
+
return $TOKEN("For", state, For$0(state));
|
|
3388
|
+
} else {
|
|
3389
|
+
return For$0(state);
|
|
3390
|
+
}
|
|
3391
|
+
}
|
|
3392
|
+
var From$0 = $TS($S($EXPECT($L106, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3393
|
+
return { $loc, token: $1 };
|
|
3394
|
+
});
|
|
3395
|
+
function From(state) {
|
|
3396
|
+
if (state.verbose)
|
|
3397
|
+
console.log("ENTER:", "From");
|
|
3398
|
+
if (state.tokenize) {
|
|
3399
|
+
return $TOKEN("From", state, From$0(state));
|
|
3400
|
+
} else {
|
|
3401
|
+
return From$0(state);
|
|
3402
|
+
}
|
|
3403
|
+
}
|
|
3404
|
+
var Function$0 = $TV($EXPECT($L107, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
3405
|
+
return { $loc, token: $1 };
|
|
3406
|
+
});
|
|
3407
|
+
function Function(state) {
|
|
3408
|
+
if (state.verbose)
|
|
3409
|
+
console.log("ENTER:", "Function");
|
|
3410
|
+
if (state.tokenize) {
|
|
3411
|
+
return $TOKEN("Function", state, Function$0(state));
|
|
3412
|
+
} else {
|
|
3413
|
+
return Function$0(state);
|
|
3414
|
+
}
|
|
3415
|
+
}
|
|
3416
|
+
var If$0 = $TV($EXPECT($L108, fail, 'If "if"'), function($skip, $loc, $0, $1) {
|
|
3417
|
+
return { $loc, token: $1 };
|
|
3418
|
+
});
|
|
3419
|
+
function If(state) {
|
|
3420
|
+
if (state.verbose)
|
|
3421
|
+
console.log("ENTER:", "If");
|
|
3422
|
+
if (state.tokenize) {
|
|
3423
|
+
return $TOKEN("If", state, If$0(state));
|
|
3424
|
+
} else {
|
|
3425
|
+
return If$0(state);
|
|
3426
|
+
}
|
|
3427
|
+
}
|
|
3428
|
+
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R26, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
3429
|
+
return { $loc, token: $1 };
|
|
3430
|
+
});
|
|
3431
|
+
function Import(state) {
|
|
3432
|
+
if (state.verbose)
|
|
3433
|
+
console.log("ENTER:", "Import");
|
|
3434
|
+
if (state.tokenize) {
|
|
3435
|
+
return $TOKEN("Import", state, Import$0(state));
|
|
3436
|
+
} else {
|
|
3437
|
+
return Import$0(state);
|
|
3438
|
+
}
|
|
3439
|
+
}
|
|
3440
|
+
var In$0 = $TV($EXPECT($L66, fail, 'In "in"'), function($skip, $loc, $0, $1) {
|
|
3441
|
+
return { $loc, token: $1 };
|
|
3442
|
+
});
|
|
3443
|
+
function In(state) {
|
|
3444
|
+
if (state.verbose)
|
|
3445
|
+
console.log("ENTER:", "In");
|
|
3446
|
+
if (state.tokenize) {
|
|
3447
|
+
return $TOKEN("In", state, In$0(state));
|
|
3448
|
+
} else {
|
|
3449
|
+
return In$0(state);
|
|
3450
|
+
}
|
|
3451
|
+
}
|
|
3452
|
+
var Loop$0 = $TS($S($EXPECT($L109, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3453
|
+
return { $loc, token: "while(true)" };
|
|
3454
|
+
});
|
|
3455
|
+
function Loop(state) {
|
|
3456
|
+
if (state.verbose)
|
|
3457
|
+
console.log("ENTER:", "Loop");
|
|
3458
|
+
if (state.tokenize) {
|
|
3459
|
+
return $TOKEN("Loop", state, Loop$0(state));
|
|
3460
|
+
} else {
|
|
3461
|
+
return Loop$0(state);
|
|
3462
|
+
}
|
|
3463
|
+
}
|
|
3464
|
+
var New$0 = $TV($EXPECT($L110, fail, 'New "new"'), function($skip, $loc, $0, $1) {
|
|
3465
|
+
return { $loc, token: $1 };
|
|
3466
|
+
});
|
|
3467
|
+
function New(state) {
|
|
3468
|
+
if (state.verbose)
|
|
3469
|
+
console.log("ENTER:", "New");
|
|
3470
|
+
if (state.tokenize) {
|
|
3471
|
+
return $TOKEN("New", state, New$0(state));
|
|
3472
|
+
} else {
|
|
3473
|
+
return New$0(state);
|
|
3474
|
+
}
|
|
3475
|
+
}
|
|
3476
|
+
var Of$0 = $TV($EXPECT($L111, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
3477
|
+
return { $loc, token: $1 };
|
|
3478
|
+
});
|
|
3479
|
+
function Of(state) {
|
|
3480
|
+
if (state.verbose)
|
|
3481
|
+
console.log("ENTER:", "Of");
|
|
3482
|
+
if (state.tokenize) {
|
|
3483
|
+
return $TOKEN("Of", state, Of$0(state));
|
|
3484
|
+
} else {
|
|
3485
|
+
return Of$0(state);
|
|
3486
|
+
}
|
|
3487
|
+
}
|
|
3488
|
+
var OpenBrace$0 = $TV($EXPECT($L112, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
3489
|
+
return { $loc, token: $1 };
|
|
3490
|
+
});
|
|
3491
|
+
function OpenBrace(state) {
|
|
3492
|
+
if (state.verbose)
|
|
3493
|
+
console.log("ENTER:", "OpenBrace");
|
|
3494
|
+
if (state.tokenize) {
|
|
3495
|
+
return $TOKEN("OpenBrace", state, OpenBrace$0(state));
|
|
3496
|
+
} else {
|
|
3497
|
+
return OpenBrace$0(state);
|
|
3498
|
+
}
|
|
3499
|
+
}
|
|
3500
|
+
var OpenBracket$0 = $TV($EXPECT($L113, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
3501
|
+
return { $loc, token: $1 };
|
|
3502
|
+
});
|
|
3503
|
+
function OpenBracket(state) {
|
|
3504
|
+
if (state.verbose)
|
|
3505
|
+
console.log("ENTER:", "OpenBracket");
|
|
3506
|
+
if (state.tokenize) {
|
|
3507
|
+
return $TOKEN("OpenBracket", state, OpenBracket$0(state));
|
|
3508
|
+
} else {
|
|
3509
|
+
return OpenBracket$0(state);
|
|
3510
|
+
}
|
|
3511
|
+
}
|
|
3512
|
+
var OpenParen$0 = $TV($EXPECT($L114, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
3513
|
+
return { $loc, token: $1 };
|
|
3514
|
+
});
|
|
3515
|
+
function OpenParen(state) {
|
|
3516
|
+
if (state.verbose)
|
|
3517
|
+
console.log("ENTER:", "OpenParen");
|
|
3518
|
+
if (state.tokenize) {
|
|
3519
|
+
return $TOKEN("OpenParen", state, OpenParen$0(state));
|
|
3520
|
+
} else {
|
|
3521
|
+
return OpenParen$0(state);
|
|
3522
|
+
}
|
|
3523
|
+
}
|
|
3524
|
+
var QuestionMark$0 = $TV($EXPECT($L115, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
3525
|
+
return { $loc, token: $1 };
|
|
3526
|
+
});
|
|
3527
|
+
function QuestionMark(state) {
|
|
3528
|
+
if (state.verbose)
|
|
3529
|
+
console.log("ENTER:", "QuestionMark");
|
|
3530
|
+
if (state.tokenize) {
|
|
3531
|
+
return $TOKEN("QuestionMark", state, QuestionMark$0(state));
|
|
3532
|
+
} else {
|
|
3533
|
+
return QuestionMark$0(state);
|
|
3534
|
+
}
|
|
3535
|
+
}
|
|
3536
|
+
var Return$0 = $TS($S($EXPECT($L116, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3537
|
+
return { $loc, token: $1 };
|
|
3538
|
+
});
|
|
3539
|
+
function Return(state) {
|
|
3540
|
+
if (state.verbose)
|
|
3541
|
+
console.log("ENTER:", "Return");
|
|
3542
|
+
if (state.tokenize) {
|
|
3543
|
+
return $TOKEN("Return", state, Return$0(state));
|
|
3544
|
+
} else {
|
|
3545
|
+
return Return$0(state);
|
|
3546
|
+
}
|
|
3547
|
+
}
|
|
3548
|
+
var Semicolon$0 = $TV($EXPECT($L73, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
3549
|
+
return { $loc, token: $1 };
|
|
3550
|
+
});
|
|
3551
|
+
function Semicolon(state) {
|
|
3552
|
+
if (state.verbose)
|
|
3553
|
+
console.log("ENTER:", "Semicolon");
|
|
3554
|
+
if (state.tokenize) {
|
|
3555
|
+
return $TOKEN("Semicolon", state, Semicolon$0(state));
|
|
3556
|
+
} else {
|
|
3557
|
+
return Semicolon$0(state);
|
|
3558
|
+
}
|
|
3559
|
+
}
|
|
3560
|
+
var Static$0 = $TV($EXPECT($L117, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
3561
|
+
return { $loc, token: $1 };
|
|
3562
|
+
});
|
|
3563
|
+
function Static(state) {
|
|
3564
|
+
if (state.verbose)
|
|
3565
|
+
console.log("ENTER:", "Static");
|
|
3566
|
+
if (state.tokenize) {
|
|
3567
|
+
return $TOKEN("Static", state, Static$0(state));
|
|
3568
|
+
} else {
|
|
3569
|
+
return Static$0(state);
|
|
3570
|
+
}
|
|
3571
|
+
}
|
|
3572
|
+
var Switch$0 = $TV($EXPECT($L118, fail, 'Switch "switch"'), function($skip, $loc, $0, $1) {
|
|
3573
|
+
return { $loc, token: $1 };
|
|
3574
|
+
});
|
|
3575
|
+
function Switch(state) {
|
|
3576
|
+
if (state.verbose)
|
|
3577
|
+
console.log("ENTER:", "Switch");
|
|
3578
|
+
if (state.tokenize) {
|
|
3579
|
+
return $TOKEN("Switch", state, Switch$0(state));
|
|
3580
|
+
} else {
|
|
3581
|
+
return Switch$0(state);
|
|
3582
|
+
}
|
|
3583
|
+
}
|
|
3584
|
+
var Target$0 = $TV($EXPECT($L119, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
|
|
3585
|
+
return { $loc, token: $1 };
|
|
3586
|
+
});
|
|
3587
|
+
function Target(state) {
|
|
3588
|
+
if (state.verbose)
|
|
3589
|
+
console.log("ENTER:", "Target");
|
|
3590
|
+
if (state.tokenize) {
|
|
3591
|
+
return $TOKEN("Target", state, Target$0(state));
|
|
3592
|
+
} else {
|
|
3593
|
+
return Target$0(state);
|
|
3594
|
+
}
|
|
3595
|
+
}
|
|
3596
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L120, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
3597
|
+
return { $loc, token: "`" };
|
|
3598
|
+
});
|
|
3599
|
+
function TripleDoubleQuote(state) {
|
|
3600
|
+
if (state.verbose)
|
|
3601
|
+
console.log("ENTER:", "TripleDoubleQuote");
|
|
3602
|
+
if (state.tokenize) {
|
|
3603
|
+
return $TOKEN("TripleDoubleQuote", state, TripleDoubleQuote$0(state));
|
|
3604
|
+
} else {
|
|
3605
|
+
return TripleDoubleQuote$0(state);
|
|
3606
|
+
}
|
|
3607
|
+
}
|
|
3608
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L121, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
3609
|
+
return { $loc, token: "`" };
|
|
3610
|
+
});
|
|
3611
|
+
function TripleSingleQuote(state) {
|
|
3612
|
+
if (state.verbose)
|
|
3613
|
+
console.log("ENTER:", "TripleSingleQuote");
|
|
3614
|
+
if (state.tokenize) {
|
|
3615
|
+
return $TOKEN("TripleSingleQuote", state, TripleSingleQuote$0(state));
|
|
3616
|
+
} else {
|
|
3617
|
+
return TripleSingleQuote$0(state);
|
|
3618
|
+
}
|
|
3619
|
+
}
|
|
3620
|
+
var Try$0 = $TV($EXPECT($L122, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
3621
|
+
return { $loc, token: $1 };
|
|
3622
|
+
});
|
|
3623
|
+
function Try(state) {
|
|
3624
|
+
if (state.verbose)
|
|
3625
|
+
console.log("ENTER:", "Try");
|
|
3626
|
+
if (state.tokenize) {
|
|
3627
|
+
return $TOKEN("Try", state, Try$0(state));
|
|
3628
|
+
} else {
|
|
3629
|
+
return Try$0(state);
|
|
3630
|
+
}
|
|
3631
|
+
}
|
|
3632
|
+
var Unless$0 = $TV($EXPECT($L123, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
3633
|
+
return { $loc, token: $1 };
|
|
3634
|
+
});
|
|
3635
|
+
function Unless(state) {
|
|
3636
|
+
if (state.verbose)
|
|
3637
|
+
console.log("ENTER:", "Unless");
|
|
3638
|
+
if (state.tokenize) {
|
|
3639
|
+
return $TOKEN("Unless", state, Unless$0(state));
|
|
3640
|
+
} else {
|
|
3641
|
+
return Unless$0(state);
|
|
3642
|
+
}
|
|
3643
|
+
}
|
|
3644
|
+
var Var$0 = $TV($EXPECT($L124, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
3645
|
+
return { $loc, token: $1 };
|
|
3646
|
+
});
|
|
3647
|
+
function Var(state) {
|
|
3648
|
+
if (state.verbose)
|
|
3649
|
+
console.log("ENTER:", "Var");
|
|
3650
|
+
if (state.tokenize) {
|
|
3651
|
+
return $TOKEN("Var", state, Var$0(state));
|
|
3652
|
+
} else {
|
|
3653
|
+
return Var$0(state);
|
|
3654
|
+
}
|
|
3655
|
+
}
|
|
3656
|
+
var When$0 = $TS($S($EXPECT($L125, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3657
|
+
return { $loc, token: "case" };
|
|
3658
|
+
});
|
|
3659
|
+
function When(state) {
|
|
3660
|
+
if (state.verbose)
|
|
3661
|
+
console.log("ENTER:", "When");
|
|
3662
|
+
if (state.tokenize) {
|
|
3663
|
+
return $TOKEN("When", state, When$0(state));
|
|
3664
|
+
} else {
|
|
3665
|
+
return When$0(state);
|
|
3666
|
+
}
|
|
3667
|
+
}
|
|
3202
3668
|
var JSXElement$0 = JSXSelfClosingElement;
|
|
3203
3669
|
var JSXElement$1 = $TS($S(JSXOpeningElement, $Q(JSXChildren), __, JSXClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
3204
3670
|
if ($1[1] !== $4[2]) {
|
|
@@ -3213,7 +3679,7 @@ var Civet = (() => {
|
|
|
3213
3679
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
3214
3680
|
}
|
|
3215
3681
|
}
|
|
3216
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($
|
|
3682
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L126, fail, 'JSXSelfClosingElement "/>"'));
|
|
3217
3683
|
function JSXSelfClosingElement(state) {
|
|
3218
3684
|
if (state.verbose)
|
|
3219
3685
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -3223,7 +3689,7 @@ var Civet = (() => {
|
|
|
3223
3689
|
return JSXSelfClosingElement$0(state);
|
|
3224
3690
|
}
|
|
3225
3691
|
}
|
|
3226
|
-
var JSXOpeningElement$0 = $S($EXPECT($
|
|
3692
|
+
var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L54, fail, 'JSXOpeningElement ">"'));
|
|
3227
3693
|
function JSXOpeningElement(state) {
|
|
3228
3694
|
if (state.verbose)
|
|
3229
3695
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -3233,7 +3699,7 @@ var Civet = (() => {
|
|
|
3233
3699
|
return JSXOpeningElement$0(state);
|
|
3234
3700
|
}
|
|
3235
3701
|
}
|
|
3236
|
-
var JSXClosingElement$0 = $S($EXPECT($L127, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($
|
|
3702
|
+
var JSXClosingElement$0 = $S($EXPECT($L127, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L54, fail, 'JSXClosingElement ">"'));
|
|
3237
3703
|
function JSXClosingElement(state) {
|
|
3238
3704
|
if (state.verbose)
|
|
3239
3705
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -3253,7 +3719,7 @@ var Civet = (() => {
|
|
|
3253
3719
|
return JSXFragment$0(state);
|
|
3254
3720
|
}
|
|
3255
3721
|
}
|
|
3256
|
-
var JSXElementName$0 = $S(JSXIdentifierName, $C($S(
|
|
3722
|
+
var JSXElementName$0 = $S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName))));
|
|
3257
3723
|
function JSXElementName(state) {
|
|
3258
3724
|
if (state.verbose)
|
|
3259
3725
|
console.log("ENTER:", "JSXElementName");
|
|
@@ -3283,7 +3749,7 @@ var Civet = (() => {
|
|
|
3283
3749
|
return JSXAttributes$0(state);
|
|
3284
3750
|
}
|
|
3285
3751
|
}
|
|
3286
|
-
var JSXAttribute$0 = $S(
|
|
3752
|
+
var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($L18, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, CloseBrace);
|
|
3287
3753
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
3288
3754
|
function JSXAttribute(state) {
|
|
3289
3755
|
if (state.tokenize) {
|
|
@@ -3292,7 +3758,7 @@ var Civet = (() => {
|
|
|
3292
3758
|
return JSXAttribute$0(state) || JSXAttribute$1(state);
|
|
3293
3759
|
}
|
|
3294
3760
|
}
|
|
3295
|
-
var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S(
|
|
3761
|
+
var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S(Colon, JSXIdentifierName)));
|
|
3296
3762
|
function JSXAttributeName(state) {
|
|
3297
3763
|
if (state.verbose)
|
|
3298
3764
|
console.log("ENTER:", "JSXAttributeName");
|
|
@@ -3302,7 +3768,7 @@ var Civet = (() => {
|
|
|
3302
3768
|
return JSXAttributeName$0(state);
|
|
3303
3769
|
}
|
|
3304
3770
|
}
|
|
3305
|
-
var JSXAttributeInitializer$0 = $S(__,
|
|
3771
|
+
var JSXAttributeInitializer$0 = $S(__, Equals, __, JSXAttributeValue);
|
|
3306
3772
|
function JSXAttributeInitializer(state) {
|
|
3307
3773
|
if (state.verbose)
|
|
3308
3774
|
console.log("ENTER:", "JSXAttributeInitializer");
|
|
@@ -3314,7 +3780,7 @@ var Civet = (() => {
|
|
|
3314
3780
|
}
|
|
3315
3781
|
var JSXAttributeValue$0 = $R$0($EXPECT($R28, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
3316
3782
|
var JSXAttributeValue$1 = $R$0($EXPECT($R29, fail, "JSXAttributeValue /'[^']*'/"));
|
|
3317
|
-
var JSXAttributeValue$2 = $S(
|
|
3783
|
+
var JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
|
|
3318
3784
|
var JSXAttributeValue$3 = JSXElement;
|
|
3319
3785
|
var JSXAttributeValue$4 = JSXFragment;
|
|
3320
3786
|
function JSXAttributeValue(state) {
|
|
@@ -3337,7 +3803,7 @@ var Civet = (() => {
|
|
|
3337
3803
|
var JSXChild$0 = JSXText;
|
|
3338
3804
|
var JSXChild$1 = JSXElement;
|
|
3339
3805
|
var JSXChild$2 = JSXFragment;
|
|
3340
|
-
var JSXChild$3 = $S(
|
|
3806
|
+
var JSXChild$3 = $S(OpenBrace, $E(JSXChildExpression), __, CloseBrace);
|
|
3341
3807
|
function JSXChild(state) {
|
|
3342
3808
|
if (state.tokenize) {
|
|
3343
3809
|
return $TOKEN("JSXChild", state, JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state));
|
|
@@ -3355,7 +3821,7 @@ var Civet = (() => {
|
|
|
3355
3821
|
return JSXText$0(state);
|
|
3356
3822
|
}
|
|
3357
3823
|
}
|
|
3358
|
-
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($
|
|
3824
|
+
var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L18, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
|
|
3359
3825
|
function JSXChildExpression(state) {
|
|
3360
3826
|
if (state.verbose)
|
|
3361
3827
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -3378,7 +3844,7 @@ var Civet = (() => {
|
|
|
3378
3844
|
}
|
|
3379
3845
|
}
|
|
3380
3846
|
var TypeDeclarationModifier$0 = $S($EXPECT($L130, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
3381
|
-
var TypeDeclarationModifier$1 =
|
|
3847
|
+
var TypeDeclarationModifier$1 = Export;
|
|
3382
3848
|
function TypeDeclarationModifier(state) {
|
|
3383
3849
|
if (state.tokenize) {
|
|
3384
3850
|
return $TOKEN("TypeDeclarationModifier", state, TypeDeclarationModifier$0(state) || TypeDeclarationModifier$1(state));
|
|
@@ -3386,7 +3852,7 @@ var Civet = (() => {
|
|
|
3386
3852
|
return TypeDeclarationModifier$0(state) || TypeDeclarationModifier$1(state);
|
|
3387
3853
|
}
|
|
3388
3854
|
}
|
|
3389
|
-
var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __,
|
|
3855
|
+
var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, Equals, __, Type);
|
|
3390
3856
|
var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, InterfaceBlock);
|
|
3391
3857
|
var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
|
|
3392
3858
|
function TypeDeclarationRest(state) {
|
|
@@ -3426,8 +3892,8 @@ var Civet = (() => {
|
|
|
3426
3892
|
return Namespace$0(state);
|
|
3427
3893
|
}
|
|
3428
3894
|
}
|
|
3429
|
-
var InterfaceBlock$0 = $S(__,
|
|
3430
|
-
var InterfaceBlock$1 = $S(__,
|
|
3895
|
+
var InterfaceBlock$0 = $S(__, OpenBrace, EOS, NestedInterfaceProperties, __, CloseBrace);
|
|
3896
|
+
var InterfaceBlock$1 = $S(__, OpenBrace, $Q($S(__, InterfaceProperty)), __, CloseBrace);
|
|
3431
3897
|
var InterfaceBlock$2 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
3432
3898
|
function InterfaceBlock(state) {
|
|
3433
3899
|
if (state.tokenize) {
|
|
@@ -3470,13 +3936,13 @@ var Civet = (() => {
|
|
|
3470
3936
|
return InterfaceProperty$0(state) || InterfaceProperty$1(state);
|
|
3471
3937
|
}
|
|
3472
3938
|
}
|
|
3473
|
-
var InterfacePropertyDelimiter$0 = $S($Q(_),
|
|
3474
|
-
var InterfacePropertyDelimiter$1 = $Y($S($Q(_),
|
|
3475
|
-
var InterfacePropertyDelimiter$2 = $
|
|
3476
|
-
return ";";
|
|
3939
|
+
var InterfacePropertyDelimiter$0 = $S($Q(_), Semicolon);
|
|
3940
|
+
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), CloseBrace));
|
|
3941
|
+
var InterfacePropertyDelimiter$2 = $TV($Y($S(__, CloseBrace)), function($skip, $loc, $0, $1) {
|
|
3942
|
+
return { $loc, token: ";" };
|
|
3477
3943
|
});
|
|
3478
|
-
var InterfacePropertyDelimiter$3 = $
|
|
3479
|
-
return ";";
|
|
3944
|
+
var InterfacePropertyDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
3945
|
+
return { $loc, token: ";" };
|
|
3480
3946
|
});
|
|
3481
3947
|
function InterfacePropertyDelimiter(state) {
|
|
3482
3948
|
if (state.tokenize) {
|
|
@@ -3485,8 +3951,8 @@ var Civet = (() => {
|
|
|
3485
3951
|
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
|
|
3486
3952
|
}
|
|
3487
3953
|
}
|
|
3488
|
-
var NamespaceBlock$0 = $S(__,
|
|
3489
|
-
var NamespaceBlock$1 = $S(__,
|
|
3954
|
+
var NamespaceBlock$0 = $S(__, OpenBrace, EOS, NestedTypeDeclarations, __, CloseBrace);
|
|
3955
|
+
var NamespaceBlock$1 = $S(__, OpenBrace, $Q($S(__, TypeDeclaration, InterfacePropertyDelimiter)), __, CloseBrace);
|
|
3490
3956
|
var NamespaceBlock$2 = $S(InsertOpenBrace, EOS, NestedTypeDeclarations, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
3491
3957
|
function NamespaceBlock(state) {
|
|
3492
3958
|
if (state.tokenize) {
|
|
@@ -3520,7 +3986,7 @@ var Civet = (() => {
|
|
|
3520
3986
|
return NestedTypeDeclaration$0(state);
|
|
3521
3987
|
}
|
|
3522
3988
|
}
|
|
3523
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L134, fail, 'TypeIndexSignature "readonly"'), __)),
|
|
3989
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L134, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R32, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
3524
3990
|
function TypeIndexSignature(state) {
|
|
3525
3991
|
if (state.verbose)
|
|
3526
3992
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -3531,7 +3997,7 @@ var Civet = (() => {
|
|
|
3531
3997
|
}
|
|
3532
3998
|
}
|
|
3533
3999
|
var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
|
|
3534
|
-
var TypeIndex$1 = $S(__, PropertyName, __,
|
|
4000
|
+
var TypeIndex$1 = $S(__, PropertyName, __, In, Type, $E($S(__, As, Type)));
|
|
3535
4001
|
function TypeIndex(state) {
|
|
3536
4002
|
if (state.tokenize) {
|
|
3537
4003
|
return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
|
|
@@ -3539,7 +4005,7 @@ var Civet = (() => {
|
|
|
3539
4005
|
return TypeIndex$0(state) || TypeIndex$1(state);
|
|
3540
4006
|
}
|
|
3541
4007
|
}
|
|
3542
|
-
var TypeSuffix$0 = $T($S($E(
|
|
4008
|
+
var TypeSuffix$0 = $T($S($E(QuestionMark), __, Colon, Type), function(value) {
|
|
3543
4009
|
return { "ts": true, "children": value };
|
|
3544
4010
|
});
|
|
3545
4011
|
function TypeSuffix(state) {
|
|
@@ -3551,7 +4017,7 @@ var Civet = (() => {
|
|
|
3551
4017
|
return TypeSuffix$0(state);
|
|
3552
4018
|
}
|
|
3553
4019
|
}
|
|
3554
|
-
var ReturnTypeSuffix$0 = $T($S(__,
|
|
4020
|
+
var ReturnTypeSuffix$0 = $T($S(__, Colon, $E($S(__, $EXPECT($L135, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
|
|
3555
4021
|
return { "ts": true, "children": value };
|
|
3556
4022
|
});
|
|
3557
4023
|
function ReturnTypeSuffix(state) {
|
|
@@ -3563,7 +4029,7 @@ var Civet = (() => {
|
|
|
3563
4029
|
return ReturnTypeSuffix$0(state);
|
|
3564
4030
|
}
|
|
3565
4031
|
}
|
|
3566
|
-
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($
|
|
4032
|
+
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L57, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
|
|
3567
4033
|
function TypePredicate(state) {
|
|
3568
4034
|
if (state.verbose)
|
|
3569
4035
|
console.log("ENTER:", "TypePredicate");
|
|
@@ -3614,7 +4080,7 @@ var Civet = (() => {
|
|
|
3614
4080
|
}
|
|
3615
4081
|
}
|
|
3616
4082
|
var TypeUnaryOp$0 = $EXPECT($L136, fail, 'TypeUnaryOp "keyof"');
|
|
3617
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
4083
|
+
var TypeUnaryOp$1 = $EXPECT($L72, fail, 'TypeUnaryOp "typeof"');
|
|
3618
4084
|
var TypeUnaryOp$2 = $EXPECT($L137, fail, 'TypeUnaryOp "infer"');
|
|
3619
4085
|
function TypeUnaryOp(state) {
|
|
3620
4086
|
if (state.tokenize) {
|
|
@@ -3623,7 +4089,7 @@ var Civet = (() => {
|
|
|
3623
4089
|
return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
|
|
3624
4090
|
}
|
|
3625
4091
|
}
|
|
3626
|
-
var TypeIndexedAccess$0 = $S(__,
|
|
4092
|
+
var TypeIndexedAccess$0 = $S(__, OpenBracket, $E(Type), __, CloseBracket);
|
|
3627
4093
|
function TypeIndexedAccess(state) {
|
|
3628
4094
|
if (state.verbose)
|
|
3629
4095
|
console.log("ENTER:", "TypeIndexedAccess");
|
|
@@ -3634,9 +4100,9 @@ var Civet = (() => {
|
|
|
3634
4100
|
}
|
|
3635
4101
|
}
|
|
3636
4102
|
var TypePrimary$0 = InterfaceBlock;
|
|
3637
|
-
var TypePrimary$1 = $S(__,
|
|
4103
|
+
var TypePrimary$1 = $S(__, OpenParen, Type, __, CloseParen);
|
|
3638
4104
|
var TypePrimary$2 = $S($Q(_), FunctionType);
|
|
3639
|
-
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S(
|
|
4105
|
+
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
|
|
3640
4106
|
var TypePrimary$4 = $S($Q(_), TypeLiteral);
|
|
3641
4107
|
function TypePrimary(state) {
|
|
3642
4108
|
if (state.tokenize) {
|
|
@@ -3645,7 +4111,7 @@ var Civet = (() => {
|
|
|
3645
4111
|
return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
|
|
3646
4112
|
}
|
|
3647
4113
|
}
|
|
3648
|
-
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($
|
|
4114
|
+
var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type)))));
|
|
3649
4115
|
function TypeConditional(state) {
|
|
3650
4116
|
if (state.verbose)
|
|
3651
4117
|
console.log("ENTER:", "TypeConditional");
|
|
@@ -3656,7 +4122,7 @@ var Civet = (() => {
|
|
|
3656
4122
|
}
|
|
3657
4123
|
}
|
|
3658
4124
|
var TypeLiteral$0 = Literal;
|
|
3659
|
-
var TypeLiteral$1 = $EXPECT($
|
|
4125
|
+
var TypeLiteral$1 = $EXPECT($L71, fail, 'TypeLiteral "void"');
|
|
3660
4126
|
var TypeLiteral$2 = $EXPECT($L138, fail, 'TypeLiteral "[]"');
|
|
3661
4127
|
function TypeLiteral(state) {
|
|
3662
4128
|
if (state.tokenize) {
|
|
@@ -3665,8 +4131,8 @@ var Civet = (() => {
|
|
|
3665
4131
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
3666
4132
|
}
|
|
3667
4133
|
}
|
|
3668
|
-
var TypeBinaryOp$0 = $EXPECT($
|
|
3669
|
-
var TypeBinaryOp$1 = $EXPECT($
|
|
4134
|
+
var TypeBinaryOp$0 = $EXPECT($L69, fail, 'TypeBinaryOp "|"');
|
|
4135
|
+
var TypeBinaryOp$1 = $EXPECT($L67, fail, 'TypeBinaryOp "&"');
|
|
3670
4136
|
function TypeBinaryOp(state) {
|
|
3671
4137
|
if (state.tokenize) {
|
|
3672
4138
|
return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
|
|
@@ -3674,7 +4140,7 @@ var Civet = (() => {
|
|
|
3674
4140
|
return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
|
|
3675
4141
|
}
|
|
3676
4142
|
}
|
|
3677
|
-
var FunctionType$0 = $S(Parameters, __, $EXPECT($
|
|
4143
|
+
var FunctionType$0 = $S(Parameters, __, $EXPECT($L4, fail, 'FunctionType "=>"'), Type);
|
|
3678
4144
|
function FunctionType(state) {
|
|
3679
4145
|
if (state.verbose)
|
|
3680
4146
|
console.log("ENTER:", "FunctionType");
|
|
@@ -3684,7 +4150,7 @@ var Civet = (() => {
|
|
|
3684
4150
|
return FunctionType$0(state);
|
|
3685
4151
|
}
|
|
3686
4152
|
}
|
|
3687
|
-
var TypeArguments$0 = $S(__, $EXPECT($
|
|
4153
|
+
var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L54, fail, 'TypeArguments ">"'));
|
|
3688
4154
|
function TypeArguments(state) {
|
|
3689
4155
|
if (state.verbose)
|
|
3690
4156
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -3694,7 +4160,7 @@ var Civet = (() => {
|
|
|
3694
4160
|
return TypeArguments$0(state);
|
|
3695
4161
|
}
|
|
3696
4162
|
}
|
|
3697
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($
|
|
4163
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L54, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
3698
4164
|
return { ts: true, children: $0 };
|
|
3699
4165
|
});
|
|
3700
4166
|
function TypeParameters(state) {
|
|
@@ -3716,7 +4182,7 @@ var Civet = (() => {
|
|
|
3716
4182
|
return TypeParameter$0(state);
|
|
3717
4183
|
}
|
|
3718
4184
|
}
|
|
3719
|
-
var TypeConstraint$0 = $S(__, $EXPECT($
|
|
4185
|
+
var TypeConstraint$0 = $S(__, $EXPECT($L6, fail, 'TypeConstraint "extends"'), Type);
|
|
3720
4186
|
function TypeConstraint(state) {
|
|
3721
4187
|
if (state.verbose)
|
|
3722
4188
|
console.log("ENTER:", "TypeConstraint");
|
|
@@ -3726,13 +4192,13 @@ var Civet = (() => {
|
|
|
3726
4192
|
return TypeConstraint$0(state);
|
|
3727
4193
|
}
|
|
3728
4194
|
}
|
|
3729
|
-
var TypeParameterDelimiter$0 = $S($Q(_),
|
|
3730
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
3731
|
-
var TypeParameterDelimiter$2 = $
|
|
3732
|
-
return ",";
|
|
4195
|
+
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
4196
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L54, fail, 'TypeParameterDelimiter ">"')));
|
|
4197
|
+
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L54, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
|
|
4198
|
+
return { $loc, token: "," };
|
|
3733
4199
|
});
|
|
3734
|
-
var TypeParameterDelimiter$3 = $
|
|
3735
|
-
return ",";
|
|
4200
|
+
var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
4201
|
+
return { $loc, token: "," };
|
|
3736
4202
|
});
|
|
3737
4203
|
function TypeParameterDelimiter(state) {
|
|
3738
4204
|
if (state.tokenize) {
|
|
@@ -3791,7 +4257,7 @@ var Civet = (() => {
|
|
|
3791
4257
|
return EOF$0(state);
|
|
3792
4258
|
}
|
|
3793
4259
|
}
|
|
3794
|
-
var Debugger$0 = $TV($EXPECT($
|
|
4260
|
+
var Debugger$0 = $TV($EXPECT($L16, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
3795
4261
|
debugger;
|
|
3796
4262
|
});
|
|
3797
4263
|
function Debugger(state) {
|
|
@@ -3803,8 +4269,8 @@ var Civet = (() => {
|
|
|
3803
4269
|
return Debugger$0(state);
|
|
3804
4270
|
}
|
|
3805
4271
|
}
|
|
3806
|
-
var InsertOpenParen$0 = $
|
|
3807
|
-
return "(";
|
|
4272
|
+
var InsertOpenParen$0 = $TV($EXPECT($L16, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
|
|
4273
|
+
return { $loc, token: "(" };
|
|
3808
4274
|
});
|
|
3809
4275
|
function InsertOpenParen(state) {
|
|
3810
4276
|
if (state.verbose)
|
|
@@ -3815,8 +4281,8 @@ var Civet = (() => {
|
|
|
3815
4281
|
return InsertOpenParen$0(state);
|
|
3816
4282
|
}
|
|
3817
4283
|
}
|
|
3818
|
-
var InsertCloseParen$0 = $
|
|
3819
|
-
return ")";
|
|
4284
|
+
var InsertCloseParen$0 = $TV($EXPECT($L16, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
|
|
4285
|
+
return { $loc, token: ")" };
|
|
3820
4286
|
});
|
|
3821
4287
|
function InsertCloseParen(state) {
|
|
3822
4288
|
if (state.verbose)
|
|
@@ -3827,8 +4293,8 @@ var Civet = (() => {
|
|
|
3827
4293
|
return InsertCloseParen$0(state);
|
|
3828
4294
|
}
|
|
3829
4295
|
}
|
|
3830
|
-
var InsertOpenBrace$0 = $
|
|
3831
|
-
return " {";
|
|
4296
|
+
var InsertOpenBrace$0 = $TV($EXPECT($L16, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
|
|
4297
|
+
return [{ $loc, token: " " }, { $loc, token: "{" }];
|
|
3832
4298
|
});
|
|
3833
4299
|
function InsertOpenBrace(state) {
|
|
3834
4300
|
if (state.verbose)
|
|
@@ -3839,8 +4305,8 @@ var Civet = (() => {
|
|
|
3839
4305
|
return InsertOpenBrace$0(state);
|
|
3840
4306
|
}
|
|
3841
4307
|
}
|
|
3842
|
-
var InsertCloseBrace$0 = $
|
|
3843
|
-
return "}";
|
|
4308
|
+
var InsertCloseBrace$0 = $TV($EXPECT($L16, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
|
|
4309
|
+
return { $loc, token: "}" };
|
|
3844
4310
|
});
|
|
3845
4311
|
function InsertCloseBrace(state) {
|
|
3846
4312
|
if (state.verbose)
|
|
@@ -3851,8 +4317,8 @@ var Civet = (() => {
|
|
|
3851
4317
|
return InsertCloseBrace$0(state);
|
|
3852
4318
|
}
|
|
3853
4319
|
}
|
|
3854
|
-
var InsertConst$0 = $
|
|
3855
|
-
return "const ";
|
|
4320
|
+
var InsertConst$0 = $TV($EXPECT($L16, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
|
|
4321
|
+
return { $loc, token: "const " };
|
|
3856
4322
|
});
|
|
3857
4323
|
function InsertConst(state) {
|
|
3858
4324
|
if (state.verbose)
|
|
@@ -3863,8 +4329,8 @@ var Civet = (() => {
|
|
|
3863
4329
|
return InsertConst$0(state);
|
|
3864
4330
|
}
|
|
3865
4331
|
}
|
|
3866
|
-
var InsertReadonly$0 = $
|
|
3867
|
-
return {
|
|
4332
|
+
var InsertReadonly$0 = $TV($EXPECT($L16, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
|
|
4333
|
+
return { ts: true, children: [{ $loc, token: "readonly " }] };
|
|
3868
4334
|
});
|
|
3869
4335
|
function InsertReadonly(state) {
|
|
3870
4336
|
if (state.verbose)
|
|
@@ -3875,7 +4341,7 @@ var Civet = (() => {
|
|
|
3875
4341
|
return InsertReadonly$0(state);
|
|
3876
4342
|
}
|
|
3877
4343
|
}
|
|
3878
|
-
var InsertNewline$0 = $TV($EXPECT($
|
|
4344
|
+
var InsertNewline$0 = $TV($EXPECT($L16, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
|
|
3879
4345
|
return "\n";
|
|
3880
4346
|
});
|
|
3881
4347
|
function InsertNewline(state) {
|
|
@@ -3887,7 +4353,7 @@ var Civet = (() => {
|
|
|
3887
4353
|
return InsertNewline$0(state);
|
|
3888
4354
|
}
|
|
3889
4355
|
}
|
|
3890
|
-
var InsertIndent$0 = $TV($EXPECT($
|
|
4356
|
+
var InsertIndent$0 = $TV($EXPECT($L16, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
|
|
3891
4357
|
return "".padStart(global.currentIndent * 2);
|
|
3892
4358
|
});
|
|
3893
4359
|
function InsertIndent(state) {
|
|
@@ -3899,8 +4365,8 @@ var Civet = (() => {
|
|
|
3899
4365
|
return InsertIndent$0(state);
|
|
3900
4366
|
}
|
|
3901
4367
|
}
|
|
3902
|
-
var InsertSpace$0 = $
|
|
3903
|
-
return " ";
|
|
4368
|
+
var InsertSpace$0 = $TV($EXPECT($L16, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
|
|
4369
|
+
return { $loc, token: " " };
|
|
3904
4370
|
});
|
|
3905
4371
|
function InsertSpace(state) {
|
|
3906
4372
|
if (state.verbose)
|
|
@@ -3911,8 +4377,8 @@ var Civet = (() => {
|
|
|
3911
4377
|
return InsertSpace$0(state);
|
|
3912
4378
|
}
|
|
3913
4379
|
}
|
|
3914
|
-
var InsertDot$0 = $
|
|
3915
|
-
return ".";
|
|
4380
|
+
var InsertDot$0 = $TV($EXPECT($L16, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
|
|
4381
|
+
return { $loc, token: "." };
|
|
3916
4382
|
});
|
|
3917
4383
|
function InsertDot(state) {
|
|
3918
4384
|
if (state.verbose)
|
|
@@ -3923,8 +4389,8 @@ var Civet = (() => {
|
|
|
3923
4389
|
return InsertDot$0(state);
|
|
3924
4390
|
}
|
|
3925
4391
|
}
|
|
3926
|
-
var InsertBreak$0 = $
|
|
3927
|
-
return "break;";
|
|
4392
|
+
var InsertBreak$0 = $TV($EXPECT($L16, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
|
|
4393
|
+
return { $loc, token: "break;" };
|
|
3928
4394
|
});
|
|
3929
4395
|
function InsertBreak(state) {
|
|
3930
4396
|
if (state.verbose)
|
|
@@ -3935,7 +4401,7 @@ var Civet = (() => {
|
|
|
3935
4401
|
return InsertBreak$0(state);
|
|
3936
4402
|
}
|
|
3937
4403
|
}
|
|
3938
|
-
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($
|
|
4404
|
+
var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L16, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3939
4405
|
var directives = $2;
|
|
3940
4406
|
global.currentIndent = 0;
|
|
3941
4407
|
global.indentLevels = [0];
|
|
@@ -3944,13 +4410,19 @@ var Civet = (() => {
|
|
|
3944
4410
|
const compatRe = /use coffee-compat/;
|
|
3945
4411
|
module.coffeeCompat = directives.some((d) => d[1].token?.match(compatRe));
|
|
3946
4412
|
}
|
|
3947
|
-
module.dedentBlockString = function(str) {
|
|
4413
|
+
module.dedentBlockString = function({ $loc: $loc2, token: str }) {
|
|
3948
4414
|
const spacing = str.match(/^(\r?\n|\n)\s+/);
|
|
3949
4415
|
if (spacing) {
|
|
3950
4416
|
str = str.replaceAll(spacing[0], "\n");
|
|
4417
|
+
const l = spacing.length;
|
|
4418
|
+
$loc2.pos += l;
|
|
4419
|
+
$loc2.length -= l;
|
|
3951
4420
|
}
|
|
3952
4421
|
str = str.replace(/^(\r?\n|\n)/, "").replace(/(\r?\n|\n)[ \t]*$/, "").replace(/(`|\$)/g, "\\$1");
|
|
3953
|
-
return
|
|
4422
|
+
return {
|
|
4423
|
+
$loc: $loc2,
|
|
4424
|
+
token: str
|
|
4425
|
+
};
|
|
3954
4426
|
};
|
|
3955
4427
|
return $0;
|
|
3956
4428
|
});
|
|
@@ -3975,7 +4447,7 @@ var Civet = (() => {
|
|
|
3975
4447
|
return Indent$0(state);
|
|
3976
4448
|
}
|
|
3977
4449
|
}
|
|
3978
|
-
var PushIndent$0 = $TV($EXPECT($
|
|
4450
|
+
var PushIndent$0 = $TV($EXPECT($L16, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
|
|
3979
4451
|
global.currentIndent++;
|
|
3980
4452
|
if (global.verbose) {
|
|
3981
4453
|
console.log("pushing indent", global.currentIndent);
|
|
@@ -3992,7 +4464,7 @@ var Civet = (() => {
|
|
|
3992
4464
|
return PushIndent$0(state);
|
|
3993
4465
|
}
|
|
3994
4466
|
}
|
|
3995
|
-
var PopIndent$0 = $TV($EXPECT($
|
|
4467
|
+
var PopIndent$0 = $TV($EXPECT($L16, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
|
|
3996
4468
|
if (global.verbose) {
|
|
3997
4469
|
console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
|
|
3998
4470
|
}
|
|
@@ -4144,15 +4616,24 @@ var Civet = (() => {
|
|
|
4144
4616
|
// source/util.coffee
|
|
4145
4617
|
var require_util = __commonJS({
|
|
4146
4618
|
"source/util.coffee"(exports, module) {
|
|
4619
|
+
"use strict";
|
|
4147
4620
|
var BASE64_CHARS;
|
|
4148
4621
|
var SourceMap;
|
|
4149
4622
|
var VLQ_CONTINUATION_BIT;
|
|
4150
4623
|
var VLQ_SHIFT;
|
|
4151
4624
|
var VLQ_VALUE_MASK;
|
|
4625
|
+
var base64Encode;
|
|
4626
|
+
var decodeError;
|
|
4627
|
+
var decodeVLQ;
|
|
4152
4628
|
var encodeBase64;
|
|
4153
4629
|
var encodeVlq;
|
|
4154
4630
|
var locationTable;
|
|
4155
4631
|
var lookupLineColumn;
|
|
4632
|
+
var prettySourceExcerpt;
|
|
4633
|
+
var remapPosition;
|
|
4634
|
+
var smRegexp;
|
|
4635
|
+
var vlqChars;
|
|
4636
|
+
var vlqTable;
|
|
4156
4637
|
locationTable = function(input) {
|
|
4157
4638
|
var line, lines, linesRe, pos, result;
|
|
4158
4639
|
linesRe = /([^\r\n]*)(\r\n|\r|\n|$)/y;
|
|
@@ -4189,6 +4670,9 @@ var Civet = (() => {
|
|
|
4189
4670
|
EOL = /\r?\n|\r/;
|
|
4190
4671
|
return {
|
|
4191
4672
|
data: sm,
|
|
4673
|
+
source: function() {
|
|
4674
|
+
return sourceString;
|
|
4675
|
+
},
|
|
4192
4676
|
renderMappings: function() {
|
|
4193
4677
|
var lastSourceColumn, lastSourceLine;
|
|
4194
4678
|
lastSourceLine = 0;
|
|
@@ -4220,20 +4704,23 @@ var Civet = (() => {
|
|
|
4220
4704
|
};
|
|
4221
4705
|
},
|
|
4222
4706
|
updateSourceMap: function(outputStr, inputPos) {
|
|
4223
|
-
var outLines;
|
|
4707
|
+
var outLines, srcCol, srcLine;
|
|
4224
4708
|
outLines = outputStr.split(EOL);
|
|
4709
|
+
if (inputPos != null) {
|
|
4710
|
+
[srcLine, srcCol] = lookupLineColumn(srcTable, inputPos);
|
|
4711
|
+
}
|
|
4225
4712
|
outLines.forEach(function(line, i) {
|
|
4226
|
-
var l
|
|
4713
|
+
var l;
|
|
4227
4714
|
if (i > 0) {
|
|
4228
4715
|
sm.lineNum++;
|
|
4229
4716
|
sm.colOffset = 0;
|
|
4230
4717
|
sm.lines[sm.lineNum] = [];
|
|
4718
|
+
srcCol = 0;
|
|
4231
4719
|
}
|
|
4232
4720
|
l = sm.colOffset;
|
|
4233
4721
|
sm.colOffset = line.length;
|
|
4234
4722
|
if (inputPos != null) {
|
|
4235
|
-
[
|
|
4236
|
-
return sm.lines[sm.lineNum].push([l, 0, srcLine, srcCol]);
|
|
4723
|
+
return sm.lines[sm.lineNum].push([l, 0, srcLine + i, srcCol]);
|
|
4237
4724
|
} else if (l !== 0) {
|
|
4238
4725
|
return sm.lines[sm.lineNum].push([l]);
|
|
4239
4726
|
}
|
|
@@ -4241,6 +4728,95 @@ var Civet = (() => {
|
|
|
4241
4728
|
}
|
|
4242
4729
|
};
|
|
4243
4730
|
};
|
|
4731
|
+
SourceMap.parseWithLines = function(base64encodedJSONstr) {
|
|
4732
|
+
var json, lines, sourceColumn, sourceLine;
|
|
4733
|
+
json = JSON.parse(Buffer.from(base64encodedJSONstr, "base64").toString("utf8"));
|
|
4734
|
+
sourceLine = 0;
|
|
4735
|
+
sourceColumn = 0;
|
|
4736
|
+
lines = json.mappings.split(";").map(function(line) {
|
|
4737
|
+
if (line.length === 0) {
|
|
4738
|
+
return [];
|
|
4739
|
+
}
|
|
4740
|
+
return line.split(",").map(function(entry) {
|
|
4741
|
+
var result;
|
|
4742
|
+
result = decodeVLQ(entry);
|
|
4743
|
+
switch (result.length) {
|
|
4744
|
+
case 1:
|
|
4745
|
+
return [result[0]];
|
|
4746
|
+
case 4:
|
|
4747
|
+
return [result[0], result[1], sourceLine += result[2], sourceColumn += result[3]];
|
|
4748
|
+
case 5:
|
|
4749
|
+
return [result[0], result[1], sourceLine += result[2], sourceColumn += result[3], result[4]];
|
|
4750
|
+
default:
|
|
4751
|
+
throw new Error("Unknown source map entry", result);
|
|
4752
|
+
}
|
|
4753
|
+
});
|
|
4754
|
+
});
|
|
4755
|
+
json.lines = lines;
|
|
4756
|
+
return json;
|
|
4757
|
+
};
|
|
4758
|
+
smRegexp = /\n\/\/# sourceMappingURL=data:application\/json;charset=utf-8;base64,([+a-zA-Z0-9\/]*=?=?)$/;
|
|
4759
|
+
SourceMap.remap = function(codeWithSourceMap, upstreamMap, sourcePath, targetPath) {
|
|
4760
|
+
var codeWithoutSourceMap, composedLines, newSourceMap, parsed, remappedCodeWithSourceMap, remappedSourceMapJSON, sourceMapText;
|
|
4761
|
+
sourceMapText = codeWithSourceMap.match(smRegexp);
|
|
4762
|
+
if (sourceMapText) {
|
|
4763
|
+
parsed = SourceMap.parseWithLines(sourceMapText[1]);
|
|
4764
|
+
} else {
|
|
4765
|
+
console.warn("No source map found in code");
|
|
4766
|
+
return codeWithSourceMap;
|
|
4767
|
+
}
|
|
4768
|
+
debugger;
|
|
4769
|
+
composedLines = SourceMap.composeLines(upstreamMap.data.lines, parsed.lines);
|
|
4770
|
+
upstreamMap.data.lines = composedLines;
|
|
4771
|
+
remappedSourceMapJSON = upstreamMap.json(sourcePath, targetPath);
|
|
4772
|
+
codeWithoutSourceMap = codeWithSourceMap.replace(smRegexp, "");
|
|
4773
|
+
newSourceMap = `${"sourceMapping"}URL=data:application/json;charset=utf-8;base64,${base64Encode(JSON.stringify(remappedSourceMapJSON))}`;
|
|
4774
|
+
remappedCodeWithSourceMap = `${codeWithoutSourceMap}
|
|
4775
|
+
//# ${newSourceMap}`;
|
|
4776
|
+
return remappedCodeWithSourceMap;
|
|
4777
|
+
};
|
|
4778
|
+
SourceMap.composeLines = function(upstreamMapping, lines) {
|
|
4779
|
+
return lines.map(function(line, l) {
|
|
4780
|
+
return line.map(function(entry) {
|
|
4781
|
+
var colDelta, sourceFileIndex, srcCol, srcLine, srcPos, upstreamCol, upstreamLine;
|
|
4782
|
+
if (entry.length === 1) {
|
|
4783
|
+
return entry;
|
|
4784
|
+
}
|
|
4785
|
+
[colDelta, sourceFileIndex, srcLine, srcCol] = entry;
|
|
4786
|
+
srcPos = remapPosition([srcLine, srcCol], upstreamMapping);
|
|
4787
|
+
if (!srcPos) {
|
|
4788
|
+
return [entry[0]];
|
|
4789
|
+
}
|
|
4790
|
+
[upstreamLine, upstreamCol] = srcPos;
|
|
4791
|
+
if (entry.length === 4) {
|
|
4792
|
+
return [colDelta, sourceFileIndex, upstreamLine, upstreamCol];
|
|
4793
|
+
}
|
|
4794
|
+
return [colDelta, sourceFileIndex, upstreamLine, upstreamCol, entry[4]];
|
|
4795
|
+
});
|
|
4796
|
+
});
|
|
4797
|
+
};
|
|
4798
|
+
prettySourceExcerpt = function(source, location, length) {
|
|
4799
|
+
var colNum, i, j, line, lineNum, lineNumStr, lines, ref, ref1;
|
|
4800
|
+
lines = source.split(/\r?\n|\r/);
|
|
4801
|
+
lineNum = location.line;
|
|
4802
|
+
colNum = location.column;
|
|
4803
|
+
for (i = j = ref = lineNum - 2, ref1 = lineNum + 2; ref <= ref1 ? j <= ref1 : j >= ref1; i = ref <= ref1 ? ++j : --j) {
|
|
4804
|
+
if (i < 0 || i >= lines.length) {
|
|
4805
|
+
continue;
|
|
4806
|
+
}
|
|
4807
|
+
line = lines[i];
|
|
4808
|
+
lineNumStr = (i + 1).toString();
|
|
4809
|
+
while (lineNumStr.length < 4) {
|
|
4810
|
+
lineNumStr = " " + lineNumStr;
|
|
4811
|
+
}
|
|
4812
|
+
if (i === lineNum) {
|
|
4813
|
+
console.log(`${lineNumStr}: ${line}`);
|
|
4814
|
+
console.log(" ".repeat(lineNumStr.length + 2 + colNum) + "^".repeat(length));
|
|
4815
|
+
} else {
|
|
4816
|
+
console.log(`${lineNumStr}: ${line}`);
|
|
4817
|
+
}
|
|
4818
|
+
}
|
|
4819
|
+
};
|
|
4244
4820
|
VLQ_SHIFT = 5;
|
|
4245
4821
|
VLQ_CONTINUATION_BIT = 1 << VLQ_SHIFT;
|
|
4246
4822
|
VLQ_VALUE_MASK = VLQ_CONTINUATION_BIT - 1;
|
|
@@ -4265,7 +4841,101 @@ var Civet = (() => {
|
|
|
4265
4841
|
throw new Error(`Cannot Base64 encode value: ${value}`);
|
|
4266
4842
|
}();
|
|
4267
4843
|
};
|
|
4268
|
-
|
|
4844
|
+
base64Encode = function(src) {
|
|
4845
|
+
return Buffer.from(src).toString("base64");
|
|
4846
|
+
};
|
|
4847
|
+
module.exports = { base64Encode, locationTable, lookupLineColumn, SourceMap };
|
|
4848
|
+
vlqTable = new Uint8Array(128);
|
|
4849
|
+
vlqChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
4850
|
+
(function() {
|
|
4851
|
+
var i, l, results;
|
|
4852
|
+
i = 0;
|
|
4853
|
+
l = vlqTable.length;
|
|
4854
|
+
while (i < l) {
|
|
4855
|
+
vlqTable[i] = 255;
|
|
4856
|
+
i++;
|
|
4857
|
+
}
|
|
4858
|
+
i = 0;
|
|
4859
|
+
l = vlqChars.length;
|
|
4860
|
+
results = [];
|
|
4861
|
+
while (i < l) {
|
|
4862
|
+
vlqTable[vlqChars.charCodeAt(i)] = i;
|
|
4863
|
+
results.push(i++);
|
|
4864
|
+
}
|
|
4865
|
+
return results;
|
|
4866
|
+
})();
|
|
4867
|
+
decodeError = function(message) {
|
|
4868
|
+
throw new Error(message);
|
|
4869
|
+
};
|
|
4870
|
+
decodeVLQ = function(mapping) {
|
|
4871
|
+
var c, i, index, l, result, shift, v, vlq;
|
|
4872
|
+
i = 0;
|
|
4873
|
+
l = mapping.length;
|
|
4874
|
+
result = [];
|
|
4875
|
+
while (i < l) {
|
|
4876
|
+
shift = 0;
|
|
4877
|
+
vlq = 0;
|
|
4878
|
+
while (true) {
|
|
4879
|
+
if (i >= l) {
|
|
4880
|
+
decodeError("Unexpected early end of mapping data");
|
|
4881
|
+
}
|
|
4882
|
+
c = mapping.charCodeAt(i);
|
|
4883
|
+
if ((c & 127) !== c) {
|
|
4884
|
+
decodeError(`Invalid mapping character: ${JSON.stringify(String.fromCharCode(c))}`);
|
|
4885
|
+
}
|
|
4886
|
+
index = vlqTable[c & 127];
|
|
4887
|
+
if (index === 255) {
|
|
4888
|
+
decodeError(`Invalid mapping character: ${JSON.stringify(String.fromCharCode(c))}`);
|
|
4889
|
+
}
|
|
4890
|
+
i++;
|
|
4891
|
+
vlq |= (index & 31) << shift;
|
|
4892
|
+
shift += 5;
|
|
4893
|
+
if ((index & 32) === 0) {
|
|
4894
|
+
break;
|
|
4895
|
+
}
|
|
4896
|
+
}
|
|
4897
|
+
if (vlq & 1) {
|
|
4898
|
+
v = -(vlq >> 1);
|
|
4899
|
+
} else {
|
|
4900
|
+
v = vlq >> 1;
|
|
4901
|
+
}
|
|
4902
|
+
result.push(v);
|
|
4903
|
+
}
|
|
4904
|
+
return result;
|
|
4905
|
+
};
|
|
4906
|
+
remapPosition = function(position, sourcemapLines) {
|
|
4907
|
+
var character, i, l, lastMapping, lastMappingPosition, line, mapping, p, textLine;
|
|
4908
|
+
[line, character] = position;
|
|
4909
|
+
textLine = sourcemapLines[line];
|
|
4910
|
+
if (!(textLine != null ? textLine.length : void 0)) {
|
|
4911
|
+
return void 0;
|
|
4912
|
+
}
|
|
4913
|
+
i = 0;
|
|
4914
|
+
p = 0;
|
|
4915
|
+
l = textLine.length;
|
|
4916
|
+
lastMapping = void 0;
|
|
4917
|
+
lastMappingPosition = 0;
|
|
4918
|
+
while (i < l) {
|
|
4919
|
+
mapping = textLine[i];
|
|
4920
|
+
p += mapping[0];
|
|
4921
|
+
if (mapping.length === 4) {
|
|
4922
|
+
lastMapping = mapping;
|
|
4923
|
+
lastMappingPosition = p;
|
|
4924
|
+
}
|
|
4925
|
+
if (p >= character) {
|
|
4926
|
+
break;
|
|
4927
|
+
}
|
|
4928
|
+
i++;
|
|
4929
|
+
}
|
|
4930
|
+
if (character - lastMappingPosition !== 0) {
|
|
4931
|
+
return void 0;
|
|
4932
|
+
}
|
|
4933
|
+
if (lastMapping) {
|
|
4934
|
+
return [lastMapping[2], lastMapping[3]];
|
|
4935
|
+
} else {
|
|
4936
|
+
return void 0;
|
|
4937
|
+
}
|
|
4938
|
+
};
|
|
4269
4939
|
}
|
|
4270
4940
|
});
|
|
4271
4941
|
|
|
@@ -4281,7 +4951,7 @@ var Civet = (() => {
|
|
|
4281
4951
|
var util;
|
|
4282
4952
|
({ parse } = require_parser());
|
|
4283
4953
|
({ prune } = gen = require_generate());
|
|
4284
|
-
({ SourceMap } = util = require_util());
|
|
4954
|
+
({ SourceMap, base64Encode } = util = require_util());
|
|
4285
4955
|
defaultOptions = {};
|
|
4286
4956
|
module.exports = {
|
|
4287
4957
|
parse,
|
|
@@ -4299,9 +4969,9 @@ var Civet = (() => {
|
|
|
4299
4969
|
options.updateSourceMap = sm.updateSourceMap;
|
|
4300
4970
|
code = gen(ast, options);
|
|
4301
4971
|
if (options.inlineMap) {
|
|
4302
|
-
srcMapJSON = sm.json(filename,
|
|
4972
|
+
srcMapJSON = sm.json(filename, "");
|
|
4303
4973
|
return `${code}
|
|
4304
|
-
//# sourceMappingURL=data:application/json;base64,${base64Encode(JSON.stringify(srcMapJSON))}
|
|
4974
|
+
${"//#"} sourceMappingURL=data:application/json;base64,${base64Encode(JSON.stringify(srcMapJSON))}
|
|
4305
4975
|
`;
|
|
4306
4976
|
} else {
|
|
4307
4977
|
return {
|
|
@@ -4315,9 +4985,6 @@ var Civet = (() => {
|
|
|
4315
4985
|
generate: gen,
|
|
4316
4986
|
util
|
|
4317
4987
|
};
|
|
4318
|
-
base64Encode = function(src) {
|
|
4319
|
-
return Buffer.from(src).toString("base64");
|
|
4320
|
-
};
|
|
4321
4988
|
}
|
|
4322
4989
|
});
|
|
4323
4990
|
return require_main();
|