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