@danielx/civet 0.2.14 → 0.3.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 +6 -5
- package/dist/browser.js +693 -323
- package/dist/browser.js.map +3 -3
- package/dist/civet +14 -13
- package/dist/cli.js.map +4 -4
- package/dist/main.js +698 -328
- package/dist/types.d.ts +24 -5
- package/package.json +8 -1
- package/register.mjs +41 -13
package/dist/browser.js
CHANGED
|
@@ -417,6 +417,7 @@ var Civet = (() => {
|
|
|
417
417
|
UnaryExpression,
|
|
418
418
|
UnaryPostfix,
|
|
419
419
|
UpdateExpression,
|
|
420
|
+
UpdateExpressionSymbol,
|
|
420
421
|
AssignmentExpression,
|
|
421
422
|
AssignmentExpressionRest,
|
|
422
423
|
YieldExpression,
|
|
@@ -428,14 +429,17 @@ var Civet = (() => {
|
|
|
428
429
|
PrimaryExpression,
|
|
429
430
|
ClassDeclaration,
|
|
430
431
|
ClassExpression,
|
|
432
|
+
Class,
|
|
431
433
|
ClassHeritage,
|
|
432
434
|
ExtendsToken,
|
|
433
435
|
ClassBody,
|
|
434
436
|
NestedClassElements,
|
|
435
437
|
NestedClassElement,
|
|
436
438
|
ClassElement,
|
|
439
|
+
Static,
|
|
437
440
|
FieldDefinition,
|
|
438
441
|
This,
|
|
442
|
+
AtAccessor,
|
|
439
443
|
LeftHandSideExpression,
|
|
440
444
|
NewExpression,
|
|
441
445
|
CallExpression,
|
|
@@ -463,13 +467,17 @@ var Civet = (() => {
|
|
|
463
467
|
FunctionDeclaration,
|
|
464
468
|
FunctionExpression,
|
|
465
469
|
ThinArrowFunction,
|
|
470
|
+
Arrow,
|
|
466
471
|
Block,
|
|
472
|
+
BracedOrEmptyBlock,
|
|
467
473
|
BracedBlock,
|
|
468
474
|
SingleNestedExpression,
|
|
469
475
|
SingleNestedBlockStatement,
|
|
470
476
|
NestedBlockExpressions,
|
|
471
477
|
BlockExpression,
|
|
472
478
|
Literal,
|
|
479
|
+
NullLiteral,
|
|
480
|
+
BooleanLiteral,
|
|
473
481
|
Comma,
|
|
474
482
|
Identifier,
|
|
475
483
|
IdentifierName,
|
|
@@ -499,7 +507,9 @@ var Civet = (() => {
|
|
|
499
507
|
AsyncGeneratorMethod,
|
|
500
508
|
AsyncGeneratorBody,
|
|
501
509
|
AssignmentOp,
|
|
510
|
+
AssignmentOpSymbol,
|
|
502
511
|
BinaryOp,
|
|
512
|
+
BinaryOpSymbol,
|
|
503
513
|
UnaryOp,
|
|
504
514
|
ModuleItem,
|
|
505
515
|
StatementListItem,
|
|
@@ -515,7 +525,9 @@ var Civet = (() => {
|
|
|
515
525
|
WhileClause,
|
|
516
526
|
ForStatement,
|
|
517
527
|
ForInOfStatement,
|
|
528
|
+
For,
|
|
518
529
|
ForDeclaration,
|
|
530
|
+
LetOrConst,
|
|
519
531
|
ForBinding,
|
|
520
532
|
SwitchStatement,
|
|
521
533
|
CaseBlock,
|
|
@@ -535,10 +547,12 @@ var Civet = (() => {
|
|
|
535
547
|
MaybeNestedExpression,
|
|
536
548
|
Return,
|
|
537
549
|
ImportDeclaration,
|
|
550
|
+
Import,
|
|
538
551
|
ImportClause,
|
|
539
552
|
NameSpaceImport,
|
|
540
553
|
NamedImports,
|
|
541
554
|
FromClause,
|
|
555
|
+
From,
|
|
542
556
|
ImportSpecifier,
|
|
543
557
|
ModuleExportName,
|
|
544
558
|
ModuleSpecifier,
|
|
@@ -559,6 +573,7 @@ var Civet = (() => {
|
|
|
559
573
|
VariableDeclarationList,
|
|
560
574
|
VariableDeclaration,
|
|
561
575
|
NumericLiteral,
|
|
576
|
+
NumericLiteralKind,
|
|
562
577
|
DecimalBigIntegerLiteral,
|
|
563
578
|
DecimalLiteral,
|
|
564
579
|
BinaryIntegerLiteral,
|
|
@@ -568,7 +583,7 @@ var Civet = (() => {
|
|
|
568
583
|
DoubleStringCharacter,
|
|
569
584
|
SingleStringCharacter,
|
|
570
585
|
TripleDoubleStringCharacter,
|
|
571
|
-
|
|
586
|
+
TripleSingleStringCharacter,
|
|
572
587
|
RegularExpressionLiteral,
|
|
573
588
|
RegularExpressionBody,
|
|
574
589
|
RegExpCharacter,
|
|
@@ -674,8 +689,8 @@ var Civet = (() => {
|
|
|
674
689
|
var $L16 = $L("}");
|
|
675
690
|
var $L17 = $L("static");
|
|
676
691
|
var $L18 = $L("this");
|
|
677
|
-
var $L19 = $L("
|
|
678
|
-
var $L20 = $L("
|
|
692
|
+
var $L19 = $L("#");
|
|
693
|
+
var $L20 = $L("@");
|
|
679
694
|
var $L21 = $L("new");
|
|
680
695
|
var $L22 = $L("super");
|
|
681
696
|
var $L23 = $L("import");
|
|
@@ -690,107 +705,106 @@ var Civet = (() => {
|
|
|
690
705
|
var $L32 = $L("...");
|
|
691
706
|
var $L33 = $L("function");
|
|
692
707
|
var $L34 = $L("->");
|
|
693
|
-
var $L35 = $L("
|
|
694
|
-
var $L36 = $L("
|
|
695
|
-
var $L37 = $L("
|
|
696
|
-
var $L38 = $L("
|
|
697
|
-
var $L39 = $L("
|
|
698
|
-
var $L40 = $L("
|
|
699
|
-
var $L41 = $L("
|
|
700
|
-
var $L42 = $L("
|
|
701
|
-
var $L43 = $L("
|
|
702
|
-
var $L44 = $L("
|
|
703
|
-
var $L45 = $L("
|
|
704
|
-
var $L46 = $L("
|
|
705
|
-
var $L47 = $L("
|
|
706
|
-
var $L48 = $L("
|
|
707
|
-
var $L49 = $L("
|
|
708
|
-
var $L50 = $L("
|
|
709
|
-
var $L51 = $L("
|
|
710
|
-
var $L52 = $L("
|
|
711
|
-
var $L53 = $L("
|
|
712
|
-
var $L54 = $L("
|
|
713
|
-
var $L55 = $L("
|
|
714
|
-
var $L56 = $L("
|
|
715
|
-
var $L57 = $L("
|
|
716
|
-
var $L58 = $L("
|
|
717
|
-
var $L59 = $L("
|
|
718
|
-
var $L60 = $L("
|
|
719
|
-
var $L61 = $L("
|
|
720
|
-
var $L62 = $L("
|
|
721
|
-
var $L63 = $L("
|
|
722
|
-
var $L64 = $L("
|
|
723
|
-
var $L65 = $L("
|
|
724
|
-
var $L66 = $L("
|
|
725
|
-
var $L67 = $L("
|
|
726
|
-
var $L68 = $L("
|
|
727
|
-
var $L69 = $L("
|
|
728
|
-
var $L70 = $L("
|
|
729
|
-
var $L71 = $L("
|
|
730
|
-
var $L72 = $L("
|
|
731
|
-
var $L73 = $L("
|
|
732
|
-
var $L74 = $L("
|
|
733
|
-
var $L75 = $L("
|
|
734
|
-
var $L76 = $L("
|
|
735
|
-
var $L77 = $L("
|
|
736
|
-
var $L78 = $L("
|
|
737
|
-
var $L79 = $L("
|
|
738
|
-
var $L80 = $L("
|
|
739
|
-
var $L81 = $L("
|
|
740
|
-
var $L82 = $L("
|
|
741
|
-
var $L83 = $L("
|
|
742
|
-
var $L84 = $L("
|
|
743
|
-
var $L85 = $L("
|
|
744
|
-
var $L86 = $L("
|
|
745
|
-
var $L87 = $L("
|
|
746
|
-
var $L88 = $L("
|
|
747
|
-
var $L89 = $L("
|
|
748
|
-
var $L90 = $L("
|
|
749
|
-
var $L91 = $L("
|
|
750
|
-
var $L92 = $L("
|
|
751
|
-
var $L93 = $L("
|
|
752
|
-
var $L94 = $L("
|
|
753
|
-
var $L95 = $L("
|
|
754
|
-
var $L96 = $L("
|
|
755
|
-
var $L97 = $L("
|
|
756
|
-
var $L98 = $L("
|
|
757
|
-
var $L99 = $L("
|
|
758
|
-
var $L100 = $L("
|
|
759
|
-
var $L101 = $L("
|
|
760
|
-
var $L102 = $L("
|
|
761
|
-
var $L103 = $L("
|
|
762
|
-
var $L104 = $L("
|
|
763
|
-
var $L105 = $L("
|
|
764
|
-
var $L106 = $L("
|
|
765
|
-
var $L107 = $L("
|
|
766
|
-
var $L108 = $L("
|
|
767
|
-
var $L109 = $L("
|
|
768
|
-
var $L110 = $L("
|
|
769
|
-
var $L111 = $L("
|
|
770
|
-
var $L112 = $L("
|
|
771
|
-
var $L113 = $L("
|
|
772
|
-
var $L114 = $L("
|
|
773
|
-
var $L115 = $L("
|
|
774
|
-
var $L116 = $L('"
|
|
708
|
+
var $L35 = $L("null");
|
|
709
|
+
var $L36 = $L("true");
|
|
710
|
+
var $L37 = $L("false");
|
|
711
|
+
var $L38 = $L("get");
|
|
712
|
+
var $L39 = $L("set");
|
|
713
|
+
var $L40 = $L("**=");
|
|
714
|
+
var $L41 = $L("*=");
|
|
715
|
+
var $L42 = $L("/=");
|
|
716
|
+
var $L43 = $L("%=");
|
|
717
|
+
var $L44 = $L("+=");
|
|
718
|
+
var $L45 = $L("-=");
|
|
719
|
+
var $L46 = $L("<<=");
|
|
720
|
+
var $L47 = $L(">>>=");
|
|
721
|
+
var $L48 = $L(">>=");
|
|
722
|
+
var $L49 = $L("&&=");
|
|
723
|
+
var $L50 = $L("&=");
|
|
724
|
+
var $L51 = $L("^=");
|
|
725
|
+
var $L52 = $L("||=");
|
|
726
|
+
var $L53 = $L("|=");
|
|
727
|
+
var $L54 = $L("??=");
|
|
728
|
+
var $L55 = $L("=");
|
|
729
|
+
var $L56 = $L("**");
|
|
730
|
+
var $L57 = $L("/");
|
|
731
|
+
var $L58 = $L("%");
|
|
732
|
+
var $L59 = $L("+");
|
|
733
|
+
var $L60 = $L("-");
|
|
734
|
+
var $L61 = $L("<=");
|
|
735
|
+
var $L62 = $L(">=");
|
|
736
|
+
var $L63 = $L("<<");
|
|
737
|
+
var $L64 = $L(">>>");
|
|
738
|
+
var $L65 = $L(">>");
|
|
739
|
+
var $L66 = $L(">");
|
|
740
|
+
var $L67 = $L("!==");
|
|
741
|
+
var $L68 = $L("!=");
|
|
742
|
+
var $L69 = $L("is");
|
|
743
|
+
var $L70 = $L("===");
|
|
744
|
+
var $L71 = $L("==");
|
|
745
|
+
var $L72 = $L("and");
|
|
746
|
+
var $L73 = $L("&&");
|
|
747
|
+
var $L74 = $L("or");
|
|
748
|
+
var $L75 = $L("||");
|
|
749
|
+
var $L76 = $L("??");
|
|
750
|
+
var $L77 = $L("instanceof");
|
|
751
|
+
var $L78 = $L("in");
|
|
752
|
+
var $L79 = $L("&");
|
|
753
|
+
var $L80 = $L("^");
|
|
754
|
+
var $L81 = $L("|");
|
|
755
|
+
var $L82 = $L("delete");
|
|
756
|
+
var $L83 = $L("void");
|
|
757
|
+
var $L84 = $L("typeof");
|
|
758
|
+
var $L85 = $L("if");
|
|
759
|
+
var $L86 = $L("unless");
|
|
760
|
+
var $L87 = $L(";");
|
|
761
|
+
var $L88 = $L("else");
|
|
762
|
+
var $L89 = $L("loop");
|
|
763
|
+
var $L90 = $L("do");
|
|
764
|
+
var $L91 = $L("while");
|
|
765
|
+
var $L92 = $L("until");
|
|
766
|
+
var $L93 = $L("var");
|
|
767
|
+
var $L94 = $L("await");
|
|
768
|
+
var $L95 = $L("of");
|
|
769
|
+
var $L96 = $L("for");
|
|
770
|
+
var $L97 = $L("let");
|
|
771
|
+
var $L98 = $L("const");
|
|
772
|
+
var $L99 = $L("switch");
|
|
773
|
+
var $L100 = $L("case");
|
|
774
|
+
var $L101 = $L("default");
|
|
775
|
+
var $L102 = $L("when");
|
|
776
|
+
var $L103 = $L("try");
|
|
777
|
+
var $L104 = $L("catch");
|
|
778
|
+
var $L105 = $L("finally");
|
|
779
|
+
var $L106 = $L("break");
|
|
780
|
+
var $L107 = $L("continue");
|
|
781
|
+
var $L108 = $L("debugger");
|
|
782
|
+
var $L109 = $L("throw");
|
|
783
|
+
var $L110 = $L("return");
|
|
784
|
+
var $L111 = $L("import type");
|
|
785
|
+
var $L112 = $L("from");
|
|
786
|
+
var $L113 = $L("export");
|
|
787
|
+
var $L114 = $L(":=");
|
|
788
|
+
var $L115 = $L('"""');
|
|
789
|
+
var $L116 = $L("'''");
|
|
775
790
|
var $L117 = $L('"');
|
|
776
791
|
var $L118 = $L("'");
|
|
777
|
-
var $L119 = $L("
|
|
778
|
-
var $L120 = $L("
|
|
779
|
-
var $L121 = $L("
|
|
780
|
-
var $L122 = $L("
|
|
781
|
-
var $L123 = $L("
|
|
782
|
-
var $L124 = $L("
|
|
783
|
-
var $L125 = $L("
|
|
784
|
-
var $L126 = $L("
|
|
785
|
-
var $L127 = $L("
|
|
786
|
-
var $L128 = $L("
|
|
787
|
-
var $L129 = $L("
|
|
788
|
-
var $L130 = $L("
|
|
789
|
-
var $L131 = $L("
|
|
790
|
-
var $L132 = $L("
|
|
791
|
-
var $L133 = $L("
|
|
792
|
-
var $L134 = $L("
|
|
793
|
-
var $L135 = $L(" ");
|
|
792
|
+
var $L119 = $L("`");
|
|
793
|
+
var $L120 = $L("${");
|
|
794
|
+
var $L121 = $L("/*");
|
|
795
|
+
var $L122 = $L("*/");
|
|
796
|
+
var $L123 = $L("###");
|
|
797
|
+
var $L124 = $L("/>");
|
|
798
|
+
var $L125 = $L("</");
|
|
799
|
+
var $L126 = $L("<>");
|
|
800
|
+
var $L127 = $L("</>");
|
|
801
|
+
var $L128 = $L("readonly");
|
|
802
|
+
var $L129 = $L("asserts");
|
|
803
|
+
var $L130 = $L("keyof");
|
|
804
|
+
var $L131 = $L("infer");
|
|
805
|
+
var $L132 = $L("[]");
|
|
806
|
+
var $L133 = $L(" ");
|
|
807
|
+
var $L134 = $L(" ");
|
|
794
808
|
var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
795
809
|
var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
796
810
|
var $R2 = $R(new RegExp("[!~+-]", "suy"));
|
|
@@ -799,33 +813,34 @@ var Civet = (() => {
|
|
|
799
813
|
var $R5 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
|
|
800
814
|
var $R6 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
|
|
801
815
|
var $R7 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
|
|
802
|
-
var $R8 = $R(new RegExp('[^"
|
|
803
|
-
var $R9 = $R(new RegExp("[^'
|
|
816
|
+
var $R8 = $R(new RegExp('(?:\\\\.|[^"])+', "suy"));
|
|
817
|
+
var $R9 = $R(new RegExp("(?:\\\\.|[^'])+", "suy"));
|
|
804
818
|
var $R10 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
|
|
805
|
-
var $R11 = $R(new RegExp("
|
|
819
|
+
var $R11 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])+", "suy"));
|
|
806
820
|
var $R12 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
|
|
807
|
-
var $R13 = $R(new RegExp("[^\\/\\r\\n]+", "suy"));
|
|
808
|
-
var $R14 = $R(new RegExp("(
|
|
821
|
+
var $R13 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
|
|
822
|
+
var $R14 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
809
823
|
var $R15 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
810
824
|
var $R16 = $R(new RegExp("(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
811
825
|
var $R17 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
812
|
-
var $R18 = $R(new RegExp("
|
|
813
|
-
var $R19 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
814
|
-
var $R20 = $R(new RegExp("[\\
|
|
815
|
-
var $R21 = $R(new RegExp("[\\
|
|
816
|
-
var $R22 = $R(new RegExp("
|
|
817
|
-
var $R23 = $R(new RegExp("(
|
|
818
|
-
var $R24 = $R(new RegExp(
|
|
819
|
-
var $R25 = $R(new RegExp("
|
|
820
|
-
var $R26 = $R(new RegExp("[^
|
|
821
|
-
var $R27 = $R(new RegExp("
|
|
822
|
-
var $R28 = $R(new RegExp("
|
|
823
|
-
var $R29 = $R(new RegExp("
|
|
824
|
-
var $R30 = $R(new RegExp("[+-]", "suy"));
|
|
825
|
-
var $R31 = $R(new RegExp("
|
|
826
|
-
var $R32 = $R(new RegExp("[\\
|
|
827
|
-
var $R33 = $R(new RegExp("\\
|
|
828
|
-
var $R34 = $R(new RegExp("
|
|
826
|
+
var $R18 = $R(new RegExp(".", "suy"));
|
|
827
|
+
var $R19 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
828
|
+
var $R20 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
829
|
+
var $R21 = $R(new RegExp("[\\t ]+", "suy"));
|
|
830
|
+
var $R22 = $R(new RegExp("[\\s]+", "suy"));
|
|
831
|
+
var $R23 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
832
|
+
var $R24 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
833
|
+
var $R25 = $R(new RegExp('"[^"]*"', "suy"));
|
|
834
|
+
var $R26 = $R(new RegExp("'[^']*'", "suy"));
|
|
835
|
+
var $R27 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
836
|
+
var $R28 = $R(new RegExp("type(?!\\p{ID_Continue})", "suy"));
|
|
837
|
+
var $R29 = $R(new RegExp("interface(?!\\p{ID_Continue})", "suy"));
|
|
838
|
+
var $R30 = $R(new RegExp("[+-]?", "suy"));
|
|
839
|
+
var $R31 = $R(new RegExp("[+-]", "suy"));
|
|
840
|
+
var $R32 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
841
|
+
var $R33 = $R(new RegExp("[\\t ]*", "suy"));
|
|
842
|
+
var $R34 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
843
|
+
var $R35 = $R(new RegExp("$", "suy"));
|
|
829
844
|
var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
|
|
830
845
|
function Program(state) {
|
|
831
846
|
if (state.verbose)
|
|
@@ -939,7 +954,9 @@ var Civet = (() => {
|
|
|
939
954
|
}
|
|
940
955
|
}
|
|
941
956
|
var UnaryPostfix$0 = $EXPECT($L3, fail, 'UnaryPostfix "?"');
|
|
942
|
-
var UnaryPostfix$1 = $S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), NonIdContinue, Type)
|
|
957
|
+
var UnaryPostfix$1 = $T($S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), NonIdContinue, Type), function(value) {
|
|
958
|
+
return { "ts": true, "children": value };
|
|
959
|
+
});
|
|
943
960
|
function UnaryPostfix(state) {
|
|
944
961
|
if (state.tokenize) {
|
|
945
962
|
return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state));
|
|
@@ -947,8 +964,8 @@ var Civet = (() => {
|
|
|
947
964
|
return UnaryPostfix$0(state) || UnaryPostfix$1(state);
|
|
948
965
|
}
|
|
949
966
|
}
|
|
950
|
-
var UpdateExpression$0 = $S(
|
|
951
|
-
var UpdateExpression$1 = $S(LeftHandSideExpression, $E(
|
|
967
|
+
var UpdateExpression$0 = $S(UpdateExpressionSymbol, UnaryExpression);
|
|
968
|
+
var UpdateExpression$1 = $S(LeftHandSideExpression, $E(UpdateExpressionSymbol));
|
|
952
969
|
function UpdateExpression(state) {
|
|
953
970
|
if (state.tokenize) {
|
|
954
971
|
return $TOKEN("UpdateExpression", state, UpdateExpression$0(state) || UpdateExpression$1(state));
|
|
@@ -956,6 +973,18 @@ var Civet = (() => {
|
|
|
956
973
|
return UpdateExpression$0(state) || UpdateExpression$1(state);
|
|
957
974
|
}
|
|
958
975
|
}
|
|
976
|
+
var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L5, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L6, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
|
|
977
|
+
return { $loc, token: $1 };
|
|
978
|
+
});
|
|
979
|
+
function UpdateExpressionSymbol(state) {
|
|
980
|
+
if (state.verbose)
|
|
981
|
+
console.log("ENTER:", "UpdateExpressionSymbol");
|
|
982
|
+
if (state.tokenize) {
|
|
983
|
+
return $TOKEN("UpdateExpressionSymbol", state, UpdateExpressionSymbol$0(state));
|
|
984
|
+
} else {
|
|
985
|
+
return UpdateExpressionSymbol$0(state);
|
|
986
|
+
}
|
|
987
|
+
}
|
|
959
988
|
var AssignmentExpression$0 = $S($Q(TrailingComment), AssignmentExpressionRest);
|
|
960
989
|
var AssignmentExpression$1 = $S(__, AssignmentExpressionRest);
|
|
961
990
|
function AssignmentExpression(state) {
|
|
@@ -1069,7 +1098,7 @@ var Civet = (() => {
|
|
|
1069
1098
|
return ClassDeclaration$0(state);
|
|
1070
1099
|
}
|
|
1071
1100
|
}
|
|
1072
|
-
var ClassExpression$0 = $S(
|
|
1101
|
+
var ClassExpression$0 = $S(Class, $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
|
|
1073
1102
|
function ClassExpression(state) {
|
|
1074
1103
|
if (state.verbose)
|
|
1075
1104
|
console.log("ENTER:", "ClassExpression");
|
|
@@ -1079,6 +1108,18 @@ var Civet = (() => {
|
|
|
1079
1108
|
return ClassExpression$0(state);
|
|
1080
1109
|
}
|
|
1081
1110
|
}
|
|
1111
|
+
var Class$0 = $TV($EXPECT($L13, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
1112
|
+
return { $loc, token: $0 };
|
|
1113
|
+
});
|
|
1114
|
+
function Class(state) {
|
|
1115
|
+
if (state.verbose)
|
|
1116
|
+
console.log("ENTER:", "Class");
|
|
1117
|
+
if (state.tokenize) {
|
|
1118
|
+
return $TOKEN("Class", state, Class$0(state));
|
|
1119
|
+
} else {
|
|
1120
|
+
return Class$0(state);
|
|
1121
|
+
}
|
|
1122
|
+
}
|
|
1082
1123
|
var ClassHeritage$0 = $S(ExtendsToken, __, MemberExpression);
|
|
1083
1124
|
function ClassHeritage(state) {
|
|
1084
1125
|
if (state.verbose)
|
|
@@ -1089,10 +1130,12 @@ var Civet = (() => {
|
|
|
1089
1130
|
return ClassHeritage$0(state);
|
|
1090
1131
|
}
|
|
1091
1132
|
}
|
|
1092
|
-
var ExtendsToken$0 = $
|
|
1093
|
-
return "extends";
|
|
1133
|
+
var ExtendsToken$0 = $TV($EXPECT($L14, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
|
|
1134
|
+
return { $loc, token: "extends" };
|
|
1135
|
+
});
|
|
1136
|
+
var ExtendsToken$1 = $TV($EXPECT($L15, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
|
|
1137
|
+
return { $loc, token: $1 };
|
|
1094
1138
|
});
|
|
1095
|
-
var ExtendsToken$1 = $EXPECT($L15, fail, 'ExtendsToken "extends"');
|
|
1096
1139
|
function ExtendsToken(state) {
|
|
1097
1140
|
if (state.tokenize) {
|
|
1098
1141
|
return $TOKEN("ExtendsToken", state, ExtendsToken$0(state) || ExtendsToken$1(state));
|
|
@@ -1134,8 +1177,8 @@ var Civet = (() => {
|
|
|
1134
1177
|
return NestedClassElement$0(state);
|
|
1135
1178
|
}
|
|
1136
1179
|
}
|
|
1137
|
-
var ClassElement$0 = $S(
|
|
1138
|
-
var ClassElement$1 = $S($E($S(
|
|
1180
|
+
var ClassElement$0 = $S(Static, BracedBlock);
|
|
1181
|
+
var ClassElement$1 = $S($E($S(Static, __)), $C(MethodDefinition, FieldDefinition));
|
|
1139
1182
|
function ClassElement(state) {
|
|
1140
1183
|
if (state.tokenize) {
|
|
1141
1184
|
return $TOKEN("ClassElement", state, ClassElement$0(state) || ClassElement$1(state));
|
|
@@ -1143,6 +1186,18 @@ var Civet = (() => {
|
|
|
1143
1186
|
return ClassElement$0(state) || ClassElement$1(state);
|
|
1144
1187
|
}
|
|
1145
1188
|
}
|
|
1189
|
+
var Static$0 = $TV($EXPECT($L17, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
1190
|
+
return { $loc, token: $0 };
|
|
1191
|
+
});
|
|
1192
|
+
function Static(state) {
|
|
1193
|
+
if (state.verbose)
|
|
1194
|
+
console.log("ENTER:", "Static");
|
|
1195
|
+
if (state.tokenize) {
|
|
1196
|
+
return $TOKEN("Static", state, Static$0(state));
|
|
1197
|
+
} else {
|
|
1198
|
+
return Static$0(state);
|
|
1199
|
+
}
|
|
1200
|
+
}
|
|
1146
1201
|
var FieldDefinition$0 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
|
|
1147
1202
|
function FieldDefinition(state) {
|
|
1148
1203
|
if (state.verbose)
|
|
@@ -1153,12 +1208,11 @@ var Civet = (() => {
|
|
|
1153
1208
|
return FieldDefinition$0(state);
|
|
1154
1209
|
}
|
|
1155
1210
|
}
|
|
1156
|
-
var This$0 = $EXPECT($L18, fail, 'This "this"')
|
|
1157
|
-
|
|
1158
|
-
var ref = value[1];
|
|
1159
|
-
return ["this.", ref];
|
|
1211
|
+
var This$0 = $TV($EXPECT($L18, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
1212
|
+
return { $loc, token: $0 };
|
|
1160
1213
|
});
|
|
1161
|
-
var This$
|
|
1214
|
+
var This$1 = $S(AtAccessor, $S($E($EXPECT($L19, fail, 'This "#"')), IdentifierName));
|
|
1215
|
+
var This$2 = $TV($EXPECT($L20, fail, 'This "@"'), function($skip, $loc, $0, $1) {
|
|
1162
1216
|
return { $loc, token: "this" };
|
|
1163
1217
|
});
|
|
1164
1218
|
function This(state) {
|
|
@@ -1168,6 +1222,18 @@ var Civet = (() => {
|
|
|
1168
1222
|
return This$0(state) || This$1(state) || This$2(state);
|
|
1169
1223
|
}
|
|
1170
1224
|
}
|
|
1225
|
+
var AtAccessor$0 = $TV($EXPECT($L20, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
|
|
1226
|
+
return { $loc, token: "this." };
|
|
1227
|
+
});
|
|
1228
|
+
function AtAccessor(state) {
|
|
1229
|
+
if (state.verbose)
|
|
1230
|
+
console.log("ENTER:", "AtAccessor");
|
|
1231
|
+
if (state.tokenize) {
|
|
1232
|
+
return $TOKEN("AtAccessor", state, AtAccessor$0(state));
|
|
1233
|
+
} else {
|
|
1234
|
+
return AtAccessor$0(state);
|
|
1235
|
+
}
|
|
1236
|
+
}
|
|
1171
1237
|
var LeftHandSideExpression$0 = NewExpression;
|
|
1172
1238
|
var LeftHandSideExpression$1 = CallExpression;
|
|
1173
1239
|
function LeftHandSideExpression(state) {
|
|
@@ -1439,11 +1505,17 @@ var Civet = (() => {
|
|
|
1439
1505
|
return FunctionExpression$0(state) || FunctionExpression$1(state);
|
|
1440
1506
|
}
|
|
1441
1507
|
}
|
|
1442
|
-
var ThinArrowFunction$0 = $
|
|
1443
|
-
var params =
|
|
1444
|
-
var suffix =
|
|
1445
|
-
var
|
|
1446
|
-
|
|
1508
|
+
var ThinArrowFunction$0 = $TS($S(Parameters, $E(ReturnTypeSuffix), __, Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1509
|
+
var params = $1;
|
|
1510
|
+
var suffix = $2;
|
|
1511
|
+
var arrow = $4;
|
|
1512
|
+
var block = $5;
|
|
1513
|
+
return [
|
|
1514
|
+
{ $loc: arrow.$loc, token: "function" },
|
|
1515
|
+
params,
|
|
1516
|
+
suffix,
|
|
1517
|
+
block
|
|
1518
|
+
];
|
|
1447
1519
|
});
|
|
1448
1520
|
function ThinArrowFunction(state) {
|
|
1449
1521
|
if (state.verbose)
|
|
@@ -1454,6 +1526,18 @@ var Civet = (() => {
|
|
|
1454
1526
|
return ThinArrowFunction$0(state);
|
|
1455
1527
|
}
|
|
1456
1528
|
}
|
|
1529
|
+
var Arrow$0 = $TV($EXPECT($L34, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
1530
|
+
return { $loc, token: $1 };
|
|
1531
|
+
});
|
|
1532
|
+
function Arrow(state) {
|
|
1533
|
+
if (state.verbose)
|
|
1534
|
+
console.log("ENTER:", "Arrow");
|
|
1535
|
+
if (state.tokenize) {
|
|
1536
|
+
return $TOKEN("Arrow", state, Arrow$0(state));
|
|
1537
|
+
} else {
|
|
1538
|
+
return Arrow$0(state);
|
|
1539
|
+
}
|
|
1540
|
+
}
|
|
1457
1541
|
var Block$0 = $S(__, $EXPECT($L11, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'Block "}"'));
|
|
1458
1542
|
var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1459
1543
|
var Block$2 = Statement;
|
|
@@ -1465,6 +1549,15 @@ var Civet = (() => {
|
|
|
1465
1549
|
return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
|
|
1466
1550
|
}
|
|
1467
1551
|
}
|
|
1552
|
+
var BracedOrEmptyBlock$0 = BracedBlock;
|
|
1553
|
+
var BracedOrEmptyBlock$1 = $S(InsertOpenBrace, InsertCloseBrace);
|
|
1554
|
+
function BracedOrEmptyBlock(state) {
|
|
1555
|
+
if (state.tokenize) {
|
|
1556
|
+
return $TOKEN("BracedOrEmptyBlock", state, BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state));
|
|
1557
|
+
} else {
|
|
1558
|
+
return BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state);
|
|
1559
|
+
}
|
|
1560
|
+
}
|
|
1468
1561
|
var BracedBlock$0 = $S(__, $EXPECT($L11, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BracedBlock "}"'));
|
|
1469
1562
|
var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1470
1563
|
var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
|
|
@@ -1530,17 +1623,39 @@ var Civet = (() => {
|
|
|
1530
1623
|
return BlockExpression$0(state);
|
|
1531
1624
|
}
|
|
1532
1625
|
}
|
|
1533
|
-
var Literal$0 =
|
|
1534
|
-
var Literal$1 =
|
|
1535
|
-
var Literal$2 =
|
|
1536
|
-
var Literal$3 =
|
|
1537
|
-
var Literal$4 = $EXPECT($L37, fail, 'Literal "null"');
|
|
1538
|
-
var Literal$5 = $EXPECT($L38, fail, 'Literal "undefined"');
|
|
1626
|
+
var Literal$0 = NullLiteral;
|
|
1627
|
+
var Literal$1 = BooleanLiteral;
|
|
1628
|
+
var Literal$2 = NumericLiteral;
|
|
1629
|
+
var Literal$3 = StringLiteral;
|
|
1539
1630
|
function Literal(state) {
|
|
1540
1631
|
if (state.tokenize) {
|
|
1541
|
-
return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state)
|
|
1632
|
+
return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state));
|
|
1633
|
+
} else {
|
|
1634
|
+
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
|
|
1635
|
+
}
|
|
1636
|
+
}
|
|
1637
|
+
var NullLiteral$0 = $TV($EXPECT($L35, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
1638
|
+
return { $loc, token: $1 };
|
|
1639
|
+
});
|
|
1640
|
+
function NullLiteral(state) {
|
|
1641
|
+
if (state.verbose)
|
|
1642
|
+
console.log("ENTER:", "NullLiteral");
|
|
1643
|
+
if (state.tokenize) {
|
|
1644
|
+
return $TOKEN("NullLiteral", state, NullLiteral$0(state));
|
|
1645
|
+
} else {
|
|
1646
|
+
return NullLiteral$0(state);
|
|
1647
|
+
}
|
|
1648
|
+
}
|
|
1649
|
+
var BooleanLiteral$0 = $TV($C($EXPECT($L36, fail, 'BooleanLiteral "true"'), $EXPECT($L37, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
|
|
1650
|
+
return { $loc, token: $1 };
|
|
1651
|
+
});
|
|
1652
|
+
function BooleanLiteral(state) {
|
|
1653
|
+
if (state.verbose)
|
|
1654
|
+
console.log("ENTER:", "BooleanLiteral");
|
|
1655
|
+
if (state.tokenize) {
|
|
1656
|
+
return $TOKEN("BooleanLiteral", state, BooleanLiteral$0(state));
|
|
1542
1657
|
} else {
|
|
1543
|
-
return
|
|
1658
|
+
return BooleanLiteral$0(state);
|
|
1544
1659
|
}
|
|
1545
1660
|
}
|
|
1546
1661
|
var Comma$0 = $S($Q(_), $EXPECT($L0, fail, 'Comma ","'), $Q(_));
|
|
@@ -1760,8 +1875,8 @@ var Civet = (() => {
|
|
|
1760
1875
|
return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
|
|
1761
1876
|
}
|
|
1762
1877
|
}
|
|
1763
|
-
var MethodDefinition$0 = $S($EXPECT($
|
|
1764
|
-
var MethodDefinition$1 = $S($EXPECT($
|
|
1878
|
+
var MethodDefinition$0 = $S($EXPECT($L38, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1879
|
+
var MethodDefinition$1 = $S($EXPECT($L39, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
|
|
1765
1880
|
var MethodDefinition$2 = AsyncGeneratorMethod;
|
|
1766
1881
|
var MethodDefinition$3 = AsyncMethod;
|
|
1767
1882
|
var MethodDefinition$4 = GeneratorMethod;
|
|
@@ -1782,7 +1897,7 @@ var Civet = (() => {
|
|
|
1782
1897
|
return ClassElementName$0(state) || ClassElementName$1(state);
|
|
1783
1898
|
}
|
|
1784
1899
|
}
|
|
1785
|
-
var PrivateIdentifier$0 = $S($EXPECT($
|
|
1900
|
+
var PrivateIdentifier$0 = $S($EXPECT($L19, fail, 'PrivateIdentifier "#"'), IdentifierName);
|
|
1786
1901
|
function PrivateIdentifier(state) {
|
|
1787
1902
|
if (state.verbose)
|
|
1788
1903
|
console.log("ENTER:", "PrivateIdentifier");
|
|
@@ -1852,80 +1967,104 @@ var Civet = (() => {
|
|
|
1852
1967
|
return AsyncGeneratorBody$0(state);
|
|
1853
1968
|
}
|
|
1854
1969
|
}
|
|
1855
|
-
var AssignmentOp$0 = $
|
|
1856
|
-
|
|
1857
|
-
|
|
1858
|
-
var AssignmentOp$3 = $EXPECT($L44, fail, 'AssignmentOp "%="');
|
|
1859
|
-
var AssignmentOp$4 = $EXPECT($L45, fail, 'AssignmentOp "+="');
|
|
1860
|
-
var AssignmentOp$5 = $EXPECT($L46, fail, 'AssignmentOp "-="');
|
|
1861
|
-
var AssignmentOp$6 = $EXPECT($L47, fail, 'AssignmentOp "<<="');
|
|
1862
|
-
var AssignmentOp$7 = $EXPECT($L48, fail, 'AssignmentOp ">>>="');
|
|
1863
|
-
var AssignmentOp$8 = $EXPECT($L49, fail, 'AssignmentOp ">>="');
|
|
1864
|
-
var AssignmentOp$9 = $EXPECT($L50, fail, 'AssignmentOp "&&="');
|
|
1865
|
-
var AssignmentOp$10 = $EXPECT($L51, fail, 'AssignmentOp "&="');
|
|
1866
|
-
var AssignmentOp$11 = $EXPECT($L52, fail, 'AssignmentOp "^="');
|
|
1867
|
-
var AssignmentOp$12 = $EXPECT($L53, fail, 'AssignmentOp "||="');
|
|
1868
|
-
var AssignmentOp$13 = $EXPECT($L54, fail, 'AssignmentOp "|="');
|
|
1869
|
-
var AssignmentOp$14 = $EXPECT($L55, fail, 'AssignmentOp "??="');
|
|
1870
|
-
var AssignmentOp$15 = $EXPECT($L56, fail, 'AssignmentOp "="');
|
|
1970
|
+
var AssignmentOp$0 = $TS($S(AssignmentOpSymbol), function($skip, $loc, $0, $1) {
|
|
1971
|
+
return { $loc, token: $1 };
|
|
1972
|
+
});
|
|
1871
1973
|
function AssignmentOp(state) {
|
|
1974
|
+
if (state.verbose)
|
|
1975
|
+
console.log("ENTER:", "AssignmentOp");
|
|
1976
|
+
if (state.tokenize) {
|
|
1977
|
+
return $TOKEN("AssignmentOp", state, AssignmentOp$0(state));
|
|
1978
|
+
} else {
|
|
1979
|
+
return AssignmentOp$0(state);
|
|
1980
|
+
}
|
|
1981
|
+
}
|
|
1982
|
+
var AssignmentOpSymbol$0 = $EXPECT($L40, fail, 'AssignmentOpSymbol "**="');
|
|
1983
|
+
var AssignmentOpSymbol$1 = $EXPECT($L41, fail, 'AssignmentOpSymbol "*="');
|
|
1984
|
+
var AssignmentOpSymbol$2 = $EXPECT($L42, fail, 'AssignmentOpSymbol "/="');
|
|
1985
|
+
var AssignmentOpSymbol$3 = $EXPECT($L43, fail, 'AssignmentOpSymbol "%="');
|
|
1986
|
+
var AssignmentOpSymbol$4 = $EXPECT($L44, fail, 'AssignmentOpSymbol "+="');
|
|
1987
|
+
var AssignmentOpSymbol$5 = $EXPECT($L45, fail, 'AssignmentOpSymbol "-="');
|
|
1988
|
+
var AssignmentOpSymbol$6 = $EXPECT($L46, fail, 'AssignmentOpSymbol "<<="');
|
|
1989
|
+
var AssignmentOpSymbol$7 = $EXPECT($L47, fail, 'AssignmentOpSymbol ">>>="');
|
|
1990
|
+
var AssignmentOpSymbol$8 = $EXPECT($L48, fail, 'AssignmentOpSymbol ">>="');
|
|
1991
|
+
var AssignmentOpSymbol$9 = $EXPECT($L49, fail, 'AssignmentOpSymbol "&&="');
|
|
1992
|
+
var AssignmentOpSymbol$10 = $EXPECT($L50, fail, 'AssignmentOpSymbol "&="');
|
|
1993
|
+
var AssignmentOpSymbol$11 = $EXPECT($L51, fail, 'AssignmentOpSymbol "^="');
|
|
1994
|
+
var AssignmentOpSymbol$12 = $EXPECT($L52, fail, 'AssignmentOpSymbol "||="');
|
|
1995
|
+
var AssignmentOpSymbol$13 = $EXPECT($L53, fail, 'AssignmentOpSymbol "|="');
|
|
1996
|
+
var AssignmentOpSymbol$14 = $EXPECT($L54, fail, 'AssignmentOpSymbol "??="');
|
|
1997
|
+
var AssignmentOpSymbol$15 = $EXPECT($L55, fail, 'AssignmentOpSymbol "="');
|
|
1998
|
+
function AssignmentOpSymbol(state) {
|
|
1999
|
+
if (state.tokenize) {
|
|
2000
|
+
return $TOKEN("AssignmentOpSymbol", state, AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state));
|
|
2001
|
+
} else {
|
|
2002
|
+
return AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state);
|
|
2003
|
+
}
|
|
2004
|
+
}
|
|
2005
|
+
var BinaryOp$0 = $TS($S(BinaryOpSymbol), function($skip, $loc, $0, $1) {
|
|
2006
|
+
return { $loc, token: $1 };
|
|
2007
|
+
});
|
|
2008
|
+
function BinaryOp(state) {
|
|
2009
|
+
if (state.verbose)
|
|
2010
|
+
console.log("ENTER:", "BinaryOp");
|
|
1872
2011
|
if (state.tokenize) {
|
|
1873
|
-
return $TOKEN("
|
|
1874
|
-
} else {
|
|
1875
|
-
return
|
|
1876
|
-
}
|
|
1877
|
-
}
|
|
1878
|
-
var
|
|
1879
|
-
var
|
|
1880
|
-
var
|
|
1881
|
-
var
|
|
1882
|
-
var
|
|
1883
|
-
var
|
|
1884
|
-
var
|
|
1885
|
-
var
|
|
1886
|
-
var
|
|
1887
|
-
var
|
|
1888
|
-
var
|
|
1889
|
-
var
|
|
1890
|
-
var
|
|
1891
|
-
var
|
|
1892
|
-
var
|
|
2012
|
+
return $TOKEN("BinaryOp", state, BinaryOp$0(state));
|
|
2013
|
+
} else {
|
|
2014
|
+
return BinaryOp$0(state);
|
|
2015
|
+
}
|
|
2016
|
+
}
|
|
2017
|
+
var BinaryOpSymbol$0 = $EXPECT($L56, fail, 'BinaryOpSymbol "**"');
|
|
2018
|
+
var BinaryOpSymbol$1 = $EXPECT($L9, fail, 'BinaryOpSymbol "*"');
|
|
2019
|
+
var BinaryOpSymbol$2 = $EXPECT($L57, fail, 'BinaryOpSymbol "/"');
|
|
2020
|
+
var BinaryOpSymbol$3 = $EXPECT($L58, fail, 'BinaryOpSymbol "%"');
|
|
2021
|
+
var BinaryOpSymbol$4 = $EXPECT($L59, fail, 'BinaryOpSymbol "+"');
|
|
2022
|
+
var BinaryOpSymbol$5 = $EXPECT($L60, fail, 'BinaryOpSymbol "-"');
|
|
2023
|
+
var BinaryOpSymbol$6 = $EXPECT($L61, fail, 'BinaryOpSymbol "<="');
|
|
2024
|
+
var BinaryOpSymbol$7 = $EXPECT($L62, fail, 'BinaryOpSymbol ">="');
|
|
2025
|
+
var BinaryOpSymbol$8 = $EXPECT($L63, fail, 'BinaryOpSymbol "<<"');
|
|
2026
|
+
var BinaryOpSymbol$9 = $EXPECT($L14, fail, 'BinaryOpSymbol "<"');
|
|
2027
|
+
var BinaryOpSymbol$10 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>>"');
|
|
2028
|
+
var BinaryOpSymbol$11 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>"');
|
|
2029
|
+
var BinaryOpSymbol$12 = $EXPECT($L66, fail, 'BinaryOpSymbol ">"');
|
|
2030
|
+
var BinaryOpSymbol$13 = $EXPECT($L67, fail, 'BinaryOpSymbol "!=="');
|
|
2031
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L68, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
1893
2032
|
if (global.coffeeCompat)
|
|
1894
2033
|
return "!==";
|
|
1895
2034
|
return $1;
|
|
1896
2035
|
});
|
|
1897
|
-
var
|
|
2036
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L69, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
1898
2037
|
return "===";
|
|
1899
2038
|
});
|
|
1900
|
-
var
|
|
1901
|
-
var
|
|
2039
|
+
var BinaryOpSymbol$16 = $EXPECT($L70, fail, 'BinaryOpSymbol "==="');
|
|
2040
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L71, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
1902
2041
|
if (global.coffeeCompat)
|
|
1903
2042
|
return "===";
|
|
1904
2043
|
return $1;
|
|
1905
2044
|
});
|
|
1906
|
-
var
|
|
2045
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L72, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
1907
2046
|
return "&&";
|
|
1908
2047
|
});
|
|
1909
|
-
var
|
|
1910
|
-
var
|
|
2048
|
+
var BinaryOpSymbol$19 = $EXPECT($L73, fail, 'BinaryOpSymbol "&&"');
|
|
2049
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
1911
2050
|
return "||";
|
|
1912
2051
|
});
|
|
1913
|
-
var
|
|
1914
|
-
var
|
|
1915
|
-
var
|
|
1916
|
-
var
|
|
1917
|
-
var
|
|
1918
|
-
var
|
|
1919
|
-
var
|
|
1920
|
-
function
|
|
2052
|
+
var BinaryOpSymbol$21 = $EXPECT($L75, fail, 'BinaryOpSymbol "||"');
|
|
2053
|
+
var BinaryOpSymbol$22 = $EXPECT($L76, fail, 'BinaryOpSymbol "??"');
|
|
2054
|
+
var BinaryOpSymbol$23 = $S($EXPECT($L77, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue);
|
|
2055
|
+
var BinaryOpSymbol$24 = $S($EXPECT($L78, fail, 'BinaryOpSymbol "in"'), NonIdContinue);
|
|
2056
|
+
var BinaryOpSymbol$25 = $EXPECT($L79, fail, 'BinaryOpSymbol "&"');
|
|
2057
|
+
var BinaryOpSymbol$26 = $EXPECT($L80, fail, 'BinaryOpSymbol "^"');
|
|
2058
|
+
var BinaryOpSymbol$27 = $EXPECT($L81, fail, 'BinaryOpSymbol "|"');
|
|
2059
|
+
function BinaryOpSymbol(state) {
|
|
1921
2060
|
if (state.tokenize) {
|
|
1922
|
-
return $TOKEN("
|
|
2061
|
+
return $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state));
|
|
1923
2062
|
} else {
|
|
1924
|
-
return
|
|
2063
|
+
return BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state);
|
|
1925
2064
|
}
|
|
1926
2065
|
}
|
|
1927
2066
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
1928
|
-
var UnaryOp$1 = $S($C($EXPECT($
|
|
2067
|
+
var UnaryOp$1 = $S($C($EXPECT($L82, fail, 'UnaryOp "delete"'), $EXPECT($L83, fail, 'UnaryOp "void"'), $EXPECT($L84, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
|
|
1929
2068
|
function UnaryOp(state) {
|
|
1930
2069
|
if (state.tokenize) {
|
|
1931
2070
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -1959,7 +2098,7 @@ var Civet = (() => {
|
|
|
1959
2098
|
return StatementListItem$0(state);
|
|
1960
2099
|
}
|
|
1961
2100
|
}
|
|
1962
|
-
var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($
|
|
2101
|
+
var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($L85, fail, 'PostfixConditional "if"'), $EXPECT($L86, fail, 'PostfixConditional "unless"')), NonIdContinue, Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1963
2102
|
var ws = $1;
|
|
1964
2103
|
var cond = $2;
|
|
1965
2104
|
var exp = $4;
|
|
@@ -1992,7 +2131,7 @@ var Civet = (() => {
|
|
|
1992
2131
|
return Statement$0(state) || Statement$1(state) || Statement$2(state) || Statement$3(state) || Statement$4(state) || Statement$5(state) || Statement$6(state) || Statement$7(state) || Statement$8(state);
|
|
1993
2132
|
}
|
|
1994
2133
|
}
|
|
1995
|
-
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($
|
|
2134
|
+
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L87, fail, 'EmptyStatement ";"')));
|
|
1996
2135
|
function EmptyStatement(state) {
|
|
1997
2136
|
if (state.verbose)
|
|
1998
2137
|
console.log("ENTER:", "EmptyStatement");
|
|
@@ -2012,8 +2151,8 @@ var Civet = (() => {
|
|
|
2012
2151
|
return BlockStatement$0(state);
|
|
2013
2152
|
}
|
|
2014
2153
|
}
|
|
2015
|
-
var IfStatement$0 = $S($EXPECT($
|
|
2016
|
-
var IfStatement$1 = $TS($S($EXPECT($
|
|
2154
|
+
var IfStatement$0 = $S($EXPECT($L85, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L88, fail, 'IfStatement "else"'), Block)));
|
|
2155
|
+
var IfStatement$1 = $TS($S($EXPECT($L86, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
|
|
2017
2156
|
var condition = $2;
|
|
2018
2157
|
var block = $3;
|
|
2019
2158
|
return ["if", condition.map((c) => {
|
|
@@ -2043,7 +2182,7 @@ var Civet = (() => {
|
|
|
2043
2182
|
return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
|
|
2044
2183
|
}
|
|
2045
2184
|
}
|
|
2046
|
-
var LoopStatement$0 = $TS($S($EXPECT($
|
|
2185
|
+
var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
|
|
2047
2186
|
var b = $3;
|
|
2048
2187
|
return ["while(true)", b];
|
|
2049
2188
|
});
|
|
@@ -2056,7 +2195,7 @@ var Civet = (() => {
|
|
|
2056
2195
|
return LoopStatement$0(state);
|
|
2057
2196
|
}
|
|
2058
2197
|
}
|
|
2059
|
-
var DoWhileStatement$0 = $S($EXPECT($
|
|
2198
|
+
var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
|
|
2060
2199
|
function DoWhileStatement(state) {
|
|
2061
2200
|
if (state.verbose)
|
|
2062
2201
|
console.log("ENTER:", "DoWhileStatement");
|
|
@@ -2076,7 +2215,7 @@ var Civet = (() => {
|
|
|
2076
2215
|
return WhileStatement$0(state);
|
|
2077
2216
|
}
|
|
2078
2217
|
}
|
|
2079
|
-
var WhileClause$0 = $TS($S($C($EXPECT($
|
|
2218
|
+
var WhileClause$0 = $TS($S($C($EXPECT($L91, fail, 'WhileClause "while"'), $EXPECT($L92, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
|
|
2080
2219
|
var kind = $1;
|
|
2081
2220
|
var cond = $3;
|
|
2082
2221
|
if (kind === "until") {
|
|
@@ -2095,7 +2234,7 @@ var Civet = (() => {
|
|
|
2095
2234
|
return WhileClause$0(state);
|
|
2096
2235
|
}
|
|
2097
2236
|
}
|
|
2098
|
-
var ForStatement$0 = $S(
|
|
2237
|
+
var ForStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L87, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L87, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
|
|
2099
2238
|
function ForStatement(state) {
|
|
2100
2239
|
if (state.verbose)
|
|
2101
2240
|
console.log("ENTER:", "ForStatement");
|
|
@@ -2105,10 +2244,10 @@ var Civet = (() => {
|
|
|
2105
2244
|
return ForStatement$0(state);
|
|
2106
2245
|
}
|
|
2107
2246
|
}
|
|
2108
|
-
var ForInOfStatement$0 = $S(
|
|
2109
|
-
var ForInOfStatement$1 = $S(
|
|
2110
|
-
var ForInOfStatement$2 = $S(
|
|
2111
|
-
var ForInOfStatement$3 = $S(
|
|
2247
|
+
var ForInOfStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
|
|
2248
|
+
var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
|
|
2249
|
+
var ForInOfStatement$2 = $S(For, $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
|
|
2250
|
+
var ForInOfStatement$3 = $S(For, $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
|
|
2112
2251
|
function ForInOfStatement(state) {
|
|
2113
2252
|
if (state.tokenize) {
|
|
2114
2253
|
return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
|
|
@@ -2116,7 +2255,19 @@ var Civet = (() => {
|
|
|
2116
2255
|
return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
|
|
2117
2256
|
}
|
|
2118
2257
|
}
|
|
2119
|
-
var
|
|
2258
|
+
var For$0 = $TS($S($EXPECT($L96, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2259
|
+
return { $loc, token: $1 };
|
|
2260
|
+
});
|
|
2261
|
+
function For(state) {
|
|
2262
|
+
if (state.verbose)
|
|
2263
|
+
console.log("ENTER:", "For");
|
|
2264
|
+
if (state.tokenize) {
|
|
2265
|
+
return $TOKEN("For", state, For$0(state));
|
|
2266
|
+
} else {
|
|
2267
|
+
return For$0(state);
|
|
2268
|
+
}
|
|
2269
|
+
}
|
|
2270
|
+
var ForDeclaration$0 = $S(LetOrConst, NonIdContinue, __, ForBinding);
|
|
2120
2271
|
function ForDeclaration(state) {
|
|
2121
2272
|
if (state.verbose)
|
|
2122
2273
|
console.log("ENTER:", "ForDeclaration");
|
|
@@ -2126,6 +2277,18 @@ var Civet = (() => {
|
|
|
2126
2277
|
return ForDeclaration$0(state);
|
|
2127
2278
|
}
|
|
2128
2279
|
}
|
|
2280
|
+
var LetOrConst$0 = $TV($C($EXPECT($L97, fail, 'LetOrConst "let"'), $EXPECT($L98, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
2281
|
+
return { $loc, token: $1 };
|
|
2282
|
+
});
|
|
2283
|
+
function LetOrConst(state) {
|
|
2284
|
+
if (state.verbose)
|
|
2285
|
+
console.log("ENTER:", "LetOrConst");
|
|
2286
|
+
if (state.tokenize) {
|
|
2287
|
+
return $TOKEN("LetOrConst", state, LetOrConst$0(state));
|
|
2288
|
+
} else {
|
|
2289
|
+
return LetOrConst$0(state);
|
|
2290
|
+
}
|
|
2291
|
+
}
|
|
2129
2292
|
var ForBinding$0 = BindingIdentifier;
|
|
2130
2293
|
var ForBinding$1 = BindingPattern;
|
|
2131
2294
|
function ForBinding(state) {
|
|
@@ -2135,7 +2298,7 @@ var Civet = (() => {
|
|
|
2135
2298
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
2136
2299
|
}
|
|
2137
2300
|
}
|
|
2138
|
-
var SwitchStatement$0 = $S($EXPECT($
|
|
2301
|
+
var SwitchStatement$0 = $S($EXPECT($L99, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
|
|
2139
2302
|
function SwitchStatement(state) {
|
|
2140
2303
|
if (state.verbose)
|
|
2141
2304
|
console.log("ENTER:", "SwitchStatement");
|
|
@@ -2179,9 +2342,9 @@ var Civet = (() => {
|
|
|
2179
2342
|
return NestedCaseClause$0(state);
|
|
2180
2343
|
}
|
|
2181
2344
|
}
|
|
2182
|
-
var CaseClause$0 = $S($EXPECT($
|
|
2345
|
+
var CaseClause$0 = $S($EXPECT($L100, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
|
|
2183
2346
|
var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
|
|
2184
|
-
var CaseClause$2 = $S($EXPECT($
|
|
2347
|
+
var CaseClause$2 = $S($EXPECT($L101, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
|
|
2185
2348
|
function CaseClause(state) {
|
|
2186
2349
|
if (state.tokenize) {
|
|
2187
2350
|
return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
|
|
@@ -2189,7 +2352,7 @@ var Civet = (() => {
|
|
|
2189
2352
|
return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
|
|
2190
2353
|
}
|
|
2191
2354
|
}
|
|
2192
|
-
var When$0 = $T($S($EXPECT($
|
|
2355
|
+
var When$0 = $T($S($EXPECT($L102, fail, 'When "when"'), NonIdContinue), function(value) {
|
|
2193
2356
|
return "case";
|
|
2194
2357
|
});
|
|
2195
2358
|
function When(state) {
|
|
@@ -2212,7 +2375,7 @@ var Civet = (() => {
|
|
|
2212
2375
|
return ImpliedColon$0(state) || ImpliedColon$1(state);
|
|
2213
2376
|
}
|
|
2214
2377
|
}
|
|
2215
|
-
var TryStatement$0 = $TS($S($EXPECT($
|
|
2378
|
+
var TryStatement$0 = $TS($S($EXPECT($L103, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2216
2379
|
var c = $3;
|
|
2217
2380
|
var f = $4;
|
|
2218
2381
|
if (!c && !f) {
|
|
@@ -2229,7 +2392,7 @@ var Civet = (() => {
|
|
|
2229
2392
|
return TryStatement$0(state);
|
|
2230
2393
|
}
|
|
2231
2394
|
}
|
|
2232
|
-
var Catch$0 = $S(__, $EXPECT($
|
|
2395
|
+
var Catch$0 = $S(__, $EXPECT($L104, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
|
|
2233
2396
|
function Catch(state) {
|
|
2234
2397
|
if (state.verbose)
|
|
2235
2398
|
console.log("ENTER:", "Catch");
|
|
@@ -2248,7 +2411,7 @@ var Civet = (() => {
|
|
|
2248
2411
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2249
2412
|
}
|
|
2250
2413
|
}
|
|
2251
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2414
|
+
var Finally$0 = $S(__, $EXPECT($L105, fail, 'Finally "finally"'), BracedBlock);
|
|
2252
2415
|
function Finally(state) {
|
|
2253
2416
|
if (state.verbose)
|
|
2254
2417
|
console.log("ENTER:", "Finally");
|
|
@@ -2286,11 +2449,11 @@ var Civet = (() => {
|
|
|
2286
2449
|
return ExpressionStatement$0(state);
|
|
2287
2450
|
}
|
|
2288
2451
|
}
|
|
2289
|
-
var KeywordStatement$0 = $S($EXPECT($
|
|
2290
|
-
var KeywordStatement$1 = $S($EXPECT($
|
|
2291
|
-
var KeywordStatement$2 = $S($EXPECT($
|
|
2452
|
+
var KeywordStatement$0 = $S($EXPECT($L106, fail, 'KeywordStatement "break"'), NonIdContinue);
|
|
2453
|
+
var KeywordStatement$1 = $S($EXPECT($L107, fail, 'KeywordStatement "continue"'), NonIdContinue);
|
|
2454
|
+
var KeywordStatement$2 = $S($EXPECT($L108, fail, 'KeywordStatement "debugger"'), NonIdContinue);
|
|
2292
2455
|
var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
|
|
2293
|
-
var KeywordStatement$4 = $S($EXPECT($
|
|
2456
|
+
var KeywordStatement$4 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
|
|
2294
2457
|
function KeywordStatement(state) {
|
|
2295
2458
|
if (state.tokenize) {
|
|
2296
2459
|
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
|
|
@@ -2307,7 +2470,9 @@ var Civet = (() => {
|
|
|
2307
2470
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2308
2471
|
}
|
|
2309
2472
|
}
|
|
2310
|
-
var Return$0 = $S($EXPECT($
|
|
2473
|
+
var Return$0 = $TS($S($EXPECT($L110, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2474
|
+
return { $loc, token: $1 };
|
|
2475
|
+
});
|
|
2311
2476
|
function Return(state) {
|
|
2312
2477
|
if (state.verbose)
|
|
2313
2478
|
console.log("ENTER:", "Return");
|
|
@@ -2317,11 +2482,11 @@ var Civet = (() => {
|
|
|
2317
2482
|
return Return$0(state);
|
|
2318
2483
|
}
|
|
2319
2484
|
}
|
|
2320
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2485
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L111, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2321
2486
|
return { "ts": true, "children": value };
|
|
2322
2487
|
});
|
|
2323
|
-
var ImportDeclaration$1 = $S(
|
|
2324
|
-
var ImportDeclaration$2 = $S(
|
|
2488
|
+
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
2489
|
+
var ImportDeclaration$2 = $S(Import, __, ModuleSpecifier);
|
|
2325
2490
|
function ImportDeclaration(state) {
|
|
2326
2491
|
if (state.tokenize) {
|
|
2327
2492
|
return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
|
|
@@ -2329,6 +2494,18 @@ var Civet = (() => {
|
|
|
2329
2494
|
return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state);
|
|
2330
2495
|
}
|
|
2331
2496
|
}
|
|
2497
|
+
var Import$0 = $TS($S($EXPECT($L23, fail, 'Import "import"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2498
|
+
return { $loc, token: $1 };
|
|
2499
|
+
});
|
|
2500
|
+
function Import(state) {
|
|
2501
|
+
if (state.verbose)
|
|
2502
|
+
console.log("ENTER:", "Import");
|
|
2503
|
+
if (state.tokenize) {
|
|
2504
|
+
return $TOKEN("Import", state, Import$0(state));
|
|
2505
|
+
} else {
|
|
2506
|
+
return Import$0(state);
|
|
2507
|
+
}
|
|
2508
|
+
}
|
|
2332
2509
|
var ImportClause$0 = $S(ImportedBinding, $E($S(__, $EXPECT($L0, fail, 'ImportClause ","'), __, $C(NameSpaceImport, NamedImports))));
|
|
2333
2510
|
var ImportClause$1 = NameSpaceImport;
|
|
2334
2511
|
var ImportClause$2 = NamedImports;
|
|
@@ -2359,7 +2536,7 @@ var Civet = (() => {
|
|
|
2359
2536
|
return NamedImports$0(state);
|
|
2360
2537
|
}
|
|
2361
2538
|
}
|
|
2362
|
-
var FromClause$0 = $S(
|
|
2539
|
+
var FromClause$0 = $S(From, __, ModuleSpecifier);
|
|
2363
2540
|
function FromClause(state) {
|
|
2364
2541
|
if (state.verbose)
|
|
2365
2542
|
console.log("ENTER:", "FromClause");
|
|
@@ -2369,6 +2546,18 @@ var Civet = (() => {
|
|
|
2369
2546
|
return FromClause$0(state);
|
|
2370
2547
|
}
|
|
2371
2548
|
}
|
|
2549
|
+
var From$0 = $TS($S($EXPECT($L112, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2550
|
+
return { $loc, token: $1 };
|
|
2551
|
+
});
|
|
2552
|
+
function From(state) {
|
|
2553
|
+
if (state.verbose)
|
|
2554
|
+
console.log("ENTER:", "From");
|
|
2555
|
+
if (state.tokenize) {
|
|
2556
|
+
return $TOKEN("From", state, From$0(state));
|
|
2557
|
+
} else {
|
|
2558
|
+
return From$0(state);
|
|
2559
|
+
}
|
|
2560
|
+
}
|
|
2372
2561
|
var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
|
|
2373
2562
|
var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
|
|
2374
2563
|
function ImportSpecifier(state) {
|
|
@@ -2407,7 +2596,7 @@ var Civet = (() => {
|
|
|
2407
2596
|
return ImportedBinding$0(state);
|
|
2408
2597
|
}
|
|
2409
2598
|
}
|
|
2410
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
2599
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L101, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2411
2600
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
2412
2601
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
2413
2602
|
function ExportDeclaration(state) {
|
|
@@ -2427,7 +2616,7 @@ var Civet = (() => {
|
|
|
2427
2616
|
return As$0(state);
|
|
2428
2617
|
}
|
|
2429
2618
|
}
|
|
2430
|
-
var Export$0 = $S($EXPECT($
|
|
2619
|
+
var Export$0 = $S($EXPECT($L113, fail, 'Export "export"'), NonIdContinue);
|
|
2431
2620
|
function Export(state) {
|
|
2432
2621
|
if (state.verbose)
|
|
2433
2622
|
console.log("ENTER:", "Export");
|
|
@@ -2487,7 +2676,7 @@ var Civet = (() => {
|
|
|
2487
2676
|
return HoistableDeclaration$0(state);
|
|
2488
2677
|
}
|
|
2489
2678
|
}
|
|
2490
|
-
var LexicalDeclaration$0 = $S(
|
|
2679
|
+
var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
|
|
2491
2680
|
var LexicalDeclaration$1 = $TS($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
2492
2681
|
var bind = $1;
|
|
2493
2682
|
var suffix = $2;
|
|
@@ -2511,7 +2700,7 @@ var Civet = (() => {
|
|
|
2511
2700
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
2512
2701
|
}
|
|
2513
2702
|
}
|
|
2514
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
2703
|
+
var ConstAssignment$0 = $TV($EXPECT($L114, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
2515
2704
|
return { $loc, token: $0 };
|
|
2516
2705
|
});
|
|
2517
2706
|
function ConstAssignment(state) {
|
|
@@ -2532,7 +2721,7 @@ var Civet = (() => {
|
|
|
2532
2721
|
return LexicalBinding$0(state) || LexicalBinding$1(state);
|
|
2533
2722
|
}
|
|
2534
2723
|
}
|
|
2535
|
-
var Initializer$0 = $S(__, $EXPECT($
|
|
2724
|
+
var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
|
|
2536
2725
|
function Initializer(state) {
|
|
2537
2726
|
if (state.verbose)
|
|
2538
2727
|
console.log("ENTER:", "Initializer");
|
|
@@ -2542,7 +2731,7 @@ var Civet = (() => {
|
|
|
2542
2731
|
return Initializer$0(state);
|
|
2543
2732
|
}
|
|
2544
2733
|
}
|
|
2545
|
-
var VariableStatement$0 = $S($EXPECT($
|
|
2734
|
+
var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
|
|
2546
2735
|
function VariableStatement(state) {
|
|
2547
2736
|
if (state.verbose)
|
|
2548
2737
|
console.log("ENTER:", "VariableStatement");
|
|
@@ -2571,16 +2760,28 @@ var Civet = (() => {
|
|
|
2571
2760
|
return VariableDeclaration$0(state) || VariableDeclaration$1(state);
|
|
2572
2761
|
}
|
|
2573
2762
|
}
|
|
2574
|
-
var NumericLiteral$0 =
|
|
2575
|
-
|
|
2576
|
-
|
|
2577
|
-
var NumericLiteral$3 = HexLiteral;
|
|
2578
|
-
var NumericLiteral$4 = DecimalLiteral;
|
|
2763
|
+
var NumericLiteral$0 = $TS($S(NumericLiteralKind), function($skip, $loc, $0, $1) {
|
|
2764
|
+
return { $loc, token: $1 };
|
|
2765
|
+
});
|
|
2579
2766
|
function NumericLiteral(state) {
|
|
2767
|
+
if (state.verbose)
|
|
2768
|
+
console.log("ENTER:", "NumericLiteral");
|
|
2769
|
+
if (state.tokenize) {
|
|
2770
|
+
return $TOKEN("NumericLiteral", state, NumericLiteral$0(state));
|
|
2771
|
+
} else {
|
|
2772
|
+
return NumericLiteral$0(state);
|
|
2773
|
+
}
|
|
2774
|
+
}
|
|
2775
|
+
var NumericLiteralKind$0 = DecimalBigIntegerLiteral;
|
|
2776
|
+
var NumericLiteralKind$1 = BinaryIntegerLiteral;
|
|
2777
|
+
var NumericLiteralKind$2 = OctalIntegerLiteral;
|
|
2778
|
+
var NumericLiteralKind$3 = HexLiteral;
|
|
2779
|
+
var NumericLiteralKind$4 = DecimalLiteral;
|
|
2780
|
+
function NumericLiteralKind(state) {
|
|
2580
2781
|
if (state.tokenize) {
|
|
2581
|
-
return $TOKEN("
|
|
2782
|
+
return $TOKEN("NumericLiteralKind", state, NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state));
|
|
2582
2783
|
} else {
|
|
2583
|
-
return
|
|
2784
|
+
return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
|
|
2584
2785
|
}
|
|
2585
2786
|
}
|
|
2586
2787
|
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R3, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
@@ -2633,34 +2834,45 @@ var Civet = (() => {
|
|
|
2633
2834
|
return HexLiteral$0(state);
|
|
2634
2835
|
}
|
|
2635
2836
|
}
|
|
2636
|
-
var StringLiteral$0 = $
|
|
2637
|
-
|
|
2837
|
+
var StringLiteral$0 = $TS($S($EXPECT($L115, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L115, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function($skip, $loc, $0, $1, $2, $3) {
|
|
2838
|
+
var str = $2;
|
|
2839
|
+
return { $loc, token: "`" + module.dedentBlockString(str) + "`" };
|
|
2840
|
+
});
|
|
2841
|
+
var StringLiteral$1 = $TS($S($EXPECT($L116, fail, `StringLiteral "'''"`), $TEXT($Q(TripleSingleStringCharacter)), $EXPECT($L116, fail, `StringLiteral "'''"`)), function($skip, $loc, $0, $1, $2, $3) {
|
|
2842
|
+
var str = $2;
|
|
2843
|
+
return { $loc, token: "`" + module.dedentBlockString(str) + "`" };
|
|
2844
|
+
});
|
|
2845
|
+
var StringLiteral$2 = $TV($TEXT($S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
|
|
2846
|
+
return { $loc, token: $1 };
|
|
2847
|
+
});
|
|
2848
|
+
var StringLiteral$3 = $TV($TEXT($S($EXPECT($L118, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L118, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
|
|
2849
|
+
return { $loc, token: $1 };
|
|
2638
2850
|
});
|
|
2639
|
-
var StringLiteral$1 = $S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'));
|
|
2640
|
-
var StringLiteral$2 = $S($EXPECT($L118, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L118, fail, `StringLiteral "\\\\'"`));
|
|
2641
2851
|
function StringLiteral(state) {
|
|
2642
2852
|
if (state.tokenize) {
|
|
2643
|
-
return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state));
|
|
2853
|
+
return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state));
|
|
2644
2854
|
} else {
|
|
2645
|
-
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
|
|
2855
|
+
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
|
|
2646
2856
|
}
|
|
2647
2857
|
}
|
|
2648
|
-
var DoubleStringCharacter$0 = $R$0($EXPECT($R8, fail, 'DoubleStringCharacter /[^"
|
|
2649
|
-
var DoubleStringCharacter$1 = EscapeSequence;
|
|
2858
|
+
var DoubleStringCharacter$0 = $R$0($EXPECT($R8, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
|
|
2650
2859
|
function DoubleStringCharacter(state) {
|
|
2860
|
+
if (state.verbose)
|
|
2861
|
+
console.log("ENTER:", "DoubleStringCharacter");
|
|
2651
2862
|
if (state.tokenize) {
|
|
2652
|
-
return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state)
|
|
2863
|
+
return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state));
|
|
2653
2864
|
} else {
|
|
2654
|
-
return DoubleStringCharacter$0(state)
|
|
2865
|
+
return DoubleStringCharacter$0(state);
|
|
2655
2866
|
}
|
|
2656
2867
|
}
|
|
2657
|
-
var SingleStringCharacter$0 = $R$0($EXPECT($R9, fail, "SingleStringCharacter /[^'
|
|
2658
|
-
var SingleStringCharacter$1 = EscapeSequence;
|
|
2868
|
+
var SingleStringCharacter$0 = $R$0($EXPECT($R9, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
|
|
2659
2869
|
function SingleStringCharacter(state) {
|
|
2870
|
+
if (state.verbose)
|
|
2871
|
+
console.log("ENTER:", "SingleStringCharacter");
|
|
2660
2872
|
if (state.tokenize) {
|
|
2661
|
-
return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state)
|
|
2873
|
+
return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state));
|
|
2662
2874
|
} else {
|
|
2663
|
-
return SingleStringCharacter$0(state)
|
|
2875
|
+
return SingleStringCharacter$0(state);
|
|
2664
2876
|
}
|
|
2665
2877
|
}
|
|
2666
2878
|
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
|
|
@@ -2673,17 +2885,19 @@ var Civet = (() => {
|
|
|
2673
2885
|
return TripleDoubleStringCharacter$0(state);
|
|
2674
2886
|
}
|
|
2675
2887
|
}
|
|
2676
|
-
var
|
|
2677
|
-
function
|
|
2888
|
+
var TripleSingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "TripleSingleStringCharacter /(?:'(?!'')|\\\\.|[^'])+/"));
|
|
2889
|
+
function TripleSingleStringCharacter(state) {
|
|
2678
2890
|
if (state.verbose)
|
|
2679
|
-
console.log("ENTER:", "
|
|
2891
|
+
console.log("ENTER:", "TripleSingleStringCharacter");
|
|
2680
2892
|
if (state.tokenize) {
|
|
2681
|
-
return $TOKEN("
|
|
2893
|
+
return $TOKEN("TripleSingleStringCharacter", state, TripleSingleStringCharacter$0(state));
|
|
2682
2894
|
} else {
|
|
2683
|
-
return
|
|
2895
|
+
return TripleSingleStringCharacter$0(state);
|
|
2684
2896
|
}
|
|
2685
2897
|
}
|
|
2686
|
-
var RegularExpressionLiteral$0 = $S($EXPECT($
|
|
2898
|
+
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
2899
|
+
return { $loc, token: $1 };
|
|
2900
|
+
});
|
|
2687
2901
|
function RegularExpressionLiteral(state) {
|
|
2688
2902
|
if (state.verbose)
|
|
2689
2903
|
console.log("ENTER:", "RegularExpressionLiteral");
|
|
@@ -2703,16 +2917,17 @@ var Civet = (() => {
|
|
|
2703
2917
|
return RegularExpressionBody$0(state);
|
|
2704
2918
|
}
|
|
2705
2919
|
}
|
|
2706
|
-
var RegExpCharacter$0 = $R$0($EXPECT($R13, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
|
|
2707
|
-
var RegExpCharacter$1 = EscapeSequence;
|
|
2920
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R13, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
2708
2921
|
function RegExpCharacter(state) {
|
|
2922
|
+
if (state.verbose)
|
|
2923
|
+
console.log("ENTER:", "RegExpCharacter");
|
|
2709
2924
|
if (state.tokenize) {
|
|
2710
|
-
return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state)
|
|
2925
|
+
return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state));
|
|
2711
2926
|
} else {
|
|
2712
|
-
return RegExpCharacter$0(state)
|
|
2927
|
+
return RegExpCharacter$0(state);
|
|
2713
2928
|
}
|
|
2714
2929
|
}
|
|
2715
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($R14, fail, "RegularExpressionFlags /(
|
|
2930
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R14, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
2716
2931
|
function RegularExpressionFlags(state) {
|
|
2717
2932
|
if (state.verbose)
|
|
2718
2933
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -2722,7 +2937,7 @@ var Civet = (() => {
|
|
|
2722
2937
|
return RegularExpressionFlags$0(state);
|
|
2723
2938
|
}
|
|
2724
2939
|
}
|
|
2725
|
-
var TemplateLiteral$0 = $S($EXPECT($
|
|
2940
|
+
var TemplateLiteral$0 = $S($EXPECT($L119, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L119, fail, 'TemplateLiteral "`"'));
|
|
2726
2941
|
function TemplateLiteral(state) {
|
|
2727
2942
|
if (state.verbose)
|
|
2728
2943
|
console.log("ENTER:", "TemplateLiteral");
|
|
@@ -2732,7 +2947,7 @@ var Civet = (() => {
|
|
|
2732
2947
|
return TemplateLiteral$0(state);
|
|
2733
2948
|
}
|
|
2734
2949
|
}
|
|
2735
|
-
var TemplateSubstitution$0 = $S($EXPECT($
|
|
2950
|
+
var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
|
|
2736
2951
|
function TemplateSubstitution(state) {
|
|
2737
2952
|
if (state.verbose)
|
|
2738
2953
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -2789,7 +3004,7 @@ var Civet = (() => {
|
|
|
2789
3004
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
2790
3005
|
}
|
|
2791
3006
|
}
|
|
2792
|
-
var JSMultiLineComment$0 = $S($EXPECT($
|
|
3007
|
+
var JSMultiLineComment$0 = $S($EXPECT($L121, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'JSMultiLineComment "*/"')), $EXPECT($R18, fail, "JSMultiLineComment /./")))), $EXPECT($L122, fail, 'JSMultiLineComment "*/"'));
|
|
2793
3008
|
function JSMultiLineComment(state) {
|
|
2794
3009
|
if (state.verbose)
|
|
2795
3010
|
console.log("ENTER:", "JSMultiLineComment");
|
|
@@ -2799,7 +3014,7 @@ var Civet = (() => {
|
|
|
2799
3014
|
return JSMultiLineComment$0(state);
|
|
2800
3015
|
}
|
|
2801
3016
|
}
|
|
2802
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
3017
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R19, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
2803
3018
|
if (!global.coffeeCompat)
|
|
2804
3019
|
return $skip;
|
|
2805
3020
|
return ["//", $1];
|
|
@@ -2813,7 +3028,7 @@ var Civet = (() => {
|
|
|
2813
3028
|
return CoffeeSingleLineComment$0(state);
|
|
2814
3029
|
}
|
|
2815
3030
|
}
|
|
2816
|
-
var CoffeeMultiLineComment$0 = $T($S($EXPECT($
|
|
3031
|
+
var CoffeeMultiLineComment$0 = $T($S($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R18, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), function(value) {
|
|
2817
3032
|
return ["/*", value[1], "*/"];
|
|
2818
3033
|
});
|
|
2819
3034
|
function CoffeeMultiLineComment(state) {
|
|
@@ -2825,7 +3040,7 @@ var Civet = (() => {
|
|
|
2825
3040
|
return CoffeeMultiLineComment$0(state);
|
|
2826
3041
|
}
|
|
2827
3042
|
}
|
|
2828
|
-
var InlineComment$0 = $S($EXPECT($
|
|
3043
|
+
var InlineComment$0 = $S($EXPECT($L121, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'InlineComment "*/"')), $EXPECT($R20, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L122, fail, 'InlineComment "*/"'));
|
|
2829
3044
|
function InlineComment(state) {
|
|
2830
3045
|
if (state.verbose)
|
|
2831
3046
|
console.log("ENTER:", "InlineComment");
|
|
@@ -2845,7 +3060,7 @@ var Civet = (() => {
|
|
|
2845
3060
|
return RestOfLine$0(state);
|
|
2846
3061
|
}
|
|
2847
3062
|
}
|
|
2848
|
-
var TrailingComment$0 = $R$0($EXPECT($
|
|
3063
|
+
var TrailingComment$0 = $R$0($EXPECT($R21, fail, "TrailingComment /[\\t ]+/"));
|
|
2849
3064
|
var TrailingComment$1 = InlineComment;
|
|
2850
3065
|
var TrailingComment$2 = SingleLineComment;
|
|
2851
3066
|
function TrailingComment(state) {
|
|
@@ -2855,7 +3070,7 @@ var Civet = (() => {
|
|
|
2855
3070
|
return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
|
|
2856
3071
|
}
|
|
2857
3072
|
}
|
|
2858
|
-
var _$0 = $P($C($R$0($EXPECT($
|
|
3073
|
+
var _$0 = $P($C($R$0($EXPECT($R21, fail, "_ /[\\t ]+/")), Comment));
|
|
2859
3074
|
function _(state) {
|
|
2860
3075
|
if (state.verbose)
|
|
2861
3076
|
console.log("ENTER:", "_");
|
|
@@ -2865,7 +3080,7 @@ var Civet = (() => {
|
|
|
2865
3080
|
return _$0(state);
|
|
2866
3081
|
}
|
|
2867
3082
|
}
|
|
2868
|
-
var __$0 = $Q($C($R$0($EXPECT($
|
|
3083
|
+
var __$0 = $Q($C($R$0($EXPECT($R22, fail, "__ /[\\s]+/")), Comment));
|
|
2869
3084
|
function __(state) {
|
|
2870
3085
|
if (state.verbose)
|
|
2871
3086
|
console.log("ENTER:", "__");
|
|
@@ -2875,7 +3090,7 @@ var Civet = (() => {
|
|
|
2875
3090
|
return __$0(state);
|
|
2876
3091
|
}
|
|
2877
3092
|
}
|
|
2878
|
-
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($
|
|
3093
|
+
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L87, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
|
|
2879
3094
|
var StatementDelimiter$1 = $T($Y(EOS), function(value) {
|
|
2880
3095
|
return [";", value];
|
|
2881
3096
|
});
|
|
@@ -2886,7 +3101,7 @@ var Civet = (() => {
|
|
|
2886
3101
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
2887
3102
|
}
|
|
2888
3103
|
}
|
|
2889
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3104
|
+
var NonIdContinue$0 = $R$0($EXPECT($R23, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
2890
3105
|
function NonIdContinue(state) {
|
|
2891
3106
|
if (state.verbose)
|
|
2892
3107
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -2910,7 +3125,7 @@ var Civet = (() => {
|
|
|
2910
3125
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
2911
3126
|
}
|
|
2912
3127
|
}
|
|
2913
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
3128
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L124, fail, 'JSXSelfClosingElement "/>"'));
|
|
2914
3129
|
function JSXSelfClosingElement(state) {
|
|
2915
3130
|
if (state.verbose)
|
|
2916
3131
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -2920,7 +3135,7 @@ var Civet = (() => {
|
|
|
2920
3135
|
return JSXSelfClosingElement$0(state);
|
|
2921
3136
|
}
|
|
2922
3137
|
}
|
|
2923
|
-
var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
3138
|
+
var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L66, fail, 'JSXOpeningElement ">"'));
|
|
2924
3139
|
function JSXOpeningElement(state) {
|
|
2925
3140
|
if (state.verbose)
|
|
2926
3141
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -2930,7 +3145,7 @@ var Civet = (() => {
|
|
|
2930
3145
|
return JSXOpeningElement$0(state);
|
|
2931
3146
|
}
|
|
2932
3147
|
}
|
|
2933
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
3148
|
+
var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
|
|
2934
3149
|
function JSXClosingElement(state) {
|
|
2935
3150
|
if (state.verbose)
|
|
2936
3151
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -2940,7 +3155,7 @@ var Civet = (() => {
|
|
|
2940
3155
|
return JSXClosingElement$0(state);
|
|
2941
3156
|
}
|
|
2942
3157
|
}
|
|
2943
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
3158
|
+
var JSXFragment$0 = $S($EXPECT($L126, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L127, fail, 'JSXFragment "</>"'));
|
|
2944
3159
|
function JSXFragment(state) {
|
|
2945
3160
|
if (state.verbose)
|
|
2946
3161
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -2960,7 +3175,7 @@ var Civet = (() => {
|
|
|
2960
3175
|
return JSXElementName$0(state);
|
|
2961
3176
|
}
|
|
2962
3177
|
}
|
|
2963
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
3178
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R24, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
2964
3179
|
function JSXIdentifierName(state) {
|
|
2965
3180
|
if (state.verbose)
|
|
2966
3181
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -2999,7 +3214,7 @@ var Civet = (() => {
|
|
|
2999
3214
|
return JSXAttributeName$0(state);
|
|
3000
3215
|
}
|
|
3001
3216
|
}
|
|
3002
|
-
var JSXAttributeInitializer$0 = $S(__, $EXPECT($
|
|
3217
|
+
var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
|
|
3003
3218
|
function JSXAttributeInitializer(state) {
|
|
3004
3219
|
if (state.verbose)
|
|
3005
3220
|
console.log("ENTER:", "JSXAttributeInitializer");
|
|
@@ -3009,8 +3224,8 @@ var Civet = (() => {
|
|
|
3009
3224
|
return JSXAttributeInitializer$0(state);
|
|
3010
3225
|
}
|
|
3011
3226
|
}
|
|
3012
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
3013
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
3227
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R25, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
3228
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R26, fail, "JSXAttributeValue /'[^']*'/"));
|
|
3014
3229
|
var JSXAttributeValue$2 = $S($EXPECT($L11, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttributeValue "}"'));
|
|
3015
3230
|
var JSXAttributeValue$3 = JSXElement;
|
|
3016
3231
|
var JSXAttributeValue$4 = JSXFragment;
|
|
@@ -3042,7 +3257,7 @@ var Civet = (() => {
|
|
|
3042
3257
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
3043
3258
|
}
|
|
3044
3259
|
}
|
|
3045
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
3260
|
+
var JSXText$0 = $R$0($EXPECT($R27, fail, "JSXText /[^{}<>]+/"));
|
|
3046
3261
|
function JSXText(state) {
|
|
3047
3262
|
if (state.verbose)
|
|
3048
3263
|
console.log("ENTER:", "JSXText");
|
|
@@ -3062,10 +3277,10 @@ var Civet = (() => {
|
|
|
3062
3277
|
return JSXChildExpression$0(state);
|
|
3063
3278
|
}
|
|
3064
3279
|
}
|
|
3065
|
-
var TypeDeclaration$0 = $T($S($EXPECT($
|
|
3280
|
+
var TypeDeclaration$0 = $T($S($EXPECT($R28, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L55, fail, 'TypeDeclaration "="'), __, Type), function(value) {
|
|
3066
3281
|
return { "ts": true, "children": value };
|
|
3067
3282
|
});
|
|
3068
|
-
var TypeDeclaration$1 = $T($S($EXPECT($
|
|
3283
|
+
var TypeDeclaration$1 = $T($S($EXPECT($R29, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
|
|
3069
3284
|
return { "ts": true, "children": value };
|
|
3070
3285
|
});
|
|
3071
3286
|
function TypeDeclaration(state) {
|
|
@@ -3120,7 +3335,7 @@ var Civet = (() => {
|
|
|
3120
3335
|
return InterfaceProperty$0(state);
|
|
3121
3336
|
}
|
|
3122
3337
|
}
|
|
3123
|
-
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($
|
|
3338
|
+
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L87, fail, 'InterfacePropertyDelimiter ";"'));
|
|
3124
3339
|
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
|
|
3125
3340
|
var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
|
|
3126
3341
|
return ";";
|
|
@@ -3135,7 +3350,7 @@ var Civet = (() => {
|
|
|
3135
3350
|
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
|
|
3136
3351
|
}
|
|
3137
3352
|
}
|
|
3138
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
3353
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L128, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L25, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L26, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
|
|
3139
3354
|
function TypeIndexSignature(state) {
|
|
3140
3355
|
if (state.verbose)
|
|
3141
3356
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -3146,7 +3361,7 @@ var Civet = (() => {
|
|
|
3146
3361
|
}
|
|
3147
3362
|
}
|
|
3148
3363
|
var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
|
|
3149
|
-
var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($
|
|
3364
|
+
var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L78, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
|
|
3150
3365
|
function TypeIndex(state) {
|
|
3151
3366
|
if (state.tokenize) {
|
|
3152
3367
|
return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
|
|
@@ -3166,7 +3381,7 @@ var Civet = (() => {
|
|
|
3166
3381
|
return TypeSuffix$0(state);
|
|
3167
3382
|
}
|
|
3168
3383
|
}
|
|
3169
|
-
var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($
|
|
3384
|
+
var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L129, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
|
|
3170
3385
|
return { "ts": true, "children": value };
|
|
3171
3386
|
});
|
|
3172
3387
|
function ReturnTypeSuffix(state) {
|
|
@@ -3178,7 +3393,7 @@ var Civet = (() => {
|
|
|
3178
3393
|
return ReturnTypeSuffix$0(state);
|
|
3179
3394
|
}
|
|
3180
3395
|
}
|
|
3181
|
-
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($
|
|
3396
|
+
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
|
|
3182
3397
|
function TypePredicate(state) {
|
|
3183
3398
|
if (state.verbose)
|
|
3184
3399
|
console.log("ENTER:", "TypePredicate");
|
|
@@ -3228,9 +3443,9 @@ var Civet = (() => {
|
|
|
3228
3443
|
return TypeUnarySuffix$0(state);
|
|
3229
3444
|
}
|
|
3230
3445
|
}
|
|
3231
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
3232
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
3233
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
3446
|
+
var TypeUnaryOp$0 = $EXPECT($L130, fail, 'TypeUnaryOp "keyof"');
|
|
3447
|
+
var TypeUnaryOp$1 = $EXPECT($L84, fail, 'TypeUnaryOp "typeof"');
|
|
3448
|
+
var TypeUnaryOp$2 = $EXPECT($L131, fail, 'TypeUnaryOp "infer"');
|
|
3234
3449
|
function TypeUnaryOp(state) {
|
|
3235
3450
|
if (state.tokenize) {
|
|
3236
3451
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -3271,8 +3486,8 @@ var Civet = (() => {
|
|
|
3271
3486
|
}
|
|
3272
3487
|
}
|
|
3273
3488
|
var TypeLiteral$0 = Literal;
|
|
3274
|
-
var TypeLiteral$1 = $EXPECT($
|
|
3275
|
-
var TypeLiteral$2 = $EXPECT($
|
|
3489
|
+
var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
|
|
3490
|
+
var TypeLiteral$2 = $EXPECT($L132, fail, 'TypeLiteral "[]"');
|
|
3276
3491
|
function TypeLiteral(state) {
|
|
3277
3492
|
if (state.tokenize) {
|
|
3278
3493
|
return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
|
|
@@ -3280,8 +3495,8 @@ var Civet = (() => {
|
|
|
3280
3495
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
3281
3496
|
}
|
|
3282
3497
|
}
|
|
3283
|
-
var TypeBinaryOp$0 = $EXPECT($
|
|
3284
|
-
var TypeBinaryOp$1 = $EXPECT($
|
|
3498
|
+
var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
|
|
3499
|
+
var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
|
|
3285
3500
|
function TypeBinaryOp(state) {
|
|
3286
3501
|
if (state.tokenize) {
|
|
3287
3502
|
return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
|
|
@@ -3299,7 +3514,7 @@ var Civet = (() => {
|
|
|
3299
3514
|
return FunctionType$0(state);
|
|
3300
3515
|
}
|
|
3301
3516
|
}
|
|
3302
|
-
var TypeArguments$0 = $S(__, $EXPECT($L14, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($
|
|
3517
|
+
var TypeArguments$0 = $S(__, $EXPECT($L14, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L66, fail, 'TypeArguments ">"'));
|
|
3303
3518
|
function TypeArguments(state) {
|
|
3304
3519
|
if (state.verbose)
|
|
3305
3520
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -3309,7 +3524,7 @@ var Civet = (() => {
|
|
|
3309
3524
|
return TypeArguments$0(state);
|
|
3310
3525
|
}
|
|
3311
3526
|
}
|
|
3312
|
-
var TypeParameters$0 = $S(__, $EXPECT($L14, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($
|
|
3527
|
+
var TypeParameters$0 = $S(__, $EXPECT($L14, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L66, fail, 'TypeParameters ">"'));
|
|
3313
3528
|
function TypeParameters(state) {
|
|
3314
3529
|
if (state.verbose)
|
|
3315
3530
|
console.log("ENTER:", "TypeParameters");
|
|
@@ -3340,8 +3555,8 @@ var Civet = (() => {
|
|
|
3340
3555
|
}
|
|
3341
3556
|
}
|
|
3342
3557
|
var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
|
|
3343
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
3344
|
-
var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
3558
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L66, fail, 'TypeParameterDelimiter ">"')));
|
|
3559
|
+
var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L66, fail, 'TypeParameterDelimiter ">"'))), function(value) {
|
|
3345
3560
|
return ",";
|
|
3346
3561
|
});
|
|
3347
3562
|
var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -3354,7 +3569,7 @@ var Civet = (() => {
|
|
|
3354
3569
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
3355
3570
|
}
|
|
3356
3571
|
}
|
|
3357
|
-
var Shebang$0 = $R$0($EXPECT($
|
|
3572
|
+
var Shebang$0 = $R$0($EXPECT($R32, fail, "Shebang /#![^\\r\\n]*/"));
|
|
3358
3573
|
function Shebang(state) {
|
|
3359
3574
|
if (state.verbose)
|
|
3360
3575
|
console.log("ENTER:", "Shebang");
|
|
@@ -3364,7 +3579,7 @@ var Civet = (() => {
|
|
|
3364
3579
|
return Shebang$0(state);
|
|
3365
3580
|
}
|
|
3366
3581
|
}
|
|
3367
|
-
var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($
|
|
3582
|
+
var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R33, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
|
|
3368
3583
|
return $0.map((p) => p.join(""));
|
|
3369
3584
|
});
|
|
3370
3585
|
function DirectivePrologue(state) {
|
|
@@ -3386,7 +3601,7 @@ var Civet = (() => {
|
|
|
3386
3601
|
return EOS$0(state);
|
|
3387
3602
|
}
|
|
3388
3603
|
}
|
|
3389
|
-
var EOL$0 = $R$0($EXPECT($
|
|
3604
|
+
var EOL$0 = $R$0($EXPECT($R34, fail, "EOL /\\r\\n|\\n|\\r|$/"));
|
|
3390
3605
|
function EOL(state) {
|
|
3391
3606
|
if (state.verbose)
|
|
3392
3607
|
console.log("ENTER:", "EOL");
|
|
@@ -3396,7 +3611,7 @@ var Civet = (() => {
|
|
|
3396
3611
|
return EOL$0(state);
|
|
3397
3612
|
}
|
|
3398
3613
|
}
|
|
3399
|
-
var EOF$0 = $R$0($EXPECT($
|
|
3614
|
+
var EOF$0 = $R$0($EXPECT($R35, fail, "EOF /$/"));
|
|
3400
3615
|
function EOF(state) {
|
|
3401
3616
|
if (state.verbose)
|
|
3402
3617
|
console.log("ENTER:", "EOF");
|
|
@@ -3535,6 +3750,15 @@ var Civet = (() => {
|
|
|
3535
3750
|
const compatRe = /use coffee-compat/;
|
|
3536
3751
|
global.coffeeCompat = directives.some((d) => d.match(compatRe));
|
|
3537
3752
|
}
|
|
3753
|
+
module.dedentBlockString = function(str) {
|
|
3754
|
+
const spacing = str.match(/^(\r?\n|\n)\s+/);
|
|
3755
|
+
if (spacing) {
|
|
3756
|
+
str = str.replaceAll(spacing[0], "\n");
|
|
3757
|
+
}
|
|
3758
|
+
str = str.replace(/^(\r?\n|\n)/, "");
|
|
3759
|
+
str = str.replace(/(\r?\n|\n)$/, "");
|
|
3760
|
+
return str;
|
|
3761
|
+
};
|
|
3538
3762
|
return $0;
|
|
3539
3763
|
});
|
|
3540
3764
|
function Init(state) {
|
|
@@ -3546,7 +3770,7 @@ var Civet = (() => {
|
|
|
3546
3770
|
return Init$0(state);
|
|
3547
3771
|
}
|
|
3548
3772
|
}
|
|
3549
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
3773
|
+
var Indent$0 = $TV($Q($C($EXPECT($L133, fail, 'Indent " "'), $EXPECT($L134, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
3550
3774
|
return $1.length;
|
|
3551
3775
|
});
|
|
3552
3776
|
function Indent(state) {
|
|
@@ -3724,21 +3948,167 @@ var Civet = (() => {
|
|
|
3724
3948
|
}
|
|
3725
3949
|
});
|
|
3726
3950
|
|
|
3951
|
+
// source/util.coffee
|
|
3952
|
+
var require_util = __commonJS({
|
|
3953
|
+
"source/util.coffee"(exports, module) {
|
|
3954
|
+
var BASE64_CHARS;
|
|
3955
|
+
var SourceMap;
|
|
3956
|
+
var VLQ_CONTINUATION_BIT;
|
|
3957
|
+
var VLQ_SHIFT;
|
|
3958
|
+
var VLQ_VALUE_MASK;
|
|
3959
|
+
var encodeBase64;
|
|
3960
|
+
var encodeVlq;
|
|
3961
|
+
var locationTable;
|
|
3962
|
+
var lookupLineColumn;
|
|
3963
|
+
locationTable = function(input) {
|
|
3964
|
+
var line, lines, linesRe, pos, result;
|
|
3965
|
+
linesRe = /([^\r\n]*)(\r\n|\r|\n|$)/y;
|
|
3966
|
+
lines = [];
|
|
3967
|
+
line = 0;
|
|
3968
|
+
pos = 0;
|
|
3969
|
+
while (result = linesRe.exec(input)) {
|
|
3970
|
+
pos += result[0].length;
|
|
3971
|
+
lines[line++] = pos;
|
|
3972
|
+
if (pos === input.length) {
|
|
3973
|
+
break;
|
|
3974
|
+
}
|
|
3975
|
+
}
|
|
3976
|
+
return lines;
|
|
3977
|
+
};
|
|
3978
|
+
lookupLineColumn = function(table, pos) {
|
|
3979
|
+
var l, prevEnd;
|
|
3980
|
+
l = 0;
|
|
3981
|
+
prevEnd = 0;
|
|
3982
|
+
while (table[l] <= pos) {
|
|
3983
|
+
prevEnd = table[l++];
|
|
3984
|
+
}
|
|
3985
|
+
return [l, pos - prevEnd];
|
|
3986
|
+
};
|
|
3987
|
+
SourceMap = function(sourceString) {
|
|
3988
|
+
var EOL, sm, srcTable;
|
|
3989
|
+
srcTable = locationTable(sourceString);
|
|
3990
|
+
sm = {
|
|
3991
|
+
lines: [[]],
|
|
3992
|
+
lineNum: 0,
|
|
3993
|
+
colOffset: 0,
|
|
3994
|
+
srcTable
|
|
3995
|
+
};
|
|
3996
|
+
EOL = /\r?\n|\r/;
|
|
3997
|
+
return {
|
|
3998
|
+
data: sm,
|
|
3999
|
+
renderMappings: function() {
|
|
4000
|
+
var lastSourceColumn, lastSourceLine;
|
|
4001
|
+
lastSourceLine = 0;
|
|
4002
|
+
lastSourceColumn = 0;
|
|
4003
|
+
return sm.lines.map(function(line) {
|
|
4004
|
+
return line.map(function(entry) {
|
|
4005
|
+
var colDelta, lineDelta, sourceFileIndex, srcCol, srcLine;
|
|
4006
|
+
if (entry.length === 4) {
|
|
4007
|
+
[colDelta, sourceFileIndex, srcLine, srcCol] = entry;
|
|
4008
|
+
lineDelta = srcLine - lastSourceLine;
|
|
4009
|
+
colDelta = srcCol - lastSourceColumn;
|
|
4010
|
+
lastSourceLine = srcLine;
|
|
4011
|
+
lastSourceColumn = srcCol;
|
|
4012
|
+
return `${encodeVlq(entry[0])}${encodeVlq(sourceFileIndex)}${encodeVlq(lineDelta)}${encodeVlq(colDelta)}`;
|
|
4013
|
+
} else {
|
|
4014
|
+
return encodeVlq(entry[0]);
|
|
4015
|
+
}
|
|
4016
|
+
}).join(",");
|
|
4017
|
+
}).join(";");
|
|
4018
|
+
},
|
|
4019
|
+
json: function(srcFileName, outFileName) {
|
|
4020
|
+
return {
|
|
4021
|
+
version: 3,
|
|
4022
|
+
file: outFileName,
|
|
4023
|
+
sources: [srcFileName],
|
|
4024
|
+
mappings: this.renderMappings(),
|
|
4025
|
+
names: [],
|
|
4026
|
+
sourcesContent: [sourceString]
|
|
4027
|
+
};
|
|
4028
|
+
},
|
|
4029
|
+
updateSourceMap: function(outputStr, inputPos) {
|
|
4030
|
+
var outLines;
|
|
4031
|
+
outLines = outputStr.split(EOL);
|
|
4032
|
+
outLines.forEach(function(line, i) {
|
|
4033
|
+
var l, srcCol, srcLine;
|
|
4034
|
+
if (i > 0) {
|
|
4035
|
+
sm.lineNum++;
|
|
4036
|
+
sm.colOffset = 0;
|
|
4037
|
+
sm.lines[sm.lineNum] = [];
|
|
4038
|
+
}
|
|
4039
|
+
l = sm.colOffset;
|
|
4040
|
+
sm.colOffset = line.length;
|
|
4041
|
+
if (inputPos != null) {
|
|
4042
|
+
[srcLine, srcCol] = lookupLineColumn(srcTable, inputPos);
|
|
4043
|
+
return sm.lines[sm.lineNum].push([l, 0, srcLine, srcCol]);
|
|
4044
|
+
} else if (l !== 0) {
|
|
4045
|
+
return sm.lines[sm.lineNum].push([l]);
|
|
4046
|
+
}
|
|
4047
|
+
});
|
|
4048
|
+
}
|
|
4049
|
+
};
|
|
4050
|
+
};
|
|
4051
|
+
VLQ_SHIFT = 5;
|
|
4052
|
+
VLQ_CONTINUATION_BIT = 1 << VLQ_SHIFT;
|
|
4053
|
+
VLQ_VALUE_MASK = VLQ_CONTINUATION_BIT - 1;
|
|
4054
|
+
encodeVlq = function(value) {
|
|
4055
|
+
var answer, nextChunk, signBit, valueToEncode;
|
|
4056
|
+
answer = "";
|
|
4057
|
+
signBit = value < 0 ? 1 : 0;
|
|
4058
|
+
valueToEncode = (Math.abs(value) << 1) + signBit;
|
|
4059
|
+
while (valueToEncode || !answer) {
|
|
4060
|
+
nextChunk = valueToEncode & VLQ_VALUE_MASK;
|
|
4061
|
+
valueToEncode = valueToEncode >> VLQ_SHIFT;
|
|
4062
|
+
if (valueToEncode) {
|
|
4063
|
+
nextChunk |= VLQ_CONTINUATION_BIT;
|
|
4064
|
+
}
|
|
4065
|
+
answer += encodeBase64(nextChunk);
|
|
4066
|
+
}
|
|
4067
|
+
return answer;
|
|
4068
|
+
};
|
|
4069
|
+
BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
4070
|
+
encodeBase64 = function(value) {
|
|
4071
|
+
return BASE64_CHARS[value] || function() {
|
|
4072
|
+
throw new Error(`Cannot Base64 encode value: ${value}`);
|
|
4073
|
+
}();
|
|
4074
|
+
};
|
|
4075
|
+
module.exports = { locationTable, lookupLineColumn, SourceMap };
|
|
4076
|
+
}
|
|
4077
|
+
});
|
|
4078
|
+
|
|
3727
4079
|
// source/main.coffee
|
|
3728
4080
|
var require_main = __commonJS({
|
|
3729
4081
|
"source/main.coffee"(exports, module) {
|
|
4082
|
+
var SourceMap;
|
|
4083
|
+
var defaultOptions;
|
|
3730
4084
|
var gen;
|
|
3731
4085
|
var parse;
|
|
4086
|
+
var prune;
|
|
4087
|
+
var util;
|
|
3732
4088
|
({ parse } = require_parser());
|
|
3733
|
-
gen = require_generate();
|
|
4089
|
+
({ prune } = gen = require_generate());
|
|
4090
|
+
({ SourceMap } = util = require_util());
|
|
4091
|
+
defaultOptions = {};
|
|
3734
4092
|
module.exports = {
|
|
3735
4093
|
parse,
|
|
3736
|
-
compile: function(src, options) {
|
|
3737
|
-
|
|
3738
|
-
|
|
3739
|
-
|
|
4094
|
+
compile: function(src, options = defaultOptions) {
|
|
4095
|
+
var ast, code, sm;
|
|
4096
|
+
ast = prune(parse(src, {
|
|
4097
|
+
filename: options.filename
|
|
4098
|
+
}));
|
|
4099
|
+
if (options.sourceMap) {
|
|
4100
|
+
sm = SourceMap(src);
|
|
4101
|
+
options.updateSourceMap = sm.updateSourceMap;
|
|
4102
|
+
code = gen(ast, options);
|
|
4103
|
+
return {
|
|
4104
|
+
code,
|
|
4105
|
+
sourceMap: sm
|
|
4106
|
+
};
|
|
4107
|
+
}
|
|
4108
|
+
return gen(ast, options);
|
|
3740
4109
|
},
|
|
3741
|
-
generate: gen
|
|
4110
|
+
generate: gen,
|
|
4111
|
+
util
|
|
3742
4112
|
};
|
|
3743
4113
|
}
|
|
3744
4114
|
});
|