@danielx/civet 0.4.16 → 0.4.17
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 +17 -12
- package/dist/browser.js +1401 -584
- package/dist/esm.mjs +1 -1
- package/dist/main.js +1401 -584
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -407,6 +407,8 @@ var Civet = (() => {
|
|
|
407
407
|
var { parse } = parserState({
|
|
408
408
|
Program,
|
|
409
409
|
TopLevelStatement,
|
|
410
|
+
ExtendedExpression,
|
|
411
|
+
ExpressionizedStatement,
|
|
410
412
|
Expression,
|
|
411
413
|
Arguments,
|
|
412
414
|
ArgumentsWithTrailingCallExpressions,
|
|
@@ -423,10 +425,11 @@ var Civet = (() => {
|
|
|
423
425
|
UpdateExpression,
|
|
424
426
|
UpdateExpressionSymbol,
|
|
425
427
|
AssignmentExpression,
|
|
426
|
-
|
|
427
|
-
AwaitExpression,
|
|
428
|
+
AssignmentExpressionTail,
|
|
428
429
|
YieldExpression,
|
|
430
|
+
YieldTail,
|
|
429
431
|
ArrowFunction,
|
|
432
|
+
ArrowFunctionTail,
|
|
430
433
|
FatArrow,
|
|
431
434
|
FatArrowBody,
|
|
432
435
|
ConditionalExpression,
|
|
@@ -444,7 +447,6 @@ var Civet = (() => {
|
|
|
444
447
|
This,
|
|
445
448
|
AtAccessor,
|
|
446
449
|
LeftHandSideExpression,
|
|
447
|
-
NewExpression,
|
|
448
450
|
CallExpression,
|
|
449
451
|
CallExpressionRest,
|
|
450
452
|
OptionalShorthand,
|
|
@@ -464,10 +466,14 @@ var Civet = (() => {
|
|
|
464
466
|
BindingIdentifier,
|
|
465
467
|
BindingPattern,
|
|
466
468
|
ObjectBindingPattern,
|
|
469
|
+
ObjectBindingPatternContent,
|
|
467
470
|
ArrayBindingPattern,
|
|
471
|
+
ArrayBindingPatternContent,
|
|
472
|
+
Elision,
|
|
468
473
|
NestedBindingProperties,
|
|
469
474
|
NestedBindingProperty,
|
|
470
475
|
BindingProperty,
|
|
476
|
+
NestedBindingRestProperty,
|
|
471
477
|
BindingRestProperty,
|
|
472
478
|
NestedBindingElements,
|
|
473
479
|
NestedBindingElement,
|
|
@@ -482,10 +488,11 @@ var Civet = (() => {
|
|
|
482
488
|
BracedOrEmptyBlock,
|
|
483
489
|
EmptyBlock,
|
|
484
490
|
BracedBlock,
|
|
485
|
-
|
|
486
|
-
|
|
487
|
-
|
|
491
|
+
BracedContent,
|
|
492
|
+
NestedBlockStatements,
|
|
493
|
+
NestedBlockStatement,
|
|
488
494
|
Literal,
|
|
495
|
+
LiteralContent,
|
|
489
496
|
NullLiteral,
|
|
490
497
|
BooleanLiteral,
|
|
491
498
|
CoffeeScriptBooleanLiteral,
|
|
@@ -494,14 +501,16 @@ var Civet = (() => {
|
|
|
494
501
|
IdentifierName,
|
|
495
502
|
IdentifierReference,
|
|
496
503
|
ArrayLiteral,
|
|
504
|
+
ArrayLiteralContent,
|
|
497
505
|
NestedElementList,
|
|
498
506
|
NestedElement,
|
|
499
507
|
ArrayElementDelimiter,
|
|
500
508
|
ElementList,
|
|
501
|
-
|
|
509
|
+
ElementListRest,
|
|
502
510
|
ArrayElementExpression,
|
|
503
|
-
Elision,
|
|
504
511
|
ObjectLiteral,
|
|
512
|
+
BracedObjectLiteral,
|
|
513
|
+
BracedObjectLiteralContent,
|
|
505
514
|
NestedObjectLiteral,
|
|
506
515
|
NestedPropertyDefinitions,
|
|
507
516
|
NestedPropertyDefinition,
|
|
@@ -528,6 +537,10 @@ var Civet = (() => {
|
|
|
528
537
|
IfStatement,
|
|
529
538
|
IfClause,
|
|
530
539
|
UnlessClause,
|
|
540
|
+
IfExpression,
|
|
541
|
+
ExpressionBlock,
|
|
542
|
+
NestedBlockExpressions,
|
|
543
|
+
NestedBlockExpression,
|
|
531
544
|
IterationStatement,
|
|
532
545
|
LoopStatement,
|
|
533
546
|
LoopClause,
|
|
@@ -541,6 +554,7 @@ var Civet = (() => {
|
|
|
541
554
|
ForDeclaration,
|
|
542
555
|
ForBinding,
|
|
543
556
|
SwitchStatement,
|
|
557
|
+
SwitchExpression,
|
|
544
558
|
CaseBlock,
|
|
545
559
|
NestedCaseClauses,
|
|
546
560
|
NestedCaseClause,
|
|
@@ -558,6 +572,8 @@ var Civet = (() => {
|
|
|
558
572
|
SuppressIndentedApplication,
|
|
559
573
|
ExpressionStatement,
|
|
560
574
|
KeywordStatement,
|
|
575
|
+
DebuggerExpression,
|
|
576
|
+
ThrowExpression,
|
|
561
577
|
MaybeNestedExpression,
|
|
562
578
|
ImportDeclaration,
|
|
563
579
|
ImpliedImport,
|
|
@@ -623,6 +639,7 @@ var Civet = (() => {
|
|
|
623
639
|
NonNewlineWhitespace,
|
|
624
640
|
__,
|
|
625
641
|
Whitespace,
|
|
642
|
+
ExpressionDelimiter,
|
|
626
643
|
StatementDelimiter,
|
|
627
644
|
NonIdContinue,
|
|
628
645
|
Loc,
|
|
@@ -659,6 +676,7 @@ var Civet = (() => {
|
|
|
659
676
|
LetOrConst,
|
|
660
677
|
Loop,
|
|
661
678
|
New,
|
|
679
|
+
Not,
|
|
662
680
|
Of,
|
|
663
681
|
OpenBrace,
|
|
664
682
|
OpenBracket,
|
|
@@ -672,6 +690,7 @@ var Civet = (() => {
|
|
|
672
690
|
SubstitutionStart,
|
|
673
691
|
Switch,
|
|
674
692
|
Target,
|
|
693
|
+
Then,
|
|
675
694
|
Throw,
|
|
676
695
|
TripleDoubleQuote,
|
|
677
696
|
TripleSingleQuote,
|
|
@@ -763,6 +782,8 @@ var Civet = (() => {
|
|
|
763
782
|
CoffeeCommentEnabled,
|
|
764
783
|
CoffeeBooleansEnabled,
|
|
765
784
|
CoffeeInterpolationEnabled,
|
|
785
|
+
CoffeeIsntEnabled,
|
|
786
|
+
CoffeeNotEnabled,
|
|
766
787
|
Reset,
|
|
767
788
|
Init,
|
|
768
789
|
Indent,
|
|
@@ -782,149 +803,153 @@ var Civet = (() => {
|
|
|
782
803
|
var $L6 = $L("this");
|
|
783
804
|
var $L7 = $L("#");
|
|
784
805
|
var $L8 = $L("@");
|
|
785
|
-
var $L9 = $L("
|
|
786
|
-
var $L10 = $L("
|
|
787
|
-
var $L11 = $L("
|
|
788
|
-
var $L12 = $L("
|
|
789
|
-
var $L13 = $L("
|
|
790
|
-
var $L14 = $L("
|
|
791
|
-
var $L15 = $L("
|
|
792
|
-
var $L16 = $L("
|
|
793
|
-
var $L17 = $L("
|
|
794
|
-
var $L18 = $L("
|
|
795
|
-
var $L19 = $L("
|
|
796
|
-
var $L20 = $L("
|
|
797
|
-
var $L21 = $L("
|
|
798
|
-
var $L22 = $L("
|
|
799
|
-
var $L23 = $L("
|
|
800
|
-
var $L24 = $L("
|
|
801
|
-
var $L25 = $L("
|
|
802
|
-
var $L26 = $L("
|
|
803
|
-
var $L27 = $L("
|
|
804
|
-
var $L28 = $L("
|
|
805
|
-
var $L29 = $L("
|
|
806
|
-
var $L30 = $L("
|
|
807
|
-
var $L31 = $L("
|
|
808
|
-
var $L32 = $L("
|
|
809
|
-
var $L33 = $L("
|
|
810
|
-
var $L34 = $L("
|
|
811
|
-
var $L35 = $L("
|
|
812
|
-
var $L36 = $L("
|
|
813
|
-
var $L37 = $L("
|
|
814
|
-
var $L38 = $L("
|
|
815
|
-
var $L39 = $L("
|
|
816
|
-
var $L40 = $L("
|
|
817
|
-
var $L41 = $L("
|
|
818
|
-
var $L42 = $L("
|
|
819
|
-
var $L43 = $L("
|
|
820
|
-
var $L44 = $L("
|
|
821
|
-
var $L45 = $L("
|
|
822
|
-
var $L46 = $L("
|
|
823
|
-
var $L47 = $L("
|
|
824
|
-
var $L48 = $L("
|
|
825
|
-
var $L49 = $L("
|
|
826
|
-
var $L50 = $L("
|
|
827
|
-
var $L51 = $L("
|
|
828
|
-
var $L52 = $L("
|
|
829
|
-
var $L53 = $L("
|
|
830
|
-
var $L54 = $L("
|
|
831
|
-
var $L55 = $L("
|
|
832
|
-
var $L56 = $L("
|
|
833
|
-
var $L57 = $L("
|
|
834
|
-
var $L58 = $L("
|
|
835
|
-
var $L59 = $L("
|
|
836
|
-
var $L60 = $L("
|
|
837
|
-
var $L61 = $L("
|
|
838
|
-
var $L62 = $L("
|
|
839
|
-
var $L63 = $L("
|
|
840
|
-
var $L64 = $L("
|
|
841
|
-
var $L65 = $L("
|
|
842
|
-
var $L66 = $L("
|
|
843
|
-
var $L67 = $L("
|
|
844
|
-
var $L68 = $L("
|
|
845
|
-
var $L69 = $L("
|
|
846
|
-
var $L70 = $L("
|
|
847
|
-
var $L71 = $L("
|
|
848
|
-
var $L72 = $L("
|
|
849
|
-
var $L73 = $L("
|
|
850
|
-
var $L74 = $L("
|
|
851
|
-
var $L75 = $L("
|
|
852
|
-
var $L76 = $L("
|
|
853
|
-
var $L77 = $L("
|
|
854
|
-
var $L78 = $L("
|
|
855
|
-
var $L79 = $L("
|
|
856
|
-
var $L80 = $L("
|
|
857
|
-
var $L81 = $L("
|
|
858
|
-
var $L82 = $L("
|
|
859
|
-
var $L83 = $L("
|
|
860
|
-
var $L84 = $L("
|
|
861
|
-
var $L85 = $L("
|
|
862
|
-
var $L86 = $L("
|
|
863
|
-
var $L87 = $L("
|
|
864
|
-
var $L88 = $L("
|
|
865
|
-
var $L89 = $L("
|
|
866
|
-
var $L90 = $L("
|
|
867
|
-
var $L91 = $L("
|
|
868
|
-
var $L92 = $L("
|
|
869
|
-
var $L93 = $L("
|
|
870
|
-
var $L94 = $L("
|
|
871
|
-
var $L95 = $L("
|
|
872
|
-
var $L96 = $L(
|
|
873
|
-
var $L97 = $L("
|
|
874
|
-
var $L98 = $L("
|
|
875
|
-
var $L99 = $L("
|
|
876
|
-
var $L100 = $L("
|
|
877
|
-
var $L101 = $L("
|
|
878
|
-
var $L102 = $L("
|
|
879
|
-
var $L103 = $L("
|
|
880
|
-
var $L104 = $L("
|
|
881
|
-
var $L105 = $L("
|
|
882
|
-
var $L106 = $L("
|
|
883
|
-
var $L107 = $L("
|
|
884
|
-
var $L108 = $L("
|
|
885
|
-
var $L109 = $L("
|
|
886
|
-
var $L110 = $L("
|
|
887
|
-
var $L111 = $L("
|
|
888
|
-
var $L112 = $L("
|
|
889
|
-
var $L113 = $L("
|
|
890
|
-
var $L114 = $L("
|
|
891
|
-
var $L115 = $L("
|
|
892
|
-
var $L116 = $L("
|
|
893
|
-
var $L117 = $L("
|
|
894
|
-
var $L118 = $L("
|
|
895
|
-
var $L119 = $L("
|
|
896
|
-
var $L120 = $L("
|
|
897
|
-
var $L121 = $L(
|
|
898
|
-
var $L122 = $L("
|
|
899
|
-
var $L123 = $L("
|
|
900
|
-
var $L124 = $L("
|
|
901
|
-
var $L125 = $L("
|
|
902
|
-
var $L126 = $L("
|
|
903
|
-
var $L127 = $L("
|
|
904
|
-
var $L128 = $L("
|
|
905
|
-
var $L129 = $L("
|
|
906
|
-
var $L130 = $L("
|
|
907
|
-
var $L131 = $L("
|
|
908
|
-
var $L132 = $L("
|
|
909
|
-
var $L133 = $L("
|
|
910
|
-
var $L134 = $L("
|
|
911
|
-
var $L135 = $L("
|
|
912
|
-
var $L136 = $L("
|
|
913
|
-
var $L137 = $L("
|
|
914
|
-
var $L138 = $L("
|
|
915
|
-
var $L139 = $L("
|
|
916
|
-
var $L140 = $L("
|
|
917
|
-
var $L141 = $L("
|
|
918
|
-
var $L142 = $L("
|
|
919
|
-
var $L143 = $L("
|
|
920
|
-
var $L144 = $L("
|
|
921
|
-
var $L145 = $L("
|
|
922
|
-
var $L146 = $L("
|
|
923
|
-
var $L147 = $L("
|
|
924
|
-
var $L148 = $L("
|
|
925
|
-
var $
|
|
806
|
+
var $L9 = $L(".");
|
|
807
|
+
var $L10 = $L("super");
|
|
808
|
+
var $L11 = $L("import");
|
|
809
|
+
var $L12 = $L("!");
|
|
810
|
+
var $L13 = $L("::");
|
|
811
|
+
var $L14 = $L("super[");
|
|
812
|
+
var $L15 = $L("import.meta");
|
|
813
|
+
var $L16 = $L(")");
|
|
814
|
+
var $L17 = $L("->");
|
|
815
|
+
var $L18 = $L("null");
|
|
816
|
+
var $L19 = $L("true");
|
|
817
|
+
var $L20 = $L("false");
|
|
818
|
+
var $L21 = $L("yes");
|
|
819
|
+
var $L22 = $L("on");
|
|
820
|
+
var $L23 = $L("no");
|
|
821
|
+
var $L24 = $L("off");
|
|
822
|
+
var $L25 = $L(",");
|
|
823
|
+
var $L26 = $L("]");
|
|
824
|
+
var $L27 = $L("}");
|
|
825
|
+
var $L28 = $L("**=");
|
|
826
|
+
var $L29 = $L("*=");
|
|
827
|
+
var $L30 = $L("/=");
|
|
828
|
+
var $L31 = $L("%=");
|
|
829
|
+
var $L32 = $L("+=");
|
|
830
|
+
var $L33 = $L("-=");
|
|
831
|
+
var $L34 = $L("<<=");
|
|
832
|
+
var $L35 = $L(">>>=");
|
|
833
|
+
var $L36 = $L(">>=");
|
|
834
|
+
var $L37 = $L("&&=");
|
|
835
|
+
var $L38 = $L("&=");
|
|
836
|
+
var $L39 = $L("^=");
|
|
837
|
+
var $L40 = $L("||=");
|
|
838
|
+
var $L41 = $L("|=");
|
|
839
|
+
var $L42 = $L("??=");
|
|
840
|
+
var $L43 = $L("?=");
|
|
841
|
+
var $L44 = $L("=");
|
|
842
|
+
var $L45 = $L("**");
|
|
843
|
+
var $L46 = $L("*");
|
|
844
|
+
var $L47 = $L("/");
|
|
845
|
+
var $L48 = $L("%");
|
|
846
|
+
var $L49 = $L("+");
|
|
847
|
+
var $L50 = $L("-");
|
|
848
|
+
var $L51 = $L("<=");
|
|
849
|
+
var $L52 = $L(">=");
|
|
850
|
+
var $L53 = $L("<<");
|
|
851
|
+
var $L54 = $L(">>>");
|
|
852
|
+
var $L55 = $L(">>");
|
|
853
|
+
var $L56 = $L(">");
|
|
854
|
+
var $L57 = $L("!==");
|
|
855
|
+
var $L58 = $L("!=");
|
|
856
|
+
var $L59 = $L("isnt");
|
|
857
|
+
var $L60 = $L("is");
|
|
858
|
+
var $L61 = $L("===");
|
|
859
|
+
var $L62 = $L("==");
|
|
860
|
+
var $L63 = $L("and");
|
|
861
|
+
var $L64 = $L("&&");
|
|
862
|
+
var $L65 = $L("or");
|
|
863
|
+
var $L66 = $L("||");
|
|
864
|
+
var $L67 = $L("??");
|
|
865
|
+
var $L68 = $L("instanceof");
|
|
866
|
+
var $L69 = $L("in");
|
|
867
|
+
var $L70 = $L("&");
|
|
868
|
+
var $L71 = $L("^");
|
|
869
|
+
var $L72 = $L("|");
|
|
870
|
+
var $L73 = $L(";");
|
|
871
|
+
var $L74 = $L("finally");
|
|
872
|
+
var $L75 = $L("break");
|
|
873
|
+
var $L76 = $L("continue");
|
|
874
|
+
var $L77 = $L("debugger");
|
|
875
|
+
var $L78 = $L("import type");
|
|
876
|
+
var $L79 = $L("default");
|
|
877
|
+
var $L80 = $L(":=");
|
|
878
|
+
var $L81 = $L("/*");
|
|
879
|
+
var $L82 = $L("*/");
|
|
880
|
+
var $L83 = $L("###");
|
|
881
|
+
var $L84 = $L("as");
|
|
882
|
+
var $L85 = $L("async");
|
|
883
|
+
var $L86 = $L("await");
|
|
884
|
+
var $L87 = $L("`");
|
|
885
|
+
var $L88 = $L("case");
|
|
886
|
+
var $L89 = $L("catch");
|
|
887
|
+
var $L90 = $L("class");
|
|
888
|
+
var $L91 = $L("#{");
|
|
889
|
+
var $L92 = $L(":");
|
|
890
|
+
var $L93 = $L("delete");
|
|
891
|
+
var $L94 = $L("do");
|
|
892
|
+
var $L95 = $L("..");
|
|
893
|
+
var $L96 = $L("...");
|
|
894
|
+
var $L97 = $L('"');
|
|
895
|
+
var $L98 = $L("else");
|
|
896
|
+
var $L99 = $L("export");
|
|
897
|
+
var $L100 = $L("for");
|
|
898
|
+
var $L101 = $L("from");
|
|
899
|
+
var $L102 = $L("function");
|
|
900
|
+
var $L103 = $L("get");
|
|
901
|
+
var $L104 = $L("set");
|
|
902
|
+
var $L105 = $L("if");
|
|
903
|
+
var $L106 = $L(" ");
|
|
904
|
+
var $L107 = $L("let");
|
|
905
|
+
var $L108 = $L("const");
|
|
906
|
+
var $L109 = $L("loop");
|
|
907
|
+
var $L110 = $L("new");
|
|
908
|
+
var $L111 = $L("not");
|
|
909
|
+
var $L112 = $L("of");
|
|
910
|
+
var $L113 = $L("{");
|
|
911
|
+
var $L114 = $L("[");
|
|
912
|
+
var $L115 = $L("(");
|
|
913
|
+
var $L116 = $L("?");
|
|
914
|
+
var $L117 = $L("return");
|
|
915
|
+
var $L118 = $L("'");
|
|
916
|
+
var $L119 = $L("static");
|
|
917
|
+
var $L120 = $L("${");
|
|
918
|
+
var $L121 = $L("switch");
|
|
919
|
+
var $L122 = $L("target");
|
|
920
|
+
var $L123 = $L("then");
|
|
921
|
+
var $L124 = $L("throw");
|
|
922
|
+
var $L125 = $L('"""');
|
|
923
|
+
var $L126 = $L("'''");
|
|
924
|
+
var $L127 = $L("```");
|
|
925
|
+
var $L128 = $L("try");
|
|
926
|
+
var $L129 = $L("typeof");
|
|
927
|
+
var $L130 = $L("unless");
|
|
928
|
+
var $L131 = $L("until");
|
|
929
|
+
var $L132 = $L("var");
|
|
930
|
+
var $L133 = $L("void");
|
|
931
|
+
var $L134 = $L("when");
|
|
932
|
+
var $L135 = $L("while");
|
|
933
|
+
var $L136 = $L("yield");
|
|
934
|
+
var $L137 = $L("/>");
|
|
935
|
+
var $L138 = $L("</");
|
|
936
|
+
var $L139 = $L("<>");
|
|
937
|
+
var $L140 = $L("</>");
|
|
938
|
+
var $L141 = $L("declare");
|
|
939
|
+
var $L142 = $L("type");
|
|
940
|
+
var $L143 = $L("interface");
|
|
941
|
+
var $L144 = $L("namespace");
|
|
942
|
+
var $L145 = $L("readonly");
|
|
943
|
+
var $L146 = $L("asserts");
|
|
944
|
+
var $L147 = $L("keyof");
|
|
945
|
+
var $L148 = $L("infer");
|
|
946
|
+
var $L149 = $L("[]");
|
|
947
|
+
var $L150 = $L("civet");
|
|
948
|
+
var $L151 = $L(" ");
|
|
949
|
+
var $L152 = $L(" ");
|
|
950
|
+
var $R0 = $R(new RegExp("(of|then)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
|
|
926
951
|
var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
927
|
-
var $R2 = $R(new RegExp("[!~+-]", "suy"));
|
|
952
|
+
var $R2 = $R(new RegExp("[!~+-](?!\\s)", "suy"));
|
|
928
953
|
var $R3 = $R(new RegExp("(?=[\\s\\)])", "suy"));
|
|
929
954
|
var $R4 = $R(new RegExp('[^;"\\s]+', "suy"));
|
|
930
955
|
var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
|
|
@@ -946,27 +971,32 @@ var Civet = (() => {
|
|
|
946
971
|
var $R21 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
947
972
|
var $R22 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
|
|
948
973
|
var $R23 = $R(new RegExp("(?:on|off|yes|no)(?!\\p{ID_Continue})", "suy"));
|
|
949
|
-
var $R24 = $R(new RegExp("(?:
|
|
950
|
-
var $R25 = $R(new RegExp("
|
|
951
|
-
var $R26 = $R(new RegExp("
|
|
952
|
-
var $R27 = $R(new RegExp("
|
|
953
|
-
var $R28 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
954
|
-
var $R29 = $R(new RegExp("[
|
|
955
|
-
var $R30 = $R(new RegExp("[\\
|
|
956
|
-
var $R31 = $R(new RegExp("
|
|
957
|
-
var $R32 = $R(new RegExp("
|
|
958
|
-
var $R33 = $R(new RegExp("
|
|
959
|
-
var $R34 = $R(new RegExp(
|
|
960
|
-
var $R35 = $R(new RegExp("
|
|
961
|
-
var $R36 = $R(new RegExp("[^
|
|
962
|
-
var $R37 = $R(new RegExp("[
|
|
963
|
-
var $R38 = $R(new RegExp("[+-]", "suy"));
|
|
964
|
-
var $R39 = $R(new RegExp("
|
|
965
|
-
var $R40 = $R(new RegExp("[\\
|
|
966
|
-
var $R41 = $R(new RegExp("[\\
|
|
967
|
-
var $R42 = $R(new RegExp("\\s
|
|
968
|
-
var $R43 = $R(new RegExp("\\
|
|
969
|
-
var
|
|
974
|
+
var $R24 = $R(new RegExp("(?:isnt)(?!\\p{ID_Continue})", "suy"));
|
|
975
|
+
var $R25 = $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|loop|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
|
|
976
|
+
var $R26 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
977
|
+
var $R27 = $R(new RegExp(".", "suy"));
|
|
978
|
+
var $R28 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
|
|
979
|
+
var $R29 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
980
|
+
var $R30 = $R(new RegExp("[ \\t]+", "suy"));
|
|
981
|
+
var $R31 = $R(new RegExp("[\\s]+", "suy"));
|
|
982
|
+
var $R32 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
|
|
983
|
+
var $R33 = $R(new RegExp("\\s", "suy"));
|
|
984
|
+
var $R34 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
|
|
985
|
+
var $R35 = $R(new RegExp('"[^"]*"', "suy"));
|
|
986
|
+
var $R36 = $R(new RegExp("'[^']*'", "suy"));
|
|
987
|
+
var $R37 = $R(new RegExp("[^{}<>]+", "suy"));
|
|
988
|
+
var $R38 = $R(new RegExp("[+-]?", "suy"));
|
|
989
|
+
var $R39 = $R(new RegExp("[+-]", "suy"));
|
|
990
|
+
var $R40 = $R(new RegExp("#![^\\r\\n]*", "suy"));
|
|
991
|
+
var $R41 = $R(new RegExp("[\\t ]*", "suy"));
|
|
992
|
+
var $R42 = $R(new RegExp("[\\s]*", "suy"));
|
|
993
|
+
var $R43 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
|
|
994
|
+
var $R44 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
|
|
995
|
+
var Program$0 = $TS($S(Reset, Init, __, $Q(TopLevelStatement), __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
996
|
+
var statements = $4;
|
|
997
|
+
module.processProgram(statements);
|
|
998
|
+
return $0;
|
|
999
|
+
});
|
|
970
1000
|
function Program(state) {
|
|
971
1001
|
if (state.verbose)
|
|
972
1002
|
console.log("ENTER:", "Program");
|
|
@@ -986,6 +1016,26 @@ var Civet = (() => {
|
|
|
986
1016
|
return TopLevelStatement$0(state);
|
|
987
1017
|
}
|
|
988
1018
|
}
|
|
1019
|
+
var ExtendedExpression$0 = $S(__, ExpressionizedStatement);
|
|
1020
|
+
var ExtendedExpression$1 = AssignmentExpression;
|
|
1021
|
+
function ExtendedExpression(state) {
|
|
1022
|
+
if (state.tokenize) {
|
|
1023
|
+
return $TOKEN("ExtendedExpression", state, ExtendedExpression$0(state) || ExtendedExpression$1(state));
|
|
1024
|
+
} else {
|
|
1025
|
+
return ExtendedExpression$0(state) || ExtendedExpression$1(state);
|
|
1026
|
+
}
|
|
1027
|
+
}
|
|
1028
|
+
var ExpressionizedStatement$0 = DebuggerExpression;
|
|
1029
|
+
var ExpressionizedStatement$1 = IfExpression;
|
|
1030
|
+
var ExpressionizedStatement$2 = SwitchExpression;
|
|
1031
|
+
var ExpressionizedStatement$3 = ThrowExpression;
|
|
1032
|
+
function ExpressionizedStatement(state) {
|
|
1033
|
+
if (state.tokenize) {
|
|
1034
|
+
return $TOKEN("ExpressionizedStatement", state, ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state));
|
|
1035
|
+
} else {
|
|
1036
|
+
return ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state);
|
|
1037
|
+
}
|
|
1038
|
+
}
|
|
989
1039
|
var Expression$0 = $TS($S(AssignmentExpression, $Q($S(__, Comma, AssignmentExpression))), function($skip, $loc, $0, $1, $2) {
|
|
990
1040
|
if ($2.length == 0)
|
|
991
1041
|
return $1;
|
|
@@ -1057,7 +1107,7 @@ var Civet = (() => {
|
|
|
1057
1107
|
return NestedArgument$0(state);
|
|
1058
1108
|
}
|
|
1059
1109
|
}
|
|
1060
|
-
var InlineArgumentExpressions$0 = $TS($S($S($E(DotDotDot),
|
|
1110
|
+
var InlineArgumentExpressions$0 = $TS($S($S($E(DotDotDot), ExtendedExpression), $Q($S(__, Comma, $Q(TrailingComment), $E(DotDotDot), ExtendedExpression))), function($skip, $loc, $0, $1, $2) {
|
|
1061
1111
|
if ($2.length == 0)
|
|
1062
1112
|
return $1;
|
|
1063
1113
|
return $0;
|
|
@@ -1185,12 +1235,17 @@ var Civet = (() => {
|
|
|
1185
1235
|
return UpdateExpressionSymbol$0(state);
|
|
1186
1236
|
}
|
|
1187
1237
|
}
|
|
1188
|
-
var AssignmentExpression$0 = $TS($S($Q(TrailingComment),
|
|
1189
|
-
if ($1.length)
|
|
1238
|
+
var AssignmentExpression$0 = $TS($S($Q(TrailingComment), AssignmentExpressionTail), function($skip, $loc, $0, $1, $2) {
|
|
1239
|
+
if ($1.length) {
|
|
1240
|
+
if ($2.children) {
|
|
1241
|
+
$2.children.splice(0, 0, ...$1);
|
|
1242
|
+
return $2;
|
|
1243
|
+
}
|
|
1190
1244
|
return $0;
|
|
1245
|
+
}
|
|
1191
1246
|
return $2;
|
|
1192
1247
|
});
|
|
1193
|
-
var AssignmentExpression$1 = $S(__,
|
|
1248
|
+
var AssignmentExpression$1 = $S(__, AssignmentExpressionTail);
|
|
1194
1249
|
function AssignmentExpression(state) {
|
|
1195
1250
|
if (state.tokenize) {
|
|
1196
1251
|
return $TOKEN("AssignmentExpression", state, AssignmentExpression$0(state) || AssignmentExpression$1(state));
|
|
@@ -1198,13 +1253,17 @@ var Civet = (() => {
|
|
|
1198
1253
|
return AssignmentExpression$0(state) || AssignmentExpression$1(state);
|
|
1199
1254
|
}
|
|
1200
1255
|
}
|
|
1201
|
-
var
|
|
1202
|
-
var
|
|
1203
|
-
var
|
|
1204
|
-
var AssignmentExpressionRest$3 = $TS($S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), Expression), function($skip, $loc, $0, $1, $2) {
|
|
1256
|
+
var AssignmentExpressionTail$0 = YieldExpression;
|
|
1257
|
+
var AssignmentExpressionTail$1 = ArrowFunction;
|
|
1258
|
+
var AssignmentExpressionTail$2 = $TS($S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), ExtendedExpression), function($skip, $loc, $0, $1, $2) {
|
|
1205
1259
|
const lastAssignment = $1[$1.length - 1];
|
|
1260
|
+
let tail = [];
|
|
1206
1261
|
if (lastAssignment[3].token === "=") {
|
|
1207
1262
|
const lhs = lastAssignment[1];
|
|
1263
|
+
if (lhs.type === "ObjectExpression") {
|
|
1264
|
+
lhs.children.splice(0, 0, "(");
|
|
1265
|
+
tail.push(")");
|
|
1266
|
+
}
|
|
1208
1267
|
if (Array.isArray(lhs) && lhs.length > 1) {
|
|
1209
1268
|
const props = lhs[lhs.length - 1];
|
|
1210
1269
|
if (Array.isArray(props)) {
|
|
@@ -1230,39 +1289,53 @@ var Civet = (() => {
|
|
|
1230
1289
|
}
|
|
1231
1290
|
return {
|
|
1232
1291
|
type: "AssignmentExpression",
|
|
1233
|
-
children:
|
|
1292
|
+
children: [...$0, ...tail]
|
|
1234
1293
|
};
|
|
1235
1294
|
});
|
|
1236
|
-
var
|
|
1237
|
-
function
|
|
1295
|
+
var AssignmentExpressionTail$3 = ConditionalExpression;
|
|
1296
|
+
function AssignmentExpressionTail(state) {
|
|
1238
1297
|
if (state.tokenize) {
|
|
1239
|
-
return $TOKEN("
|
|
1298
|
+
return $TOKEN("AssignmentExpressionTail", state, AssignmentExpressionTail$0(state) || AssignmentExpressionTail$1(state) || AssignmentExpressionTail$2(state) || AssignmentExpressionTail$3(state));
|
|
1240
1299
|
} else {
|
|
1241
|
-
return
|
|
1300
|
+
return AssignmentExpressionTail$0(state) || AssignmentExpressionTail$1(state) || AssignmentExpressionTail$2(state) || AssignmentExpressionTail$3(state);
|
|
1242
1301
|
}
|
|
1243
1302
|
}
|
|
1244
|
-
var
|
|
1245
|
-
function
|
|
1303
|
+
var YieldExpression$0 = $S(Yield, YieldTail);
|
|
1304
|
+
function YieldExpression(state) {
|
|
1246
1305
|
if (state.verbose)
|
|
1247
|
-
console.log("ENTER:", "
|
|
1306
|
+
console.log("ENTER:", "YieldExpression");
|
|
1307
|
+
if (state.tokenize) {
|
|
1308
|
+
return $TOKEN("YieldExpression", state, YieldExpression$0(state));
|
|
1309
|
+
} else {
|
|
1310
|
+
return YieldExpression$0(state);
|
|
1311
|
+
}
|
|
1312
|
+
}
|
|
1313
|
+
var YieldTail$0 = $Y(EOS);
|
|
1314
|
+
var YieldTail$1 = $S($E($S($Q(TrailingComment), Star)), AssignmentExpression);
|
|
1315
|
+
function YieldTail(state) {
|
|
1248
1316
|
if (state.tokenize) {
|
|
1249
|
-
return $TOKEN("
|
|
1317
|
+
return $TOKEN("YieldTail", state, YieldTail$0(state) || YieldTail$1(state));
|
|
1250
1318
|
} else {
|
|
1251
|
-
return
|
|
1319
|
+
return YieldTail$0(state) || YieldTail$1(state);
|
|
1252
1320
|
}
|
|
1253
1321
|
}
|
|
1254
|
-
var
|
|
1255
|
-
|
|
1322
|
+
var ArrowFunction$0 = $TS($S($E($S(Async, __)), ArrowFunctionTail), function($skip, $loc, $0, $1, $2) {
|
|
1323
|
+
if ($1)
|
|
1324
|
+
$2.children.unshift($1);
|
|
1325
|
+
return $2;
|
|
1326
|
+
});
|
|
1327
|
+
function ArrowFunction(state) {
|
|
1256
1328
|
if (state.verbose)
|
|
1257
|
-
console.log("ENTER:", "
|
|
1329
|
+
console.log("ENTER:", "ArrowFunction");
|
|
1258
1330
|
if (state.tokenize) {
|
|
1259
|
-
return $TOKEN("
|
|
1331
|
+
return $TOKEN("ArrowFunction", state, ArrowFunction$0(state));
|
|
1260
1332
|
} else {
|
|
1261
|
-
return
|
|
1333
|
+
return ArrowFunction$0(state);
|
|
1262
1334
|
}
|
|
1263
1335
|
}
|
|
1264
|
-
var
|
|
1265
|
-
var
|
|
1336
|
+
var ArrowFunctionTail$0 = ThinArrowFunction;
|
|
1337
|
+
var ArrowFunctionTail$1 = $TS($S(Parameters, $E(ReturnTypeSuffix), FatArrow, FatArrowBody), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1338
|
+
var parameters = $1;
|
|
1266
1339
|
var suffix = $2;
|
|
1267
1340
|
var expOrBlock = $4;
|
|
1268
1341
|
const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
|
|
@@ -1271,15 +1344,19 @@ var Civet = (() => {
|
|
|
1271
1344
|
module.addImplicitReturns(expOrBlock);
|
|
1272
1345
|
}
|
|
1273
1346
|
return {
|
|
1274
|
-
type: "
|
|
1347
|
+
type: "ArrowFunction",
|
|
1348
|
+
parameters,
|
|
1349
|
+
returnType: suffix,
|
|
1350
|
+
ts: false,
|
|
1351
|
+
block: expOrBlock,
|
|
1275
1352
|
children: $0
|
|
1276
1353
|
};
|
|
1277
1354
|
});
|
|
1278
|
-
function
|
|
1355
|
+
function ArrowFunctionTail(state) {
|
|
1279
1356
|
if (state.tokenize) {
|
|
1280
|
-
return $TOKEN("
|
|
1357
|
+
return $TOKEN("ArrowFunctionTail", state, ArrowFunctionTail$0(state) || ArrowFunctionTail$1(state));
|
|
1281
1358
|
} else {
|
|
1282
|
-
return
|
|
1359
|
+
return ArrowFunctionTail$0(state) || ArrowFunctionTail$1(state);
|
|
1283
1360
|
}
|
|
1284
1361
|
}
|
|
1285
1362
|
var FatArrow$0 = $TS($S(__, $EXPECT($L3, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
|
|
@@ -1297,25 +1374,24 @@ var Civet = (() => {
|
|
|
1297
1374
|
return FatArrow$0(state);
|
|
1298
1375
|
}
|
|
1299
1376
|
}
|
|
1300
|
-
var FatArrowBody$0 = $T($S(__, OpenBrace, EOS,
|
|
1377
|
+
var FatArrowBody$0 = $T($S(__, OpenBrace, EOS, NestedBlockStatements, __, CloseBrace), function(value) {
|
|
1301
1378
|
var exps = value[3];
|
|
1302
1379
|
return { "type": "BlockStatement", "expressions": exps, "children": value };
|
|
1303
1380
|
});
|
|
1304
|
-
var FatArrowBody$1 = $T($S(InsertOpenBrace, EOS,
|
|
1381
|
+
var FatArrowBody$1 = $T($S(InsertOpenBrace, EOS, NestedBlockStatements, InsertNewline, InsertIndent, InsertCloseBrace), function(value) {
|
|
1305
1382
|
var exps = value[2];
|
|
1306
1383
|
return { "type": "BlockStatement", "expressions": exps, "children": value };
|
|
1307
1384
|
});
|
|
1308
1385
|
var FatArrowBody$2 = AssignmentExpression;
|
|
1309
|
-
var FatArrowBody$3 =
|
|
1310
|
-
var FatArrowBody$4 = EmptyBlock;
|
|
1386
|
+
var FatArrowBody$3 = EmptyBlock;
|
|
1311
1387
|
function FatArrowBody(state) {
|
|
1312
1388
|
if (state.tokenize) {
|
|
1313
|
-
return $TOKEN("FatArrowBody", state, FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state)
|
|
1389
|
+
return $TOKEN("FatArrowBody", state, FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state));
|
|
1314
1390
|
} else {
|
|
1315
|
-
return FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state)
|
|
1391
|
+
return FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state);
|
|
1316
1392
|
}
|
|
1317
1393
|
}
|
|
1318
|
-
var ConditionalExpression$0 = $TS($S(ShortCircuitExpression, $E($S(__, QuestionMark,
|
|
1394
|
+
var ConditionalExpression$0 = $TS($S(ShortCircuitExpression, $E($S(__, QuestionMark, ExtendedExpression, __, Colon, ExtendedExpression))), function($skip, $loc, $0, $1, $2) {
|
|
1319
1395
|
if ($2)
|
|
1320
1396
|
return $0;
|
|
1321
1397
|
return $1;
|
|
@@ -1348,7 +1424,7 @@ var Civet = (() => {
|
|
|
1348
1424
|
var PrimaryExpression$6 = ClassExpression;
|
|
1349
1425
|
var PrimaryExpression$7 = RegularExpressionLiteral;
|
|
1350
1426
|
var PrimaryExpression$8 = TemplateLiteral;
|
|
1351
|
-
var PrimaryExpression$9 = $S(OpenParen,
|
|
1427
|
+
var PrimaryExpression$9 = $S(OpenParen, ExtendedExpression, __, CloseParen);
|
|
1352
1428
|
var PrimaryExpression$10 = JSXElement;
|
|
1353
1429
|
var PrimaryExpression$11 = JSXFragment;
|
|
1354
1430
|
function PrimaryExpression(state) {
|
|
@@ -1444,7 +1520,7 @@ var Civet = (() => {
|
|
|
1444
1520
|
return ClassElement$0(state) || ClassElement$1(state);
|
|
1445
1521
|
}
|
|
1446
1522
|
}
|
|
1447
|
-
var FieldDefinition$0 = $TS($S(InsertReadonly, ClassElementName, $E(TypeSuffix), __, ConstAssignment,
|
|
1523
|
+
var FieldDefinition$0 = $TS($S(InsertReadonly, ClassElementName, $E(TypeSuffix), __, ConstAssignment, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
1448
1524
|
var r = $1;
|
|
1449
1525
|
var ca = $5;
|
|
1450
1526
|
r.children[0].$loc = {
|
|
@@ -1487,27 +1563,22 @@ var Civet = (() => {
|
|
|
1487
1563
|
return AtAccessor$0(state);
|
|
1488
1564
|
}
|
|
1489
1565
|
}
|
|
1490
|
-
var LeftHandSideExpression$0 =
|
|
1491
|
-
|
|
1566
|
+
var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($L9, fail, 'LeftHandSideExpression "."')), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
|
|
1567
|
+
if ($1.length)
|
|
1568
|
+
return $0;
|
|
1569
|
+
return $2;
|
|
1570
|
+
});
|
|
1492
1571
|
function LeftHandSideExpression(state) {
|
|
1493
|
-
if (state.tokenize) {
|
|
1494
|
-
return $TOKEN("LeftHandSideExpression", state, LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state));
|
|
1495
|
-
} else {
|
|
1496
|
-
return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
|
|
1497
|
-
}
|
|
1498
|
-
}
|
|
1499
|
-
var NewExpression$0 = $S($P($S(New, __)), CallExpression);
|
|
1500
|
-
function NewExpression(state) {
|
|
1501
1572
|
if (state.verbose)
|
|
1502
|
-
console.log("ENTER:", "
|
|
1573
|
+
console.log("ENTER:", "LeftHandSideExpression");
|
|
1503
1574
|
if (state.tokenize) {
|
|
1504
|
-
return $TOKEN("
|
|
1575
|
+
return $TOKEN("LeftHandSideExpression", state, LeftHandSideExpression$0(state));
|
|
1505
1576
|
} else {
|
|
1506
|
-
return
|
|
1577
|
+
return LeftHandSideExpression$0(state);
|
|
1507
1578
|
}
|
|
1508
1579
|
}
|
|
1509
|
-
var CallExpression$0 = $S($EXPECT($
|
|
1510
|
-
var CallExpression$1 = $S($EXPECT($
|
|
1580
|
+
var CallExpression$0 = $S($EXPECT($L10, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
|
|
1581
|
+
var CallExpression$1 = $S($EXPECT($L11, fail, 'CallExpression "import"'), __, OpenParen, ExtendedExpression, __, CloseParen);
|
|
1511
1582
|
var CallExpression$2 = $TS($S(MemberExpression, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2) {
|
|
1512
1583
|
if ($2.length)
|
|
1513
1584
|
return $0;
|
|
@@ -1540,7 +1611,7 @@ var Civet = (() => {
|
|
|
1540
1611
|
return OptionalShorthand$0(state);
|
|
1541
1612
|
}
|
|
1542
1613
|
}
|
|
1543
|
-
var NonNullAssertion$0 = $T($EXPECT($
|
|
1614
|
+
var NonNullAssertion$0 = $T($EXPECT($L12, fail, 'NonNullAssertion "!"'), function(value) {
|
|
1544
1615
|
return { "ts": true, "children": value };
|
|
1545
1616
|
});
|
|
1546
1617
|
function NonNullAssertion(state) {
|
|
@@ -1552,7 +1623,7 @@ var Civet = (() => {
|
|
|
1552
1623
|
return NonNullAssertion$0(state);
|
|
1553
1624
|
}
|
|
1554
1625
|
}
|
|
1555
|
-
var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
1626
|
+
var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of|then)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
|
|
1556
1627
|
function AdditionalReservedWords(state) {
|
|
1557
1628
|
if (state.verbose)
|
|
1558
1629
|
console.log("ENTER:", "AdditionalReservedWords");
|
|
@@ -1567,8 +1638,8 @@ var Civet = (() => {
|
|
|
1567
1638
|
return $0;
|
|
1568
1639
|
return $1;
|
|
1569
1640
|
});
|
|
1570
|
-
var MemberExpression$1 =
|
|
1571
|
-
var MemberExpression$2 =
|
|
1641
|
+
var MemberExpression$1 = SuperProperty;
|
|
1642
|
+
var MemberExpression$2 = MetaProperty;
|
|
1572
1643
|
function MemberExpression(state) {
|
|
1573
1644
|
if (state.tokenize) {
|
|
1574
1645
|
return $TOKEN("MemberExpression", state, MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state));
|
|
@@ -1582,7 +1653,7 @@ var Civet = (() => {
|
|
|
1582
1653
|
return $2;
|
|
1583
1654
|
});
|
|
1584
1655
|
var MemberExpressionRest$1 = $S($E($S($Y(EOS), IndentedFurther)), PropertyAccess);
|
|
1585
|
-
var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($
|
|
1656
|
+
var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L13, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1586
1657
|
var id = $3;
|
|
1587
1658
|
if (id)
|
|
1588
1659
|
return [".prototype.", id];
|
|
@@ -1596,7 +1667,7 @@ var Civet = (() => {
|
|
|
1596
1667
|
return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state);
|
|
1597
1668
|
}
|
|
1598
1669
|
}
|
|
1599
|
-
var MemberBracketContent$0 = $TS($S(OpenBracket,
|
|
1670
|
+
var MemberBracketContent$0 = $TS($S(OpenBracket, ExtendedExpression, $E($S($C(DotDotDot, DotDot), $E(ExtendedExpression))), __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1600
1671
|
if ($3) {
|
|
1601
1672
|
const sep = $3[0];
|
|
1602
1673
|
const end = $3[1];
|
|
@@ -1648,7 +1719,7 @@ var Civet = (() => {
|
|
|
1648
1719
|
return PropertyAccess$0(state);
|
|
1649
1720
|
}
|
|
1650
1721
|
}
|
|
1651
|
-
var SuperProperty$0 = $S($EXPECT($
|
|
1722
|
+
var SuperProperty$0 = $S($EXPECT($L14, fail, 'SuperProperty "super["'), ExtendedExpression, __, CloseBracket);
|
|
1652
1723
|
function SuperProperty(state) {
|
|
1653
1724
|
if (state.verbose)
|
|
1654
1725
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1659,7 +1730,7 @@ var Civet = (() => {
|
|
|
1659
1730
|
}
|
|
1660
1731
|
}
|
|
1661
1732
|
var MetaProperty$0 = $S(New, Dot, Target);
|
|
1662
|
-
var MetaProperty$1 = $TV($EXPECT($
|
|
1733
|
+
var MetaProperty$1 = $TV($EXPECT($L15, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
|
|
1663
1734
|
return { $loc, token: $1 };
|
|
1664
1735
|
});
|
|
1665
1736
|
function MetaProperty(state) {
|
|
@@ -1671,7 +1742,11 @@ var Civet = (() => {
|
|
|
1671
1742
|
}
|
|
1672
1743
|
var Parameters$0 = NonEmptyParameters;
|
|
1673
1744
|
var Parameters$1 = $TV($EXPECT($L0, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
|
|
1674
|
-
return {
|
|
1745
|
+
return {
|
|
1746
|
+
type: "Parameters",
|
|
1747
|
+
children: [{ $loc, token: "()" }],
|
|
1748
|
+
names: []
|
|
1749
|
+
};
|
|
1675
1750
|
});
|
|
1676
1751
|
function Parameters(state) {
|
|
1677
1752
|
if (state.tokenize) {
|
|
@@ -1680,7 +1755,13 @@ var Civet = (() => {
|
|
|
1680
1755
|
return Parameters$0(state) || Parameters$1(state);
|
|
1681
1756
|
}
|
|
1682
1757
|
}
|
|
1683
|
-
var NonEmptyParameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), $E(FunctionRestParameter), __, CloseParen)
|
|
1758
|
+
var NonEmptyParameters$0 = $TS($S($E(TypeParameters), OpenParen, $Q(ParameterElement), $E(FunctionRestParameter), __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
1759
|
+
return {
|
|
1760
|
+
type: "Parameters",
|
|
1761
|
+
children: $0,
|
|
1762
|
+
names: $3.flatMap((p) => p.names)
|
|
1763
|
+
};
|
|
1764
|
+
});
|
|
1684
1765
|
function NonEmptyParameters(state) {
|
|
1685
1766
|
if (state.verbose)
|
|
1686
1767
|
console.log("ENTER:", "NonEmptyParameters");
|
|
@@ -1700,7 +1781,13 @@ var Civet = (() => {
|
|
|
1700
1781
|
return FunctionRestParameter$0(state);
|
|
1701
1782
|
}
|
|
1702
1783
|
}
|
|
1703
|
-
var ParameterElement$0 = $S(
|
|
1784
|
+
var ParameterElement$0 = $TS($S($C(BindingIdentifier, BindingPattern), $E(TypeSuffix), $E(Initializer), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1785
|
+
return {
|
|
1786
|
+
type: "Parameter",
|
|
1787
|
+
children: $0,
|
|
1788
|
+
names: $1.names
|
|
1789
|
+
};
|
|
1790
|
+
});
|
|
1704
1791
|
function ParameterElement(state) {
|
|
1705
1792
|
if (state.verbose)
|
|
1706
1793
|
console.log("ENTER:", "ParameterElement");
|
|
@@ -1711,7 +1798,7 @@ var Civet = (() => {
|
|
|
1711
1798
|
}
|
|
1712
1799
|
}
|
|
1713
1800
|
var ParameterElementDelimiter$0 = $S($Q(_), Comma);
|
|
1714
|
-
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
1801
|
+
var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L16, fail, 'ParameterElementDelimiter ")"')));
|
|
1715
1802
|
var ParameterElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
1716
1803
|
return { $loc, token: "," };
|
|
1717
1804
|
});
|
|
@@ -1722,7 +1809,10 @@ var Civet = (() => {
|
|
|
1722
1809
|
return ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state);
|
|
1723
1810
|
}
|
|
1724
1811
|
}
|
|
1725
|
-
var BindingIdentifier$0 = $S(__, Identifier)
|
|
1812
|
+
var BindingIdentifier$0 = $TS($S(__, Identifier), function($skip, $loc, $0, $1, $2) {
|
|
1813
|
+
$2.children.unshift($1);
|
|
1814
|
+
return $2;
|
|
1815
|
+
});
|
|
1726
1816
|
function BindingIdentifier(state) {
|
|
1727
1817
|
if (state.verbose)
|
|
1728
1818
|
console.log("ENTER:", "BindingIdentifier");
|
|
@@ -1732,8 +1822,16 @@ var Civet = (() => {
|
|
|
1732
1822
|
return BindingIdentifier$0(state);
|
|
1733
1823
|
}
|
|
1734
1824
|
}
|
|
1735
|
-
var BindingPattern$0 = $S(__, ObjectBindingPattern)
|
|
1736
|
-
|
|
1825
|
+
var BindingPattern$0 = $TS($S(__, ObjectBindingPattern), function($skip, $loc, $0, $1, $2) {
|
|
1826
|
+
var p = $2;
|
|
1827
|
+
p.children.unshift($1);
|
|
1828
|
+
return p;
|
|
1829
|
+
});
|
|
1830
|
+
var BindingPattern$1 = $TS($S(__, ArrayBindingPattern), function($skip, $loc, $0, $1, $2) {
|
|
1831
|
+
var p = $2;
|
|
1832
|
+
p.children.unshift($1);
|
|
1833
|
+
return p;
|
|
1834
|
+
});
|
|
1737
1835
|
function BindingPattern(state) {
|
|
1738
1836
|
if (state.tokenize) {
|
|
1739
1837
|
return $TOKEN("BindingPattern", state, BindingPattern$0(state) || BindingPattern$1(state));
|
|
@@ -1741,32 +1839,111 @@ var Civet = (() => {
|
|
|
1741
1839
|
return BindingPattern$0(state) || BindingPattern$1(state);
|
|
1742
1840
|
}
|
|
1743
1841
|
}
|
|
1744
|
-
var ObjectBindingPattern$0 = $S(OpenBrace,
|
|
1745
|
-
|
|
1842
|
+
var ObjectBindingPattern$0 = $TS($S(OpenBrace, ObjectBindingPatternContent, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1843
|
+
var c = $2;
|
|
1844
|
+
c.children.unshift($1);
|
|
1845
|
+
c.children.push($3, $4);
|
|
1846
|
+
return c;
|
|
1847
|
+
});
|
|
1746
1848
|
function ObjectBindingPattern(state) {
|
|
1849
|
+
if (state.verbose)
|
|
1850
|
+
console.log("ENTER:", "ObjectBindingPattern");
|
|
1851
|
+
if (state.tokenize) {
|
|
1852
|
+
return $TOKEN("ObjectBindingPattern", state, ObjectBindingPattern$0(state));
|
|
1853
|
+
} else {
|
|
1854
|
+
return ObjectBindingPattern$0(state);
|
|
1855
|
+
}
|
|
1856
|
+
}
|
|
1857
|
+
var ObjectBindingPatternContent$0 = $T($S($Y(EOS), NestedBindingProperties), function(value) {
|
|
1858
|
+
return value[1];
|
|
1859
|
+
});
|
|
1860
|
+
var ObjectBindingPatternContent$1 = $TS($S($Q(BindingProperty), $E($S(__, BindingRestProperty))), function($skip, $loc, $0, $1, $2) {
|
|
1861
|
+
var props = $1;
|
|
1862
|
+
var rest = $2;
|
|
1863
|
+
const names = props.flatMap((p) => p.names);
|
|
1864
|
+
if (rest) {
|
|
1865
|
+
props.push(...rest);
|
|
1866
|
+
names.push(...rest[1].names);
|
|
1867
|
+
}
|
|
1868
|
+
return {
|
|
1869
|
+
type: "BindingPattern",
|
|
1870
|
+
names,
|
|
1871
|
+
children: props
|
|
1872
|
+
};
|
|
1873
|
+
});
|
|
1874
|
+
function ObjectBindingPatternContent(state) {
|
|
1747
1875
|
if (state.tokenize) {
|
|
1748
|
-
return $TOKEN("
|
|
1876
|
+
return $TOKEN("ObjectBindingPatternContent", state, ObjectBindingPatternContent$0(state) || ObjectBindingPatternContent$1(state));
|
|
1749
1877
|
} else {
|
|
1750
|
-
return
|
|
1878
|
+
return ObjectBindingPatternContent$0(state) || ObjectBindingPatternContent$1(state);
|
|
1751
1879
|
}
|
|
1752
1880
|
}
|
|
1753
|
-
var ArrayBindingPattern$0 = $S(OpenBracket,
|
|
1754
|
-
|
|
1881
|
+
var ArrayBindingPattern$0 = $TS($S(OpenBracket, ArrayBindingPatternContent, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1882
|
+
var c = $2;
|
|
1883
|
+
return {
|
|
1884
|
+
type: "BindingPattern",
|
|
1885
|
+
names: c.names,
|
|
1886
|
+
children: $0
|
|
1887
|
+
};
|
|
1888
|
+
});
|
|
1755
1889
|
function ArrayBindingPattern(state) {
|
|
1890
|
+
if (state.verbose)
|
|
1891
|
+
console.log("ENTER:", "ArrayBindingPattern");
|
|
1892
|
+
if (state.tokenize) {
|
|
1893
|
+
return $TOKEN("ArrayBindingPattern", state, ArrayBindingPattern$0(state));
|
|
1894
|
+
} else {
|
|
1895
|
+
return ArrayBindingPattern$0(state);
|
|
1896
|
+
}
|
|
1897
|
+
}
|
|
1898
|
+
var ArrayBindingPatternContent$0 = $T($S($Y(EOS), NestedBindingElements), function(value) {
|
|
1899
|
+
return value[1];
|
|
1900
|
+
});
|
|
1901
|
+
var ArrayBindingPatternContent$1 = $TS($S($Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement))), function($skip, $loc, $0, $1, $2) {
|
|
1902
|
+
var props = $1;
|
|
1903
|
+
var rest = $2;
|
|
1904
|
+
const names = props.flatMap((p) => p.names || []);
|
|
1905
|
+
if (rest) {
|
|
1906
|
+
props.push(...rest);
|
|
1907
|
+
names.push(...rest[1].names);
|
|
1908
|
+
}
|
|
1909
|
+
return {
|
|
1910
|
+
type: "BindingPattern",
|
|
1911
|
+
names,
|
|
1912
|
+
children: props
|
|
1913
|
+
};
|
|
1914
|
+
});
|
|
1915
|
+
function ArrayBindingPatternContent(state) {
|
|
1756
1916
|
if (state.tokenize) {
|
|
1757
|
-
return $TOKEN("
|
|
1917
|
+
return $TOKEN("ArrayBindingPatternContent", state, ArrayBindingPatternContent$0(state) || ArrayBindingPatternContent$1(state));
|
|
1758
1918
|
} else {
|
|
1759
|
-
return
|
|
1919
|
+
return ArrayBindingPatternContent$0(state) || ArrayBindingPatternContent$1(state);
|
|
1760
1920
|
}
|
|
1761
1921
|
}
|
|
1762
|
-
var
|
|
1922
|
+
var Elision$0 = $S(__, Comma);
|
|
1923
|
+
function Elision(state) {
|
|
1924
|
+
if (state.verbose)
|
|
1925
|
+
console.log("ENTER:", "Elision");
|
|
1926
|
+
if (state.tokenize) {
|
|
1927
|
+
return $TOKEN("Elision", state, Elision$0(state));
|
|
1928
|
+
} else {
|
|
1929
|
+
return Elision$0(state);
|
|
1930
|
+
}
|
|
1931
|
+
}
|
|
1932
|
+
var NestedBindingProperties$0 = $TS($S(PushIndent, $Q(NestedBindingProperty), $E(NestedBindingRestProperty), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1763
1933
|
var props = $2;
|
|
1764
1934
|
var rest = $3;
|
|
1765
|
-
if (!props.length)
|
|
1935
|
+
if (!(props.length || rest))
|
|
1766
1936
|
return $skip;
|
|
1767
|
-
|
|
1937
|
+
const names = props.flatMap((p) => p.names);
|
|
1938
|
+
if (rest) {
|
|
1768
1939
|
props.push(rest);
|
|
1769
|
-
|
|
1940
|
+
names.push(...rest.names);
|
|
1941
|
+
}
|
|
1942
|
+
return {
|
|
1943
|
+
type: "BindingPattern",
|
|
1944
|
+
children: props,
|
|
1945
|
+
names
|
|
1946
|
+
};
|
|
1770
1947
|
});
|
|
1771
1948
|
function NestedBindingProperties(state) {
|
|
1772
1949
|
if (state.verbose)
|
|
@@ -1777,7 +1954,10 @@ var Civet = (() => {
|
|
|
1777
1954
|
return NestedBindingProperties$0(state);
|
|
1778
1955
|
}
|
|
1779
1956
|
}
|
|
1780
|
-
var NestedBindingProperty$0 = $S(Nested, BindingProperty)
|
|
1957
|
+
var NestedBindingProperty$0 = $TS($S(Nested, BindingProperty), function($skip, $loc, $0, $1, $2) {
|
|
1958
|
+
$2.children.unshift($1);
|
|
1959
|
+
return $2;
|
|
1960
|
+
});
|
|
1781
1961
|
function NestedBindingProperty(state) {
|
|
1782
1962
|
if (state.verbose)
|
|
1783
1963
|
console.log("ENTER:", "NestedBindingProperty");
|
|
@@ -1787,8 +1967,22 @@ var Civet = (() => {
|
|
|
1787
1967
|
return NestedBindingProperty$0(state);
|
|
1788
1968
|
}
|
|
1789
1969
|
}
|
|
1790
|
-
var BindingProperty$0 = $S(__, PropertyName, __, Colon, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter)
|
|
1791
|
-
|
|
1970
|
+
var BindingProperty$0 = $TS($S(__, PropertyName, __, Colon, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
1971
|
+
var b = $5;
|
|
1972
|
+
return {
|
|
1973
|
+
type: "BindingPattern",
|
|
1974
|
+
names: b.names,
|
|
1975
|
+
children: $0
|
|
1976
|
+
};
|
|
1977
|
+
});
|
|
1978
|
+
var BindingProperty$1 = $TS($S(BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
|
|
1979
|
+
var b = $1;
|
|
1980
|
+
return {
|
|
1981
|
+
type: "BindingPattern",
|
|
1982
|
+
names: b.names,
|
|
1983
|
+
children: $0
|
|
1984
|
+
};
|
|
1985
|
+
});
|
|
1792
1986
|
function BindingProperty(state) {
|
|
1793
1987
|
if (state.tokenize) {
|
|
1794
1988
|
return $TOKEN("BindingProperty", state, BindingProperty$0(state) || BindingProperty$1(state));
|
|
@@ -1796,7 +1990,23 @@ var Civet = (() => {
|
|
|
1796
1990
|
return BindingProperty$0(state) || BindingProperty$1(state);
|
|
1797
1991
|
}
|
|
1798
1992
|
}
|
|
1799
|
-
var
|
|
1993
|
+
var NestedBindingRestProperty$0 = $TS($S(Nested, BindingRestProperty), function($skip, $loc, $0, $1, $2) {
|
|
1994
|
+
$2.children.unshift($1);
|
|
1995
|
+
return $2;
|
|
1996
|
+
});
|
|
1997
|
+
function NestedBindingRestProperty(state) {
|
|
1998
|
+
if (state.verbose)
|
|
1999
|
+
console.log("ENTER:", "NestedBindingRestProperty");
|
|
2000
|
+
if (state.tokenize) {
|
|
2001
|
+
return $TOKEN("NestedBindingRestProperty", state, NestedBindingRestProperty$0(state));
|
|
2002
|
+
} else {
|
|
2003
|
+
return NestedBindingRestProperty$0(state);
|
|
2004
|
+
}
|
|
2005
|
+
}
|
|
2006
|
+
var BindingRestProperty$0 = $TS($S(DotDotDot, BindingIdentifier), function($skip, $loc, $0, $1, $2) {
|
|
2007
|
+
$2.children.unshift($1);
|
|
2008
|
+
return $2;
|
|
2009
|
+
});
|
|
1800
2010
|
function BindingRestProperty(state) {
|
|
1801
2011
|
if (state.verbose)
|
|
1802
2012
|
console.log("ENTER:", "BindingRestProperty");
|
|
@@ -1809,11 +2019,18 @@ var Civet = (() => {
|
|
|
1809
2019
|
var NestedBindingElements$0 = $TS($S(PushIndent, $Q(NestedBindingElement), $E($S(Nested, BindingRestElement)), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
1810
2020
|
var props = $2;
|
|
1811
2021
|
var rest = $3;
|
|
1812
|
-
if (!props.length)
|
|
2022
|
+
if (!(props.length || rest))
|
|
1813
2023
|
return $skip;
|
|
1814
|
-
|
|
1815
|
-
|
|
1816
|
-
|
|
2024
|
+
const names = props.flatMap((p) => p.names);
|
|
2025
|
+
if (rest) {
|
|
2026
|
+
props.push(...rest);
|
|
2027
|
+
names.push(...rest[1].names);
|
|
2028
|
+
}
|
|
2029
|
+
return {
|
|
2030
|
+
type: "BindingPattern",
|
|
2031
|
+
children: props,
|
|
2032
|
+
names
|
|
2033
|
+
};
|
|
1817
2034
|
});
|
|
1818
2035
|
function NestedBindingElements(state) {
|
|
1819
2036
|
if (state.verbose)
|
|
@@ -1824,7 +2041,10 @@ var Civet = (() => {
|
|
|
1824
2041
|
return NestedBindingElements$0(state);
|
|
1825
2042
|
}
|
|
1826
2043
|
}
|
|
1827
|
-
var NestedBindingElement$0 = $S(Nested, BindingElement)
|
|
2044
|
+
var NestedBindingElement$0 = $TS($S(Nested, BindingElement), function($skip, $loc, $0, $1, $2) {
|
|
2045
|
+
$2.children.unshift($1);
|
|
2046
|
+
return $2;
|
|
2047
|
+
});
|
|
1828
2048
|
function NestedBindingElement(state) {
|
|
1829
2049
|
if (state.verbose)
|
|
1830
2050
|
console.log("ENTER:", "NestedBindingElement");
|
|
@@ -1834,7 +2054,14 @@ var Civet = (() => {
|
|
|
1834
2054
|
return NestedBindingElement$0(state);
|
|
1835
2055
|
}
|
|
1836
2056
|
}
|
|
1837
|
-
var BindingElement$0 = $S(
|
|
2057
|
+
var BindingElement$0 = $TS($S($C(BindingIdentifier, BindingPattern), $E(Initializer), ArrayElementDelimiter), function($skip, $loc, $0, $1, $2, $3) {
|
|
2058
|
+
var binding = $1;
|
|
2059
|
+
return {
|
|
2060
|
+
type: "BindingPattern",
|
|
2061
|
+
names: binding.names,
|
|
2062
|
+
children: $0
|
|
2063
|
+
};
|
|
2064
|
+
});
|
|
1838
2065
|
function BindingElement(state) {
|
|
1839
2066
|
if (state.verbose)
|
|
1840
2067
|
console.log("ENTER:", "BindingElement");
|
|
@@ -1844,7 +2071,11 @@ var Civet = (() => {
|
|
|
1844
2071
|
return BindingElement$0(state);
|
|
1845
2072
|
}
|
|
1846
2073
|
}
|
|
1847
|
-
var BindingRestElement$0 = $S(DotDotDot,
|
|
2074
|
+
var BindingRestElement$0 = $TS($S(DotDotDot, $C(BindingIdentifier, BindingPattern)), function($skip, $loc, $0, $1, $2) {
|
|
2075
|
+
var binding = $2;
|
|
2076
|
+
binding.children.unshift($1);
|
|
2077
|
+
return binding;
|
|
2078
|
+
});
|
|
1848
2079
|
function BindingRestElement(state) {
|
|
1849
2080
|
if (state.verbose)
|
|
1850
2081
|
console.log("ENTER:", "BindingRestElement");
|
|
@@ -1864,7 +2095,21 @@ var Civet = (() => {
|
|
|
1864
2095
|
return FunctionDeclaration$0(state);
|
|
1865
2096
|
}
|
|
1866
2097
|
}
|
|
1867
|
-
var FunctionSignature$0 = $S($E($S(Async, __)), Function, $E(
|
|
2098
|
+
var FunctionSignature$0 = $TS($S($E($S(Async, __)), Function, $E(Star), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
2099
|
+
var id = $4;
|
|
2100
|
+
var parameters = $6;
|
|
2101
|
+
id = id || [];
|
|
2102
|
+
$0[3] = id;
|
|
2103
|
+
return {
|
|
2104
|
+
type: "FunctionSignature",
|
|
2105
|
+
id,
|
|
2106
|
+
parameters,
|
|
2107
|
+
returnType: $7,
|
|
2108
|
+
ts: false,
|
|
2109
|
+
block: null,
|
|
2110
|
+
children: $0
|
|
2111
|
+
};
|
|
2112
|
+
});
|
|
1868
2113
|
function FunctionSignature(state) {
|
|
1869
2114
|
if (state.verbose)
|
|
1870
2115
|
console.log("ENTER:", "FunctionSignature");
|
|
@@ -1874,36 +2119,34 @@ var Civet = (() => {
|
|
|
1874
2119
|
return FunctionSignature$0(state);
|
|
1875
2120
|
}
|
|
1876
2121
|
}
|
|
1877
|
-
var FunctionExpression$0 =
|
|
1878
|
-
|
|
2122
|
+
var FunctionExpression$0 = $TS($S(FunctionSignature, $E(BracedBlock)), function($skip, $loc, $0, $1, $2) {
|
|
2123
|
+
var signature = $1;
|
|
1879
2124
|
var block = $2;
|
|
1880
2125
|
if (!block) {
|
|
1881
|
-
|
|
1882
|
-
|
|
1883
|
-
ts: true,
|
|
1884
|
-
children: $1
|
|
1885
|
-
};
|
|
2126
|
+
signature.ts = true;
|
|
2127
|
+
return signature;
|
|
1886
2128
|
}
|
|
1887
|
-
const suffix =
|
|
2129
|
+
const suffix = signature.returnType;
|
|
1888
2130
|
const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
|
|
1889
2131
|
if (module.config.implicitReturns && !isVoid) {
|
|
1890
2132
|
module.addImplicitReturns(block);
|
|
1891
2133
|
}
|
|
1892
|
-
$1.
|
|
1893
|
-
|
|
1894
|
-
|
|
1895
|
-
|
|
1896
|
-
};
|
|
2134
|
+
$1.block = block;
|
|
2135
|
+
$1.children.push(block);
|
|
2136
|
+
$1.type = "FunctionExpression";
|
|
2137
|
+
return $1;
|
|
1897
2138
|
});
|
|
1898
2139
|
function FunctionExpression(state) {
|
|
2140
|
+
if (state.verbose)
|
|
2141
|
+
console.log("ENTER:", "FunctionExpression");
|
|
1899
2142
|
if (state.tokenize) {
|
|
1900
|
-
return $TOKEN("FunctionExpression", state, FunctionExpression$0(state)
|
|
2143
|
+
return $TOKEN("FunctionExpression", state, FunctionExpression$0(state));
|
|
1901
2144
|
} else {
|
|
1902
|
-
return FunctionExpression$0(state)
|
|
2145
|
+
return FunctionExpression$0(state);
|
|
1903
2146
|
}
|
|
1904
2147
|
}
|
|
1905
2148
|
var ThinArrowFunction$0 = $TS($S(Parameters, $E(ReturnTypeSuffix), $Q(_), Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
1906
|
-
var
|
|
2149
|
+
var parameters = $1;
|
|
1907
2150
|
var suffix = $2;
|
|
1908
2151
|
var arrow = $4;
|
|
1909
2152
|
var block = $5;
|
|
@@ -1911,11 +2154,18 @@ var Civet = (() => {
|
|
|
1911
2154
|
if (module.config.implicitReturns && !isVoid) {
|
|
1912
2155
|
block = module.addImplicitReturns(block);
|
|
1913
2156
|
}
|
|
2157
|
+
const id = [];
|
|
1914
2158
|
return {
|
|
1915
2159
|
type: "FunctionExpression",
|
|
2160
|
+
id,
|
|
2161
|
+
parameters,
|
|
2162
|
+
returnType: suffix,
|
|
2163
|
+
ts: false,
|
|
2164
|
+
block,
|
|
1916
2165
|
children: [
|
|
1917
2166
|
{ $loc: arrow.$loc, token: "function" },
|
|
1918
|
-
|
|
2167
|
+
id,
|
|
2168
|
+
parameters,
|
|
1919
2169
|
suffix,
|
|
1920
2170
|
block
|
|
1921
2171
|
]
|
|
@@ -1930,7 +2180,7 @@ var Civet = (() => {
|
|
|
1930
2180
|
return ThinArrowFunction$0(state);
|
|
1931
2181
|
}
|
|
1932
2182
|
}
|
|
1933
|
-
var Arrow$0 = $TV($EXPECT($
|
|
2183
|
+
var Arrow$0 = $TV($EXPECT($L17, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
|
|
1934
2184
|
return { $loc, token: $1 };
|
|
1935
2185
|
});
|
|
1936
2186
|
function Arrow(state) {
|
|
@@ -1942,16 +2192,20 @@ var Civet = (() => {
|
|
|
1942
2192
|
return Arrow$0(state);
|
|
1943
2193
|
}
|
|
1944
2194
|
}
|
|
1945
|
-
var Block$0 = $T($S(__, OpenBrace, EOS,
|
|
2195
|
+
var Block$0 = $T($S(__, OpenBrace, EOS, NestedBlockStatements, __, CloseBrace), function(value) {
|
|
1946
2196
|
var exps = value[3];
|
|
1947
2197
|
return { "type": "BlockStatement", "expressions": exps, "children": value };
|
|
1948
2198
|
});
|
|
1949
|
-
var Block$1 = $T($S(InsertOpenBrace, EOS,
|
|
2199
|
+
var Block$1 = $T($S(InsertOpenBrace, EOS, NestedBlockStatements, InsertNewline, InsertIndent, InsertCloseBrace), function(value) {
|
|
1950
2200
|
var exps = value[2];
|
|
1951
2201
|
return { "type": "BlockStatement", "expressions": exps, "children": value };
|
|
1952
2202
|
});
|
|
1953
|
-
var Block$2 = Statement
|
|
1954
|
-
|
|
2203
|
+
var Block$2 = $T($S($E(Then), Statement), function(value) {
|
|
2204
|
+
return value[1];
|
|
2205
|
+
});
|
|
2206
|
+
var Block$3 = $T($S($E(Then), __, Statement), function(value) {
|
|
2207
|
+
return [value[1], value[2]];
|
|
2208
|
+
});
|
|
1955
2209
|
function Block(state) {
|
|
1956
2210
|
if (state.tokenize) {
|
|
1957
2211
|
return $TOKEN("Block", state, Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state));
|
|
@@ -1980,11 +2234,11 @@ var Civet = (() => {
|
|
|
1980
2234
|
return EmptyBlock$0(state);
|
|
1981
2235
|
}
|
|
1982
2236
|
}
|
|
1983
|
-
var BracedBlock$0 = $T($S(
|
|
1984
|
-
var exps = value[
|
|
2237
|
+
var BracedBlock$0 = $T($S($Q(TrailingComment), OpenBrace, BracedContent, __, CloseBrace), function(value) {
|
|
2238
|
+
var exps = value[2];
|
|
1985
2239
|
return { "type": "BlockStatement", "expressions": exps, "children": value };
|
|
1986
2240
|
});
|
|
1987
|
-
var BracedBlock$1 = $T($S(InsertOpenBrace, EOS,
|
|
2241
|
+
var BracedBlock$1 = $T($S(InsertOpenBrace, EOS, NestedBlockStatements, InsertNewline, InsertIndent, InsertCloseBrace), function(value) {
|
|
1988
2242
|
var exps = value[2];
|
|
1989
2243
|
return { "type": "BlockStatement", "expressions": exps, "children": value };
|
|
1990
2244
|
});
|
|
@@ -2003,58 +2257,69 @@ var Civet = (() => {
|
|
|
2003
2257
|
return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state);
|
|
2004
2258
|
}
|
|
2005
2259
|
}
|
|
2006
|
-
var
|
|
2007
|
-
|
|
2008
|
-
if (exp)
|
|
2009
|
-
return exp;
|
|
2010
|
-
return $skip;
|
|
2260
|
+
var BracedContent$0 = $T($S($Y(EOS), NestedBlockStatements), function(value) {
|
|
2261
|
+
return value[1];
|
|
2011
2262
|
});
|
|
2012
|
-
|
|
2013
|
-
|
|
2014
|
-
console.log("ENTER:", "SingleNestedExpression");
|
|
2263
|
+
var BracedContent$1 = $S($Q(TrailingComment), Statement);
|
|
2264
|
+
function BracedContent(state) {
|
|
2015
2265
|
if (state.tokenize) {
|
|
2016
|
-
return $TOKEN("
|
|
2266
|
+
return $TOKEN("BracedContent", state, BracedContent$0(state) || BracedContent$1(state));
|
|
2017
2267
|
} else {
|
|
2018
|
-
return
|
|
2268
|
+
return BracedContent$0(state) || BracedContent$1(state);
|
|
2019
2269
|
}
|
|
2020
2270
|
}
|
|
2021
|
-
var
|
|
2022
|
-
var
|
|
2023
|
-
if (!
|
|
2271
|
+
var NestedBlockStatements$0 = $TS($S(PushIndent, $Q(NestedBlockStatement), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
2272
|
+
var statements = $2;
|
|
2273
|
+
if (!statements.length)
|
|
2024
2274
|
return $skip;
|
|
2025
|
-
return
|
|
2275
|
+
return statements;
|
|
2026
2276
|
});
|
|
2027
|
-
function
|
|
2277
|
+
function NestedBlockStatements(state) {
|
|
2028
2278
|
if (state.verbose)
|
|
2029
|
-
console.log("ENTER:", "
|
|
2279
|
+
console.log("ENTER:", "NestedBlockStatements");
|
|
2030
2280
|
if (state.tokenize) {
|
|
2031
|
-
return $TOKEN("
|
|
2281
|
+
return $TOKEN("NestedBlockStatements", state, NestedBlockStatements$0(state));
|
|
2032
2282
|
} else {
|
|
2033
|
-
return
|
|
2283
|
+
return NestedBlockStatements$0(state);
|
|
2034
2284
|
}
|
|
2035
2285
|
}
|
|
2036
|
-
var
|
|
2037
|
-
function
|
|
2286
|
+
var NestedBlockStatement$0 = $S(Nested, StatementListItem, StatementDelimiter);
|
|
2287
|
+
function NestedBlockStatement(state) {
|
|
2038
2288
|
if (state.verbose)
|
|
2039
|
-
console.log("ENTER:", "
|
|
2289
|
+
console.log("ENTER:", "NestedBlockStatement");
|
|
2040
2290
|
if (state.tokenize) {
|
|
2041
|
-
return $TOKEN("
|
|
2291
|
+
return $TOKEN("NestedBlockStatement", state, NestedBlockStatement$0(state));
|
|
2042
2292
|
} else {
|
|
2043
|
-
return
|
|
2293
|
+
return NestedBlockStatement$0(state);
|
|
2044
2294
|
}
|
|
2045
2295
|
}
|
|
2046
|
-
var Literal$0 =
|
|
2047
|
-
|
|
2048
|
-
|
|
2049
|
-
|
|
2296
|
+
var Literal$0 = $TS($S(LiteralContent), function($skip, $loc, $0, $1) {
|
|
2297
|
+
return {
|
|
2298
|
+
type: "Literal",
|
|
2299
|
+
children: $0
|
|
2300
|
+
};
|
|
2301
|
+
});
|
|
2050
2302
|
function Literal(state) {
|
|
2303
|
+
if (state.verbose)
|
|
2304
|
+
console.log("ENTER:", "Literal");
|
|
2305
|
+
if (state.tokenize) {
|
|
2306
|
+
return $TOKEN("Literal", state, Literal$0(state));
|
|
2307
|
+
} else {
|
|
2308
|
+
return Literal$0(state);
|
|
2309
|
+
}
|
|
2310
|
+
}
|
|
2311
|
+
var LiteralContent$0 = NullLiteral;
|
|
2312
|
+
var LiteralContent$1 = BooleanLiteral;
|
|
2313
|
+
var LiteralContent$2 = NumericLiteral;
|
|
2314
|
+
var LiteralContent$3 = StringLiteral;
|
|
2315
|
+
function LiteralContent(state) {
|
|
2051
2316
|
if (state.tokenize) {
|
|
2052
|
-
return $TOKEN("
|
|
2317
|
+
return $TOKEN("LiteralContent", state, LiteralContent$0(state) || LiteralContent$1(state) || LiteralContent$2(state) || LiteralContent$3(state));
|
|
2053
2318
|
} else {
|
|
2054
|
-
return
|
|
2319
|
+
return LiteralContent$0(state) || LiteralContent$1(state) || LiteralContent$2(state) || LiteralContent$3(state);
|
|
2055
2320
|
}
|
|
2056
2321
|
}
|
|
2057
|
-
var NullLiteral$0 = $TV($EXPECT($
|
|
2322
|
+
var NullLiteral$0 = $TV($EXPECT($L18, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
|
|
2058
2323
|
return { $loc, token: $1 };
|
|
2059
2324
|
});
|
|
2060
2325
|
function NullLiteral(state) {
|
|
@@ -2067,7 +2332,7 @@ var Civet = (() => {
|
|
|
2067
2332
|
}
|
|
2068
2333
|
}
|
|
2069
2334
|
var BooleanLiteral$0 = CoffeeScriptBooleanLiteral;
|
|
2070
|
-
var BooleanLiteral$1 = $TV($C($EXPECT($
|
|
2335
|
+
var BooleanLiteral$1 = $TV($C($EXPECT($L19, fail, 'BooleanLiteral "true"'), $EXPECT($L20, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
|
|
2071
2336
|
return { $loc, token: $1 };
|
|
2072
2337
|
});
|
|
2073
2338
|
function BooleanLiteral(state) {
|
|
@@ -2077,10 +2342,10 @@ var Civet = (() => {
|
|
|
2077
2342
|
return BooleanLiteral$0(state) || BooleanLiteral$1(state);
|
|
2078
2343
|
}
|
|
2079
2344
|
}
|
|
2080
|
-
var CoffeeScriptBooleanLiteral$0 = $TV($C($EXPECT($
|
|
2345
|
+
var CoffeeScriptBooleanLiteral$0 = $TV($C($EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "on"')), function($skip, $loc, $0, $1) {
|
|
2081
2346
|
return { $loc, token: "true" };
|
|
2082
2347
|
});
|
|
2083
|
-
var CoffeeScriptBooleanLiteral$1 = $TV($C($EXPECT($
|
|
2348
|
+
var CoffeeScriptBooleanLiteral$1 = $TV($C($EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L24, fail, 'CoffeeScriptBooleanLiteral "off"')), function($skip, $loc, $0, $1) {
|
|
2084
2349
|
return { $loc, token: "false" };
|
|
2085
2350
|
});
|
|
2086
2351
|
function CoffeeScriptBooleanLiteral(state) {
|
|
@@ -2090,7 +2355,7 @@ var Civet = (() => {
|
|
|
2090
2355
|
return CoffeeScriptBooleanLiteral$0(state) || CoffeeScriptBooleanLiteral$1(state);
|
|
2091
2356
|
}
|
|
2092
2357
|
}
|
|
2093
|
-
var Comma$0 = $TV($EXPECT($
|
|
2358
|
+
var Comma$0 = $TV($EXPECT($L25, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
|
|
2094
2359
|
return { $loc, token: $1 };
|
|
2095
2360
|
});
|
|
2096
2361
|
function Comma(state) {
|
|
@@ -2117,8 +2382,12 @@ var Civet = (() => {
|
|
|
2117
2382
|
var IdentifierName$0 = $TR($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
2118
2383
|
return {
|
|
2119
2384
|
type: "Identifier",
|
|
2120
|
-
$
|
|
2121
|
-
|
|
2385
|
+
name: $0,
|
|
2386
|
+
names: [$0],
|
|
2387
|
+
children: [{
|
|
2388
|
+
$loc,
|
|
2389
|
+
token: $0
|
|
2390
|
+
}]
|
|
2122
2391
|
};
|
|
2123
2392
|
});
|
|
2124
2393
|
function IdentifierName(state) {
|
|
@@ -2140,19 +2409,44 @@ var Civet = (() => {
|
|
|
2140
2409
|
return IdentifierReference$0(state);
|
|
2141
2410
|
}
|
|
2142
2411
|
}
|
|
2143
|
-
var ArrayLiteral$0 = $S(OpenBracket,
|
|
2144
|
-
|
|
2412
|
+
var ArrayLiteral$0 = $TS($S(OpenBracket, ArrayLiteralContent, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2413
|
+
let children;
|
|
2414
|
+
if (Array.isArray($2)) {
|
|
2415
|
+
children = [$1, ...$2, ...$3, $4];
|
|
2416
|
+
} else {
|
|
2417
|
+
children = [$1, $2, ...$3, $4];
|
|
2418
|
+
}
|
|
2419
|
+
const names = children.flatMap((c) => {
|
|
2420
|
+
return c.names || [];
|
|
2421
|
+
});
|
|
2422
|
+
return {
|
|
2423
|
+
type: "ArrayExpression",
|
|
2424
|
+
children,
|
|
2425
|
+
names
|
|
2426
|
+
};
|
|
2427
|
+
});
|
|
2145
2428
|
function ArrayLiteral(state) {
|
|
2429
|
+
if (state.verbose)
|
|
2430
|
+
console.log("ENTER:", "ArrayLiteral");
|
|
2146
2431
|
if (state.tokenize) {
|
|
2147
|
-
return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state)
|
|
2432
|
+
return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state));
|
|
2148
2433
|
} else {
|
|
2149
|
-
return ArrayLiteral$0(state)
|
|
2434
|
+
return ArrayLiteral$0(state);
|
|
2435
|
+
}
|
|
2436
|
+
}
|
|
2437
|
+
var ArrayLiteralContent$0 = NestedElementList;
|
|
2438
|
+
var ArrayLiteralContent$1 = ElementList;
|
|
2439
|
+
function ArrayLiteralContent(state) {
|
|
2440
|
+
if (state.tokenize) {
|
|
2441
|
+
return $TOKEN("ArrayLiteralContent", state, ArrayLiteralContent$0(state) || ArrayLiteralContent$1(state));
|
|
2442
|
+
} else {
|
|
2443
|
+
return ArrayLiteralContent$0(state) || ArrayLiteralContent$1(state);
|
|
2150
2444
|
}
|
|
2151
2445
|
}
|
|
2152
2446
|
var NestedElementList$0 = $TS($S(PushIndent, $Q(NestedElement), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
2153
2447
|
var elements = $2;
|
|
2154
2448
|
if (elements.length)
|
|
2155
|
-
return elements;
|
|
2449
|
+
return elements.flat();
|
|
2156
2450
|
return $skip;
|
|
2157
2451
|
});
|
|
2158
2452
|
function NestedElementList(state) {
|
|
@@ -2164,7 +2458,13 @@ var Civet = (() => {
|
|
|
2164
2458
|
return NestedElementList$0(state);
|
|
2165
2459
|
}
|
|
2166
2460
|
}
|
|
2167
|
-
var NestedElement$0 = $S(Nested,
|
|
2461
|
+
var NestedElement$0 = $TS($S(Nested, ElementList, ArrayElementDelimiter), function($skip, $loc, $0, $1, $2, $3) {
|
|
2462
|
+
const result = [...$1, ...$2];
|
|
2463
|
+
if ($3) {
|
|
2464
|
+
result.push($3);
|
|
2465
|
+
}
|
|
2466
|
+
return result;
|
|
2467
|
+
});
|
|
2168
2468
|
function NestedElement(state) {
|
|
2169
2469
|
if (state.verbose)
|
|
2170
2470
|
console.log("ENTER:", "NestedElement");
|
|
@@ -2175,7 +2475,7 @@ var Civet = (() => {
|
|
|
2175
2475
|
}
|
|
2176
2476
|
}
|
|
2177
2477
|
var ArrayElementDelimiter$0 = $S($Q(_), Comma);
|
|
2178
|
-
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2478
|
+
var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
|
|
2179
2479
|
var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2180
2480
|
return { $loc, token: "," };
|
|
2181
2481
|
});
|
|
@@ -2186,7 +2486,15 @@ var Civet = (() => {
|
|
|
2186
2486
|
return ArrayElementDelimiter$0(state) || ArrayElementDelimiter$1(state) || ArrayElementDelimiter$2(state);
|
|
2187
2487
|
}
|
|
2188
2488
|
}
|
|
2189
|
-
var ElementList$0 = $S(ArrayElementExpression, $Q($
|
|
2489
|
+
var ElementList$0 = $TS($S(ArrayElementExpression, $Q(ElementListRest)), function($skip, $loc, $0, $1, $2) {
|
|
2490
|
+
if ($2.length) {
|
|
2491
|
+
return [].concat($1 || [], ...$2);
|
|
2492
|
+
}
|
|
2493
|
+
if ($1) {
|
|
2494
|
+
return [].concat($1);
|
|
2495
|
+
}
|
|
2496
|
+
return [];
|
|
2497
|
+
});
|
|
2190
2498
|
function ElementList(state) {
|
|
2191
2499
|
if (state.verbose)
|
|
2192
2500
|
console.log("ENTER:", "ElementList");
|
|
@@ -2196,17 +2504,28 @@ var Civet = (() => {
|
|
|
2196
2504
|
return ElementList$0(state);
|
|
2197
2505
|
}
|
|
2198
2506
|
}
|
|
2199
|
-
var
|
|
2200
|
-
|
|
2507
|
+
var ElementListRest$0 = $TS($S(__, Comma, __, ArrayElementExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2508
|
+
const result = [...$1, $2, ...$3];
|
|
2509
|
+
if ($4) {
|
|
2510
|
+
result.push($4);
|
|
2511
|
+
}
|
|
2512
|
+
return result;
|
|
2513
|
+
});
|
|
2514
|
+
function ElementListRest(state) {
|
|
2201
2515
|
if (state.verbose)
|
|
2202
|
-
console.log("ENTER:", "
|
|
2516
|
+
console.log("ENTER:", "ElementListRest");
|
|
2203
2517
|
if (state.tokenize) {
|
|
2204
|
-
return $TOKEN("
|
|
2518
|
+
return $TOKEN("ElementListRest", state, ElementListRest$0(state));
|
|
2205
2519
|
} else {
|
|
2206
|
-
return
|
|
2520
|
+
return ElementListRest$0(state);
|
|
2207
2521
|
}
|
|
2208
2522
|
}
|
|
2209
|
-
var ArrayElementExpression$0 = $E($S($E($S(DotDotDot, __)),
|
|
2523
|
+
var ArrayElementExpression$0 = $TV($E($S($E($S(DotDotDot, __)), ExtendedExpression)), function($skip, $loc, $0, $1) {
|
|
2524
|
+
if ($1 && !$1[0]) {
|
|
2525
|
+
return $1[1];
|
|
2526
|
+
}
|
|
2527
|
+
return $1;
|
|
2528
|
+
});
|
|
2210
2529
|
function ArrayElementExpression(state) {
|
|
2211
2530
|
if (state.verbose)
|
|
2212
2531
|
console.log("ENTER:", "ArrayElementExpression");
|
|
@@ -2216,28 +2535,69 @@ var Civet = (() => {
|
|
|
2216
2535
|
return ArrayElementExpression$0(state);
|
|
2217
2536
|
}
|
|
2218
2537
|
}
|
|
2219
|
-
var
|
|
2220
|
-
|
|
2538
|
+
var ObjectLiteral$0 = BracedObjectLiteral;
|
|
2539
|
+
var ObjectLiteral$1 = NestedObjectLiteral;
|
|
2540
|
+
function ObjectLiteral(state) {
|
|
2541
|
+
if (state.tokenize) {
|
|
2542
|
+
return $TOKEN("ObjectLiteral", state, ObjectLiteral$0(state) || ObjectLiteral$1(state));
|
|
2543
|
+
} else {
|
|
2544
|
+
return ObjectLiteral$0(state) || ObjectLiteral$1(state);
|
|
2545
|
+
}
|
|
2546
|
+
}
|
|
2547
|
+
var BracedObjectLiteral$0 = $TS($S(OpenBrace, $E(BracedObjectLiteralContent), __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2548
|
+
if ($2) {
|
|
2549
|
+
$2.unshift($1);
|
|
2550
|
+
if ($3.length) {
|
|
2551
|
+
$2.push(...$3);
|
|
2552
|
+
}
|
|
2553
|
+
$2.push($4);
|
|
2554
|
+
return {
|
|
2555
|
+
type: "ObjectExpression",
|
|
2556
|
+
children: $2,
|
|
2557
|
+
names: $2.flatMap((c) => {
|
|
2558
|
+
return c.names || [];
|
|
2559
|
+
})
|
|
2560
|
+
};
|
|
2561
|
+
}
|
|
2562
|
+
return {
|
|
2563
|
+
type: "ObjectExpression",
|
|
2564
|
+
children: [$1, ...$3, $4],
|
|
2565
|
+
names: []
|
|
2566
|
+
};
|
|
2567
|
+
});
|
|
2568
|
+
function BracedObjectLiteral(state) {
|
|
2221
2569
|
if (state.verbose)
|
|
2222
|
-
console.log("ENTER:", "
|
|
2570
|
+
console.log("ENTER:", "BracedObjectLiteral");
|
|
2223
2571
|
if (state.tokenize) {
|
|
2224
|
-
return $TOKEN("
|
|
2572
|
+
return $TOKEN("BracedObjectLiteral", state, BracedObjectLiteral$0(state));
|
|
2225
2573
|
} else {
|
|
2226
|
-
return
|
|
2574
|
+
return BracedObjectLiteral$0(state);
|
|
2227
2575
|
}
|
|
2228
2576
|
}
|
|
2229
|
-
var
|
|
2230
|
-
|
|
2231
|
-
|
|
2232
|
-
var
|
|
2233
|
-
|
|
2577
|
+
var BracedObjectLiteralContent$0 = $T($S($Y(EOS), NestedPropertyDefinitions), function(value) {
|
|
2578
|
+
return value[1];
|
|
2579
|
+
});
|
|
2580
|
+
var BracedObjectLiteralContent$1 = $TS($S(__, PropertyDefinitionList, $E($S(__, Comma))), function($skip, $loc, $0, $1, $2, $3) {
|
|
2581
|
+
if ($1.length) {
|
|
2582
|
+
$2.splice(0, 0, ...$1);
|
|
2583
|
+
}
|
|
2584
|
+
if ($3) {
|
|
2585
|
+
$2.push($3);
|
|
2586
|
+
}
|
|
2587
|
+
return $2;
|
|
2588
|
+
});
|
|
2589
|
+
function BracedObjectLiteralContent(state) {
|
|
2234
2590
|
if (state.tokenize) {
|
|
2235
|
-
return $TOKEN("
|
|
2591
|
+
return $TOKEN("BracedObjectLiteralContent", state, BracedObjectLiteralContent$0(state) || BracedObjectLiteralContent$1(state));
|
|
2236
2592
|
} else {
|
|
2237
|
-
return
|
|
2593
|
+
return BracedObjectLiteralContent$0(state) || BracedObjectLiteralContent$1(state);
|
|
2238
2594
|
}
|
|
2239
2595
|
}
|
|
2240
|
-
var NestedObjectLiteral$0 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace)
|
|
2596
|
+
var NestedObjectLiteral$0 = $TS($S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
2597
|
+
$3.unshift($1);
|
|
2598
|
+
$3.push($4, $5, $6);
|
|
2599
|
+
return $3;
|
|
2600
|
+
});
|
|
2241
2601
|
function NestedObjectLiteral(state) {
|
|
2242
2602
|
if (state.verbose)
|
|
2243
2603
|
console.log("ENTER:", "NestedObjectLiteral");
|
|
@@ -2251,7 +2611,7 @@ var Civet = (() => {
|
|
|
2251
2611
|
var defs = $2;
|
|
2252
2612
|
if (!defs.length)
|
|
2253
2613
|
return $skip;
|
|
2254
|
-
return defs;
|
|
2614
|
+
return defs.flat();
|
|
2255
2615
|
});
|
|
2256
2616
|
function NestedPropertyDefinitions(state) {
|
|
2257
2617
|
if (state.verbose)
|
|
@@ -2262,7 +2622,13 @@ var Civet = (() => {
|
|
|
2262
2622
|
return NestedPropertyDefinitions$0(state);
|
|
2263
2623
|
}
|
|
2264
2624
|
}
|
|
2265
|
-
var NestedPropertyDefinition$0 = $S(Nested, PropertyDefinition, ObjectPropertyDelimiter)
|
|
2625
|
+
var NestedPropertyDefinition$0 = $TS($S(Nested, PropertyDefinition, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
|
|
2626
|
+
const result = [...$1, $2];
|
|
2627
|
+
if ($3) {
|
|
2628
|
+
result.push($3);
|
|
2629
|
+
}
|
|
2630
|
+
return result;
|
|
2631
|
+
});
|
|
2266
2632
|
function NestedPropertyDefinition(state) {
|
|
2267
2633
|
if (state.verbose)
|
|
2268
2634
|
console.log("ENTER:", "NestedPropertyDefinition");
|
|
@@ -2273,7 +2639,7 @@ var Civet = (() => {
|
|
|
2273
2639
|
}
|
|
2274
2640
|
}
|
|
2275
2641
|
var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
|
|
2276
|
-
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($
|
|
2642
|
+
var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L27, fail, 'ObjectPropertyDelimiter "}"')));
|
|
2277
2643
|
var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
2278
2644
|
return { $loc, token: "," };
|
|
2279
2645
|
});
|
|
@@ -2284,7 +2650,15 @@ var Civet = (() => {
|
|
|
2284
2650
|
return ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state);
|
|
2285
2651
|
}
|
|
2286
2652
|
}
|
|
2287
|
-
var PropertyDefinitionList$0 = $S(PropertyDefinition, $Q($S(__, Comma, __, PropertyDefinition)))
|
|
2653
|
+
var PropertyDefinitionList$0 = $TS($S(PropertyDefinition, $Q($S(__, Comma, __, PropertyDefinition))), function($skip, $loc, $0, $1, $2) {
|
|
2654
|
+
if ($2.length) {
|
|
2655
|
+
return [].concat($1 || [], ...$2);
|
|
2656
|
+
}
|
|
2657
|
+
if ($1) {
|
|
2658
|
+
return [].concat($1);
|
|
2659
|
+
}
|
|
2660
|
+
return [];
|
|
2661
|
+
});
|
|
2288
2662
|
function PropertyDefinitionList(state) {
|
|
2289
2663
|
if (state.verbose)
|
|
2290
2664
|
console.log("ENTER:", "PropertyDefinitionList");
|
|
@@ -2294,9 +2668,16 @@ var Civet = (() => {
|
|
|
2294
2668
|
return PropertyDefinitionList$0(state);
|
|
2295
2669
|
}
|
|
2296
2670
|
}
|
|
2297
|
-
var PropertyDefinition$0 = $S(PropertyName, __, Colon,
|
|
2671
|
+
var PropertyDefinition$0 = $TS($S(PropertyName, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
2672
|
+
var exp = $4;
|
|
2673
|
+
return {
|
|
2674
|
+
type: "Property",
|
|
2675
|
+
children: $0,
|
|
2676
|
+
names: exp.names || []
|
|
2677
|
+
};
|
|
2678
|
+
});
|
|
2298
2679
|
var PropertyDefinition$1 = MethodDefinition;
|
|
2299
|
-
var PropertyDefinition$2 = $S(DotDotDot,
|
|
2680
|
+
var PropertyDefinition$2 = $S(DotDotDot, ExtendedExpression);
|
|
2300
2681
|
var PropertyDefinition$3 = IdentifierReference;
|
|
2301
2682
|
function PropertyDefinition(state) {
|
|
2302
2683
|
if (state.tokenize) {
|
|
@@ -2308,7 +2689,7 @@ var Civet = (() => {
|
|
|
2308
2689
|
var PropertyName$0 = NumericLiteral;
|
|
2309
2690
|
var PropertyName$1 = StringLiteral;
|
|
2310
2691
|
var PropertyName$2 = IdentifierName;
|
|
2311
|
-
var PropertyName$3 = $S(OpenBracket,
|
|
2692
|
+
var PropertyName$3 = $S(OpenBracket, ExtendedExpression, __, CloseBracket);
|
|
2312
2693
|
function PropertyName(state) {
|
|
2313
2694
|
if (state.tokenize) {
|
|
2314
2695
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -2358,7 +2739,11 @@ var Civet = (() => {
|
|
|
2358
2739
|
var MethodSignature$1 = $TS($S($E(MethodModifier), ClassElementName, $Q(_), NonEmptyParameters, $E(ReturnTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
2359
2740
|
var name = $2;
|
|
2360
2741
|
var suffix = $5;
|
|
2361
|
-
|
|
2742
|
+
if (name.name) {
|
|
2743
|
+
name = name.name;
|
|
2744
|
+
} else if (name.token) {
|
|
2745
|
+
name = name.token.match(/^(?:"|')/) ? name.token.slice(1, -1) : name.token;
|
|
2746
|
+
}
|
|
2362
2747
|
return {
|
|
2363
2748
|
type: "MethodSignature",
|
|
2364
2749
|
children: $0,
|
|
@@ -2410,25 +2795,25 @@ var Civet = (() => {
|
|
|
2410
2795
|
return AssignmentOp$0(state);
|
|
2411
2796
|
}
|
|
2412
2797
|
}
|
|
2413
|
-
var AssignmentOpSymbol$0 = $EXPECT($
|
|
2414
|
-
var AssignmentOpSymbol$1 = $EXPECT($
|
|
2415
|
-
var AssignmentOpSymbol$2 = $EXPECT($
|
|
2416
|
-
var AssignmentOpSymbol$3 = $EXPECT($
|
|
2417
|
-
var AssignmentOpSymbol$4 = $EXPECT($
|
|
2418
|
-
var AssignmentOpSymbol$5 = $EXPECT($
|
|
2419
|
-
var AssignmentOpSymbol$6 = $EXPECT($
|
|
2420
|
-
var AssignmentOpSymbol$7 = $EXPECT($
|
|
2421
|
-
var AssignmentOpSymbol$8 = $EXPECT($
|
|
2422
|
-
var AssignmentOpSymbol$9 = $EXPECT($
|
|
2423
|
-
var AssignmentOpSymbol$10 = $EXPECT($
|
|
2424
|
-
var AssignmentOpSymbol$11 = $EXPECT($
|
|
2425
|
-
var AssignmentOpSymbol$12 = $EXPECT($
|
|
2426
|
-
var AssignmentOpSymbol$13 = $EXPECT($
|
|
2427
|
-
var AssignmentOpSymbol$14 = $EXPECT($
|
|
2428
|
-
var AssignmentOpSymbol$15 = $T($EXPECT($
|
|
2798
|
+
var AssignmentOpSymbol$0 = $EXPECT($L28, fail, 'AssignmentOpSymbol "**="');
|
|
2799
|
+
var AssignmentOpSymbol$1 = $EXPECT($L29, fail, 'AssignmentOpSymbol "*="');
|
|
2800
|
+
var AssignmentOpSymbol$2 = $EXPECT($L30, fail, 'AssignmentOpSymbol "/="');
|
|
2801
|
+
var AssignmentOpSymbol$3 = $EXPECT($L31, fail, 'AssignmentOpSymbol "%="');
|
|
2802
|
+
var AssignmentOpSymbol$4 = $EXPECT($L32, fail, 'AssignmentOpSymbol "+="');
|
|
2803
|
+
var AssignmentOpSymbol$5 = $EXPECT($L33, fail, 'AssignmentOpSymbol "-="');
|
|
2804
|
+
var AssignmentOpSymbol$6 = $EXPECT($L34, fail, 'AssignmentOpSymbol "<<="');
|
|
2805
|
+
var AssignmentOpSymbol$7 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>>="');
|
|
2806
|
+
var AssignmentOpSymbol$8 = $EXPECT($L36, fail, 'AssignmentOpSymbol ">>="');
|
|
2807
|
+
var AssignmentOpSymbol$9 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&&="');
|
|
2808
|
+
var AssignmentOpSymbol$10 = $EXPECT($L38, fail, 'AssignmentOpSymbol "&="');
|
|
2809
|
+
var AssignmentOpSymbol$11 = $EXPECT($L39, fail, 'AssignmentOpSymbol "^="');
|
|
2810
|
+
var AssignmentOpSymbol$12 = $EXPECT($L40, fail, 'AssignmentOpSymbol "||="');
|
|
2811
|
+
var AssignmentOpSymbol$13 = $EXPECT($L41, fail, 'AssignmentOpSymbol "|="');
|
|
2812
|
+
var AssignmentOpSymbol$14 = $EXPECT($L42, fail, 'AssignmentOpSymbol "??="');
|
|
2813
|
+
var AssignmentOpSymbol$15 = $T($EXPECT($L43, fail, 'AssignmentOpSymbol "?="'), function(value) {
|
|
2429
2814
|
return "??=";
|
|
2430
2815
|
});
|
|
2431
|
-
var AssignmentOpSymbol$16 = $EXPECT($
|
|
2816
|
+
var AssignmentOpSymbol$16 = $EXPECT($L44, fail, 'AssignmentOpSymbol "="');
|
|
2432
2817
|
function AssignmentOpSymbol(state) {
|
|
2433
2818
|
if (state.tokenize) {
|
|
2434
2819
|
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));
|
|
@@ -2448,68 +2833,74 @@ var Civet = (() => {
|
|
|
2448
2833
|
return BinaryOp$0(state);
|
|
2449
2834
|
}
|
|
2450
2835
|
}
|
|
2451
|
-
var BinaryOpSymbol$0 = $EXPECT($
|
|
2452
|
-
var BinaryOpSymbol$1 = $EXPECT($
|
|
2453
|
-
var BinaryOpSymbol$2 = $EXPECT($
|
|
2454
|
-
var BinaryOpSymbol$3 = $EXPECT($
|
|
2455
|
-
var BinaryOpSymbol$4 = $EXPECT($
|
|
2456
|
-
var BinaryOpSymbol$5 = $EXPECT($
|
|
2457
|
-
var BinaryOpSymbol$6 = $EXPECT($
|
|
2458
|
-
var BinaryOpSymbol$7 = $EXPECT($
|
|
2459
|
-
var BinaryOpSymbol$8 = $EXPECT($
|
|
2836
|
+
var BinaryOpSymbol$0 = $EXPECT($L45, fail, 'BinaryOpSymbol "**"');
|
|
2837
|
+
var BinaryOpSymbol$1 = $EXPECT($L46, fail, 'BinaryOpSymbol "*"');
|
|
2838
|
+
var BinaryOpSymbol$2 = $EXPECT($L47, fail, 'BinaryOpSymbol "/"');
|
|
2839
|
+
var BinaryOpSymbol$3 = $EXPECT($L48, fail, 'BinaryOpSymbol "%"');
|
|
2840
|
+
var BinaryOpSymbol$4 = $EXPECT($L49, fail, 'BinaryOpSymbol "+"');
|
|
2841
|
+
var BinaryOpSymbol$5 = $EXPECT($L50, fail, 'BinaryOpSymbol "-"');
|
|
2842
|
+
var BinaryOpSymbol$6 = $EXPECT($L51, fail, 'BinaryOpSymbol "<="');
|
|
2843
|
+
var BinaryOpSymbol$7 = $EXPECT($L52, fail, 'BinaryOpSymbol ">="');
|
|
2844
|
+
var BinaryOpSymbol$8 = $EXPECT($L53, fail, 'BinaryOpSymbol "<<"');
|
|
2460
2845
|
var BinaryOpSymbol$9 = $EXPECT($L4, fail, 'BinaryOpSymbol "<"');
|
|
2461
|
-
var BinaryOpSymbol$10 = $EXPECT($
|
|
2462
|
-
var BinaryOpSymbol$11 = $EXPECT($
|
|
2463
|
-
var BinaryOpSymbol$12 = $EXPECT($
|
|
2464
|
-
var BinaryOpSymbol$13 = $EXPECT($
|
|
2465
|
-
var BinaryOpSymbol$14 = $TV($EXPECT($
|
|
2846
|
+
var BinaryOpSymbol$10 = $EXPECT($L54, fail, 'BinaryOpSymbol ">>>"');
|
|
2847
|
+
var BinaryOpSymbol$11 = $EXPECT($L55, fail, 'BinaryOpSymbol ">>"');
|
|
2848
|
+
var BinaryOpSymbol$12 = $EXPECT($L56, fail, 'BinaryOpSymbol ">"');
|
|
2849
|
+
var BinaryOpSymbol$13 = $EXPECT($L57, fail, 'BinaryOpSymbol "!=="');
|
|
2850
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L58, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
2466
2851
|
if (module.config.coffeeEq)
|
|
2467
2852
|
return "!==";
|
|
2468
2853
|
return $1;
|
|
2469
2854
|
});
|
|
2470
|
-
var BinaryOpSymbol$15 = $
|
|
2855
|
+
var BinaryOpSymbol$15 = $TS($S($EXPECT($L59, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2856
|
+
if (module.config.coffeeIsnt)
|
|
2857
|
+
return "!==";
|
|
2858
|
+
return $skip;
|
|
2859
|
+
});
|
|
2860
|
+
var BinaryOpSymbol$16 = $T($S($EXPECT($L60, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
2471
2861
|
return "===";
|
|
2472
2862
|
});
|
|
2473
|
-
var BinaryOpSymbol$
|
|
2474
|
-
var BinaryOpSymbol$
|
|
2863
|
+
var BinaryOpSymbol$17 = $EXPECT($L61, fail, 'BinaryOpSymbol "==="');
|
|
2864
|
+
var BinaryOpSymbol$18 = $TV($EXPECT($L62, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
2475
2865
|
if (module.config.coffeeEq)
|
|
2476
2866
|
return "===";
|
|
2477
2867
|
return $1;
|
|
2478
2868
|
});
|
|
2479
|
-
var BinaryOpSymbol$
|
|
2869
|
+
var BinaryOpSymbol$19 = $T($S($EXPECT($L63, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
2480
2870
|
return "&&";
|
|
2481
2871
|
});
|
|
2482
|
-
var BinaryOpSymbol$
|
|
2483
|
-
var BinaryOpSymbol$
|
|
2872
|
+
var BinaryOpSymbol$20 = $EXPECT($L64, fail, 'BinaryOpSymbol "&&"');
|
|
2873
|
+
var BinaryOpSymbol$21 = $T($S($EXPECT($L65, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
2484
2874
|
return "||";
|
|
2485
2875
|
});
|
|
2486
|
-
var BinaryOpSymbol$
|
|
2487
|
-
var BinaryOpSymbol$
|
|
2488
|
-
var BinaryOpSymbol$
|
|
2876
|
+
var BinaryOpSymbol$22 = $EXPECT($L66, fail, 'BinaryOpSymbol "||"');
|
|
2877
|
+
var BinaryOpSymbol$23 = $EXPECT($L67, fail, 'BinaryOpSymbol "??"');
|
|
2878
|
+
var BinaryOpSymbol$24 = $TS($S($EXPECT($L68, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2489
2879
|
return $1;
|
|
2490
2880
|
});
|
|
2491
|
-
var BinaryOpSymbol$
|
|
2881
|
+
var BinaryOpSymbol$25 = $TS($S($EXPECT($L69, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
2492
2882
|
return $1;
|
|
2493
2883
|
});
|
|
2494
|
-
var BinaryOpSymbol$
|
|
2495
|
-
var BinaryOpSymbol$
|
|
2496
|
-
var BinaryOpSymbol$
|
|
2884
|
+
var BinaryOpSymbol$26 = $EXPECT($L70, fail, 'BinaryOpSymbol "&"');
|
|
2885
|
+
var BinaryOpSymbol$27 = $EXPECT($L71, fail, 'BinaryOpSymbol "^"');
|
|
2886
|
+
var BinaryOpSymbol$28 = $EXPECT($L72, fail, 'BinaryOpSymbol "|"');
|
|
2497
2887
|
function BinaryOpSymbol(state) {
|
|
2498
2888
|
if (state.tokenize) {
|
|
2499
|
-
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));
|
|
2889
|
+
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) || BinaryOpSymbol$28(state));
|
|
2500
2890
|
} else {
|
|
2501
|
-
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);
|
|
2891
|
+
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) || BinaryOpSymbol$28(state);
|
|
2502
2892
|
}
|
|
2503
2893
|
}
|
|
2504
|
-
var UnaryOp$0 = $TR($EXPECT($R2, fail, "UnaryOp /[!~+-]/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
2894
|
+
var UnaryOp$0 = $TR($EXPECT($R2, fail, "UnaryOp /[!~+-](?!\\s)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
2505
2895
|
return { $loc, token: $0 };
|
|
2506
2896
|
});
|
|
2507
|
-
var UnaryOp$1 = $S($C(Delete, Void, Typeof), __);
|
|
2897
|
+
var UnaryOp$1 = $S($C(Await, Delete, Void, Typeof), __);
|
|
2898
|
+
var UnaryOp$2 = Not;
|
|
2508
2899
|
function UnaryOp(state) {
|
|
2509
2900
|
if (state.tokenize) {
|
|
2510
|
-
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
2901
|
+
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state));
|
|
2511
2902
|
} else {
|
|
2512
|
-
return UnaryOp$0(state) || UnaryOp$1(state);
|
|
2903
|
+
return UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state);
|
|
2513
2904
|
}
|
|
2514
2905
|
}
|
|
2515
2906
|
var ModuleItem$0 = ImportDeclaration;
|
|
@@ -2570,7 +2961,7 @@ var Civet = (() => {
|
|
|
2570
2961
|
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);
|
|
2571
2962
|
}
|
|
2572
2963
|
}
|
|
2573
|
-
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($
|
|
2964
|
+
var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L73, fail, 'EmptyStatement ";"'))), function(value) {
|
|
2574
2965
|
return { "type": "EmptyStatement", "children": value[0] };
|
|
2575
2966
|
});
|
|
2576
2967
|
function EmptyStatement(state) {
|
|
@@ -2582,7 +2973,7 @@ var Civet = (() => {
|
|
|
2582
2973
|
return EmptyStatement$0(state);
|
|
2583
2974
|
}
|
|
2584
2975
|
}
|
|
2585
|
-
var BlockStatement$0 = $T($S(__, OpenBrace, EOS,
|
|
2976
|
+
var BlockStatement$0 = $T($S(__, OpenBrace, EOS, NestedBlockStatements, __, CloseBrace, $N($S(__, $EXPECT($L44, fail, 'BlockStatement "="')))), function(value) {
|
|
2586
2977
|
var exps = value[3];
|
|
2587
2978
|
return { "type": "BlockStatement", "children": value, "expressions": exps };
|
|
2588
2979
|
});
|
|
@@ -2595,7 +2986,7 @@ var Civet = (() => {
|
|
|
2595
2986
|
return BlockStatement$0(state);
|
|
2596
2987
|
}
|
|
2597
2988
|
}
|
|
2598
|
-
var IfStatement$0 = $TS($S(IfClause, Block, $E($S(__, Else, Block))), function($skip, $loc, $0, $1, $2, $3) {
|
|
2989
|
+
var IfStatement$0 = $TS($S($C(IfClause, UnlessClause), Block, $E($S(__, Else, Block))), function($skip, $loc, $0, $1, $2, $3) {
|
|
2599
2990
|
var clause = $1;
|
|
2600
2991
|
var block = $2;
|
|
2601
2992
|
var e = $3;
|
|
@@ -2604,17 +2995,13 @@ var Civet = (() => {
|
|
|
2604
2995
|
clause.children.push(e);
|
|
2605
2996
|
return clause;
|
|
2606
2997
|
});
|
|
2607
|
-
var IfStatement$1 = $TS($S(UnlessClause, Block), function($skip, $loc, $0, $1, $2) {
|
|
2608
|
-
var clause = $1;
|
|
2609
|
-
var block = $2;
|
|
2610
|
-
clause.children.push(block);
|
|
2611
|
-
return clause;
|
|
2612
|
-
});
|
|
2613
2998
|
function IfStatement(state) {
|
|
2999
|
+
if (state.verbose)
|
|
3000
|
+
console.log("ENTER:", "IfStatement");
|
|
2614
3001
|
if (state.tokenize) {
|
|
2615
|
-
return $TOKEN("IfStatement", state, IfStatement$0(state)
|
|
3002
|
+
return $TOKEN("IfStatement", state, IfStatement$0(state));
|
|
2616
3003
|
} else {
|
|
2617
|
-
return IfStatement$0(state)
|
|
3004
|
+
return IfStatement$0(state);
|
|
2618
3005
|
}
|
|
2619
3006
|
}
|
|
2620
3007
|
var IfClause$0 = $T($S(If, Condition), function(value) {
|
|
@@ -2655,6 +3042,72 @@ var Civet = (() => {
|
|
|
2655
3042
|
return UnlessClause$0(state);
|
|
2656
3043
|
}
|
|
2657
3044
|
}
|
|
3045
|
+
var IfExpression$0 = $TS($S(IfClause, ExpressionBlock, $E($S(__, Else, ExpressionBlock))), function($skip, $loc, $0, $1, $2, $3) {
|
|
3046
|
+
var clause = $1;
|
|
3047
|
+
var b = $2;
|
|
3048
|
+
var e = $3;
|
|
3049
|
+
clause.children.shift();
|
|
3050
|
+
clause.children.push("?", b, ":");
|
|
3051
|
+
if (e) {
|
|
3052
|
+
e.splice(1, 1);
|
|
3053
|
+
clause.children.push(e);
|
|
3054
|
+
} else {
|
|
3055
|
+
clause.children.push("void 0");
|
|
3056
|
+
}
|
|
3057
|
+
clause.type = "IfExpression";
|
|
3058
|
+
return clause;
|
|
3059
|
+
});
|
|
3060
|
+
function IfExpression(state) {
|
|
3061
|
+
if (state.verbose)
|
|
3062
|
+
console.log("ENTER:", "IfExpression");
|
|
3063
|
+
if (state.tokenize) {
|
|
3064
|
+
return $TOKEN("IfExpression", state, IfExpression$0(state));
|
|
3065
|
+
} else {
|
|
3066
|
+
return IfExpression$0(state);
|
|
3067
|
+
}
|
|
3068
|
+
}
|
|
3069
|
+
var ExpressionBlock$0 = $TS($S(InsertOpenParen, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
3070
|
+
var exps = $3;
|
|
3071
|
+
exps[exps.length - 1].pop();
|
|
3072
|
+
return {
|
|
3073
|
+
type: "BlockExpressions",
|
|
3074
|
+
expressions: exps,
|
|
3075
|
+
children: $0
|
|
3076
|
+
};
|
|
3077
|
+
});
|
|
3078
|
+
var ExpressionBlock$1 = $S($E(Then), ExtendedExpression);
|
|
3079
|
+
function ExpressionBlock(state) {
|
|
3080
|
+
if (state.tokenize) {
|
|
3081
|
+
return $TOKEN("ExpressionBlock", state, ExpressionBlock$0(state) || ExpressionBlock$1(state));
|
|
3082
|
+
} else {
|
|
3083
|
+
return ExpressionBlock$0(state) || ExpressionBlock$1(state);
|
|
3084
|
+
}
|
|
3085
|
+
}
|
|
3086
|
+
var NestedBlockExpressions$0 = $TS($S(PushIndent, $Q(NestedBlockExpression), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
|
|
3087
|
+
var exps = $2;
|
|
3088
|
+
if (!exps.length)
|
|
3089
|
+
return $skip;
|
|
3090
|
+
return exps;
|
|
3091
|
+
});
|
|
3092
|
+
function NestedBlockExpressions(state) {
|
|
3093
|
+
if (state.verbose)
|
|
3094
|
+
console.log("ENTER:", "NestedBlockExpressions");
|
|
3095
|
+
if (state.tokenize) {
|
|
3096
|
+
return $TOKEN("NestedBlockExpressions", state, NestedBlockExpressions$0(state));
|
|
3097
|
+
} else {
|
|
3098
|
+
return NestedBlockExpressions$0(state);
|
|
3099
|
+
}
|
|
3100
|
+
}
|
|
3101
|
+
var NestedBlockExpression$0 = $S(Nested, ExtendedExpression, ExpressionDelimiter);
|
|
3102
|
+
function NestedBlockExpression(state) {
|
|
3103
|
+
if (state.verbose)
|
|
3104
|
+
console.log("ENTER:", "NestedBlockExpression");
|
|
3105
|
+
if (state.tokenize) {
|
|
3106
|
+
return $TOKEN("NestedBlockExpression", state, NestedBlockExpression$0(state));
|
|
3107
|
+
} else {
|
|
3108
|
+
return NestedBlockExpression$0(state);
|
|
3109
|
+
}
|
|
3110
|
+
}
|
|
2658
3111
|
var IterationStatement$0 = LoopStatement;
|
|
2659
3112
|
var IterationStatement$1 = DoWhileStatement;
|
|
2660
3113
|
var IterationStatement$2 = WhileStatement;
|
|
@@ -2747,6 +3200,7 @@ var Civet = (() => {
|
|
|
2747
3200
|
var clause = $1;
|
|
2748
3201
|
var block = $2;
|
|
2749
3202
|
clause.children.push(block);
|
|
3203
|
+
clause.block = block;
|
|
2750
3204
|
return clause;
|
|
2751
3205
|
});
|
|
2752
3206
|
function ForStatement(state) {
|
|
@@ -2758,8 +3212,16 @@ var Civet = (() => {
|
|
|
2758
3212
|
return ForStatement$0(state);
|
|
2759
3213
|
}
|
|
2760
3214
|
}
|
|
2761
|
-
var ForClause$0 = $
|
|
2762
|
-
|
|
3215
|
+
var ForClause$0 = $TS($S(For, __, ForStatementControl), function($skip, $loc, $0, $1, $2, $3) {
|
|
3216
|
+
var c = $3;
|
|
3217
|
+
const { children, declaration } = c;
|
|
3218
|
+
children.splice(0, 0, $1, ...$2);
|
|
3219
|
+
return {
|
|
3220
|
+
type: "ForStatement",
|
|
3221
|
+
children,
|
|
3222
|
+
declaration,
|
|
3223
|
+
block: null
|
|
3224
|
+
};
|
|
2763
3225
|
});
|
|
2764
3226
|
function ForClause(state) {
|
|
2765
3227
|
if (state.verbose)
|
|
@@ -2770,20 +3232,49 @@ var Civet = (() => {
|
|
|
2770
3232
|
return ForClause$0(state);
|
|
2771
3233
|
}
|
|
2772
3234
|
}
|
|
2773
|
-
var ForStatementControl$0 = $S(OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E(Expression), __, CloseParen)
|
|
2774
|
-
|
|
2775
|
-
|
|
2776
|
-
|
|
2777
|
-
|
|
2778
|
-
|
|
3235
|
+
var ForStatementControl$0 = $TS($S(OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E(Expression), __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
|
|
3236
|
+
var declaration = $3;
|
|
3237
|
+
return {
|
|
3238
|
+
declaration,
|
|
3239
|
+
children: $0
|
|
3240
|
+
};
|
|
3241
|
+
});
|
|
3242
|
+
var ForStatementControl$1 = $TS($S(InsertOpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E($S($N(EOS), Expression)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3243
|
+
var declaration = $3;
|
|
3244
|
+
return {
|
|
3245
|
+
declaration,
|
|
3246
|
+
children: $0
|
|
3247
|
+
};
|
|
3248
|
+
});
|
|
3249
|
+
var ForStatementControl$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of), ExtendedExpression, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3250
|
+
var declaration = $4;
|
|
3251
|
+
return {
|
|
3252
|
+
declaration,
|
|
3253
|
+
children: $0
|
|
3254
|
+
};
|
|
3255
|
+
});
|
|
3256
|
+
var ForStatementControl$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of), ExtendedExpression, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
3257
|
+
var declaration = $3;
|
|
3258
|
+
return {
|
|
3259
|
+
declaration,
|
|
3260
|
+
children: $0
|
|
3261
|
+
};
|
|
3262
|
+
});
|
|
2779
3263
|
function ForStatementControl(state) {
|
|
2780
3264
|
if (state.tokenize) {
|
|
2781
|
-
return $TOKEN("ForStatementControl", state, ForStatementControl$0(state) || ForStatementControl$1(state) || ForStatementControl$2(state) || ForStatementControl$3(state)
|
|
3265
|
+
return $TOKEN("ForStatementControl", state, ForStatementControl$0(state) || ForStatementControl$1(state) || ForStatementControl$2(state) || ForStatementControl$3(state));
|
|
2782
3266
|
} else {
|
|
2783
|
-
return ForStatementControl$0(state) || ForStatementControl$1(state) || ForStatementControl$2(state) || ForStatementControl$3(state)
|
|
3267
|
+
return ForStatementControl$0(state) || ForStatementControl$1(state) || ForStatementControl$2(state) || ForStatementControl$3(state);
|
|
2784
3268
|
}
|
|
2785
3269
|
}
|
|
2786
|
-
var ForInOfDeclaration$0 = $S(Var, ForBinding)
|
|
3270
|
+
var ForInOfDeclaration$0 = $TS($S(Var, ForBinding), function($skip, $loc, $0, $1, $2) {
|
|
3271
|
+
var binding = $2;
|
|
3272
|
+
return {
|
|
3273
|
+
type: "ForDeclaration",
|
|
3274
|
+
children: $0,
|
|
3275
|
+
names: binding.names
|
|
3276
|
+
};
|
|
3277
|
+
});
|
|
2787
3278
|
var ForInOfDeclaration$1 = ForDeclaration;
|
|
2788
3279
|
var ForInOfDeclaration$2 = LeftHandSideExpression;
|
|
2789
3280
|
function ForInOfDeclaration(state) {
|
|
@@ -2793,8 +3284,24 @@ var Civet = (() => {
|
|
|
2793
3284
|
return ForInOfDeclaration$0(state) || ForInOfDeclaration$1(state) || ForInOfDeclaration$2(state);
|
|
2794
3285
|
}
|
|
2795
3286
|
}
|
|
2796
|
-
var ForDeclaration$0 = $S(LetOrConst, NonIdContinue, ForBinding)
|
|
2797
|
-
|
|
3287
|
+
var ForDeclaration$0 = $TS($S(LetOrConst, NonIdContinue, ForBinding), function($skip, $loc, $0, $1, $2, $3) {
|
|
3288
|
+
var c = $1;
|
|
3289
|
+
var binding = $3;
|
|
3290
|
+
return {
|
|
3291
|
+
type: "ForDeclaration",
|
|
3292
|
+
children: [c, binding],
|
|
3293
|
+
names: binding.names
|
|
3294
|
+
};
|
|
3295
|
+
});
|
|
3296
|
+
var ForDeclaration$1 = $TS($S(InsertConst, ForBinding, $EXPECT($R3, fail, "ForDeclaration /(?=[\\s\\)])/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
3297
|
+
var c = $1;
|
|
3298
|
+
var binding = $2;
|
|
3299
|
+
return {
|
|
3300
|
+
type: "ForDeclaration",
|
|
3301
|
+
children: [c, binding],
|
|
3302
|
+
names: binding.names
|
|
3303
|
+
};
|
|
3304
|
+
});
|
|
2798
3305
|
function ForDeclaration(state) {
|
|
2799
3306
|
if (state.tokenize) {
|
|
2800
3307
|
return $TOKEN("ForDeclaration", state, ForDeclaration$0(state) || ForDeclaration$1(state));
|
|
@@ -2823,6 +3330,22 @@ var Civet = (() => {
|
|
|
2823
3330
|
return SwitchStatement$0(state);
|
|
2824
3331
|
}
|
|
2825
3332
|
}
|
|
3333
|
+
var SwitchExpression$0 = $TV(SwitchStatement, function($skip, $loc, $0, $1) {
|
|
3334
|
+
var e = $0;
|
|
3335
|
+
module.addImplicitReturns(e.children[2]);
|
|
3336
|
+
e.type = "SwitchExpression";
|
|
3337
|
+
e.children = ["($=>{", e.children, "})()"];
|
|
3338
|
+
return e;
|
|
3339
|
+
});
|
|
3340
|
+
function SwitchExpression(state) {
|
|
3341
|
+
if (state.verbose)
|
|
3342
|
+
console.log("ENTER:", "SwitchExpression");
|
|
3343
|
+
if (state.tokenize) {
|
|
3344
|
+
return $TOKEN("SwitchExpression", state, SwitchExpression$0(state));
|
|
3345
|
+
} else {
|
|
3346
|
+
return SwitchExpression$0(state);
|
|
3347
|
+
}
|
|
3348
|
+
}
|
|
2826
3349
|
var CaseBlock$0 = $TS($S(__, OpenBrace, $Y(EOS), NestedCaseClauses, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
2827
3350
|
var clauses = $4;
|
|
2828
3351
|
$0.splice(2, 1);
|
|
@@ -2876,19 +3399,19 @@ var Civet = (() => {
|
|
|
2876
3399
|
return NestedCaseClause$0(state);
|
|
2877
3400
|
}
|
|
2878
3401
|
}
|
|
2879
|
-
var CaseClause$0 = $T($S(Case, CaseExpressionList, $C(
|
|
3402
|
+
var CaseClause$0 = $T($S(Case, CaseExpressionList, $C(NestedBlockStatements, NoExpressions)), function(value) {
|
|
2880
3403
|
var exps = value[2];
|
|
2881
3404
|
return { "type": "CaseClause", "expressions": exps, "children": value };
|
|
2882
3405
|
});
|
|
2883
|
-
var CaseClause$1 = $T($S(When, CaseExpressionList,
|
|
3406
|
+
var CaseClause$1 = $T($S(When, CaseExpressionList, NestedBlockStatements, InsertBreak), function(value) {
|
|
2884
3407
|
var exps = value[2];
|
|
2885
3408
|
return { "type": "WhenClause", "expressions": exps, "children": value };
|
|
2886
3409
|
});
|
|
2887
|
-
var CaseClause$2 = $T($S(Default, ImpliedColon, $C(
|
|
3410
|
+
var CaseClause$2 = $T($S(Default, ImpliedColon, $C(NestedBlockStatements, NoExpressions)), function(value) {
|
|
2888
3411
|
var exps = value[2];
|
|
2889
3412
|
return { "type": "DefaultClause", "expressions": exps, "children": value };
|
|
2890
3413
|
});
|
|
2891
|
-
var CaseClause$3 = $TS($S(Else, ImpliedColon,
|
|
3414
|
+
var CaseClause$3 = $TS($S(Else, ImpliedColon, NestedBlockStatements), function($skip, $loc, $0, $1, $2, $3) {
|
|
2892
3415
|
var exps = $3;
|
|
2893
3416
|
$1.token = "default";
|
|
2894
3417
|
return {
|
|
@@ -2990,7 +3513,7 @@ var Civet = (() => {
|
|
|
2990
3513
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2991
3514
|
}
|
|
2992
3515
|
}
|
|
2993
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
3516
|
+
var Finally$0 = $S(__, $EXPECT($L74, fail, 'Finally "finally"'), BracedBlock);
|
|
2994
3517
|
function Finally(state) {
|
|
2995
3518
|
if (state.verbose)
|
|
2996
3519
|
console.log("ENTER:", "Finally");
|
|
@@ -3009,7 +3532,7 @@ var Civet = (() => {
|
|
|
3009
3532
|
return CatchParameter$0(state) || CatchParameter$1(state);
|
|
3010
3533
|
}
|
|
3011
3534
|
}
|
|
3012
|
-
var Condition$0 = $S(__, OpenParen,
|
|
3535
|
+
var Condition$0 = $S(__, OpenParen, ExtendedExpression, __, CloseParen);
|
|
3013
3536
|
var Condition$1 = $TS($S($N(EOS), __, InsertOpenParen, ExpressionWithIndentedApplicationSuppressed, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
3014
3537
|
$0.shift();
|
|
3015
3538
|
return $0;
|
|
@@ -3021,7 +3544,7 @@ var Civet = (() => {
|
|
|
3021
3544
|
return Condition$0(state) || Condition$1(state);
|
|
3022
3545
|
}
|
|
3023
3546
|
}
|
|
3024
|
-
var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(
|
|
3547
|
+
var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(ExtendedExpression)), function($skip, $loc, $0, $1, $2) {
|
|
3025
3548
|
var exp = $2;
|
|
3026
3549
|
module.suppressIndentedApplication = false;
|
|
3027
3550
|
if (exp)
|
|
@@ -3059,19 +3582,19 @@ var Civet = (() => {
|
|
|
3059
3582
|
return ExpressionStatement$0(state);
|
|
3060
3583
|
}
|
|
3061
3584
|
}
|
|
3062
|
-
var KeywordStatement$0 = $T($S($EXPECT($
|
|
3585
|
+
var KeywordStatement$0 = $T($S($EXPECT($L75, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
|
|
3063
3586
|
return { "type": "BreakStatement", "children": value };
|
|
3064
3587
|
});
|
|
3065
|
-
var KeywordStatement$1 = $T($S($EXPECT($
|
|
3588
|
+
var KeywordStatement$1 = $T($S($EXPECT($L76, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
|
|
3066
3589
|
return { "type": "ContinueStatement", "children": value };
|
|
3067
3590
|
});
|
|
3068
|
-
var KeywordStatement$2 = $T($S($EXPECT($
|
|
3591
|
+
var KeywordStatement$2 = $T($S($EXPECT($L77, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
|
|
3069
3592
|
return { "type": "DebuggerStatement", "children": value };
|
|
3070
3593
|
});
|
|
3071
3594
|
var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
|
|
3072
3595
|
return { "type": "ReturnStatement", "children": value };
|
|
3073
3596
|
});
|
|
3074
|
-
var KeywordStatement$4 = $T($S(Throw,
|
|
3597
|
+
var KeywordStatement$4 = $T($S(Throw, ExtendedExpression), function(value) {
|
|
3075
3598
|
return { "type": "ThrowStatement", "children": value };
|
|
3076
3599
|
});
|
|
3077
3600
|
function KeywordStatement(state) {
|
|
@@ -3081,8 +3604,42 @@ var Civet = (() => {
|
|
|
3081
3604
|
return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state);
|
|
3082
3605
|
}
|
|
3083
3606
|
}
|
|
3084
|
-
var
|
|
3085
|
-
|
|
3607
|
+
var DebuggerExpression$0 = $TS($S($EXPECT($L77, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3608
|
+
return {
|
|
3609
|
+
type: "DebuggerExpression",
|
|
3610
|
+
children: ["($=>{", $1, "})()"]
|
|
3611
|
+
};
|
|
3612
|
+
});
|
|
3613
|
+
function DebuggerExpression(state) {
|
|
3614
|
+
if (state.verbose)
|
|
3615
|
+
console.log("ENTER:", "DebuggerExpression");
|
|
3616
|
+
if (state.tokenize) {
|
|
3617
|
+
return $TOKEN("DebuggerExpression", state, DebuggerExpression$0(state));
|
|
3618
|
+
} else {
|
|
3619
|
+
return DebuggerExpression$0(state);
|
|
3620
|
+
}
|
|
3621
|
+
}
|
|
3622
|
+
var ThrowExpression$0 = $TS($S(Throw, ExtendedExpression), function($skip, $loc, $0, $1, $2) {
|
|
3623
|
+
return {
|
|
3624
|
+
type: "ThrowExpression",
|
|
3625
|
+
children: ["($=>{", ...$0, "})()"]
|
|
3626
|
+
};
|
|
3627
|
+
});
|
|
3628
|
+
function ThrowExpression(state) {
|
|
3629
|
+
if (state.verbose)
|
|
3630
|
+
console.log("ENTER:", "ThrowExpression");
|
|
3631
|
+
if (state.tokenize) {
|
|
3632
|
+
return $TOKEN("ThrowExpression", state, ThrowExpression$0(state));
|
|
3633
|
+
} else {
|
|
3634
|
+
return ThrowExpression$0(state);
|
|
3635
|
+
}
|
|
3636
|
+
}
|
|
3637
|
+
var MaybeNestedExpression$0 = $TS($S($N(EOS), $Q(TrailingComment), AssignmentExpression), function($skip, $loc, $0, $1, $2, $3) {
|
|
3638
|
+
return [...$2, $3];
|
|
3639
|
+
});
|
|
3640
|
+
var MaybeNestedExpression$1 = $T($S($Y(EOS), ObjectLiteral), function(value) {
|
|
3641
|
+
return value[1];
|
|
3642
|
+
});
|
|
3086
3643
|
function MaybeNestedExpression(state) {
|
|
3087
3644
|
if (state.tokenize) {
|
|
3088
3645
|
return $TOKEN("MaybeNestedExpression", state, MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state));
|
|
@@ -3090,7 +3647,7 @@ var Civet = (() => {
|
|
|
3090
3647
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
3091
3648
|
}
|
|
3092
3649
|
}
|
|
3093
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
3650
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L78, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
3094
3651
|
return { "ts": true, "children": value };
|
|
3095
3652
|
});
|
|
3096
3653
|
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
@@ -3125,7 +3682,19 @@ var Civet = (() => {
|
|
|
3125
3682
|
return ImpliedImport$0(state);
|
|
3126
3683
|
}
|
|
3127
3684
|
}
|
|
3128
|
-
var ImportClause$0 = $S(ImportedBinding, $E($S(__, Comma, __, $C(NameSpaceImport, NamedImports))))
|
|
3685
|
+
var ImportClause$0 = $TS($S(ImportedBinding, $E($S(__, Comma, __, $C(NameSpaceImport, NamedImports)))), function($skip, $loc, $0, $1, $2) {
|
|
3686
|
+
var binding = $1;
|
|
3687
|
+
var rest = $2;
|
|
3688
|
+
if (rest) {
|
|
3689
|
+
return {
|
|
3690
|
+
type: "Declaration",
|
|
3691
|
+
children: $0,
|
|
3692
|
+
names: [...binding.names, ...rest[3].names]
|
|
3693
|
+
};
|
|
3694
|
+
}
|
|
3695
|
+
$1.type = "Declaration";
|
|
3696
|
+
return $1;
|
|
3697
|
+
});
|
|
3129
3698
|
var ImportClause$1 = NameSpaceImport;
|
|
3130
3699
|
var ImportClause$2 = NamedImports;
|
|
3131
3700
|
function ImportClause(state) {
|
|
@@ -3135,7 +3704,14 @@ var Civet = (() => {
|
|
|
3135
3704
|
return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
|
|
3136
3705
|
}
|
|
3137
3706
|
}
|
|
3138
|
-
var NameSpaceImport$0 = $S(Star, __, As,
|
|
3707
|
+
var NameSpaceImport$0 = $TS($S(Star, __, As, __, ImportedBinding), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
3708
|
+
var binding = $5;
|
|
3709
|
+
return {
|
|
3710
|
+
type: "Declaration",
|
|
3711
|
+
children: $0,
|
|
3712
|
+
names: binding.names
|
|
3713
|
+
};
|
|
3714
|
+
});
|
|
3139
3715
|
function NameSpaceImport(state) {
|
|
3140
3716
|
if (state.verbose)
|
|
3141
3717
|
console.log("ENTER:", "NameSpaceImport");
|
|
@@ -3145,7 +3721,17 @@ var Civet = (() => {
|
|
|
3145
3721
|
return NameSpaceImport$0(state);
|
|
3146
3722
|
}
|
|
3147
3723
|
}
|
|
3148
|
-
var NamedImports$0 = $S(OpenBrace, $Q(ImportSpecifier), $E($S(__, Comma)), __, CloseBrace)
|
|
3724
|
+
var NamedImports$0 = $TS($S(OpenBrace, $Q(ImportSpecifier), $E($S(__, Comma)), __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
3725
|
+
var specifiers = $2;
|
|
3726
|
+
const names = specifiers.flatMap(({ binding }) => {
|
|
3727
|
+
return binding.names;
|
|
3728
|
+
});
|
|
3729
|
+
return {
|
|
3730
|
+
type: "Declaration",
|
|
3731
|
+
children: $0,
|
|
3732
|
+
names
|
|
3733
|
+
};
|
|
3734
|
+
});
|
|
3149
3735
|
function NamedImports(state) {
|
|
3150
3736
|
if (state.verbose)
|
|
3151
3737
|
console.log("ENTER:", "NamedImports");
|
|
@@ -3165,8 +3751,20 @@ var Civet = (() => {
|
|
|
3165
3751
|
return FromClause$0(state);
|
|
3166
3752
|
}
|
|
3167
3753
|
}
|
|
3168
|
-
var ImportSpecifier$0 = $S(__, ModuleExportName, __, As,
|
|
3169
|
-
|
|
3754
|
+
var ImportSpecifier$0 = $TS($S(__, ModuleExportName, __, As, __, ImportedBinding, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
|
|
3755
|
+
var binding = $6;
|
|
3756
|
+
return {
|
|
3757
|
+
binding,
|
|
3758
|
+
children: $0
|
|
3759
|
+
};
|
|
3760
|
+
});
|
|
3761
|
+
var ImportSpecifier$1 = $TS($S(__, ImportedBinding, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
|
|
3762
|
+
var binding = $2;
|
|
3763
|
+
return {
|
|
3764
|
+
binding,
|
|
3765
|
+
children: $0
|
|
3766
|
+
};
|
|
3767
|
+
});
|
|
3170
3768
|
function ImportSpecifier(state) {
|
|
3171
3769
|
if (state.tokenize) {
|
|
3172
3770
|
return $TOKEN("ImportSpecifier", state, ImportSpecifier$0(state) || ImportSpecifier$1(state));
|
|
@@ -3228,7 +3826,7 @@ var Civet = (() => {
|
|
|
3228
3826
|
return ImportedBinding$0(state);
|
|
3229
3827
|
}
|
|
3230
3828
|
}
|
|
3231
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
3829
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L79, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression));
|
|
3232
3830
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
3233
3831
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
3234
3832
|
function ExportDeclaration(state) {
|
|
@@ -3238,7 +3836,7 @@ var Civet = (() => {
|
|
|
3238
3836
|
return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
|
|
3239
3837
|
}
|
|
3240
3838
|
}
|
|
3241
|
-
var ExportFromClause$0 = $S(Star, $E($S(__, As,
|
|
3839
|
+
var ExportFromClause$0 = $S(Star, $E($S(__, As, __, ModuleExportName)));
|
|
3242
3840
|
var ExportFromClause$1 = NamedExports;
|
|
3243
3841
|
function ExportFromClause(state) {
|
|
3244
3842
|
if (state.tokenize) {
|
|
@@ -3288,18 +3886,43 @@ var Civet = (() => {
|
|
|
3288
3886
|
return HoistableDeclaration$0(state);
|
|
3289
3887
|
}
|
|
3290
3888
|
}
|
|
3291
|
-
var LexicalDeclaration$0 = $
|
|
3292
|
-
|
|
3889
|
+
var LexicalDeclaration$0 = $TS($S(LetOrConst, LexicalBinding, $Q($S(__, Comma, LexicalBinding))), function($skip, $loc, $0, $1, $2, $3) {
|
|
3890
|
+
var binding = $2;
|
|
3891
|
+
var tail = $3;
|
|
3892
|
+
return {
|
|
3893
|
+
type: "Declaration",
|
|
3894
|
+
children: $0,
|
|
3895
|
+
names: [...binding.names].concat(tail.flatMap(([, , b]) => b.names))
|
|
3896
|
+
};
|
|
3293
3897
|
});
|
|
3294
|
-
var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment,
|
|
3898
|
+
var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
|
|
3295
3899
|
var c = $1;
|
|
3900
|
+
var id = $2;
|
|
3296
3901
|
var ca = $5;
|
|
3902
|
+
var e = $6;
|
|
3297
3903
|
c.$loc = {
|
|
3298
3904
|
pos: ca.$loc.pos - 1,
|
|
3299
3905
|
length: ca.$loc.length + 1
|
|
3300
3906
|
};
|
|
3907
|
+
let exp;
|
|
3908
|
+
if (e.type === "FunctionExpression") {
|
|
3909
|
+
exp = e;
|
|
3910
|
+
} else {
|
|
3911
|
+
exp = e[1];
|
|
3912
|
+
}
|
|
3913
|
+
if (exp?.children?.[0]?.token?.match(/^\s+$/))
|
|
3914
|
+
exp.children.shift();
|
|
3915
|
+
if (id.type === "Identifier" && exp?.type === "FunctionExpression") {
|
|
3916
|
+
if (exp.id.length === 0) {
|
|
3917
|
+
exp.id.push(" ", id, $3, $4);
|
|
3918
|
+
}
|
|
3919
|
+
exp.type = "Declaration";
|
|
3920
|
+
exp.names = id.names;
|
|
3921
|
+
return exp;
|
|
3922
|
+
}
|
|
3301
3923
|
return {
|
|
3302
|
-
type: "
|
|
3924
|
+
type: "Declaration",
|
|
3925
|
+
names: id.names,
|
|
3303
3926
|
children: $0
|
|
3304
3927
|
};
|
|
3305
3928
|
});
|
|
@@ -3310,7 +3933,7 @@ var Civet = (() => {
|
|
|
3310
3933
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
3311
3934
|
}
|
|
3312
3935
|
}
|
|
3313
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
3936
|
+
var ConstAssignment$0 = $TV($EXPECT($L80, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
3314
3937
|
return { $loc, token: "=" };
|
|
3315
3938
|
});
|
|
3316
3939
|
function ConstAssignment(state) {
|
|
@@ -3322,8 +3945,19 @@ var Civet = (() => {
|
|
|
3322
3945
|
return ConstAssignment$0(state);
|
|
3323
3946
|
}
|
|
3324
3947
|
}
|
|
3325
|
-
var LexicalBinding$0 = $S(BindingPattern, $E(TypeSuffix), Initializer)
|
|
3326
|
-
|
|
3948
|
+
var LexicalBinding$0 = $TS($S(BindingPattern, $E(TypeSuffix), Initializer), function($skip, $loc, $0, $1, $2, $3) {
|
|
3949
|
+
if ($2)
|
|
3950
|
+
$1.children.push($2);
|
|
3951
|
+
$1.children.push($3);
|
|
3952
|
+
return $1;
|
|
3953
|
+
});
|
|
3954
|
+
var LexicalBinding$1 = $TS($S(BindingIdentifier, $E(TypeSuffix), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3) {
|
|
3955
|
+
if ($2)
|
|
3956
|
+
$1.children.push($2);
|
|
3957
|
+
if ($3)
|
|
3958
|
+
$1.children.push($3);
|
|
3959
|
+
return $1;
|
|
3960
|
+
});
|
|
3327
3961
|
function LexicalBinding(state) {
|
|
3328
3962
|
if (state.tokenize) {
|
|
3329
3963
|
return $TOKEN("LexicalBinding", state, LexicalBinding$0(state) || LexicalBinding$1(state));
|
|
@@ -3331,7 +3965,7 @@ var Civet = (() => {
|
|
|
3331
3965
|
return LexicalBinding$0(state) || LexicalBinding$1(state);
|
|
3332
3966
|
}
|
|
3333
3967
|
}
|
|
3334
|
-
var Initializer$0 = $S(__, Equals,
|
|
3968
|
+
var Initializer$0 = $S(__, Equals, ExtendedExpression);
|
|
3335
3969
|
function Initializer(state) {
|
|
3336
3970
|
if (state.verbose)
|
|
3337
3971
|
console.log("ENTER:", "Initializer");
|
|
@@ -3341,8 +3975,9 @@ var Civet = (() => {
|
|
|
3341
3975
|
return Initializer$0(state);
|
|
3342
3976
|
}
|
|
3343
3977
|
}
|
|
3344
|
-
var VariableStatement$0 = $
|
|
3345
|
-
|
|
3978
|
+
var VariableStatement$0 = $TS($S(Var, __, VariableDeclarationList), function($skip, $loc, $0, $1, $2, $3) {
|
|
3979
|
+
$3.children.splice(0, 0, $1, ...$2);
|
|
3980
|
+
return $3;
|
|
3346
3981
|
});
|
|
3347
3982
|
function VariableStatement(state) {
|
|
3348
3983
|
if (state.verbose)
|
|
@@ -3353,7 +3988,20 @@ var Civet = (() => {
|
|
|
3353
3988
|
return VariableStatement$0(state);
|
|
3354
3989
|
}
|
|
3355
3990
|
}
|
|
3356
|
-
var VariableDeclarationList$0 = $S(VariableDeclaration, $Q($S(__, Comma, __, VariableDeclaration)))
|
|
3991
|
+
var VariableDeclarationList$0 = $TS($S(VariableDeclaration, $Q($S(__, Comma, __, VariableDeclaration))), function($skip, $loc, $0, $1, $2) {
|
|
3992
|
+
let children;
|
|
3993
|
+
if ($2.length) {
|
|
3994
|
+
children = [$1, ...$2];
|
|
3995
|
+
} else {
|
|
3996
|
+
children = [$1];
|
|
3997
|
+
}
|
|
3998
|
+
const names = children.flatMap((c) => c.names || []);
|
|
3999
|
+
return {
|
|
4000
|
+
type: "Declaration",
|
|
4001
|
+
children,
|
|
4002
|
+
names
|
|
4003
|
+
};
|
|
4004
|
+
});
|
|
3357
4005
|
function VariableDeclarationList(state) {
|
|
3358
4006
|
if (state.verbose)
|
|
3359
4007
|
console.log("ENTER:", "VariableDeclarationList");
|
|
@@ -3363,8 +4011,19 @@ var Civet = (() => {
|
|
|
3363
4011
|
return VariableDeclarationList$0(state);
|
|
3364
4012
|
}
|
|
3365
4013
|
}
|
|
3366
|
-
var VariableDeclaration$0 = $S(BindingPattern, $E(TypeSuffix), Initializer)
|
|
3367
|
-
|
|
4014
|
+
var VariableDeclaration$0 = $TS($S(BindingPattern, $E(TypeSuffix), Initializer), function($skip, $loc, $0, $1, $2, $3) {
|
|
4015
|
+
if ($2)
|
|
4016
|
+
$1.children.push($2);
|
|
4017
|
+
$1.children.push($3);
|
|
4018
|
+
return $1;
|
|
4019
|
+
});
|
|
4020
|
+
var VariableDeclaration$1 = $TS($S(BindingIdentifier, $E(TypeSuffix), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3) {
|
|
4021
|
+
if ($2)
|
|
4022
|
+
$1.children.push($2);
|
|
4023
|
+
if ($3)
|
|
4024
|
+
$1.children.push($3);
|
|
4025
|
+
return $1;
|
|
4026
|
+
});
|
|
3368
4027
|
function VariableDeclaration(state) {
|
|
3369
4028
|
if (state.tokenize) {
|
|
3370
4029
|
return $TOKEN("VariableDeclaration", state, VariableDeclaration$0(state) || VariableDeclaration$1(state));
|
|
@@ -3545,7 +4204,7 @@ var Civet = (() => {
|
|
|
3545
4204
|
return TripleSingleStringCharacters$0(state);
|
|
3546
4205
|
}
|
|
3547
4206
|
}
|
|
3548
|
-
var CoffeeStringSubstitution$0 = $S(CoffeeSubstitutionStart,
|
|
4207
|
+
var CoffeeStringSubstitution$0 = $S(CoffeeSubstitutionStart, ExtendedExpression, __, CloseBrace);
|
|
3549
4208
|
function CoffeeStringSubstitution(state) {
|
|
3550
4209
|
if (state.verbose)
|
|
3551
4210
|
console.log("ENTER:", "CoffeeStringSubstitution");
|
|
@@ -3596,7 +4255,7 @@ var Civet = (() => {
|
|
|
3596
4255
|
return CoffeeDoubleQuotedStringCharacters$0(state);
|
|
3597
4256
|
}
|
|
3598
4257
|
}
|
|
3599
|
-
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($
|
|
4258
|
+
var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L47, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L47, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
|
|
3600
4259
|
return { $loc, token: $1 };
|
|
3601
4260
|
});
|
|
3602
4261
|
function RegularExpressionLiteral(state) {
|
|
@@ -3649,7 +4308,7 @@ var Civet = (() => {
|
|
|
3649
4308
|
return TemplateLiteral$0(state) || TemplateLiteral$1(state);
|
|
3650
4309
|
}
|
|
3651
4310
|
}
|
|
3652
|
-
var TemplateSubstitution$0 = $S(SubstitutionStart,
|
|
4311
|
+
var TemplateSubstitution$0 = $S(SubstitutionStart, ExtendedExpression, __, CloseBrace);
|
|
3653
4312
|
function TemplateSubstitution(state) {
|
|
3654
4313
|
if (state.verbose)
|
|
3655
4314
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -3684,12 +4343,13 @@ var Civet = (() => {
|
|
|
3684
4343
|
}
|
|
3685
4344
|
}
|
|
3686
4345
|
var ReservedWord$0 = $S(CoffeeBooleansEnabled, $R$0($EXPECT($R23, fail, "ReservedWord /(?:on|off|yes|no)(?!\\p{ID_Continue})/")));
|
|
3687
|
-
var ReservedWord$1 = $R$0($EXPECT($R24, fail, "ReservedWord /(?:
|
|
4346
|
+
var ReservedWord$1 = $S(CoffeeIsntEnabled, $R$0($EXPECT($R24, fail, "ReservedWord /(?:isnt)(?!\\p{ID_Continue})/")));
|
|
4347
|
+
var ReservedWord$2 = $R$0($EXPECT($R25, 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|loop|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
|
|
3688
4348
|
function ReservedWord(state) {
|
|
3689
4349
|
if (state.tokenize) {
|
|
3690
|
-
return $TOKEN("ReservedWord", state, ReservedWord$0(state) || ReservedWord$1(state));
|
|
4350
|
+
return $TOKEN("ReservedWord", state, ReservedWord$0(state) || ReservedWord$1(state) || ReservedWord$2(state));
|
|
3691
4351
|
} else {
|
|
3692
|
-
return ReservedWord$0(state) || ReservedWord$1(state);
|
|
4352
|
+
return ReservedWord$0(state) || ReservedWord$1(state) || ReservedWord$2(state);
|
|
3693
4353
|
}
|
|
3694
4354
|
}
|
|
3695
4355
|
var Comment$0 = MultiLineComment;
|
|
@@ -3701,7 +4361,7 @@ var Civet = (() => {
|
|
|
3701
4361
|
return Comment$0(state) || Comment$1(state);
|
|
3702
4362
|
}
|
|
3703
4363
|
}
|
|
3704
|
-
var SingleLineComment$0 = $TR($EXPECT($
|
|
4364
|
+
var SingleLineComment$0 = $TR($EXPECT($R26, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3705
4365
|
return { $loc, token: $0 };
|
|
3706
4366
|
});
|
|
3707
4367
|
var SingleLineComment$1 = $S(CoffeeCommentEnabled, CoffeeSingleLineComment);
|
|
@@ -3721,7 +4381,7 @@ var Civet = (() => {
|
|
|
3721
4381
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
3722
4382
|
}
|
|
3723
4383
|
}
|
|
3724
|
-
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($
|
|
4384
|
+
var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L81, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L82, fail, 'JSMultiLineComment "*/"')), $EXPECT($R27, fail, "JSMultiLineComment /./"))), $EXPECT($L82, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
3725
4385
|
return { $loc, token: $1 };
|
|
3726
4386
|
});
|
|
3727
4387
|
function JSMultiLineComment(state) {
|
|
@@ -3733,7 +4393,7 @@ var Civet = (() => {
|
|
|
3733
4393
|
return JSMultiLineComment$0(state);
|
|
3734
4394
|
}
|
|
3735
4395
|
}
|
|
3736
|
-
var CoffeeSingleLineComment$0 = $TR($EXPECT($
|
|
4396
|
+
var CoffeeSingleLineComment$0 = $TR($EXPECT($R28, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3737
4397
|
return { $loc, token: `//${$1}` };
|
|
3738
4398
|
});
|
|
3739
4399
|
function CoffeeSingleLineComment(state) {
|
|
@@ -3745,7 +4405,7 @@ var Civet = (() => {
|
|
|
3745
4405
|
return CoffeeSingleLineComment$0(state);
|
|
3746
4406
|
}
|
|
3747
4407
|
}
|
|
3748
|
-
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($
|
|
4408
|
+
var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L83, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L83, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L82, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R27, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L83, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
|
|
3749
4409
|
return { $loc, token: `/*${$2}*/` };
|
|
3750
4410
|
});
|
|
3751
4411
|
function CoffeeMultiLineComment(state) {
|
|
@@ -3757,7 +4417,7 @@ var Civet = (() => {
|
|
|
3757
4417
|
return CoffeeMultiLineComment$0(state);
|
|
3758
4418
|
}
|
|
3759
4419
|
}
|
|
3760
|
-
var InlineComment$0 = $TV($TEXT($S($EXPECT($
|
|
4420
|
+
var InlineComment$0 = $TV($TEXT($S($EXPECT($L81, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L82, fail, 'InlineComment "*/"')), $EXPECT($R29, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L82, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
|
|
3761
4421
|
return { $loc, token: $1 };
|
|
3762
4422
|
});
|
|
3763
4423
|
function InlineComment(state) {
|
|
@@ -3799,7 +4459,7 @@ var Civet = (() => {
|
|
|
3799
4459
|
return _$0(state);
|
|
3800
4460
|
}
|
|
3801
4461
|
}
|
|
3802
|
-
var NonNewlineWhitespace$0 = $TR($EXPECT($
|
|
4462
|
+
var NonNewlineWhitespace$0 = $TR($EXPECT($R30, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3803
4463
|
return { $loc, token: $0 };
|
|
3804
4464
|
});
|
|
3805
4465
|
function NonNewlineWhitespace(state) {
|
|
@@ -3821,7 +4481,7 @@ var Civet = (() => {
|
|
|
3821
4481
|
return __$0(state);
|
|
3822
4482
|
}
|
|
3823
4483
|
}
|
|
3824
|
-
var Whitespace$0 = $TR($EXPECT($
|
|
4484
|
+
var Whitespace$0 = $TR($EXPECT($R31, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
3825
4485
|
return { $loc, token: $0 };
|
|
3826
4486
|
});
|
|
3827
4487
|
function Whitespace(state) {
|
|
@@ -3833,6 +4493,20 @@ var Civet = (() => {
|
|
|
3833
4493
|
return Whitespace$0(state);
|
|
3834
4494
|
}
|
|
3835
4495
|
}
|
|
4496
|
+
var ExpressionDelimiter$0 = $TS($S($Q(TrailingComment), Semicolon, $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3) {
|
|
4497
|
+
$2.token = ",";
|
|
4498
|
+
return $0;
|
|
4499
|
+
});
|
|
4500
|
+
var ExpressionDelimiter$1 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
4501
|
+
return { $loc, token: "," };
|
|
4502
|
+
});
|
|
4503
|
+
function ExpressionDelimiter(state) {
|
|
4504
|
+
if (state.tokenize) {
|
|
4505
|
+
return $TOKEN("ExpressionDelimiter", state, ExpressionDelimiter$0(state) || ExpressionDelimiter$1(state));
|
|
4506
|
+
} else {
|
|
4507
|
+
return ExpressionDelimiter$0(state) || ExpressionDelimiter$1(state);
|
|
4508
|
+
}
|
|
4509
|
+
}
|
|
3836
4510
|
var StatementDelimiter$0 = $S($Q(TrailingComment), Semicolon, $Q(TrailingComment));
|
|
3837
4511
|
var StatementDelimiter$1 = $Y(EOS);
|
|
3838
4512
|
function StatementDelimiter(state) {
|
|
@@ -3842,7 +4516,7 @@ var Civet = (() => {
|
|
|
3842
4516
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
3843
4517
|
}
|
|
3844
4518
|
}
|
|
3845
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
4519
|
+
var NonIdContinue$0 = $R$0($EXPECT($R32, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
3846
4520
|
function NonIdContinue(state) {
|
|
3847
4521
|
if (state.verbose)
|
|
3848
4522
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -3864,7 +4538,7 @@ var Civet = (() => {
|
|
|
3864
4538
|
return Loc$0(state);
|
|
3865
4539
|
}
|
|
3866
4540
|
}
|
|
3867
|
-
var As$0 = $TS($S($EXPECT($
|
|
4541
|
+
var As$0 = $TS($S($EXPECT($L84, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3868
4542
|
return { $loc, token: $1 };
|
|
3869
4543
|
});
|
|
3870
4544
|
function As(state) {
|
|
@@ -3876,7 +4550,7 @@ var Civet = (() => {
|
|
|
3876
4550
|
return As$0(state);
|
|
3877
4551
|
}
|
|
3878
4552
|
}
|
|
3879
|
-
var Async$0 = $TV($EXPECT($
|
|
4553
|
+
var Async$0 = $TV($EXPECT($L85, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
|
|
3880
4554
|
return { $loc, token: $1 };
|
|
3881
4555
|
});
|
|
3882
4556
|
function Async(state) {
|
|
@@ -3888,7 +4562,7 @@ var Civet = (() => {
|
|
|
3888
4562
|
return Async$0(state);
|
|
3889
4563
|
}
|
|
3890
4564
|
}
|
|
3891
|
-
var Await$0 = $TS($S($EXPECT($
|
|
4565
|
+
var Await$0 = $TS($S($EXPECT($L86, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3892
4566
|
return { $loc, token: $1 };
|
|
3893
4567
|
});
|
|
3894
4568
|
function Await(state) {
|
|
@@ -3900,7 +4574,7 @@ var Civet = (() => {
|
|
|
3900
4574
|
return Await$0(state);
|
|
3901
4575
|
}
|
|
3902
4576
|
}
|
|
3903
|
-
var Backtick$0 = $TV($EXPECT($
|
|
4577
|
+
var Backtick$0 = $TV($EXPECT($L87, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
|
|
3904
4578
|
return { $loc, token: $1 };
|
|
3905
4579
|
});
|
|
3906
4580
|
function Backtick(state) {
|
|
@@ -3912,7 +4586,7 @@ var Civet = (() => {
|
|
|
3912
4586
|
return Backtick$0(state);
|
|
3913
4587
|
}
|
|
3914
4588
|
}
|
|
3915
|
-
var Case$0 = $TS($S($EXPECT($
|
|
4589
|
+
var Case$0 = $TS($S($EXPECT($L88, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
3916
4590
|
return { $loc, token: $1 };
|
|
3917
4591
|
});
|
|
3918
4592
|
function Case(state) {
|
|
@@ -3924,7 +4598,7 @@ var Civet = (() => {
|
|
|
3924
4598
|
return Case$0(state);
|
|
3925
4599
|
}
|
|
3926
4600
|
}
|
|
3927
|
-
var Catch$0 = $TV($EXPECT($
|
|
4601
|
+
var Catch$0 = $TV($EXPECT($L89, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
|
|
3928
4602
|
return { $loc, token: $1 };
|
|
3929
4603
|
});
|
|
3930
4604
|
function Catch(state) {
|
|
@@ -3936,7 +4610,7 @@ var Civet = (() => {
|
|
|
3936
4610
|
return Catch$0(state);
|
|
3937
4611
|
}
|
|
3938
4612
|
}
|
|
3939
|
-
var Class$0 = $TV($EXPECT($
|
|
4613
|
+
var Class$0 = $TV($EXPECT($L90, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
|
|
3940
4614
|
return { $loc, token: $1 };
|
|
3941
4615
|
});
|
|
3942
4616
|
function Class(state) {
|
|
@@ -3948,7 +4622,7 @@ var Civet = (() => {
|
|
|
3948
4622
|
return Class$0(state);
|
|
3949
4623
|
}
|
|
3950
4624
|
}
|
|
3951
|
-
var CloseBrace$0 = $TV($EXPECT($
|
|
4625
|
+
var CloseBrace$0 = $TV($EXPECT($L27, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
|
|
3952
4626
|
return { $loc, token: $1 };
|
|
3953
4627
|
});
|
|
3954
4628
|
function CloseBrace(state) {
|
|
@@ -3960,7 +4634,7 @@ var Civet = (() => {
|
|
|
3960
4634
|
return CloseBrace$0(state);
|
|
3961
4635
|
}
|
|
3962
4636
|
}
|
|
3963
|
-
var CloseBracket$0 = $TV($EXPECT($
|
|
4637
|
+
var CloseBracket$0 = $TV($EXPECT($L26, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
|
|
3964
4638
|
return { $loc, token: $1 };
|
|
3965
4639
|
});
|
|
3966
4640
|
function CloseBracket(state) {
|
|
@@ -3972,7 +4646,7 @@ var Civet = (() => {
|
|
|
3972
4646
|
return CloseBracket$0(state);
|
|
3973
4647
|
}
|
|
3974
4648
|
}
|
|
3975
|
-
var CloseParen$0 = $TV($EXPECT($
|
|
4649
|
+
var CloseParen$0 = $TV($EXPECT($L16, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
|
|
3976
4650
|
return { $loc, token: $1 };
|
|
3977
4651
|
});
|
|
3978
4652
|
function CloseParen(state) {
|
|
@@ -3984,7 +4658,7 @@ var Civet = (() => {
|
|
|
3984
4658
|
return CloseParen$0(state);
|
|
3985
4659
|
}
|
|
3986
4660
|
}
|
|
3987
|
-
var CoffeeSubstitutionStart$0 = $TV($EXPECT($
|
|
4661
|
+
var CoffeeSubstitutionStart$0 = $TV($EXPECT($L91, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
|
|
3988
4662
|
return { $loc, token: "${" };
|
|
3989
4663
|
});
|
|
3990
4664
|
function CoffeeSubstitutionStart(state) {
|
|
@@ -3996,7 +4670,7 @@ var Civet = (() => {
|
|
|
3996
4670
|
return CoffeeSubstitutionStart$0(state);
|
|
3997
4671
|
}
|
|
3998
4672
|
}
|
|
3999
|
-
var Colon$0 = $TV($EXPECT($
|
|
4673
|
+
var Colon$0 = $TV($EXPECT($L92, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
|
|
4000
4674
|
return { $loc, token: $1 };
|
|
4001
4675
|
});
|
|
4002
4676
|
function Colon(state) {
|
|
@@ -4020,7 +4694,7 @@ var Civet = (() => {
|
|
|
4020
4694
|
return ConstructorShorthand$0(state);
|
|
4021
4695
|
}
|
|
4022
4696
|
}
|
|
4023
|
-
var Default$0 = $TS($S($EXPECT($
|
|
4697
|
+
var Default$0 = $TS($S($EXPECT($L79, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4024
4698
|
return { $loc, token: $1 };
|
|
4025
4699
|
});
|
|
4026
4700
|
function Default(state) {
|
|
@@ -4032,7 +4706,7 @@ var Civet = (() => {
|
|
|
4032
4706
|
return Default$0(state);
|
|
4033
4707
|
}
|
|
4034
4708
|
}
|
|
4035
|
-
var Delete$0 = $TS($S($EXPECT($
|
|
4709
|
+
var Delete$0 = $TS($S($EXPECT($L93, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4036
4710
|
return { $loc, token: $1 };
|
|
4037
4711
|
});
|
|
4038
4712
|
function Delete(state) {
|
|
@@ -4044,7 +4718,7 @@ var Civet = (() => {
|
|
|
4044
4718
|
return Delete$0(state);
|
|
4045
4719
|
}
|
|
4046
4720
|
}
|
|
4047
|
-
var Do$0 = $TS($S($EXPECT($
|
|
4721
|
+
var Do$0 = $TS($S($EXPECT($L94, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4048
4722
|
return { $loc, token: $1 };
|
|
4049
4723
|
});
|
|
4050
4724
|
function Do(state) {
|
|
@@ -4056,7 +4730,7 @@ var Civet = (() => {
|
|
|
4056
4730
|
return Do$0(state);
|
|
4057
4731
|
}
|
|
4058
4732
|
}
|
|
4059
|
-
var Dot$0 = $TV($EXPECT($
|
|
4733
|
+
var Dot$0 = $TV($EXPECT($L9, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
|
|
4060
4734
|
return { $loc, token: $1 };
|
|
4061
4735
|
});
|
|
4062
4736
|
function Dot(state) {
|
|
@@ -4068,7 +4742,7 @@ var Civet = (() => {
|
|
|
4068
4742
|
return Dot$0(state);
|
|
4069
4743
|
}
|
|
4070
4744
|
}
|
|
4071
|
-
var DotDot$0 = $TV($EXPECT($
|
|
4745
|
+
var DotDot$0 = $TV($EXPECT($L95, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
|
|
4072
4746
|
return { $loc, token: $1 };
|
|
4073
4747
|
});
|
|
4074
4748
|
function DotDot(state) {
|
|
@@ -4080,7 +4754,7 @@ var Civet = (() => {
|
|
|
4080
4754
|
return DotDot$0(state);
|
|
4081
4755
|
}
|
|
4082
4756
|
}
|
|
4083
|
-
var DotDotDot$0 = $TV($EXPECT($
|
|
4757
|
+
var DotDotDot$0 = $TV($EXPECT($L96, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
|
|
4084
4758
|
return { $loc, token: $1 };
|
|
4085
4759
|
});
|
|
4086
4760
|
function DotDotDot(state) {
|
|
@@ -4092,7 +4766,7 @@ var Civet = (() => {
|
|
|
4092
4766
|
return DotDotDot$0(state);
|
|
4093
4767
|
}
|
|
4094
4768
|
}
|
|
4095
|
-
var DoubleQuote$0 = $TV($EXPECT($
|
|
4769
|
+
var DoubleQuote$0 = $TV($EXPECT($L97, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
4096
4770
|
return { $loc, token: $1 };
|
|
4097
4771
|
});
|
|
4098
4772
|
function DoubleQuote(state) {
|
|
@@ -4104,7 +4778,7 @@ var Civet = (() => {
|
|
|
4104
4778
|
return DoubleQuote$0(state);
|
|
4105
4779
|
}
|
|
4106
4780
|
}
|
|
4107
|
-
var Else$0 = $TV($EXPECT($
|
|
4781
|
+
var Else$0 = $TV($EXPECT($L98, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
|
|
4108
4782
|
return { $loc, token: $1 };
|
|
4109
4783
|
});
|
|
4110
4784
|
function Else(state) {
|
|
@@ -4116,7 +4790,7 @@ var Civet = (() => {
|
|
|
4116
4790
|
return Else$0(state);
|
|
4117
4791
|
}
|
|
4118
4792
|
}
|
|
4119
|
-
var Equals$0 = $TV($EXPECT($
|
|
4793
|
+
var Equals$0 = $TV($EXPECT($L44, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
|
|
4120
4794
|
return { $loc, token: $1 };
|
|
4121
4795
|
});
|
|
4122
4796
|
function Equals(state) {
|
|
@@ -4128,7 +4802,7 @@ var Civet = (() => {
|
|
|
4128
4802
|
return Equals$0(state);
|
|
4129
4803
|
}
|
|
4130
4804
|
}
|
|
4131
|
-
var Export$0 = $TS($S($EXPECT($
|
|
4805
|
+
var Export$0 = $TS($S($EXPECT($L99, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4132
4806
|
return { $loc, token: $1 };
|
|
4133
4807
|
});
|
|
4134
4808
|
function Export(state) {
|
|
@@ -4140,7 +4814,7 @@ var Civet = (() => {
|
|
|
4140
4814
|
return Export$0(state);
|
|
4141
4815
|
}
|
|
4142
4816
|
}
|
|
4143
|
-
var For$0 = $TS($S($EXPECT($
|
|
4817
|
+
var For$0 = $TS($S($EXPECT($L100, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4144
4818
|
return { $loc, token: $1 };
|
|
4145
4819
|
});
|
|
4146
4820
|
function For(state) {
|
|
@@ -4152,7 +4826,7 @@ var Civet = (() => {
|
|
|
4152
4826
|
return For$0(state);
|
|
4153
4827
|
}
|
|
4154
4828
|
}
|
|
4155
|
-
var From$0 = $TS($S($EXPECT($
|
|
4829
|
+
var From$0 = $TS($S($EXPECT($L101, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4156
4830
|
return { $loc, token: $1 };
|
|
4157
4831
|
});
|
|
4158
4832
|
function From(state) {
|
|
@@ -4164,7 +4838,7 @@ var Civet = (() => {
|
|
|
4164
4838
|
return From$0(state);
|
|
4165
4839
|
}
|
|
4166
4840
|
}
|
|
4167
|
-
var Function$0 = $TV($EXPECT($
|
|
4841
|
+
var Function$0 = $TV($EXPECT($L102, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
|
|
4168
4842
|
return { $loc, token: $1 };
|
|
4169
4843
|
});
|
|
4170
4844
|
function Function(state) {
|
|
@@ -4176,7 +4850,7 @@ var Civet = (() => {
|
|
|
4176
4850
|
return Function$0(state);
|
|
4177
4851
|
}
|
|
4178
4852
|
}
|
|
4179
|
-
var GetOrSet$0 = $TS($S($C($EXPECT($
|
|
4853
|
+
var GetOrSet$0 = $TS($S($C($EXPECT($L103, fail, 'GetOrSet "get"'), $EXPECT($L104, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4180
4854
|
return { $loc, token: $1 };
|
|
4181
4855
|
});
|
|
4182
4856
|
function GetOrSet(state) {
|
|
@@ -4188,7 +4862,7 @@ var Civet = (() => {
|
|
|
4188
4862
|
return GetOrSet$0(state);
|
|
4189
4863
|
}
|
|
4190
4864
|
}
|
|
4191
|
-
var If$0 = $TV($EXPECT($
|
|
4865
|
+
var If$0 = $TV($TEXT($S($EXPECT($L105, fail, 'If "if"'), $E($EXPECT($L106, fail, 'If " "')))), function($skip, $loc, $0, $1) {
|
|
4192
4866
|
return { $loc, token: $1 };
|
|
4193
4867
|
});
|
|
4194
4868
|
function If(state) {
|
|
@@ -4200,7 +4874,7 @@ var Civet = (() => {
|
|
|
4200
4874
|
return If$0(state);
|
|
4201
4875
|
}
|
|
4202
4876
|
}
|
|
4203
|
-
var Import$0 = $TS($S($EXPECT($
|
|
4877
|
+
var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R33, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
|
|
4204
4878
|
return { $loc, token: $1 };
|
|
4205
4879
|
});
|
|
4206
4880
|
function Import(state) {
|
|
@@ -4212,7 +4886,7 @@ var Civet = (() => {
|
|
|
4212
4886
|
return Import$0(state);
|
|
4213
4887
|
}
|
|
4214
4888
|
}
|
|
4215
|
-
var In$0 = $TV($EXPECT($
|
|
4889
|
+
var In$0 = $TV($EXPECT($L69, fail, 'In "in"'), function($skip, $loc, $0, $1) {
|
|
4216
4890
|
return { $loc, token: $1 };
|
|
4217
4891
|
});
|
|
4218
4892
|
function In(state) {
|
|
@@ -4224,7 +4898,7 @@ var Civet = (() => {
|
|
|
4224
4898
|
return In$0(state);
|
|
4225
4899
|
}
|
|
4226
4900
|
}
|
|
4227
|
-
var LetOrConst$0 = $TV($C($EXPECT($
|
|
4901
|
+
var LetOrConst$0 = $TV($C($EXPECT($L107, fail, 'LetOrConst "let"'), $EXPECT($L108, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
|
|
4228
4902
|
return { $loc, token: $1 };
|
|
4229
4903
|
});
|
|
4230
4904
|
function LetOrConst(state) {
|
|
@@ -4236,7 +4910,7 @@ var Civet = (() => {
|
|
|
4236
4910
|
return LetOrConst$0(state);
|
|
4237
4911
|
}
|
|
4238
4912
|
}
|
|
4239
|
-
var Loop$0 = $TS($S($EXPECT($
|
|
4913
|
+
var Loop$0 = $TS($S($EXPECT($L109, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4240
4914
|
return { $loc, token: "while(true)" };
|
|
4241
4915
|
});
|
|
4242
4916
|
function Loop(state) {
|
|
@@ -4248,7 +4922,7 @@ var Civet = (() => {
|
|
|
4248
4922
|
return Loop$0(state);
|
|
4249
4923
|
}
|
|
4250
4924
|
}
|
|
4251
|
-
var New$0 = $TV($EXPECT($
|
|
4925
|
+
var New$0 = $TV($EXPECT($L110, fail, 'New "new"'), function($skip, $loc, $0, $1) {
|
|
4252
4926
|
return { $loc, token: $1 };
|
|
4253
4927
|
});
|
|
4254
4928
|
function New(state) {
|
|
@@ -4260,7 +4934,19 @@ var Civet = (() => {
|
|
|
4260
4934
|
return New$0(state);
|
|
4261
4935
|
}
|
|
4262
4936
|
}
|
|
4263
|
-
var
|
|
4937
|
+
var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L111, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L106, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
4938
|
+
return { $loc, token: "!" };
|
|
4939
|
+
});
|
|
4940
|
+
function Not(state) {
|
|
4941
|
+
if (state.verbose)
|
|
4942
|
+
console.log("ENTER:", "Not");
|
|
4943
|
+
if (state.tokenize) {
|
|
4944
|
+
return $TOKEN("Not", state, Not$0(state));
|
|
4945
|
+
} else {
|
|
4946
|
+
return Not$0(state);
|
|
4947
|
+
}
|
|
4948
|
+
}
|
|
4949
|
+
var Of$0 = $TV($EXPECT($L112, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
|
|
4264
4950
|
return { $loc, token: $1 };
|
|
4265
4951
|
});
|
|
4266
4952
|
function Of(state) {
|
|
@@ -4272,7 +4958,7 @@ var Civet = (() => {
|
|
|
4272
4958
|
return Of$0(state);
|
|
4273
4959
|
}
|
|
4274
4960
|
}
|
|
4275
|
-
var OpenBrace$0 = $TV($EXPECT($
|
|
4961
|
+
var OpenBrace$0 = $TV($EXPECT($L113, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
|
|
4276
4962
|
return { $loc, token: $1 };
|
|
4277
4963
|
});
|
|
4278
4964
|
function OpenBrace(state) {
|
|
@@ -4284,7 +4970,7 @@ var Civet = (() => {
|
|
|
4284
4970
|
return OpenBrace$0(state);
|
|
4285
4971
|
}
|
|
4286
4972
|
}
|
|
4287
|
-
var OpenBracket$0 = $TV($EXPECT($
|
|
4973
|
+
var OpenBracket$0 = $TV($EXPECT($L114, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
|
|
4288
4974
|
return { $loc, token: $1 };
|
|
4289
4975
|
});
|
|
4290
4976
|
function OpenBracket(state) {
|
|
@@ -4296,7 +4982,7 @@ var Civet = (() => {
|
|
|
4296
4982
|
return OpenBracket$0(state);
|
|
4297
4983
|
}
|
|
4298
4984
|
}
|
|
4299
|
-
var OpenParen$0 = $TV($EXPECT($
|
|
4985
|
+
var OpenParen$0 = $TV($EXPECT($L115, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
|
|
4300
4986
|
return { $loc, token: $1 };
|
|
4301
4987
|
});
|
|
4302
4988
|
function OpenParen(state) {
|
|
@@ -4308,7 +4994,7 @@ var Civet = (() => {
|
|
|
4308
4994
|
return OpenParen$0(state);
|
|
4309
4995
|
}
|
|
4310
4996
|
}
|
|
4311
|
-
var QuestionMark$0 = $TV($EXPECT($
|
|
4997
|
+
var QuestionMark$0 = $TV($EXPECT($L116, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
|
|
4312
4998
|
return { $loc, token: $1 };
|
|
4313
4999
|
});
|
|
4314
5000
|
function QuestionMark(state) {
|
|
@@ -4320,7 +5006,7 @@ var Civet = (() => {
|
|
|
4320
5006
|
return QuestionMark$0(state);
|
|
4321
5007
|
}
|
|
4322
5008
|
}
|
|
4323
|
-
var Return$0 = $TS($S($EXPECT($
|
|
5009
|
+
var Return$0 = $TS($S($EXPECT($L117, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4324
5010
|
return { $loc, token: $1 };
|
|
4325
5011
|
});
|
|
4326
5012
|
function Return(state) {
|
|
@@ -4332,7 +5018,7 @@ var Civet = (() => {
|
|
|
4332
5018
|
return Return$0(state);
|
|
4333
5019
|
}
|
|
4334
5020
|
}
|
|
4335
|
-
var Semicolon$0 = $TV($EXPECT($
|
|
5021
|
+
var Semicolon$0 = $TV($EXPECT($L73, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
|
|
4336
5022
|
return { $loc, token: $1 };
|
|
4337
5023
|
});
|
|
4338
5024
|
function Semicolon(state) {
|
|
@@ -4344,7 +5030,7 @@ var Civet = (() => {
|
|
|
4344
5030
|
return Semicolon$0(state);
|
|
4345
5031
|
}
|
|
4346
5032
|
}
|
|
4347
|
-
var SingleQuote$0 = $TV($EXPECT($
|
|
5033
|
+
var SingleQuote$0 = $TV($EXPECT($L118, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
|
|
4348
5034
|
return { $loc, token: $1 };
|
|
4349
5035
|
});
|
|
4350
5036
|
function SingleQuote(state) {
|
|
@@ -4356,7 +5042,7 @@ var Civet = (() => {
|
|
|
4356
5042
|
return SingleQuote$0(state);
|
|
4357
5043
|
}
|
|
4358
5044
|
}
|
|
4359
|
-
var Star$0 = $TV($EXPECT($
|
|
5045
|
+
var Star$0 = $TV($EXPECT($L46, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
|
|
4360
5046
|
return { $loc, token: $1 };
|
|
4361
5047
|
});
|
|
4362
5048
|
function Star(state) {
|
|
@@ -4368,10 +5054,10 @@ var Civet = (() => {
|
|
|
4368
5054
|
return Star$0(state);
|
|
4369
5055
|
}
|
|
4370
5056
|
}
|
|
4371
|
-
var Static$0 = $TV($EXPECT($
|
|
5057
|
+
var Static$0 = $TV($EXPECT($L119, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
|
|
4372
5058
|
return { $loc, token: $1 };
|
|
4373
5059
|
});
|
|
4374
|
-
var Static$1 = $TS($S($EXPECT($L8, fail, 'Static "@"'), $N($EXPECT($
|
|
5060
|
+
var Static$1 = $TS($S($EXPECT($L8, fail, 'Static "@"'), $N($EXPECT($L115, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
|
|
4375
5061
|
return { $loc, token: "static " };
|
|
4376
5062
|
});
|
|
4377
5063
|
function Static(state) {
|
|
@@ -4381,7 +5067,7 @@ var Civet = (() => {
|
|
|
4381
5067
|
return Static$0(state) || Static$1(state);
|
|
4382
5068
|
}
|
|
4383
5069
|
}
|
|
4384
|
-
var SubstitutionStart$0 = $TV($EXPECT($
|
|
5070
|
+
var SubstitutionStart$0 = $TV($EXPECT($L120, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
|
|
4385
5071
|
return { $loc, token: $1 };
|
|
4386
5072
|
});
|
|
4387
5073
|
function SubstitutionStart(state) {
|
|
@@ -4393,7 +5079,7 @@ var Civet = (() => {
|
|
|
4393
5079
|
return SubstitutionStart$0(state);
|
|
4394
5080
|
}
|
|
4395
5081
|
}
|
|
4396
|
-
var Switch$0 = $TS($S($EXPECT($
|
|
5082
|
+
var Switch$0 = $TS($S($EXPECT($L121, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4397
5083
|
return { $loc, token: $1 };
|
|
4398
5084
|
});
|
|
4399
5085
|
function Switch(state) {
|
|
@@ -4405,7 +5091,7 @@ var Civet = (() => {
|
|
|
4405
5091
|
return Switch$0(state);
|
|
4406
5092
|
}
|
|
4407
5093
|
}
|
|
4408
|
-
var Target$0 = $TV($EXPECT($
|
|
5094
|
+
var Target$0 = $TV($EXPECT($L122, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
|
|
4409
5095
|
return { $loc, token: $1 };
|
|
4410
5096
|
});
|
|
4411
5097
|
function Target(state) {
|
|
@@ -4417,7 +5103,19 @@ var Civet = (() => {
|
|
|
4417
5103
|
return Target$0(state);
|
|
4418
5104
|
}
|
|
4419
5105
|
}
|
|
4420
|
-
var
|
|
5106
|
+
var Then$0 = $TS($S(__, $EXPECT($L123, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
|
|
5107
|
+
return { $loc, token: "" };
|
|
5108
|
+
});
|
|
5109
|
+
function Then(state) {
|
|
5110
|
+
if (state.verbose)
|
|
5111
|
+
console.log("ENTER:", "Then");
|
|
5112
|
+
if (state.tokenize) {
|
|
5113
|
+
return $TOKEN("Then", state, Then$0(state));
|
|
5114
|
+
} else {
|
|
5115
|
+
return Then$0(state);
|
|
5116
|
+
}
|
|
5117
|
+
}
|
|
5118
|
+
var Throw$0 = $TS($S($EXPECT($L124, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4421
5119
|
return { $loc, token: $1 };
|
|
4422
5120
|
});
|
|
4423
5121
|
function Throw(state) {
|
|
@@ -4429,7 +5127,7 @@ var Civet = (() => {
|
|
|
4429
5127
|
return Throw$0(state);
|
|
4430
5128
|
}
|
|
4431
5129
|
}
|
|
4432
|
-
var TripleDoubleQuote$0 = $TV($EXPECT($
|
|
5130
|
+
var TripleDoubleQuote$0 = $TV($EXPECT($L125, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
|
|
4433
5131
|
return { $loc, token: "`" };
|
|
4434
5132
|
});
|
|
4435
5133
|
function TripleDoubleQuote(state) {
|
|
@@ -4441,7 +5139,7 @@ var Civet = (() => {
|
|
|
4441
5139
|
return TripleDoubleQuote$0(state);
|
|
4442
5140
|
}
|
|
4443
5141
|
}
|
|
4444
|
-
var TripleSingleQuote$0 = $TV($EXPECT($
|
|
5142
|
+
var TripleSingleQuote$0 = $TV($EXPECT($L126, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
|
|
4445
5143
|
return { $loc, token: "`" };
|
|
4446
5144
|
});
|
|
4447
5145
|
function TripleSingleQuote(state) {
|
|
@@ -4453,7 +5151,7 @@ var Civet = (() => {
|
|
|
4453
5151
|
return TripleSingleQuote$0(state);
|
|
4454
5152
|
}
|
|
4455
5153
|
}
|
|
4456
|
-
var TripleTick$0 = $TV($EXPECT($
|
|
5154
|
+
var TripleTick$0 = $TV($EXPECT($L127, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
|
|
4457
5155
|
return { $loc, token: "`" };
|
|
4458
5156
|
});
|
|
4459
5157
|
function TripleTick(state) {
|
|
@@ -4465,7 +5163,7 @@ var Civet = (() => {
|
|
|
4465
5163
|
return TripleTick$0(state);
|
|
4466
5164
|
}
|
|
4467
5165
|
}
|
|
4468
|
-
var Try$0 = $TV($EXPECT($
|
|
5166
|
+
var Try$0 = $TV($EXPECT($L128, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
|
|
4469
5167
|
return { $loc, token: $1 };
|
|
4470
5168
|
});
|
|
4471
5169
|
function Try(state) {
|
|
@@ -4477,7 +5175,7 @@ var Civet = (() => {
|
|
|
4477
5175
|
return Try$0(state);
|
|
4478
5176
|
}
|
|
4479
5177
|
}
|
|
4480
|
-
var Typeof$0 = $TS($S($EXPECT($
|
|
5178
|
+
var Typeof$0 = $TS($S($EXPECT($L129, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4481
5179
|
return { $loc, token: $1 };
|
|
4482
5180
|
});
|
|
4483
5181
|
function Typeof(state) {
|
|
@@ -4489,7 +5187,7 @@ var Civet = (() => {
|
|
|
4489
5187
|
return Typeof$0(state);
|
|
4490
5188
|
}
|
|
4491
5189
|
}
|
|
4492
|
-
var Unless$0 = $TV($EXPECT($
|
|
5190
|
+
var Unless$0 = $TV($EXPECT($L130, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
|
|
4493
5191
|
return { $loc, token: $1 };
|
|
4494
5192
|
});
|
|
4495
5193
|
function Unless(state) {
|
|
@@ -4501,7 +5199,7 @@ var Civet = (() => {
|
|
|
4501
5199
|
return Unless$0(state);
|
|
4502
5200
|
}
|
|
4503
5201
|
}
|
|
4504
|
-
var Until$0 = $TS($S($EXPECT($
|
|
5202
|
+
var Until$0 = $TS($S($EXPECT($L131, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4505
5203
|
return { $loc, token: $1 };
|
|
4506
5204
|
});
|
|
4507
5205
|
function Until(state) {
|
|
@@ -4513,7 +5211,7 @@ var Civet = (() => {
|
|
|
4513
5211
|
return Until$0(state);
|
|
4514
5212
|
}
|
|
4515
5213
|
}
|
|
4516
|
-
var Var$0 = $TV($EXPECT($
|
|
5214
|
+
var Var$0 = $TV($EXPECT($L132, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
|
|
4517
5215
|
return { $loc, token: $1 };
|
|
4518
5216
|
});
|
|
4519
5217
|
function Var(state) {
|
|
@@ -4525,7 +5223,7 @@ var Civet = (() => {
|
|
|
4525
5223
|
return Var$0(state);
|
|
4526
5224
|
}
|
|
4527
5225
|
}
|
|
4528
|
-
var Void$0 = $TS($S($EXPECT($
|
|
5226
|
+
var Void$0 = $TS($S($EXPECT($L133, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4529
5227
|
return { $loc, token: $1 };
|
|
4530
5228
|
});
|
|
4531
5229
|
function Void(state) {
|
|
@@ -4537,7 +5235,7 @@ var Civet = (() => {
|
|
|
4537
5235
|
return Void$0(state);
|
|
4538
5236
|
}
|
|
4539
5237
|
}
|
|
4540
|
-
var When$0 = $TS($S($EXPECT($
|
|
5238
|
+
var When$0 = $TS($S($EXPECT($L134, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4541
5239
|
return { $loc, token: "case" };
|
|
4542
5240
|
});
|
|
4543
5241
|
function When(state) {
|
|
@@ -4549,7 +5247,7 @@ var Civet = (() => {
|
|
|
4549
5247
|
return When$0(state);
|
|
4550
5248
|
}
|
|
4551
5249
|
}
|
|
4552
|
-
var While$0 = $TS($S($EXPECT($
|
|
5250
|
+
var While$0 = $TS($S($EXPECT($L135, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4553
5251
|
return { $loc, token: $1 };
|
|
4554
5252
|
});
|
|
4555
5253
|
function While(state) {
|
|
@@ -4561,7 +5259,7 @@ var Civet = (() => {
|
|
|
4561
5259
|
return While$0(state);
|
|
4562
5260
|
}
|
|
4563
5261
|
}
|
|
4564
|
-
var Yield$0 = $TS($S($EXPECT($
|
|
5262
|
+
var Yield$0 = $TS($S($EXPECT($L136, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
|
|
4565
5263
|
return { $loc, token: $1 };
|
|
4566
5264
|
});
|
|
4567
5265
|
function Yield(state) {
|
|
@@ -4587,7 +5285,7 @@ var Civet = (() => {
|
|
|
4587
5285
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
4588
5286
|
}
|
|
4589
5287
|
}
|
|
4590
|
-
var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
5288
|
+
var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L137, fail, 'JSXSelfClosingElement "/>"'));
|
|
4591
5289
|
function JSXSelfClosingElement(state) {
|
|
4592
5290
|
if (state.verbose)
|
|
4593
5291
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -4597,7 +5295,7 @@ var Civet = (() => {
|
|
|
4597
5295
|
return JSXSelfClosingElement$0(state);
|
|
4598
5296
|
}
|
|
4599
5297
|
}
|
|
4600
|
-
var JSXOpeningElement$0 = $S($EXPECT($L4, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($
|
|
5298
|
+
var JSXOpeningElement$0 = $S($EXPECT($L4, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L56, fail, 'JSXOpeningElement ">"'));
|
|
4601
5299
|
function JSXOpeningElement(state) {
|
|
4602
5300
|
if (state.verbose)
|
|
4603
5301
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -4607,7 +5305,7 @@ var Civet = (() => {
|
|
|
4607
5305
|
return JSXOpeningElement$0(state);
|
|
4608
5306
|
}
|
|
4609
5307
|
}
|
|
4610
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
5308
|
+
var JSXClosingElement$0 = $S($EXPECT($L138, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L56, fail, 'JSXClosingElement ">"'));
|
|
4611
5309
|
function JSXClosingElement(state) {
|
|
4612
5310
|
if (state.verbose)
|
|
4613
5311
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -4617,7 +5315,7 @@ var Civet = (() => {
|
|
|
4617
5315
|
return JSXClosingElement$0(state);
|
|
4618
5316
|
}
|
|
4619
5317
|
}
|
|
4620
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
5318
|
+
var JSXFragment$0 = $S($EXPECT($L139, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L140, fail, 'JSXFragment "</>"'));
|
|
4621
5319
|
function JSXFragment(state) {
|
|
4622
5320
|
if (state.verbose)
|
|
4623
5321
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -4637,7 +5335,7 @@ var Civet = (() => {
|
|
|
4637
5335
|
return JSXElementName$0(state);
|
|
4638
5336
|
}
|
|
4639
5337
|
}
|
|
4640
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
5338
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R34, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
4641
5339
|
function JSXIdentifierName(state) {
|
|
4642
5340
|
if (state.verbose)
|
|
4643
5341
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -4657,7 +5355,7 @@ var Civet = (() => {
|
|
|
4657
5355
|
return JSXAttributes$0(state);
|
|
4658
5356
|
}
|
|
4659
5357
|
}
|
|
4660
|
-
var JSXAttribute$0 = $S(OpenBrace, __, DotDotDot,
|
|
5358
|
+
var JSXAttribute$0 = $S(OpenBrace, __, DotDotDot, ExtendedExpression, __, CloseBrace);
|
|
4661
5359
|
var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
|
|
4662
5360
|
function JSXAttribute(state) {
|
|
4663
5361
|
if (state.tokenize) {
|
|
@@ -4686,9 +5384,9 @@ var Civet = (() => {
|
|
|
4686
5384
|
return JSXAttributeInitializer$0(state);
|
|
4687
5385
|
}
|
|
4688
5386
|
}
|
|
4689
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
4690
|
-
var JSXAttributeValue$1 = $R$0($EXPECT($
|
|
4691
|
-
var JSXAttributeValue$2 = $S(OpenBrace,
|
|
5387
|
+
var JSXAttributeValue$0 = $R$0($EXPECT($R35, fail, 'JSXAttributeValue /"[^"]*"/'));
|
|
5388
|
+
var JSXAttributeValue$1 = $R$0($EXPECT($R36, fail, "JSXAttributeValue /'[^']*'/"));
|
|
5389
|
+
var JSXAttributeValue$2 = $S(OpenBrace, ExtendedExpression, __, CloseBrace);
|
|
4692
5390
|
var JSXAttributeValue$3 = JSXElement;
|
|
4693
5391
|
var JSXAttributeValue$4 = JSXFragment;
|
|
4694
5392
|
function JSXAttributeValue(state) {
|
|
@@ -4719,7 +5417,7 @@ var Civet = (() => {
|
|
|
4719
5417
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
4720
5418
|
}
|
|
4721
5419
|
}
|
|
4722
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
5420
|
+
var JSXText$0 = $R$0($EXPECT($R37, fail, "JSXText /[^{}<>]+/"));
|
|
4723
5421
|
function JSXText(state) {
|
|
4724
5422
|
if (state.verbose)
|
|
4725
5423
|
console.log("ENTER:", "JSXText");
|
|
@@ -4729,7 +5427,7 @@ var Civet = (() => {
|
|
|
4729
5427
|
return JSXText$0(state);
|
|
4730
5428
|
}
|
|
4731
5429
|
}
|
|
4732
|
-
var JSXChildExpression$0 = $S(__, $E($S(DotDotDot, __)),
|
|
5430
|
+
var JSXChildExpression$0 = $S(__, $E($S(DotDotDot, __)), ExtendedExpression);
|
|
4733
5431
|
function JSXChildExpression(state) {
|
|
4734
5432
|
if (state.verbose)
|
|
4735
5433
|
console.log("ENTER:", "JSXChildExpression");
|
|
@@ -4751,7 +5449,7 @@ var Civet = (() => {
|
|
|
4751
5449
|
return TypeDeclaration$0(state);
|
|
4752
5450
|
}
|
|
4753
5451
|
}
|
|
4754
|
-
var TypeDeclarationModifier$0 = $S($EXPECT($
|
|
5452
|
+
var TypeDeclarationModifier$0 = $S($EXPECT($L141, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
|
|
4755
5453
|
var TypeDeclarationModifier$1 = Export;
|
|
4756
5454
|
function TypeDeclarationModifier(state) {
|
|
4757
5455
|
if (state.tokenize) {
|
|
@@ -4771,7 +5469,7 @@ var Civet = (() => {
|
|
|
4771
5469
|
return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state) || TypeDeclarationRest$3(state);
|
|
4772
5470
|
}
|
|
4773
5471
|
}
|
|
4774
|
-
var TypeKeyword$0 = $S($EXPECT($
|
|
5472
|
+
var TypeKeyword$0 = $S($EXPECT($L142, fail, 'TypeKeyword "type"'), NonIdContinue);
|
|
4775
5473
|
function TypeKeyword(state) {
|
|
4776
5474
|
if (state.verbose)
|
|
4777
5475
|
console.log("ENTER:", "TypeKeyword");
|
|
@@ -4781,7 +5479,7 @@ var Civet = (() => {
|
|
|
4781
5479
|
return TypeKeyword$0(state);
|
|
4782
5480
|
}
|
|
4783
5481
|
}
|
|
4784
|
-
var Interface$0 = $S($EXPECT($
|
|
5482
|
+
var Interface$0 = $S($EXPECT($L143, fail, 'Interface "interface"'), NonIdContinue);
|
|
4785
5483
|
function Interface(state) {
|
|
4786
5484
|
if (state.verbose)
|
|
4787
5485
|
console.log("ENTER:", "Interface");
|
|
@@ -4791,7 +5489,7 @@ var Civet = (() => {
|
|
|
4791
5489
|
return Interface$0(state);
|
|
4792
5490
|
}
|
|
4793
5491
|
}
|
|
4794
|
-
var Namespace$0 = $S($EXPECT($
|
|
5492
|
+
var Namespace$0 = $S($EXPECT($L144, fail, 'Namespace "namespace"'), NonIdContinue);
|
|
4795
5493
|
function Namespace(state) {
|
|
4796
5494
|
if (state.verbose)
|
|
4797
5495
|
console.log("ENTER:", "Namespace");
|
|
@@ -4891,7 +5589,7 @@ var Civet = (() => {
|
|
|
4891
5589
|
return NestedTypeDeclaration$0(state);
|
|
4892
5590
|
}
|
|
4893
5591
|
}
|
|
4894
|
-
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($
|
|
5592
|
+
var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R38, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L145, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R39, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
|
|
4895
5593
|
function TypeIndexSignature(state) {
|
|
4896
5594
|
if (state.verbose)
|
|
4897
5595
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -4922,7 +5620,7 @@ var Civet = (() => {
|
|
|
4922
5620
|
return TypeSuffix$0(state);
|
|
4923
5621
|
}
|
|
4924
5622
|
}
|
|
4925
|
-
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($
|
|
5623
|
+
var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L146, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
|
|
4926
5624
|
if (!$3)
|
|
4927
5625
|
$0.splice(2, 1);
|
|
4928
5626
|
if ($1.length === 0)
|
|
@@ -4942,7 +5640,7 @@ var Civet = (() => {
|
|
|
4942
5640
|
return ReturnTypeSuffix$0(state);
|
|
4943
5641
|
}
|
|
4944
5642
|
}
|
|
4945
|
-
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($
|
|
5643
|
+
var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L60, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
|
|
4946
5644
|
if (!$2)
|
|
4947
5645
|
return $1;
|
|
4948
5646
|
return $0;
|
|
@@ -5005,9 +5703,9 @@ var Civet = (() => {
|
|
|
5005
5703
|
return TypeUnarySuffix$0(state) || TypeUnarySuffix$1(state);
|
|
5006
5704
|
}
|
|
5007
5705
|
}
|
|
5008
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
5009
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
5010
|
-
var TypeUnaryOp$2 = $EXPECT($
|
|
5706
|
+
var TypeUnaryOp$0 = $EXPECT($L147, fail, 'TypeUnaryOp "keyof"');
|
|
5707
|
+
var TypeUnaryOp$1 = $EXPECT($L129, fail, 'TypeUnaryOp "typeof"');
|
|
5708
|
+
var TypeUnaryOp$2 = $EXPECT($L148, fail, 'TypeUnaryOp "infer"');
|
|
5011
5709
|
function TypeUnaryOp(state) {
|
|
5012
5710
|
if (state.tokenize) {
|
|
5013
5711
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -5097,10 +5795,10 @@ var Civet = (() => {
|
|
|
5097
5795
|
}
|
|
5098
5796
|
}
|
|
5099
5797
|
var TypeLiteral$0 = Literal;
|
|
5100
|
-
var TypeLiteral$1 = $TV($EXPECT($
|
|
5798
|
+
var TypeLiteral$1 = $TV($EXPECT($L133, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
|
|
5101
5799
|
return { $loc, token: "void" };
|
|
5102
5800
|
});
|
|
5103
|
-
var TypeLiteral$2 = $TV($EXPECT($
|
|
5801
|
+
var TypeLiteral$2 = $TV($EXPECT($L149, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
|
|
5104
5802
|
return { $loc, token: "[]" };
|
|
5105
5803
|
});
|
|
5106
5804
|
function TypeLiteral(state) {
|
|
@@ -5110,10 +5808,10 @@ var Civet = (() => {
|
|
|
5110
5808
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
5111
5809
|
}
|
|
5112
5810
|
}
|
|
5113
|
-
var TypeBinaryOp$0 = $TV($EXPECT($
|
|
5811
|
+
var TypeBinaryOp$0 = $TV($EXPECT($L72, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
|
|
5114
5812
|
return { $loc, token: "|" };
|
|
5115
5813
|
});
|
|
5116
|
-
var TypeBinaryOp$1 = $TV($EXPECT($
|
|
5814
|
+
var TypeBinaryOp$1 = $TV($EXPECT($L70, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
|
|
5117
5815
|
return { $loc, token: "&" };
|
|
5118
5816
|
});
|
|
5119
5817
|
function TypeBinaryOp(state) {
|
|
@@ -5133,7 +5831,7 @@ var Civet = (() => {
|
|
|
5133
5831
|
return FunctionType$0(state);
|
|
5134
5832
|
}
|
|
5135
5833
|
}
|
|
5136
|
-
var TypeArguments$0 = $S(__, $EXPECT($L4, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
5834
|
+
var TypeArguments$0 = $S(__, $EXPECT($L4, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L56, fail, 'TypeArguments ">"'));
|
|
5137
5835
|
function TypeArguments(state) {
|
|
5138
5836
|
if (state.verbose)
|
|
5139
5837
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -5143,7 +5841,7 @@ var Civet = (() => {
|
|
|
5143
5841
|
return TypeArguments$0(state);
|
|
5144
5842
|
}
|
|
5145
5843
|
}
|
|
5146
|
-
var TypeParameters$0 = $TS($S(__, $EXPECT($L4, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($
|
|
5844
|
+
var TypeParameters$0 = $TS($S(__, $EXPECT($L4, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L56, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
|
|
5147
5845
|
return { ts: true, children: $0 };
|
|
5148
5846
|
});
|
|
5149
5847
|
function TypeParameters(state) {
|
|
@@ -5176,8 +5874,8 @@ var Civet = (() => {
|
|
|
5176
5874
|
}
|
|
5177
5875
|
}
|
|
5178
5876
|
var TypeParameterDelimiter$0 = $S($Q(_), Comma);
|
|
5179
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
5180
|
-
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($
|
|
5877
|
+
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L56, fail, 'TypeParameterDelimiter ">"')));
|
|
5878
|
+
var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L56, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
|
|
5181
5879
|
return { $loc, token: "," };
|
|
5182
5880
|
});
|
|
5183
5881
|
var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
|
|
@@ -5190,7 +5888,7 @@ var Civet = (() => {
|
|
|
5190
5888
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
5191
5889
|
}
|
|
5192
5890
|
}
|
|
5193
|
-
var Shebang$0 = $S($R$0($EXPECT($
|
|
5891
|
+
var Shebang$0 = $S($R$0($EXPECT($R40, fail, "Shebang /#![^\\r\\n]*/")), EOL);
|
|
5194
5892
|
function Shebang(state) {
|
|
5195
5893
|
if (state.verbose)
|
|
5196
5894
|
console.log("ENTER:", "Shebang");
|
|
@@ -5200,11 +5898,11 @@ var Civet = (() => {
|
|
|
5200
5898
|
return Shebang$0(state);
|
|
5201
5899
|
}
|
|
5202
5900
|
}
|
|
5203
|
-
var CivetPrologue$0 = $T($S($EXPECT($
|
|
5901
|
+
var CivetPrologue$0 = $T($S($EXPECT($R41, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
5204
5902
|
var content = value[2];
|
|
5205
5903
|
return content;
|
|
5206
5904
|
});
|
|
5207
|
-
var CivetPrologue$1 = $T($S($EXPECT($
|
|
5905
|
+
var CivetPrologue$1 = $T($S($EXPECT($R41, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
|
|
5208
5906
|
var content = value[2];
|
|
5209
5907
|
return content;
|
|
5210
5908
|
});
|
|
@@ -5215,7 +5913,7 @@ var Civet = (() => {
|
|
|
5215
5913
|
return CivetPrologue$0(state) || CivetPrologue$1(state);
|
|
5216
5914
|
}
|
|
5217
5915
|
}
|
|
5218
|
-
var CivetPrologueContent$0 = $TS($S($EXPECT($
|
|
5916
|
+
var CivetPrologueContent$0 = $TS($S($EXPECT($L150, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R42, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
|
|
5219
5917
|
var options = $2;
|
|
5220
5918
|
return {
|
|
5221
5919
|
type: "CivetPrologue",
|
|
@@ -5232,7 +5930,7 @@ var Civet = (() => {
|
|
|
5232
5930
|
return CivetPrologueContent$0(state);
|
|
5233
5931
|
}
|
|
5234
5932
|
}
|
|
5235
|
-
var CivetOption$0 = $TR($EXPECT($
|
|
5933
|
+
var CivetOption$0 = $TR($EXPECT($R43, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
5236
5934
|
const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
|
|
5237
5935
|
if (l)
|
|
5238
5936
|
return l.toUpperCase();
|
|
@@ -5250,7 +5948,7 @@ var Civet = (() => {
|
|
|
5250
5948
|
return CivetOption$0(state);
|
|
5251
5949
|
}
|
|
5252
5950
|
}
|
|
5253
|
-
var UnknownPrologue$0 = $S($R$0($EXPECT($
|
|
5951
|
+
var UnknownPrologue$0 = $S($R$0($EXPECT($R41, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
|
|
5254
5952
|
function UnknownPrologue(state) {
|
|
5255
5953
|
if (state.verbose)
|
|
5256
5954
|
console.log("ENTER:", "UnknownPrologue");
|
|
@@ -5279,7 +5977,7 @@ var Civet = (() => {
|
|
|
5279
5977
|
return EOS$0(state);
|
|
5280
5978
|
}
|
|
5281
5979
|
}
|
|
5282
|
-
var EOL$0 = $TR($EXPECT($
|
|
5980
|
+
var EOL$0 = $TR($EXPECT($R44, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
5283
5981
|
return { $loc, token: $0 };
|
|
5284
5982
|
});
|
|
5285
5983
|
function EOL(state) {
|
|
@@ -5477,6 +6175,34 @@ var Civet = (() => {
|
|
|
5477
6175
|
return CoffeeInterpolationEnabled$0(state);
|
|
5478
6176
|
}
|
|
5479
6177
|
}
|
|
6178
|
+
var CoffeeIsntEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6179
|
+
if (module.config.coffeeIsnt)
|
|
6180
|
+
return;
|
|
6181
|
+
return $skip;
|
|
6182
|
+
});
|
|
6183
|
+
function CoffeeIsntEnabled(state) {
|
|
6184
|
+
if (state.verbose)
|
|
6185
|
+
console.log("ENTER:", "CoffeeIsntEnabled");
|
|
6186
|
+
if (state.tokenize) {
|
|
6187
|
+
return $TOKEN("CoffeeIsntEnabled", state, CoffeeIsntEnabled$0(state));
|
|
6188
|
+
} else {
|
|
6189
|
+
return CoffeeIsntEnabled$0(state);
|
|
6190
|
+
}
|
|
6191
|
+
}
|
|
6192
|
+
var CoffeeNotEnabled$0 = $TV($EXPECT($L0, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
|
|
6193
|
+
if (module.config.coffeeNot)
|
|
6194
|
+
return;
|
|
6195
|
+
return $skip;
|
|
6196
|
+
});
|
|
6197
|
+
function CoffeeNotEnabled(state) {
|
|
6198
|
+
if (state.verbose)
|
|
6199
|
+
console.log("ENTER:", "CoffeeNotEnabled");
|
|
6200
|
+
if (state.tokenize) {
|
|
6201
|
+
return $TOKEN("CoffeeNotEnabled", state, CoffeeNotEnabled$0(state));
|
|
6202
|
+
} else {
|
|
6203
|
+
return CoffeeNotEnabled$0(state);
|
|
6204
|
+
}
|
|
6205
|
+
}
|
|
5480
6206
|
var Reset$0 = $TV($EXPECT($L0, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
|
|
5481
6207
|
module.currentIndent = 0;
|
|
5482
6208
|
module.indentLevels = [0];
|
|
@@ -5487,6 +6213,8 @@ var Civet = (() => {
|
|
|
5487
6213
|
coffeeComment: false,
|
|
5488
6214
|
coffeeEq: false,
|
|
5489
6215
|
coffeeInterpolation: false,
|
|
6216
|
+
coffeeIsnt: false,
|
|
6217
|
+
coffeeNot: false,
|
|
5490
6218
|
implicitReturns: true
|
|
5491
6219
|
};
|
|
5492
6220
|
Object.defineProperty(module.config, "coffeeCompat", {
|
|
@@ -5497,14 +6225,16 @@ var Civet = (() => {
|
|
|
5497
6225
|
this.coffeeComment = true;
|
|
5498
6226
|
this.coffeeEq = true;
|
|
5499
6227
|
this.coffeeInterpolation = true;
|
|
5500
|
-
this.
|
|
6228
|
+
this.coffeeIsnt = true;
|
|
6229
|
+
this.coffeeNot = true;
|
|
5501
6230
|
} else {
|
|
5502
6231
|
this.autoVar = false;
|
|
5503
6232
|
this.coffeeBooleans = false;
|
|
5504
6233
|
this.coffeeComment = false;
|
|
5505
6234
|
this.coffeeEq = false;
|
|
5506
6235
|
this.coffeeInterpolation = false;
|
|
5507
|
-
this.
|
|
6236
|
+
this.coffeeIsnt = false;
|
|
6237
|
+
this.coffeeNot = false;
|
|
5508
6238
|
}
|
|
5509
6239
|
}
|
|
5510
6240
|
});
|
|
@@ -5536,7 +6266,7 @@ var Civet = (() => {
|
|
|
5536
6266
|
node.children.unshift("return ");
|
|
5537
6267
|
return;
|
|
5538
6268
|
case "Identifier":
|
|
5539
|
-
node.
|
|
6269
|
+
node.children.unshift("return ");
|
|
5540
6270
|
return;
|
|
5541
6271
|
case "BlockStatement":
|
|
5542
6272
|
insertReturn(node.expressions[node.expressions.length - 1]);
|
|
@@ -5569,10 +6299,11 @@ var Civet = (() => {
|
|
|
5569
6299
|
case "ContinueStatement":
|
|
5570
6300
|
case "DebuggerStatement":
|
|
5571
6301
|
case "EmptyStatement":
|
|
6302
|
+
case "ForStatement":
|
|
5572
6303
|
case "IterationStatement":
|
|
5573
6304
|
case "ReturnStatement":
|
|
5574
6305
|
case "ThrowStatement":
|
|
5575
|
-
case "
|
|
6306
|
+
case "Declaration":
|
|
5576
6307
|
return;
|
|
5577
6308
|
case "BlockStatement":
|
|
5578
6309
|
insertReturn(exp.expressions[exp.expressions.length - 1]);
|
|
@@ -5680,9 +6411,10 @@ var Civet = (() => {
|
|
|
5680
6411
|
};
|
|
5681
6412
|
module.insertTrimmingSpace = function(spacing, c) {
|
|
5682
6413
|
let target = spacing;
|
|
5683
|
-
|
|
5684
|
-
|
|
5685
|
-
|
|
6414
|
+
if (Array.isArray(target))
|
|
6415
|
+
return module.insertTrimmingSpace(target[0], c);
|
|
6416
|
+
if (target.children)
|
|
6417
|
+
return module.insertTrimmingSpace(target.children[0], c);
|
|
5686
6418
|
if (target.token) {
|
|
5687
6419
|
target.token = target.token.replace(/^ ?/, c);
|
|
5688
6420
|
}
|
|
@@ -5738,6 +6470,91 @@ var Civet = (() => {
|
|
|
5738
6470
|
token: str
|
|
5739
6471
|
};
|
|
5740
6472
|
};
|
|
6473
|
+
function gatherNodes(node, predicate) {
|
|
6474
|
+
if (node == null)
|
|
6475
|
+
return [];
|
|
6476
|
+
if (Array.isArray(node)) {
|
|
6477
|
+
return node.flatMap((n) => gatherNodes(n, predicate));
|
|
6478
|
+
}
|
|
6479
|
+
if (predicate(node)) {
|
|
6480
|
+
return [node];
|
|
6481
|
+
}
|
|
6482
|
+
switch (node.type) {
|
|
6483
|
+
case "BlockStatement":
|
|
6484
|
+
return [];
|
|
6485
|
+
case "ForStatement":
|
|
6486
|
+
if (node.declaration.type === "Declaration")
|
|
6487
|
+
return [];
|
|
6488
|
+
return gatherNodes(node.declaration, predicate);
|
|
6489
|
+
default:
|
|
6490
|
+
return gatherNodes(node.children, predicate);
|
|
6491
|
+
}
|
|
6492
|
+
return [];
|
|
6493
|
+
}
|
|
6494
|
+
module.processProgram = function(statements) {
|
|
6495
|
+
if (module.config.autoVar) {
|
|
6496
|
+
module.autoVar(statements, []);
|
|
6497
|
+
}
|
|
6498
|
+
};
|
|
6499
|
+
function findDecs(statements) {
|
|
6500
|
+
const declarationNames = gatherNodes(statements, (node) => {
|
|
6501
|
+
if (node.type === "Declaration") {
|
|
6502
|
+
return true;
|
|
6503
|
+
}
|
|
6504
|
+
}).flatMap((d) => d.names);
|
|
6505
|
+
return new Set(declarationNames);
|
|
6506
|
+
}
|
|
6507
|
+
module.autoVar = function(statements, scopes, pushVar) {
|
|
6508
|
+
function hasDec(name) {
|
|
6509
|
+
return scopes.some((s) => s.has(name));
|
|
6510
|
+
}
|
|
6511
|
+
function findAssignments(statements2, decs2) {
|
|
6512
|
+
const assignmentStatements = gatherNodes(statements2, (node) => {
|
|
6513
|
+
return node.type === "AssignmentExpression";
|
|
6514
|
+
});
|
|
6515
|
+
const undeclaredIdentifiers = assignmentStatements.flatMap((a) => {
|
|
6516
|
+
return a.children[0].flatMap((x) => {
|
|
6517
|
+
return x[1].names || [];
|
|
6518
|
+
});
|
|
6519
|
+
});
|
|
6520
|
+
return undeclaredIdentifiers.filter((x, i, a) => {
|
|
6521
|
+
if (!hasDec(x))
|
|
6522
|
+
return a.indexOf(x) === i;
|
|
6523
|
+
});
|
|
6524
|
+
}
|
|
6525
|
+
if (!pushVar) {
|
|
6526
|
+
pushVar = function(name) {
|
|
6527
|
+
varIds.push(name);
|
|
6528
|
+
decs.add(name);
|
|
6529
|
+
};
|
|
6530
|
+
}
|
|
6531
|
+
const decs = findDecs(statements);
|
|
6532
|
+
scopes.push(decs);
|
|
6533
|
+
const varIds = [];
|
|
6534
|
+
findAssignments(statements, scopes).forEach(pushVar);
|
|
6535
|
+
const fnNodes = gatherNodes(statements, (s) => s.type === "FunctionExpression");
|
|
6536
|
+
const forNodes = gatherNodes(statements, (s) => s.type === "ForStatement");
|
|
6537
|
+
const blockNodes = new Set(gatherNodes(statements, (s) => s.type === "BlockStatement"));
|
|
6538
|
+
fnNodes.forEach(({ block }) => blockNodes.delete(block));
|
|
6539
|
+
forNodes.forEach(({ block }) => blockNodes.delete(block));
|
|
6540
|
+
blockNodes.forEach((block) => {
|
|
6541
|
+
module.autoVar(block.expressions, scopes, pushVar);
|
|
6542
|
+
});
|
|
6543
|
+
forNodes.forEach(({ block, declaration }) => {
|
|
6544
|
+
scopes.push(new Set(declaration.names));
|
|
6545
|
+
module.autoVar(block.expressions, scopes, pushVar);
|
|
6546
|
+
scopes.pop();
|
|
6547
|
+
});
|
|
6548
|
+
fnNodes.forEach(({ block, parameters }) => {
|
|
6549
|
+
scopes.push(new Set(parameters.names));
|
|
6550
|
+
module.autoVar(block.expressions, scopes);
|
|
6551
|
+
scopes.pop();
|
|
6552
|
+
});
|
|
6553
|
+
if (varIds.length) {
|
|
6554
|
+
const indent = statements[0][0];
|
|
6555
|
+
statements.unshift([indent, "var ", varIds.join(", "), "\n"]);
|
|
6556
|
+
}
|
|
6557
|
+
};
|
|
5741
6558
|
return $0;
|
|
5742
6559
|
});
|
|
5743
6560
|
function Init(state) {
|
|
@@ -5749,7 +6566,7 @@ var Civet = (() => {
|
|
|
5749
6566
|
return Init$0(state);
|
|
5750
6567
|
}
|
|
5751
6568
|
}
|
|
5752
|
-
var Indent$0 = $TV($Q($C($EXPECT($
|
|
6569
|
+
var Indent$0 = $TV($Q($C($EXPECT($L151, fail, 'Indent " "'), $EXPECT($L152, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
|
|
5753
6570
|
const level = $1.length;
|
|
5754
6571
|
return {
|
|
5755
6572
|
$loc,
|