@danielx/civet 0.2.14 → 0.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +6 -5
- package/dist/browser.js +693 -323
- package/dist/browser.js.map +3 -3
- package/dist/civet +14 -13
- package/dist/cli.js.map +4 -4
- package/dist/main.js +698 -328
- package/dist/types.d.ts +24 -5
- package/package.json +8 -1
- package/register.mjs +41 -13
package/dist/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)
|
|
@@ -938,7 +953,9 @@ var require_parser = __commonJS({
|
|
|
938
953
|
}
|
|
939
954
|
}
|
|
940
955
|
var UnaryPostfix$0 = $EXPECT($L3, fail, 'UnaryPostfix "?"');
|
|
941
|
-
var UnaryPostfix$1 = $S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), NonIdContinue, Type)
|
|
956
|
+
var UnaryPostfix$1 = $T($S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), NonIdContinue, Type), function(value) {
|
|
957
|
+
return { "ts": true, "children": value };
|
|
958
|
+
});
|
|
942
959
|
function UnaryPostfix(state) {
|
|
943
960
|
if (state.tokenize) {
|
|
944
961
|
return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state));
|
|
@@ -946,8 +963,8 @@ var require_parser = __commonJS({
|
|
|
946
963
|
return UnaryPostfix$0(state) || UnaryPostfix$1(state);
|
|
947
964
|
}
|
|
948
965
|
}
|
|
949
|
-
var UpdateExpression$0 = $S(
|
|
950
|
-
var UpdateExpression$1 = $S(LeftHandSideExpression, $E(
|
|
966
|
+
var UpdateExpression$0 = $S(UpdateExpressionSymbol, UnaryExpression);
|
|
967
|
+
var UpdateExpression$1 = $S(LeftHandSideExpression, $E(UpdateExpressionSymbol));
|
|
951
968
|
function UpdateExpression(state) {
|
|
952
969
|
if (state.tokenize) {
|
|
953
970
|
return $TOKEN("UpdateExpression", state, UpdateExpression$0(state) || UpdateExpression$1(state));
|
|
@@ -955,6 +972,18 @@ var require_parser = __commonJS({
|
|
|
955
972
|
return UpdateExpression$0(state) || UpdateExpression$1(state);
|
|
956
973
|
}
|
|
957
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
|
+
}
|
|
958
987
|
var AssignmentExpression$0 = $S($Q(TrailingComment), AssignmentExpressionRest);
|
|
959
988
|
var AssignmentExpression$1 = $S(__, AssignmentExpressionRest);
|
|
960
989
|
function AssignmentExpression(state) {
|
|
@@ -1068,7 +1097,7 @@ var require_parser = __commonJS({
|
|
|
1068
1097
|
return ClassDeclaration$0(state);
|
|
1069
1098
|
}
|
|
1070
1099
|
}
|
|
1071
|
-
var ClassExpression$0 = $S(
|
|
1100
|
+
var ClassExpression$0 = $S(Class, $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
|
|
1072
1101
|
function ClassExpression(state) {
|
|
1073
1102
|
if (state.verbose)
|
|
1074
1103
|
console.log("ENTER:", "ClassExpression");
|
|
@@ -1078,6 +1107,18 @@ var require_parser = __commonJS({
|
|
|
1078
1107
|
return ClassExpression$0(state);
|
|
1079
1108
|
}
|
|
1080
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
|
+
}
|
|
1081
1122
|
var ClassHeritage$0 = $S(ExtendsToken, __, MemberExpression);
|
|
1082
1123
|
function ClassHeritage(state) {
|
|
1083
1124
|
if (state.verbose)
|
|
@@ -1088,10 +1129,12 @@ var require_parser = __commonJS({
|
|
|
1088
1129
|
return ClassHeritage$0(state);
|
|
1089
1130
|
}
|
|
1090
1131
|
}
|
|
1091
|
-
var ExtendsToken$0 = $
|
|
1092
|
-
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 };
|
|
1093
1137
|
});
|
|
1094
|
-
var ExtendsToken$1 = $EXPECT($L15, fail, 'ExtendsToken "extends"');
|
|
1095
1138
|
function ExtendsToken(state) {
|
|
1096
1139
|
if (state.tokenize) {
|
|
1097
1140
|
return $TOKEN("ExtendsToken", state, ExtendsToken$0(state) || ExtendsToken$1(state));
|
|
@@ -1133,8 +1176,8 @@ var require_parser = __commonJS({
|
|
|
1133
1176
|
return NestedClassElement$0(state);
|
|
1134
1177
|
}
|
|
1135
1178
|
}
|
|
1136
|
-
var ClassElement$0 = $S(
|
|
1137
|
-
var ClassElement$1 = $S($E($S(
|
|
1179
|
+
var ClassElement$0 = $S(Static, BracedBlock);
|
|
1180
|
+
var ClassElement$1 = $S($E($S(Static, __)), $C(MethodDefinition, FieldDefinition));
|
|
1138
1181
|
function ClassElement(state) {
|
|
1139
1182
|
if (state.tokenize) {
|
|
1140
1183
|
return $TOKEN("ClassElement", state, ClassElement$0(state) || ClassElement$1(state));
|
|
@@ -1142,6 +1185,18 @@ var require_parser = __commonJS({
|
|
|
1142
1185
|
return ClassElement$0(state) || ClassElement$1(state);
|
|
1143
1186
|
}
|
|
1144
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
|
+
}
|
|
1145
1200
|
var FieldDefinition$0 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
|
|
1146
1201
|
function FieldDefinition(state) {
|
|
1147
1202
|
if (state.verbose)
|
|
@@ -1152,12 +1207,11 @@ var require_parser = __commonJS({
|
|
|
1152
1207
|
return FieldDefinition$0(state);
|
|
1153
1208
|
}
|
|
1154
1209
|
}
|
|
1155
|
-
var This$0 = $EXPECT($L18, fail, 'This "this"')
|
|
1156
|
-
|
|
1157
|
-
var ref = value[1];
|
|
1158
|
-
return ["this.", ref];
|
|
1210
|
+
var This$0 = $TV($EXPECT($L18, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
1211
|
+
return { $loc, token: $0 };
|
|
1159
1212
|
});
|
|
1160
|
-
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) {
|
|
1161
1215
|
return { $loc, token: "this" };
|
|
1162
1216
|
});
|
|
1163
1217
|
function This(state) {
|
|
@@ -1167,6 +1221,18 @@ var require_parser = __commonJS({
|
|
|
1167
1221
|
return This$0(state) || This$1(state) || This$2(state);
|
|
1168
1222
|
}
|
|
1169
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
|
+
}
|
|
1170
1236
|
var LeftHandSideExpression$0 = NewExpression;
|
|
1171
1237
|
var LeftHandSideExpression$1 = CallExpression;
|
|
1172
1238
|
function LeftHandSideExpression(state) {
|
|
@@ -1438,11 +1504,17 @@ var require_parser = __commonJS({
|
|
|
1438
1504
|
return FunctionExpression$0(state) || FunctionExpression$1(state);
|
|
1439
1505
|
}
|
|
1440
1506
|
}
|
|
1441
|
-
var ThinArrowFunction$0 = $
|
|
1442
|
-
var params =
|
|
1443
|
-
var suffix =
|
|
1444
|
-
var
|
|
1445
|
-
|
|
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
|
+
];
|
|
1446
1518
|
});
|
|
1447
1519
|
function ThinArrowFunction(state) {
|
|
1448
1520
|
if (state.verbose)
|
|
@@ -1453,6 +1525,18 @@ var require_parser = __commonJS({
|
|
|
1453
1525
|
return ThinArrowFunction$0(state);
|
|
1454
1526
|
}
|
|
1455
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
|
+
}
|
|
1456
1540
|
var Block$0 = $S(__, $EXPECT($L11, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'Block "}"'));
|
|
1457
1541
|
var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1458
1542
|
var Block$2 = Statement;
|
|
@@ -1464,6 +1548,15 @@ var require_parser = __commonJS({
|
|
|
1464
1548
|
return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
|
|
1465
1549
|
}
|
|
1466
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
|
+
}
|
|
1467
1560
|
var BracedBlock$0 = $S(__, $EXPECT($L11, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BracedBlock "}"'));
|
|
1468
1561
|
var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1469
1562
|
var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
|
|
@@ -1529,17 +1622,39 @@ var require_parser = __commonJS({
|
|
|
1529
1622
|
return BlockExpression$0(state);
|
|
1530
1623
|
}
|
|
1531
1624
|
}
|
|
1532
|
-
var Literal$0 =
|
|
1533
|
-
var Literal$1 =
|
|
1534
|
-
var Literal$2 =
|
|
1535
|
-
var Literal$3 =
|
|
1536
|
-
var Literal$4 = $EXPECT($L37, fail, 'Literal "null"');
|
|
1537
|
-
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;
|
|
1538
1629
|
function Literal(state) {
|
|
1539
1630
|
if (state.tokenize) {
|
|
1540
|
-
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));
|
|
1541
1656
|
} else {
|
|
1542
|
-
return
|
|
1657
|
+
return BooleanLiteral$0(state);
|
|
1543
1658
|
}
|
|
1544
1659
|
}
|
|
1545
1660
|
var Comma$0 = $S($Q(_), $EXPECT($L0, fail, 'Comma ","'), $Q(_));
|
|
@@ -1759,8 +1874,8 @@ var require_parser = __commonJS({
|
|
|
1759
1874
|
return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
|
|
1760
1875
|
}
|
|
1761
1876
|
}
|
|
1762
|
-
var MethodDefinition$0 = $S($EXPECT($
|
|
1763
|
-
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);
|
|
1764
1879
|
var MethodDefinition$2 = AsyncGeneratorMethod;
|
|
1765
1880
|
var MethodDefinition$3 = AsyncMethod;
|
|
1766
1881
|
var MethodDefinition$4 = GeneratorMethod;
|
|
@@ -1781,7 +1896,7 @@ var require_parser = __commonJS({
|
|
|
1781
1896
|
return ClassElementName$0(state) || ClassElementName$1(state);
|
|
1782
1897
|
}
|
|
1783
1898
|
}
|
|
1784
|
-
var PrivateIdentifier$0 = $S($EXPECT($
|
|
1899
|
+
var PrivateIdentifier$0 = $S($EXPECT($L19, fail, 'PrivateIdentifier "#"'), IdentifierName);
|
|
1785
1900
|
function PrivateIdentifier(state) {
|
|
1786
1901
|
if (state.verbose)
|
|
1787
1902
|
console.log("ENTER:", "PrivateIdentifier");
|
|
@@ -1851,80 +1966,104 @@ var require_parser = __commonJS({
|
|
|
1851
1966
|
return AsyncGeneratorBody$0(state);
|
|
1852
1967
|
}
|
|
1853
1968
|
}
|
|
1854
|
-
var AssignmentOp$0 = $
|
|
1855
|
-
|
|
1856
|
-
|
|
1857
|
-
var AssignmentOp$3 = $EXPECT($L44, fail, 'AssignmentOp "%="');
|
|
1858
|
-
var AssignmentOp$4 = $EXPECT($L45, fail, 'AssignmentOp "+="');
|
|
1859
|
-
var AssignmentOp$5 = $EXPECT($L46, fail, 'AssignmentOp "-="');
|
|
1860
|
-
var AssignmentOp$6 = $EXPECT($L47, fail, 'AssignmentOp "<<="');
|
|
1861
|
-
var AssignmentOp$7 = $EXPECT($L48, fail, 'AssignmentOp ">>>="');
|
|
1862
|
-
var AssignmentOp$8 = $EXPECT($L49, fail, 'AssignmentOp ">>="');
|
|
1863
|
-
var AssignmentOp$9 = $EXPECT($L50, fail, 'AssignmentOp "&&="');
|
|
1864
|
-
var AssignmentOp$10 = $EXPECT($L51, fail, 'AssignmentOp "&="');
|
|
1865
|
-
var AssignmentOp$11 = $EXPECT($L52, fail, 'AssignmentOp "^="');
|
|
1866
|
-
var AssignmentOp$12 = $EXPECT($L53, fail, 'AssignmentOp "||="');
|
|
1867
|
-
var AssignmentOp$13 = $EXPECT($L54, fail, 'AssignmentOp "|="');
|
|
1868
|
-
var AssignmentOp$14 = $EXPECT($L55, fail, 'AssignmentOp "??="');
|
|
1869
|
-
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
|
+
});
|
|
1870
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) {
|
|
1998
|
+
if (state.tokenize) {
|
|
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");
|
|
1871
2010
|
if (state.tokenize) {
|
|
1872
|
-
return $TOKEN("
|
|
1873
|
-
} else {
|
|
1874
|
-
return
|
|
1875
|
-
}
|
|
1876
|
-
}
|
|
1877
|
-
var
|
|
1878
|
-
var
|
|
1879
|
-
var
|
|
1880
|
-
var
|
|
1881
|
-
var
|
|
1882
|
-
var
|
|
1883
|
-
var
|
|
1884
|
-
var
|
|
1885
|
-
var
|
|
1886
|
-
var
|
|
1887
|
-
var
|
|
1888
|
-
var
|
|
1889
|
-
var
|
|
1890
|
-
var
|
|
1891
|
-
var
|
|
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) {
|
|
1892
2031
|
if (global.coffeeCompat)
|
|
1893
2032
|
return "!==";
|
|
1894
2033
|
return $1;
|
|
1895
2034
|
});
|
|
1896
|
-
var
|
|
2035
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L69, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
1897
2036
|
return "===";
|
|
1898
2037
|
});
|
|
1899
|
-
var
|
|
1900
|
-
var
|
|
2038
|
+
var BinaryOpSymbol$16 = $EXPECT($L70, fail, 'BinaryOpSymbol "==="');
|
|
2039
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L71, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
1901
2040
|
if (global.coffeeCompat)
|
|
1902
2041
|
return "===";
|
|
1903
2042
|
return $1;
|
|
1904
2043
|
});
|
|
1905
|
-
var
|
|
2044
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L72, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
1906
2045
|
return "&&";
|
|
1907
2046
|
});
|
|
1908
|
-
var
|
|
1909
|
-
var
|
|
2047
|
+
var BinaryOpSymbol$19 = $EXPECT($L73, fail, 'BinaryOpSymbol "&&"');
|
|
2048
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
1910
2049
|
return "||";
|
|
1911
2050
|
});
|
|
1912
|
-
var
|
|
1913
|
-
var
|
|
1914
|
-
var
|
|
1915
|
-
var
|
|
1916
|
-
var
|
|
1917
|
-
var
|
|
1918
|
-
var
|
|
1919
|
-
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) {
|
|
1920
2059
|
if (state.tokenize) {
|
|
1921
|
-
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));
|
|
1922
2061
|
} else {
|
|
1923
|
-
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);
|
|
1924
2063
|
}
|
|
1925
2064
|
}
|
|
1926
2065
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
1927
|
-
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, __);
|
|
1928
2067
|
function UnaryOp(state) {
|
|
1929
2068
|
if (state.tokenize) {
|
|
1930
2069
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -1958,7 +2097,7 @@ var require_parser = __commonJS({
|
|
|
1958
2097
|
return StatementListItem$0(state);
|
|
1959
2098
|
}
|
|
1960
2099
|
}
|
|
1961
|
-
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) {
|
|
1962
2101
|
var ws = $1;
|
|
1963
2102
|
var cond = $2;
|
|
1964
2103
|
var exp = $4;
|
|
@@ -1991,7 +2130,7 @@ var require_parser = __commonJS({
|
|
|
1991
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);
|
|
1992
2131
|
}
|
|
1993
2132
|
}
|
|
1994
|
-
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($
|
|
2133
|
+
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L87, fail, 'EmptyStatement ";"')));
|
|
1995
2134
|
function EmptyStatement(state) {
|
|
1996
2135
|
if (state.verbose)
|
|
1997
2136
|
console.log("ENTER:", "EmptyStatement");
|
|
@@ -2011,8 +2150,8 @@ var require_parser = __commonJS({
|
|
|
2011
2150
|
return BlockStatement$0(state);
|
|
2012
2151
|
}
|
|
2013
2152
|
}
|
|
2014
|
-
var IfStatement$0 = $S($EXPECT($
|
|
2015
|
-
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) {
|
|
2016
2155
|
var condition = $2;
|
|
2017
2156
|
var block = $3;
|
|
2018
2157
|
return ["if", condition.map((c) => {
|
|
@@ -2042,7 +2181,7 @@ var require_parser = __commonJS({
|
|
|
2042
2181
|
return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
|
|
2043
2182
|
}
|
|
2044
2183
|
}
|
|
2045
|
-
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) {
|
|
2046
2185
|
var b = $3;
|
|
2047
2186
|
return ["while(true)", b];
|
|
2048
2187
|
});
|
|
@@ -2055,7 +2194,7 @@ var require_parser = __commonJS({
|
|
|
2055
2194
|
return LoopStatement$0(state);
|
|
2056
2195
|
}
|
|
2057
2196
|
}
|
|
2058
|
-
var DoWhileStatement$0 = $S($EXPECT($
|
|
2197
|
+
var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
|
|
2059
2198
|
function DoWhileStatement(state) {
|
|
2060
2199
|
if (state.verbose)
|
|
2061
2200
|
console.log("ENTER:", "DoWhileStatement");
|
|
@@ -2075,7 +2214,7 @@ var require_parser = __commonJS({
|
|
|
2075
2214
|
return WhileStatement$0(state);
|
|
2076
2215
|
}
|
|
2077
2216
|
}
|
|
2078
|
-
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) {
|
|
2079
2218
|
var kind = $1;
|
|
2080
2219
|
var cond = $3;
|
|
2081
2220
|
if (kind === "until") {
|
|
@@ -2094,7 +2233,7 @@ var require_parser = __commonJS({
|
|
|
2094
2233
|
return WhileClause$0(state);
|
|
2095
2234
|
}
|
|
2096
2235
|
}
|
|
2097
|
-
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);
|
|
2098
2237
|
function ForStatement(state) {
|
|
2099
2238
|
if (state.verbose)
|
|
2100
2239
|
console.log("ENTER:", "ForStatement");
|
|
@@ -2104,10 +2243,10 @@ var require_parser = __commonJS({
|
|
|
2104
2243
|
return ForStatement$0(state);
|
|
2105
2244
|
}
|
|
2106
2245
|
}
|
|
2107
|
-
var ForInOfStatement$0 = $S(
|
|
2108
|
-
var ForInOfStatement$1 = $S(
|
|
2109
|
-
var ForInOfStatement$2 = $S(
|
|
2110
|
-
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);
|
|
2111
2250
|
function ForInOfStatement(state) {
|
|
2112
2251
|
if (state.tokenize) {
|
|
2113
2252
|
return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
|
|
@@ -2115,7 +2254,19 @@ var require_parser = __commonJS({
|
|
|
2115
2254
|
return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
|
|
2116
2255
|
}
|
|
2117
2256
|
}
|
|
2118
|
-
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);
|
|
2119
2270
|
function ForDeclaration(state) {
|
|
2120
2271
|
if (state.verbose)
|
|
2121
2272
|
console.log("ENTER:", "ForDeclaration");
|
|
@@ -2125,6 +2276,18 @@ var require_parser = __commonJS({
|
|
|
2125
2276
|
return ForDeclaration$0(state);
|
|
2126
2277
|
}
|
|
2127
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
|
+
}
|
|
2128
2291
|
var ForBinding$0 = BindingIdentifier;
|
|
2129
2292
|
var ForBinding$1 = BindingPattern;
|
|
2130
2293
|
function ForBinding(state) {
|
|
@@ -2134,7 +2297,7 @@ var require_parser = __commonJS({
|
|
|
2134
2297
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
2135
2298
|
}
|
|
2136
2299
|
}
|
|
2137
|
-
var SwitchStatement$0 = $S($EXPECT($
|
|
2300
|
+
var SwitchStatement$0 = $S($EXPECT($L99, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
|
|
2138
2301
|
function SwitchStatement(state) {
|
|
2139
2302
|
if (state.verbose)
|
|
2140
2303
|
console.log("ENTER:", "SwitchStatement");
|
|
@@ -2178,9 +2341,9 @@ var require_parser = __commonJS({
|
|
|
2178
2341
|
return NestedCaseClause$0(state);
|
|
2179
2342
|
}
|
|
2180
2343
|
}
|
|
2181
|
-
var CaseClause$0 = $S($EXPECT($
|
|
2344
|
+
var CaseClause$0 = $S($EXPECT($L100, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
|
|
2182
2345
|
var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
|
|
2183
|
-
var CaseClause$2 = $S($EXPECT($
|
|
2346
|
+
var CaseClause$2 = $S($EXPECT($L101, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
|
|
2184
2347
|
function CaseClause(state) {
|
|
2185
2348
|
if (state.tokenize) {
|
|
2186
2349
|
return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
|
|
@@ -2188,7 +2351,7 @@ var require_parser = __commonJS({
|
|
|
2188
2351
|
return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
|
|
2189
2352
|
}
|
|
2190
2353
|
}
|
|
2191
|
-
var When$0 = $T($S($EXPECT($
|
|
2354
|
+
var When$0 = $T($S($EXPECT($L102, fail, 'When "when"'), NonIdContinue), function(value) {
|
|
2192
2355
|
return "case";
|
|
2193
2356
|
});
|
|
2194
2357
|
function When(state) {
|
|
@@ -2211,7 +2374,7 @@ var require_parser = __commonJS({
|
|
|
2211
2374
|
return ImpliedColon$0(state) || ImpliedColon$1(state);
|
|
2212
2375
|
}
|
|
2213
2376
|
}
|
|
2214
|
-
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) {
|
|
2215
2378
|
var c = $3;
|
|
2216
2379
|
var f = $4;
|
|
2217
2380
|
if (!c && !f) {
|
|
@@ -2228,7 +2391,7 @@ var require_parser = __commonJS({
|
|
|
2228
2391
|
return TryStatement$0(state);
|
|
2229
2392
|
}
|
|
2230
2393
|
}
|
|
2231
|
-
var Catch$0 = $S(__, $EXPECT($
|
|
2394
|
+
var Catch$0 = $S(__, $EXPECT($L104, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
|
|
2232
2395
|
function Catch(state) {
|
|
2233
2396
|
if (state.verbose)
|
|
2234
2397
|
console.log("ENTER:", "Catch");
|
|
@@ -2247,7 +2410,7 @@ var require_parser = __commonJS({
|
|
|
2247
2410
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2248
2411
|
}
|
|
2249
2412
|
}
|
|
2250
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2413
|
+
var Finally$0 = $S(__, $EXPECT($L105, fail, 'Finally "finally"'), BracedBlock);
|
|
2251
2414
|
function Finally(state) {
|
|
2252
2415
|
if (state.verbose)
|
|
2253
2416
|
console.log("ENTER:", "Finally");
|
|
@@ -2285,11 +2448,11 @@ var require_parser = __commonJS({
|
|
|
2285
2448
|
return ExpressionStatement$0(state);
|
|
2286
2449
|
}
|
|
2287
2450
|
}
|
|
2288
|
-
var KeywordStatement$0 = $S($EXPECT($
|
|
2289
|
-
var KeywordStatement$1 = $S($EXPECT($
|
|
2290
|
-
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);
|
|
2291
2454
|
var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
|
|
2292
|
-
var KeywordStatement$4 = $S($EXPECT($
|
|
2455
|
+
var KeywordStatement$4 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
|
|
2293
2456
|
function KeywordStatement(state) {
|
|
2294
2457
|
if (state.tokenize) {
|
|
2295
2458
|
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
|
|
@@ -2306,7 +2469,9 @@ var require_parser = __commonJS({
|
|
|
2306
2469
|
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2307
2470
|
}
|
|
2308
2471
|
}
|
|
2309
|
-
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
|
+
});
|
|
2310
2475
|
function Return(state) {
|
|
2311
2476
|
if (state.verbose)
|
|
2312
2477
|
console.log("ENTER:", "Return");
|
|
@@ -2316,11 +2481,11 @@ var require_parser = __commonJS({
|
|
|
2316
2481
|
return Return$0(state);
|
|
2317
2482
|
}
|
|
2318
2483
|
}
|
|
2319
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2484
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L111, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2320
2485
|
return { "ts": true, "children": value };
|
|
2321
2486
|
});
|
|
2322
|
-
var ImportDeclaration$1 = $S(
|
|
2323
|
-
var ImportDeclaration$2 = $S(
|
|
2487
|
+
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
2488
|
+
var ImportDeclaration$2 = $S(Import, __, ModuleSpecifier);
|
|
2324
2489
|
function ImportDeclaration(state) {
|
|
2325
2490
|
if (state.tokenize) {
|
|
2326
2491
|
return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
|
|
@@ -2328,6 +2493,18 @@ var require_parser = __commonJS({
|
|
|
2328
2493
|
return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state);
|
|
2329
2494
|
}
|
|
2330
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
|
+
}
|
|
2331
2508
|
var ImportClause$0 = $S(ImportedBinding, $E($S(__, $EXPECT($L0, fail, 'ImportClause ","'), __, $C(NameSpaceImport, NamedImports))));
|
|
2332
2509
|
var ImportClause$1 = NameSpaceImport;
|
|
2333
2510
|
var ImportClause$2 = NamedImports;
|
|
@@ -2358,7 +2535,7 @@ var require_parser = __commonJS({
|
|
|
2358
2535
|
return NamedImports$0(state);
|
|
2359
2536
|
}
|
|
2360
2537
|
}
|
|
2361
|
-
var FromClause$0 = $S(
|
|
2538
|
+
var FromClause$0 = $S(From, __, ModuleSpecifier);
|
|
2362
2539
|
function FromClause(state) {
|
|
2363
2540
|
if (state.verbose)
|
|
2364
2541
|
console.log("ENTER:", "FromClause");
|
|
@@ -2368,6 +2545,18 @@ var require_parser = __commonJS({
|
|
|
2368
2545
|
return FromClause$0(state);
|
|
2369
2546
|
}
|
|
2370
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
|
+
}
|
|
2371
2560
|
var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
|
|
2372
2561
|
var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
|
|
2373
2562
|
function ImportSpecifier(state) {
|
|
@@ -2406,7 +2595,7 @@ var require_parser = __commonJS({
|
|
|
2406
2595
|
return ImportedBinding$0(state);
|
|
2407
2596
|
}
|
|
2408
2597
|
}
|
|
2409
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
2598
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L101, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2410
2599
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
2411
2600
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
2412
2601
|
function ExportDeclaration(state) {
|
|
@@ -2426,7 +2615,7 @@ var require_parser = __commonJS({
|
|
|
2426
2615
|
return As$0(state);
|
|
2427
2616
|
}
|
|
2428
2617
|
}
|
|
2429
|
-
var Export$0 = $S($EXPECT($
|
|
2618
|
+
var Export$0 = $S($EXPECT($L113, fail, 'Export "export"'), NonIdContinue);
|
|
2430
2619
|
function Export(state) {
|
|
2431
2620
|
if (state.verbose)
|
|
2432
2621
|
console.log("ENTER:", "Export");
|
|
@@ -2486,7 +2675,7 @@ var require_parser = __commonJS({
|
|
|
2486
2675
|
return HoistableDeclaration$0(state);
|
|
2487
2676
|
}
|
|
2488
2677
|
}
|
|
2489
|
-
var LexicalDeclaration$0 = $S(
|
|
2678
|
+
var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
|
|
2490
2679
|
var LexicalDeclaration$1 = $TS($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
2491
2680
|
var bind = $1;
|
|
2492
2681
|
var suffix = $2;
|
|
@@ -2510,7 +2699,7 @@ var require_parser = __commonJS({
|
|
|
2510
2699
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
2511
2700
|
}
|
|
2512
2701
|
}
|
|
2513
|
-
var ConstAssignment$0 = $TV($EXPECT($
|
|
2702
|
+
var ConstAssignment$0 = $TV($EXPECT($L114, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
2514
2703
|
return { $loc, token: $0 };
|
|
2515
2704
|
});
|
|
2516
2705
|
function ConstAssignment(state) {
|
|
@@ -2531,7 +2720,7 @@ var require_parser = __commonJS({
|
|
|
2531
2720
|
return LexicalBinding$0(state) || LexicalBinding$1(state);
|
|
2532
2721
|
}
|
|
2533
2722
|
}
|
|
2534
|
-
var Initializer$0 = $S(__, $EXPECT($
|
|
2723
|
+
var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
|
|
2535
2724
|
function Initializer(state) {
|
|
2536
2725
|
if (state.verbose)
|
|
2537
2726
|
console.log("ENTER:", "Initializer");
|
|
@@ -2541,7 +2730,7 @@ var require_parser = __commonJS({
|
|
|
2541
2730
|
return Initializer$0(state);
|
|
2542
2731
|
}
|
|
2543
2732
|
}
|
|
2544
|
-
var VariableStatement$0 = $S($EXPECT($
|
|
2733
|
+
var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
|
|
2545
2734
|
function VariableStatement(state) {
|
|
2546
2735
|
if (state.verbose)
|
|
2547
2736
|
console.log("ENTER:", "VariableStatement");
|
|
@@ -2570,16 +2759,28 @@ var require_parser = __commonJS({
|
|
|
2570
2759
|
return VariableDeclaration$0(state) || VariableDeclaration$1(state);
|
|
2571
2760
|
}
|
|
2572
2761
|
}
|
|
2573
|
-
var NumericLiteral$0 =
|
|
2574
|
-
|
|
2575
|
-
|
|
2576
|
-
var NumericLiteral$3 = HexLiteral;
|
|
2577
|
-
var NumericLiteral$4 = DecimalLiteral;
|
|
2762
|
+
var NumericLiteral$0 = $TS($S(NumericLiteralKind), function($skip, $loc, $0, $1) {
|
|
2763
|
+
return { $loc, token: $1 };
|
|
2764
|
+
});
|
|
2578
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) {
|
|
2579
2780
|
if (state.tokenize) {
|
|
2580
|
-
return $TOKEN("
|
|
2781
|
+
return $TOKEN("NumericLiteralKind", state, NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state));
|
|
2581
2782
|
} else {
|
|
2582
|
-
return
|
|
2783
|
+
return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
|
|
2583
2784
|
}
|
|
2584
2785
|
}
|
|
2585
2786
|
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R3, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
@@ -2632,34 +2833,45 @@ var require_parser = __commonJS({
|
|
|
2632
2833
|
return HexLiteral$0(state);
|
|
2633
2834
|
}
|
|
2634
2835
|
}
|
|
2635
|
-
var StringLiteral$0 = $
|
|
2636
|
-
|
|
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 };
|
|
2637
2849
|
});
|
|
2638
|
-
var StringLiteral$1 = $S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'));
|
|
2639
|
-
var StringLiteral$2 = $S($EXPECT($L118, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L118, fail, `StringLiteral "\\\\'"`));
|
|
2640
2850
|
function StringLiteral(state) {
|
|
2641
2851
|
if (state.tokenize) {
|
|
2642
|
-
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));
|
|
2643
2853
|
} else {
|
|
2644
|
-
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
|
|
2854
|
+
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
|
|
2645
2855
|
}
|
|
2646
2856
|
}
|
|
2647
|
-
var DoubleStringCharacter$0 = $R$0($EXPECT($R8, fail, 'DoubleStringCharacter /[^"
|
|
2648
|
-
var DoubleStringCharacter$1 = EscapeSequence;
|
|
2857
|
+
var DoubleStringCharacter$0 = $R$0($EXPECT($R8, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
|
|
2649
2858
|
function DoubleStringCharacter(state) {
|
|
2859
|
+
if (state.verbose)
|
|
2860
|
+
console.log("ENTER:", "DoubleStringCharacter");
|
|
2650
2861
|
if (state.tokenize) {
|
|
2651
|
-
return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state)
|
|
2862
|
+
return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state));
|
|
2652
2863
|
} else {
|
|
2653
|
-
return DoubleStringCharacter$0(state)
|
|
2864
|
+
return DoubleStringCharacter$0(state);
|
|
2654
2865
|
}
|
|
2655
2866
|
}
|
|
2656
|
-
var SingleStringCharacter$0 = $R$0($EXPECT($R9, fail, "SingleStringCharacter /[^'
|
|
2657
|
-
var SingleStringCharacter$1 = EscapeSequence;
|
|
2867
|
+
var SingleStringCharacter$0 = $R$0($EXPECT($R9, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
|
|
2658
2868
|
function SingleStringCharacter(state) {
|
|
2869
|
+
if (state.verbose)
|
|
2870
|
+
console.log("ENTER:", "SingleStringCharacter");
|
|
2659
2871
|
if (state.tokenize) {
|
|
2660
|
-
return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state)
|
|
2872
|
+
return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state));
|
|
2661
2873
|
} else {
|
|
2662
|
-
return SingleStringCharacter$0(state)
|
|
2874
|
+
return SingleStringCharacter$0(state);
|
|
2663
2875
|
}
|
|
2664
2876
|
}
|
|
2665
2877
|
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
|
|
@@ -2672,17 +2884,19 @@ var require_parser = __commonJS({
|
|
|
2672
2884
|
return TripleDoubleStringCharacter$0(state);
|
|
2673
2885
|
}
|
|
2674
2886
|
}
|
|
2675
|
-
var
|
|
2676
|
-
function
|
|
2887
|
+
var TripleSingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "TripleSingleStringCharacter /(?:'(?!'')|\\\\.|[^'])+/"));
|
|
2888
|
+
function TripleSingleStringCharacter(state) {
|
|
2677
2889
|
if (state.verbose)
|
|
2678
|
-
console.log("ENTER:", "
|
|
2890
|
+
console.log("ENTER:", "TripleSingleStringCharacter");
|
|
2679
2891
|
if (state.tokenize) {
|
|
2680
|
-
return $TOKEN("
|
|
2892
|
+
return $TOKEN("TripleSingleStringCharacter", state, TripleSingleStringCharacter$0(state));
|
|
2681
2893
|
} else {
|
|
2682
|
-
return
|
|
2894
|
+
return TripleSingleStringCharacter$0(state);
|
|
2683
2895
|
}
|
|
2684
2896
|
}
|
|
2685
|
-
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
|
+
});
|
|
2686
2900
|
function RegularExpressionLiteral(state) {
|
|
2687
2901
|
if (state.verbose)
|
|
2688
2902
|
console.log("ENTER:", "RegularExpressionLiteral");
|
|
@@ -2702,16 +2916,17 @@ var require_parser = __commonJS({
|
|
|
2702
2916
|
return RegularExpressionBody$0(state);
|
|
2703
2917
|
}
|
|
2704
2918
|
}
|
|
2705
|
-
var RegExpCharacter$0 = $R$0($EXPECT($R13, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
|
|
2706
|
-
var RegExpCharacter$1 = EscapeSequence;
|
|
2919
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R13, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
2707
2920
|
function RegExpCharacter(state) {
|
|
2921
|
+
if (state.verbose)
|
|
2922
|
+
console.log("ENTER:", "RegExpCharacter");
|
|
2708
2923
|
if (state.tokenize) {
|
|
2709
|
-
return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state)
|
|
2924
|
+
return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state));
|
|
2710
2925
|
} else {
|
|
2711
|
-
return RegExpCharacter$0(state)
|
|
2926
|
+
return RegExpCharacter$0(state);
|
|
2712
2927
|
}
|
|
2713
2928
|
}
|
|
2714
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($R14, fail, "RegularExpressionFlags /(
|
|
2929
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R14, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
2715
2930
|
function RegularExpressionFlags(state) {
|
|
2716
2931
|
if (state.verbose)
|
|
2717
2932
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -2721,7 +2936,7 @@ var require_parser = __commonJS({
|
|
|
2721
2936
|
return RegularExpressionFlags$0(state);
|
|
2722
2937
|
}
|
|
2723
2938
|
}
|
|
2724
|
-
var TemplateLiteral$0 = $S($EXPECT($
|
|
2939
|
+
var TemplateLiteral$0 = $S($EXPECT($L119, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L119, fail, 'TemplateLiteral "`"'));
|
|
2725
2940
|
function TemplateLiteral(state) {
|
|
2726
2941
|
if (state.verbose)
|
|
2727
2942
|
console.log("ENTER:", "TemplateLiteral");
|
|
@@ -2731,7 +2946,7 @@ var require_parser = __commonJS({
|
|
|
2731
2946
|
return TemplateLiteral$0(state);
|
|
2732
2947
|
}
|
|
2733
2948
|
}
|
|
2734
|
-
var TemplateSubstitution$0 = $S($EXPECT($
|
|
2949
|
+
var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
|
|
2735
2950
|
function TemplateSubstitution(state) {
|
|
2736
2951
|
if (state.verbose)
|
|
2737
2952
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -2788,7 +3003,7 @@ var require_parser = __commonJS({
|
|
|
2788
3003
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
2789
3004
|
}
|
|
2790
3005
|
}
|
|
2791
|
-
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 "*/"'));
|
|
2792
3007
|
function JSMultiLineComment(state) {
|
|
2793
3008
|
if (state.verbose)
|
|
2794
3009
|
console.log("ENTER:", "JSMultiLineComment");
|
|
@@ -2798,7 +3013,7 @@ var require_parser = __commonJS({
|
|
|
2798
3013
|
return JSMultiLineComment$0(state);
|
|
2799
3014
|
}
|
|
2800
3015
|
}
|
|
2801
|
-
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) {
|
|
2802
3017
|
if (!global.coffeeCompat)
|
|
2803
3018
|
return $skip;
|
|
2804
3019
|
return ["//", $1];
|
|
@@ -2812,7 +3027,7 @@ var require_parser = __commonJS({
|
|
|
2812
3027
|
return CoffeeSingleLineComment$0(state);
|
|
2813
3028
|
}
|
|
2814
3029
|
}
|
|
2815
|
-
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) {
|
|
2816
3031
|
return ["/*", value[1], "*/"];
|
|
2817
3032
|
});
|
|
2818
3033
|
function CoffeeMultiLineComment(state) {
|
|
@@ -2824,7 +3039,7 @@ var require_parser = __commonJS({
|
|
|
2824
3039
|
return CoffeeMultiLineComment$0(state);
|
|
2825
3040
|
}
|
|
2826
3041
|
}
|
|
2827
|
-
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 "*/"'));
|
|
2828
3043
|
function InlineComment(state) {
|
|
2829
3044
|
if (state.verbose)
|
|
2830
3045
|
console.log("ENTER:", "InlineComment");
|
|
@@ -2844,7 +3059,7 @@ var require_parser = __commonJS({
|
|
|
2844
3059
|
return RestOfLine$0(state);
|
|
2845
3060
|
}
|
|
2846
3061
|
}
|
|
2847
|
-
var TrailingComment$0 = $R$0($EXPECT($
|
|
3062
|
+
var TrailingComment$0 = $R$0($EXPECT($R21, fail, "TrailingComment /[\\t ]+/"));
|
|
2848
3063
|
var TrailingComment$1 = InlineComment;
|
|
2849
3064
|
var TrailingComment$2 = SingleLineComment;
|
|
2850
3065
|
function TrailingComment(state) {
|
|
@@ -2854,7 +3069,7 @@ var require_parser = __commonJS({
|
|
|
2854
3069
|
return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
|
|
2855
3070
|
}
|
|
2856
3071
|
}
|
|
2857
|
-
var _$0 = $P($C($R$0($EXPECT($
|
|
3072
|
+
var _$0 = $P($C($R$0($EXPECT($R21, fail, "_ /[\\t ]+/")), Comment));
|
|
2858
3073
|
function _(state) {
|
|
2859
3074
|
if (state.verbose)
|
|
2860
3075
|
console.log("ENTER:", "_");
|
|
@@ -2864,7 +3079,7 @@ var require_parser = __commonJS({
|
|
|
2864
3079
|
return _$0(state);
|
|
2865
3080
|
}
|
|
2866
3081
|
}
|
|
2867
|
-
var __$0 = $Q($C($R$0($EXPECT($
|
|
3082
|
+
var __$0 = $Q($C($R$0($EXPECT($R22, fail, "__ /[\\s]+/")), Comment));
|
|
2868
3083
|
function __(state) {
|
|
2869
3084
|
if (state.verbose)
|
|
2870
3085
|
console.log("ENTER:", "__");
|
|
@@ -2874,7 +3089,7 @@ var require_parser = __commonJS({
|
|
|
2874
3089
|
return __$0(state);
|
|
2875
3090
|
}
|
|
2876
3091
|
}
|
|
2877
|
-
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($
|
|
3092
|
+
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L87, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
|
|
2878
3093
|
var StatementDelimiter$1 = $T($Y(EOS), function(value) {
|
|
2879
3094
|
return [";", value];
|
|
2880
3095
|
});
|
|
@@ -2885,7 +3100,7 @@ var require_parser = __commonJS({
|
|
|
2885
3100
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
2886
3101
|
}
|
|
2887
3102
|
}
|
|
2888
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3103
|
+
var NonIdContinue$0 = $R$0($EXPECT($R23, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
2889
3104
|
function NonIdContinue(state) {
|
|
2890
3105
|
if (state.verbose)
|
|
2891
3106
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -2909,7 +3124,7 @@ var require_parser = __commonJS({
|
|
|
2909
3124
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
2910
3125
|
}
|
|
2911
3126
|
}
|
|
2912
|
-
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 "/>"'));
|
|
2913
3128
|
function JSXSelfClosingElement(state) {
|
|
2914
3129
|
if (state.verbose)
|
|
2915
3130
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -2919,7 +3134,7 @@ var require_parser = __commonJS({
|
|
|
2919
3134
|
return JSXSelfClosingElement$0(state);
|
|
2920
3135
|
}
|
|
2921
3136
|
}
|
|
2922
|
-
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 ">"'));
|
|
2923
3138
|
function JSXOpeningElement(state) {
|
|
2924
3139
|
if (state.verbose)
|
|
2925
3140
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -2929,7 +3144,7 @@ var require_parser = __commonJS({
|
|
|
2929
3144
|
return JSXOpeningElement$0(state);
|
|
2930
3145
|
}
|
|
2931
3146
|
}
|
|
2932
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
3147
|
+
var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
|
|
2933
3148
|
function JSXClosingElement(state) {
|
|
2934
3149
|
if (state.verbose)
|
|
2935
3150
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -2939,7 +3154,7 @@ var require_parser = __commonJS({
|
|
|
2939
3154
|
return JSXClosingElement$0(state);
|
|
2940
3155
|
}
|
|
2941
3156
|
}
|
|
2942
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
3157
|
+
var JSXFragment$0 = $S($EXPECT($L126, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L127, fail, 'JSXFragment "</>"'));
|
|
2943
3158
|
function JSXFragment(state) {
|
|
2944
3159
|
if (state.verbose)
|
|
2945
3160
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -2959,7 +3174,7 @@ var require_parser = __commonJS({
|
|
|
2959
3174
|
return JSXElementName$0(state);
|
|
2960
3175
|
}
|
|
2961
3176
|
}
|
|
2962
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
3177
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R24, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
2963
3178
|
function JSXIdentifierName(state) {
|
|
2964
3179
|
if (state.verbose)
|
|
2965
3180
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -2998,7 +3213,7 @@ var require_parser = __commonJS({
|
|
|
2998
3213
|
return JSXAttributeName$0(state);
|
|
2999
3214
|
}
|
|
3000
3215
|
}
|
|
3001
|
-
var JSXAttributeInitializer$0 = $S(__, $EXPECT($
|
|
3216
|
+
var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
|
|
3002
3217
|
function JSXAttributeInitializer(state) {
|
|
3003
3218
|
if (state.verbose)
|
|
3004
3219
|
console.log("ENTER:", "JSXAttributeInitializer");
|
|
@@ -3008,8 +3223,8 @@ var require_parser = __commonJS({
|
|
|
3008
3223
|
return JSXAttributeInitializer$0(state);
|
|
3009
3224
|
}
|
|
3010
3225
|
}
|
|
3011
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
3012
|
-
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 /'[^']*'/"));
|
|
3013
3228
|
var JSXAttributeValue$2 = $S($EXPECT($L11, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttributeValue "}"'));
|
|
3014
3229
|
var JSXAttributeValue$3 = JSXElement;
|
|
3015
3230
|
var JSXAttributeValue$4 = JSXFragment;
|
|
@@ -3041,7 +3256,7 @@ var require_parser = __commonJS({
|
|
|
3041
3256
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
3042
3257
|
}
|
|
3043
3258
|
}
|
|
3044
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
3259
|
+
var JSXText$0 = $R$0($EXPECT($R27, fail, "JSXText /[^{}<>]+/"));
|
|
3045
3260
|
function JSXText(state) {
|
|
3046
3261
|
if (state.verbose)
|
|
3047
3262
|
console.log("ENTER:", "JSXText");
|
|
@@ -3061,10 +3276,10 @@ var require_parser = __commonJS({
|
|
|
3061
3276
|
return JSXChildExpression$0(state);
|
|
3062
3277
|
}
|
|
3063
3278
|
}
|
|
3064
|
-
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) {
|
|
3065
3280
|
return { "ts": true, "children": value };
|
|
3066
3281
|
});
|
|
3067
|
-
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) {
|
|
3068
3283
|
return { "ts": true, "children": value };
|
|
3069
3284
|
});
|
|
3070
3285
|
function TypeDeclaration(state) {
|
|
@@ -3119,7 +3334,7 @@ var require_parser = __commonJS({
|
|
|
3119
3334
|
return InterfaceProperty$0(state);
|
|
3120
3335
|
}
|
|
3121
3336
|
}
|
|
3122
|
-
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($
|
|
3337
|
+
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L87, fail, 'InterfacePropertyDelimiter ";"'));
|
|
3123
3338
|
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
|
|
3124
3339
|
var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
|
|
3125
3340
|
return ";";
|
|
@@ -3134,7 +3349,7 @@ var require_parser = __commonJS({
|
|
|
3134
3349
|
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
|
|
3135
3350
|
}
|
|
3136
3351
|
}
|
|
3137
|
-
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 "?"'))));
|
|
3138
3353
|
function TypeIndexSignature(state) {
|
|
3139
3354
|
if (state.verbose)
|
|
3140
3355
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -3145,7 +3360,7 @@ var require_parser = __commonJS({
|
|
|
3145
3360
|
}
|
|
3146
3361
|
}
|
|
3147
3362
|
var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
|
|
3148
|
-
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)));
|
|
3149
3364
|
function TypeIndex(state) {
|
|
3150
3365
|
if (state.tokenize) {
|
|
3151
3366
|
return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
|
|
@@ -3165,7 +3380,7 @@ var require_parser = __commonJS({
|
|
|
3165
3380
|
return TypeSuffix$0(state);
|
|
3166
3381
|
}
|
|
3167
3382
|
}
|
|
3168
|
-
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) {
|
|
3169
3384
|
return { "ts": true, "children": value };
|
|
3170
3385
|
});
|
|
3171
3386
|
function ReturnTypeSuffix(state) {
|
|
@@ -3177,7 +3392,7 @@ var require_parser = __commonJS({
|
|
|
3177
3392
|
return ReturnTypeSuffix$0(state);
|
|
3178
3393
|
}
|
|
3179
3394
|
}
|
|
3180
|
-
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($
|
|
3395
|
+
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
|
|
3181
3396
|
function TypePredicate(state) {
|
|
3182
3397
|
if (state.verbose)
|
|
3183
3398
|
console.log("ENTER:", "TypePredicate");
|
|
@@ -3227,9 +3442,9 @@ var require_parser = __commonJS({
|
|
|
3227
3442
|
return TypeUnarySuffix$0(state);
|
|
3228
3443
|
}
|
|
3229
3444
|
}
|
|
3230
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
3231
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
3232
|
-
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"');
|
|
3233
3448
|
function TypeUnaryOp(state) {
|
|
3234
3449
|
if (state.tokenize) {
|
|
3235
3450
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -3270,8 +3485,8 @@ var require_parser = __commonJS({
|
|
|
3270
3485
|
}
|
|
3271
3486
|
}
|
|
3272
3487
|
var TypeLiteral$0 = Literal;
|
|
3273
|
-
var TypeLiteral$1 = $EXPECT($
|
|
3274
|
-
var TypeLiteral$2 = $EXPECT($
|
|
3488
|
+
var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
|
|
3489
|
+
var TypeLiteral$2 = $EXPECT($L132, fail, 'TypeLiteral "[]"');
|
|
3275
3490
|
function TypeLiteral(state) {
|
|
3276
3491
|
if (state.tokenize) {
|
|
3277
3492
|
return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
|
|
@@ -3279,8 +3494,8 @@ var require_parser = __commonJS({
|
|
|
3279
3494
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
3280
3495
|
}
|
|
3281
3496
|
}
|
|
3282
|
-
var TypeBinaryOp$0 = $EXPECT($
|
|
3283
|
-
var TypeBinaryOp$1 = $EXPECT($
|
|
3497
|
+
var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
|
|
3498
|
+
var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
|
|
3284
3499
|
function TypeBinaryOp(state) {
|
|
3285
3500
|
if (state.tokenize) {
|
|
3286
3501
|
return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
|
|
@@ -3298,7 +3513,7 @@ var require_parser = __commonJS({
|
|
|
3298
3513
|
return FunctionType$0(state);
|
|
3299
3514
|
}
|
|
3300
3515
|
}
|
|
3301
|
-
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 ">"'));
|
|
3302
3517
|
function TypeArguments(state) {
|
|
3303
3518
|
if (state.verbose)
|
|
3304
3519
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -3308,7 +3523,7 @@ var require_parser = __commonJS({
|
|
|
3308
3523
|
return TypeArguments$0(state);
|
|
3309
3524
|
}
|
|
3310
3525
|
}
|
|
3311
|
-
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 ">"'));
|
|
3312
3527
|
function TypeParameters(state) {
|
|
3313
3528
|
if (state.verbose)
|
|
3314
3529
|
console.log("ENTER:", "TypeParameters");
|
|
@@ -3339,8 +3554,8 @@ var require_parser = __commonJS({
|
|
|
3339
3554
|
}
|
|
3340
3555
|
}
|
|
3341
3556
|
var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
|
|
3342
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
3343
|
-
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) {
|
|
3344
3559
|
return ",";
|
|
3345
3560
|
});
|
|
3346
3561
|
var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -3353,7 +3568,7 @@ var require_parser = __commonJS({
|
|
|
3353
3568
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
3354
3569
|
}
|
|
3355
3570
|
}
|
|
3356
|
-
var Shebang$0 = $R$0($EXPECT($
|
|
3571
|
+
var Shebang$0 = $R$0($EXPECT($R32, fail, "Shebang /#![^\\r\\n]*/"));
|
|
3357
3572
|
function Shebang(state) {
|
|
3358
3573
|
if (state.verbose)
|
|
3359
3574
|
console.log("ENTER:", "Shebang");
|
|
@@ -3363,7 +3578,7 @@ var require_parser = __commonJS({
|
|
|
3363
3578
|
return Shebang$0(state);
|
|
3364
3579
|
}
|
|
3365
3580
|
}
|
|
3366
|
-
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) {
|
|
3367
3582
|
return $0.map((p) => p.join(""));
|
|
3368
3583
|
});
|
|
3369
3584
|
function DirectivePrologue(state) {
|
|
@@ -3385,7 +3600,7 @@ var require_parser = __commonJS({
|
|
|
3385
3600
|
return EOS$0(state);
|
|
3386
3601
|
}
|
|
3387
3602
|
}
|
|
3388
|
-
var EOL$0 = $R$0($EXPECT($
|
|
3603
|
+
var EOL$0 = $R$0($EXPECT($R34, fail, "EOL /\\r\\n|\\n|\\r|$/"));
|
|
3389
3604
|
function EOL(state) {
|
|
3390
3605
|
if (state.verbose)
|
|
3391
3606
|
console.log("ENTER:", "EOL");
|
|
@@ -3395,7 +3610,7 @@ var require_parser = __commonJS({
|
|
|
3395
3610
|
return EOL$0(state);
|
|
3396
3611
|
}
|
|
3397
3612
|
}
|
|
3398
|
-
var EOF$0 = $R$0($EXPECT($
|
|
3613
|
+
var EOF$0 = $R$0($EXPECT($R35, fail, "EOF /$/"));
|
|
3399
3614
|
function EOF(state) {
|
|
3400
3615
|
if (state.verbose)
|
|
3401
3616
|
console.log("ENTER:", "EOF");
|
|
@@ -3534,6 +3749,15 @@ var require_parser = __commonJS({
|
|
|
3534
3749
|
const compatRe = /use coffee-compat/;
|
|
3535
3750
|
global.coffeeCompat = directives.some((d) => d.match(compatRe));
|
|
3536
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
|
+
};
|
|
3537
3761
|
return $0;
|
|
3538
3762
|
});
|
|
3539
3763
|
function Init(state) {
|
|
@@ -3545,7 +3769,7 @@ var require_parser = __commonJS({
|
|
|
3545
3769
|
return Init$0(state);
|
|
3546
3770
|
}
|
|
3547
3771
|
}
|
|
3548
|
-
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) {
|
|
3549
3773
|
return $1.length;
|
|
3550
3774
|
});
|
|
3551
3775
|
function Indent(state) {
|
|
@@ -3651,7 +3875,7 @@ var require_parser = __commonJS({
|
|
|
3651
3875
|
var require_generate = __commonJS({
|
|
3652
3876
|
"source/generate.coffee"(exports2, module2) {
|
|
3653
3877
|
var gen2;
|
|
3654
|
-
var
|
|
3878
|
+
var prune2;
|
|
3655
3879
|
gen2 = function(node, options) {
|
|
3656
3880
|
var $loc, token;
|
|
3657
3881
|
if (node === null || node === void 0) {
|
|
@@ -3691,7 +3915,7 @@ var require_generate = __commonJS({
|
|
|
3691
3915
|
throw new Error("Unknown node", JSON.stringify(node));
|
|
3692
3916
|
};
|
|
3693
3917
|
module2.exports = gen2;
|
|
3694
|
-
|
|
3918
|
+
prune2 = function(node) {
|
|
3695
3919
|
var a;
|
|
3696
3920
|
if (node === null || node === void 0) {
|
|
3697
3921
|
return;
|
|
@@ -3701,7 +3925,7 @@ var require_generate = __commonJS({
|
|
|
3701
3925
|
}
|
|
3702
3926
|
if (Array.isArray(node)) {
|
|
3703
3927
|
a = node.map(function(n) {
|
|
3704
|
-
return
|
|
3928
|
+
return prune2(n);
|
|
3705
3929
|
}).filter(function(n) {
|
|
3706
3930
|
return !!n;
|
|
3707
3931
|
});
|
|
@@ -3714,26 +3938,172 @@ var require_generate = __commonJS({
|
|
|
3714
3938
|
return;
|
|
3715
3939
|
}
|
|
3716
3940
|
if (node.children != null) {
|
|
3717
|
-
node.children =
|
|
3941
|
+
node.children = prune2(node.children);
|
|
3718
3942
|
return node;
|
|
3719
3943
|
}
|
|
3720
3944
|
return node;
|
|
3721
3945
|
};
|
|
3722
|
-
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 };
|
|
3723
4075
|
}
|
|
3724
4076
|
});
|
|
3725
4077
|
|
|
3726
4078
|
// source/main.coffee
|
|
4079
|
+
var SourceMap;
|
|
4080
|
+
var defaultOptions;
|
|
3727
4081
|
var gen;
|
|
3728
4082
|
var parse;
|
|
4083
|
+
var prune;
|
|
4084
|
+
var util;
|
|
3729
4085
|
({ parse } = require_parser());
|
|
3730
|
-
gen = require_generate();
|
|
4086
|
+
({ prune } = gen = require_generate());
|
|
4087
|
+
({ SourceMap } = util = require_util());
|
|
4088
|
+
defaultOptions = {};
|
|
3731
4089
|
module.exports = {
|
|
3732
4090
|
parse,
|
|
3733
|
-
compile: function(src, options) {
|
|
3734
|
-
|
|
3735
|
-
|
|
3736
|
-
|
|
4091
|
+
compile: function(src, options = defaultOptions) {
|
|
4092
|
+
var ast, code, sm;
|
|
4093
|
+
ast = prune(parse(src, {
|
|
4094
|
+
filename: options.filename
|
|
4095
|
+
}));
|
|
4096
|
+
if (options.sourceMap) {
|
|
4097
|
+
sm = SourceMap(src);
|
|
4098
|
+
options.updateSourceMap = sm.updateSourceMap;
|
|
4099
|
+
code = gen(ast, options);
|
|
4100
|
+
return {
|
|
4101
|
+
code,
|
|
4102
|
+
sourceMap: sm
|
|
4103
|
+
};
|
|
4104
|
+
}
|
|
4105
|
+
return gen(ast, options);
|
|
3737
4106
|
},
|
|
3738
|
-
generate: gen
|
|
4107
|
+
generate: gen,
|
|
4108
|
+
util
|
|
3739
4109
|
};
|