@danielx/civet 0.2.13 → 0.2.16
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +4 -3
- package/dist/browser.js +866 -369
- package/dist/browser.js.map +3 -3
- package/dist/civet +10 -8
- package/dist/cli.js.map +4 -4
- package/dist/main.js +866 -369
- package/dist/types.d.ts +25 -5
- package/esbuild-plugin.js +16 -15
- package/package.json +4 -1
- package/register.mjs +7 -6
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,
|
|
@@ -444,6 +448,8 @@ var require_parser = __commonJS({
|
|
|
444
448
|
ApplicationStart,
|
|
445
449
|
AdditionalReservedWords,
|
|
446
450
|
MemberExpression,
|
|
451
|
+
MemberExpressionRest,
|
|
452
|
+
PropertyAccess,
|
|
447
453
|
SuperProperty,
|
|
448
454
|
MetaProperty,
|
|
449
455
|
Parameters,
|
|
@@ -460,13 +466,17 @@ var require_parser = __commonJS({
|
|
|
460
466
|
FunctionDeclaration,
|
|
461
467
|
FunctionExpression,
|
|
462
468
|
ThinArrowFunction,
|
|
469
|
+
Arrow,
|
|
463
470
|
Block,
|
|
471
|
+
BracedOrEmptyBlock,
|
|
464
472
|
BracedBlock,
|
|
465
473
|
SingleNestedExpression,
|
|
466
474
|
SingleNestedBlockStatement,
|
|
467
475
|
NestedBlockExpressions,
|
|
468
476
|
BlockExpression,
|
|
469
477
|
Literal,
|
|
478
|
+
NullLiteral,
|
|
479
|
+
BooleanLiteral,
|
|
470
480
|
Comma,
|
|
471
481
|
Identifier,
|
|
472
482
|
IdentifierName,
|
|
@@ -496,7 +506,9 @@ var require_parser = __commonJS({
|
|
|
496
506
|
AsyncGeneratorMethod,
|
|
497
507
|
AsyncGeneratorBody,
|
|
498
508
|
AssignmentOp,
|
|
509
|
+
AssignmentOpSymbol,
|
|
499
510
|
BinaryOp,
|
|
511
|
+
BinaryOpSymbol,
|
|
500
512
|
UnaryOp,
|
|
501
513
|
ModuleItem,
|
|
502
514
|
StatementListItem,
|
|
@@ -512,7 +524,9 @@ var require_parser = __commonJS({
|
|
|
512
524
|
WhileClause,
|
|
513
525
|
ForStatement,
|
|
514
526
|
ForInOfStatement,
|
|
527
|
+
For,
|
|
515
528
|
ForDeclaration,
|
|
529
|
+
LetOrConst,
|
|
516
530
|
ForBinding,
|
|
517
531
|
SwitchStatement,
|
|
518
532
|
CaseBlock,
|
|
@@ -532,10 +546,12 @@ var require_parser = __commonJS({
|
|
|
532
546
|
MaybeNestedExpression,
|
|
533
547
|
Return,
|
|
534
548
|
ImportDeclaration,
|
|
549
|
+
Import,
|
|
535
550
|
ImportClause,
|
|
536
551
|
NameSpaceImport,
|
|
537
552
|
NamedImports,
|
|
538
553
|
FromClause,
|
|
554
|
+
From,
|
|
539
555
|
ImportSpecifier,
|
|
540
556
|
ModuleExportName,
|
|
541
557
|
ModuleSpecifier,
|
|
@@ -549,12 +565,14 @@ var require_parser = __commonJS({
|
|
|
549
565
|
Declaration,
|
|
550
566
|
HoistableDeclaration,
|
|
551
567
|
LexicalDeclaration,
|
|
568
|
+
ConstAssignment,
|
|
552
569
|
LexicalBinding,
|
|
553
570
|
Initializer,
|
|
554
571
|
VariableStatement,
|
|
555
572
|
VariableDeclarationList,
|
|
556
573
|
VariableDeclaration,
|
|
557
574
|
NumericLiteral,
|
|
575
|
+
NumericLiteralKind,
|
|
558
576
|
DecimalBigIntegerLiteral,
|
|
559
577
|
DecimalLiteral,
|
|
560
578
|
BinaryIntegerLiteral,
|
|
@@ -564,7 +582,7 @@ var require_parser = __commonJS({
|
|
|
564
582
|
DoubleStringCharacter,
|
|
565
583
|
SingleStringCharacter,
|
|
566
584
|
TripleDoubleStringCharacter,
|
|
567
|
-
|
|
585
|
+
TripleSingleStringCharacter,
|
|
568
586
|
RegularExpressionLiteral,
|
|
569
587
|
RegularExpressionBody,
|
|
570
588
|
RegExpCharacter,
|
|
@@ -634,6 +652,7 @@ var require_parser = __commonJS({
|
|
|
634
652
|
EOS,
|
|
635
653
|
EOL,
|
|
636
654
|
EOF,
|
|
655
|
+
Debugger,
|
|
637
656
|
InsertOpenParen,
|
|
638
657
|
InsertCloseParen,
|
|
639
658
|
InsertOpenBrace,
|
|
@@ -647,7 +666,8 @@ var require_parser = __commonJS({
|
|
|
647
666
|
Indent,
|
|
648
667
|
PushIndent,
|
|
649
668
|
PopIndent,
|
|
650
|
-
Nested
|
|
669
|
+
Nested,
|
|
670
|
+
NestedFurther
|
|
651
671
|
});
|
|
652
672
|
var $L0 = $L(",");
|
|
653
673
|
var $L1 = $L("(");
|
|
@@ -668,14 +688,14 @@ var require_parser = __commonJS({
|
|
|
668
688
|
var $L16 = $L("}");
|
|
669
689
|
var $L17 = $L("static");
|
|
670
690
|
var $L18 = $L("this");
|
|
671
|
-
var $L19 = $L("
|
|
672
|
-
var $L20 = $L("
|
|
691
|
+
var $L19 = $L("#");
|
|
692
|
+
var $L20 = $L("@");
|
|
673
693
|
var $L21 = $L("new");
|
|
674
694
|
var $L22 = $L("super");
|
|
675
695
|
var $L23 = $L("import");
|
|
676
|
-
var $L24 = $L("
|
|
677
|
-
var $L25 = $L("
|
|
678
|
-
var $L26 = $L("
|
|
696
|
+
var $L24 = $L(".");
|
|
697
|
+
var $L25 = $L("[");
|
|
698
|
+
var $L26 = $L("]");
|
|
679
699
|
var $L27 = $L("::");
|
|
680
700
|
var $L28 = $L("super[");
|
|
681
701
|
var $L29 = $L("new.target");
|
|
@@ -684,107 +704,106 @@ var require_parser = __commonJS({
|
|
|
684
704
|
var $L32 = $L("...");
|
|
685
705
|
var $L33 = $L("function");
|
|
686
706
|
var $L34 = $L("->");
|
|
687
|
-
var $L35 = $L("
|
|
688
|
-
var $L36 = $L("
|
|
689
|
-
var $L37 = $L("
|
|
690
|
-
var $L38 = $L("
|
|
691
|
-
var $L39 = $L("
|
|
692
|
-
var $L40 = $L("
|
|
693
|
-
var $L41 = $L("
|
|
694
|
-
var $L42 = $L("
|
|
695
|
-
var $L43 = $L("
|
|
696
|
-
var $L44 = $L("
|
|
697
|
-
var $L45 = $L("
|
|
698
|
-
var $L46 = $L("
|
|
699
|
-
var $L47 = $L("
|
|
700
|
-
var $L48 = $L("
|
|
701
|
-
var $L49 = $L("
|
|
702
|
-
var $L50 = $L("
|
|
703
|
-
var $L51 = $L("
|
|
704
|
-
var $L52 = $L("
|
|
705
|
-
var $L53 = $L("
|
|
706
|
-
var $L54 = $L("
|
|
707
|
-
var $L55 = $L("
|
|
708
|
-
var $L56 = $L("
|
|
709
|
-
var $L57 = $L("
|
|
710
|
-
var $L58 = $L("
|
|
711
|
-
var $L59 = $L("
|
|
712
|
-
var $L60 = $L("
|
|
713
|
-
var $L61 = $L("
|
|
714
|
-
var $L62 = $L("
|
|
715
|
-
var $L63 = $L("
|
|
716
|
-
var $L64 = $L("
|
|
717
|
-
var $L65 = $L("
|
|
718
|
-
var $L66 = $L("
|
|
719
|
-
var $L67 = $L("
|
|
720
|
-
var $L68 = $L("
|
|
721
|
-
var $L69 = $L("
|
|
722
|
-
var $L70 = $L("
|
|
723
|
-
var $L71 = $L("
|
|
724
|
-
var $L72 = $L("
|
|
725
|
-
var $L73 = $L("
|
|
726
|
-
var $L74 = $L("
|
|
727
|
-
var $L75 = $L("
|
|
728
|
-
var $L76 = $L("
|
|
729
|
-
var $L77 = $L("
|
|
730
|
-
var $L78 = $L("
|
|
731
|
-
var $L79 = $L("
|
|
732
|
-
var $L80 = $L("
|
|
733
|
-
var $L81 = $L("
|
|
734
|
-
var $L82 = $L("
|
|
735
|
-
var $L83 = $L("
|
|
736
|
-
var $L84 = $L("
|
|
737
|
-
var $L85 = $L("
|
|
738
|
-
var $L86 = $L("
|
|
739
|
-
var $L87 = $L("
|
|
740
|
-
var $L88 = $L("
|
|
741
|
-
var $L89 = $L("
|
|
742
|
-
var $L90 = $L("
|
|
743
|
-
var $L91 = $L("
|
|
744
|
-
var $L92 = $L("
|
|
745
|
-
var $L93 = $L("
|
|
746
|
-
var $L94 = $L("
|
|
747
|
-
var $L95 = $L("
|
|
748
|
-
var $L96 = $L("
|
|
749
|
-
var $L97 = $L("
|
|
750
|
-
var $L98 = $L("
|
|
751
|
-
var $L99 = $L("
|
|
752
|
-
var $L100 = $L("
|
|
753
|
-
var $L101 = $L("
|
|
754
|
-
var $L102 = $L("
|
|
755
|
-
var $L103 = $L("
|
|
756
|
-
var $L104 = $L("
|
|
757
|
-
var $L105 = $L("
|
|
758
|
-
var $L106 = $L("
|
|
759
|
-
var $L107 = $L("
|
|
760
|
-
var $L108 = $L("
|
|
761
|
-
var $L109 = $L("
|
|
762
|
-
var $L110 = $L("
|
|
763
|
-
var $L111 = $L("
|
|
764
|
-
var $L112 = $L("
|
|
765
|
-
var $L113 = $L("
|
|
766
|
-
var $L114 = $L("
|
|
767
|
-
var $L115 = $L("
|
|
768
|
-
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("'''");
|
|
769
789
|
var $L117 = $L('"');
|
|
770
790
|
var $L118 = $L("'");
|
|
771
|
-
var $L119 = $L("
|
|
772
|
-
var $L120 = $L("
|
|
773
|
-
var $L121 = $L("
|
|
774
|
-
var $L122 = $L("
|
|
775
|
-
var $L123 = $L("
|
|
776
|
-
var $L124 = $L("
|
|
777
|
-
var $L125 = $L("
|
|
778
|
-
var $L126 = $L("
|
|
779
|
-
var $L127 = $L("
|
|
780
|
-
var $L128 = $L("
|
|
781
|
-
var $L129 = $L("
|
|
782
|
-
var $L130 = $L("
|
|
783
|
-
var $L131 = $L("
|
|
784
|
-
var $L132 = $L("
|
|
785
|
-
var $L133 = $L("
|
|
786
|
-
var $L134 = $L("
|
|
787
|
-
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(" ");
|
|
788
807
|
var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
|
|
789
808
|
var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
|
|
790
809
|
var $R2 = $R(new RegExp("[!~+-]", "suy"));
|
|
@@ -793,33 +812,34 @@ var require_parser = __commonJS({
|
|
|
793
812
|
var $R5 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
|
|
794
813
|
var $R6 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
|
|
795
814
|
var $R7 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
|
|
796
|
-
var $R8 = $R(new RegExp('[^"
|
|
797
|
-
var $R9 = $R(new RegExp("[^'
|
|
815
|
+
var $R8 = $R(new RegExp('(?:\\\\.|[^"])+', "suy"));
|
|
816
|
+
var $R9 = $R(new RegExp("(?:\\\\.|[^'])+", "suy"));
|
|
798
817
|
var $R10 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
|
|
799
|
-
var $R11 = $R(new RegExp("
|
|
818
|
+
var $R11 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])+", "suy"));
|
|
800
819
|
var $R12 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
|
|
801
|
-
var $R13 = $R(new RegExp("[^\\/\\r\\n]+", "suy"));
|
|
802
|
-
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"));
|
|
803
822
|
var $R15 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
|
|
804
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"));
|
|
805
824
|
var $R17 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
|
|
806
|
-
var $R18 = $R(new RegExp("
|
|
807
|
-
var $R19 = $R(new RegExp("[^\\r\\n]", "suy"));
|
|
808
|
-
var $R20 = $R(new RegExp("[\\
|
|
809
|
-
var $R21 = $R(new RegExp("[\\
|
|
810
|
-
var $R22 = $R(new RegExp("
|
|
811
|
-
var $R23 = $R(new RegExp("(
|
|
812
|
-
var $R24 = $R(new RegExp(
|
|
813
|
-
var $R25 = $R(new RegExp("
|
|
814
|
-
var $R26 = $R(new RegExp("[^
|
|
815
|
-
var $R27 = $R(new RegExp("
|
|
816
|
-
var $R28 = $R(new RegExp("
|
|
817
|
-
var $R29 = $R(new RegExp("
|
|
818
|
-
var $R30 = $R(new RegExp("[+-]", "suy"));
|
|
819
|
-
var $R31 = $R(new RegExp("
|
|
820
|
-
var $R32 = $R(new RegExp("[\\
|
|
821
|
-
var $R33 = $R(new RegExp("\\
|
|
822
|
-
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"));
|
|
823
843
|
var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
|
|
824
844
|
function Program(state) {
|
|
825
845
|
if (state.verbose)
|
|
@@ -933,7 +953,9 @@ var require_parser = __commonJS({
|
|
|
933
953
|
}
|
|
934
954
|
}
|
|
935
955
|
var UnaryPostfix$0 = $EXPECT($L3, fail, 'UnaryPostfix "?"');
|
|
936
|
-
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
|
+
});
|
|
937
959
|
function UnaryPostfix(state) {
|
|
938
960
|
if (state.tokenize) {
|
|
939
961
|
return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state));
|
|
@@ -941,8 +963,8 @@ var require_parser = __commonJS({
|
|
|
941
963
|
return UnaryPostfix$0(state) || UnaryPostfix$1(state);
|
|
942
964
|
}
|
|
943
965
|
}
|
|
944
|
-
var UpdateExpression$0 = $S(
|
|
945
|
-
var UpdateExpression$1 = $S(LeftHandSideExpression, $E(
|
|
966
|
+
var UpdateExpression$0 = $S(UpdateExpressionSymbol, UnaryExpression);
|
|
967
|
+
var UpdateExpression$1 = $S(LeftHandSideExpression, $E(UpdateExpressionSymbol));
|
|
946
968
|
function UpdateExpression(state) {
|
|
947
969
|
if (state.tokenize) {
|
|
948
970
|
return $TOKEN("UpdateExpression", state, UpdateExpression$0(state) || UpdateExpression$1(state));
|
|
@@ -950,6 +972,18 @@ var require_parser = __commonJS({
|
|
|
950
972
|
return UpdateExpression$0(state) || UpdateExpression$1(state);
|
|
951
973
|
}
|
|
952
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
|
+
}
|
|
953
987
|
var AssignmentExpression$0 = $S($Q(TrailingComment), AssignmentExpressionRest);
|
|
954
988
|
var AssignmentExpression$1 = $S(__, AssignmentExpressionRest);
|
|
955
989
|
function AssignmentExpression(state) {
|
|
@@ -1063,7 +1097,7 @@ var require_parser = __commonJS({
|
|
|
1063
1097
|
return ClassDeclaration$0(state);
|
|
1064
1098
|
}
|
|
1065
1099
|
}
|
|
1066
|
-
var ClassExpression$0 = $S(
|
|
1100
|
+
var ClassExpression$0 = $S(Class, $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
|
|
1067
1101
|
function ClassExpression(state) {
|
|
1068
1102
|
if (state.verbose)
|
|
1069
1103
|
console.log("ENTER:", "ClassExpression");
|
|
@@ -1073,7 +1107,19 @@ var require_parser = __commonJS({
|
|
|
1073
1107
|
return ClassExpression$0(state);
|
|
1074
1108
|
}
|
|
1075
1109
|
}
|
|
1076
|
-
var
|
|
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
|
+
}
|
|
1122
|
+
var ClassHeritage$0 = $S(ExtendsToken, __, MemberExpression);
|
|
1077
1123
|
function ClassHeritage(state) {
|
|
1078
1124
|
if (state.verbose)
|
|
1079
1125
|
console.log("ENTER:", "ClassHeritage");
|
|
@@ -1083,10 +1129,12 @@ var require_parser = __commonJS({
|
|
|
1083
1129
|
return ClassHeritage$0(state);
|
|
1084
1130
|
}
|
|
1085
1131
|
}
|
|
1086
|
-
var ExtendsToken$0 = $
|
|
1087
|
-
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 };
|
|
1088
1137
|
});
|
|
1089
|
-
var ExtendsToken$1 = $EXPECT($L15, fail, 'ExtendsToken "extends"');
|
|
1090
1138
|
function ExtendsToken(state) {
|
|
1091
1139
|
if (state.tokenize) {
|
|
1092
1140
|
return $TOKEN("ExtendsToken", state, ExtendsToken$0(state) || ExtendsToken$1(state));
|
|
@@ -1128,8 +1176,8 @@ var require_parser = __commonJS({
|
|
|
1128
1176
|
return NestedClassElement$0(state);
|
|
1129
1177
|
}
|
|
1130
1178
|
}
|
|
1131
|
-
var ClassElement$0 = $S(
|
|
1132
|
-
var ClassElement$1 = $S($E($S(
|
|
1179
|
+
var ClassElement$0 = $S(Static, BracedBlock);
|
|
1180
|
+
var ClassElement$1 = $S($E($S(Static, __)), $C(MethodDefinition, FieldDefinition));
|
|
1133
1181
|
function ClassElement(state) {
|
|
1134
1182
|
if (state.tokenize) {
|
|
1135
1183
|
return $TOKEN("ClassElement", state, ClassElement$0(state) || ClassElement$1(state));
|
|
@@ -1137,6 +1185,18 @@ var require_parser = __commonJS({
|
|
|
1137
1185
|
return ClassElement$0(state) || ClassElement$1(state);
|
|
1138
1186
|
}
|
|
1139
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
|
+
}
|
|
1140
1200
|
var FieldDefinition$0 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
|
|
1141
1201
|
function FieldDefinition(state) {
|
|
1142
1202
|
if (state.verbose)
|
|
@@ -1147,13 +1207,12 @@ var require_parser = __commonJS({
|
|
|
1147
1207
|
return FieldDefinition$0(state);
|
|
1148
1208
|
}
|
|
1149
1209
|
}
|
|
1150
|
-
var This$0 = $EXPECT($L18, fail, 'This "this"')
|
|
1151
|
-
|
|
1152
|
-
var ref = value[1];
|
|
1153
|
-
return ["this.", ref];
|
|
1210
|
+
var This$0 = $TV($EXPECT($L18, fail, 'This "this"'), function($skip, $loc, $0, $1) {
|
|
1211
|
+
return { $loc, token: $0 };
|
|
1154
1212
|
});
|
|
1155
|
-
var This$
|
|
1156
|
-
|
|
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) {
|
|
1215
|
+
return { $loc, token: "this" };
|
|
1157
1216
|
});
|
|
1158
1217
|
function This(state) {
|
|
1159
1218
|
if (state.tokenize) {
|
|
@@ -1162,6 +1221,18 @@ var require_parser = __commonJS({
|
|
|
1162
1221
|
return This$0(state) || This$1(state) || This$2(state);
|
|
1163
1222
|
}
|
|
1164
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
|
+
}
|
|
1165
1236
|
var LeftHandSideExpression$0 = NewExpression;
|
|
1166
1237
|
var LeftHandSideExpression$1 = CallExpression;
|
|
1167
1238
|
function LeftHandSideExpression(state) {
|
|
@@ -1171,7 +1242,7 @@ var require_parser = __commonJS({
|
|
|
1171
1242
|
return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
|
|
1172
1243
|
}
|
|
1173
1244
|
}
|
|
1174
|
-
var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)),
|
|
1245
|
+
var NewExpression$0 = $S($P($S($EXPECT($L21, fail, 'NewExpression "new"'), __)), CallExpression);
|
|
1175
1246
|
function NewExpression(state) {
|
|
1176
1247
|
if (state.verbose)
|
|
1177
1248
|
console.log("ENTER:", "NewExpression");
|
|
@@ -1183,7 +1254,7 @@ var require_parser = __commonJS({
|
|
|
1183
1254
|
}
|
|
1184
1255
|
var CallExpression$0 = $S($EXPECT($L22, fail, 'CallExpression "super"'), __, Arguments);
|
|
1185
1256
|
var CallExpression$1 = $S($EXPECT($L23, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
|
|
1186
|
-
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest)
|
|
1257
|
+
var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
|
|
1187
1258
|
function CallExpression(state) {
|
|
1188
1259
|
if (state.tokenize) {
|
|
1189
1260
|
return $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state));
|
|
@@ -1192,23 +1263,17 @@ var require_parser = __commonJS({
|
|
|
1192
1263
|
}
|
|
1193
1264
|
}
|
|
1194
1265
|
var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
|
|
1195
|
-
var CallExpressionRest$1 =
|
|
1196
|
-
var CallExpressionRest$2 =
|
|
1197
|
-
var CallExpressionRest$3 =
|
|
1198
|
-
var id = $2;
|
|
1199
|
-
if (id)
|
|
1200
|
-
return [".prototype.", id];
|
|
1201
|
-
return ".prototype";
|
|
1202
|
-
});
|
|
1203
|
-
var CallExpressionRest$4 = TemplateLiteral;
|
|
1266
|
+
var CallExpressionRest$1 = MemberExpressionRest;
|
|
1267
|
+
var CallExpressionRest$2 = SpacedApplication;
|
|
1268
|
+
var CallExpressionRest$3 = TemplateLiteral;
|
|
1204
1269
|
function CallExpressionRest(state) {
|
|
1205
1270
|
if (state.tokenize) {
|
|
1206
|
-
return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state)
|
|
1271
|
+
return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state));
|
|
1207
1272
|
} else {
|
|
1208
|
-
return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state)
|
|
1273
|
+
return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
|
|
1209
1274
|
}
|
|
1210
1275
|
}
|
|
1211
|
-
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($
|
|
1276
|
+
var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L24, fail, 'OptionalShorthand "."'), InsertDot));
|
|
1212
1277
|
function OptionalShorthand(state) {
|
|
1213
1278
|
if (state.verbose)
|
|
1214
1279
|
console.log("ENTER:", "OptionalShorthand");
|
|
@@ -1218,7 +1283,7 @@ var require_parser = __commonJS({
|
|
|
1218
1283
|
return OptionalShorthand$0(state);
|
|
1219
1284
|
}
|
|
1220
1285
|
}
|
|
1221
|
-
var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen);
|
|
1286
|
+
var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen, $Q($S($Y(EOS), Nested, CallExpressionRest)));
|
|
1222
1287
|
function SpacedApplication(state) {
|
|
1223
1288
|
if (state.verbose)
|
|
1224
1289
|
console.log("ENTER:", "SpacedApplication");
|
|
@@ -1252,7 +1317,7 @@ var require_parser = __commonJS({
|
|
|
1252
1317
|
return AdditionalReservedWords$0(state);
|
|
1253
1318
|
}
|
|
1254
1319
|
}
|
|
1255
|
-
var MemberExpression$0 = $S(PrimaryExpression, $Q(
|
|
1320
|
+
var MemberExpression$0 = $S(PrimaryExpression, $Q(MemberExpressionRest));
|
|
1256
1321
|
var MemberExpression$1 = $S($Q(TrailingComment), SuperProperty);
|
|
1257
1322
|
var MemberExpression$2 = $S($Q(TrailingComment), MetaProperty);
|
|
1258
1323
|
function MemberExpression(state) {
|
|
@@ -1262,7 +1327,32 @@ var require_parser = __commonJS({
|
|
|
1262
1327
|
return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
|
|
1263
1328
|
}
|
|
1264
1329
|
}
|
|
1265
|
-
var
|
|
1330
|
+
var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L25, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L26, fail, 'MemberExpressionRest "]"'));
|
|
1331
|
+
var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
|
|
1332
|
+
var MemberExpressionRest$2 = $TS($S($EXPECT($L27, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
|
|
1333
|
+
var id = $2;
|
|
1334
|
+
if (id)
|
|
1335
|
+
return [".prototype.", id];
|
|
1336
|
+
return ".prototype";
|
|
1337
|
+
});
|
|
1338
|
+
function MemberExpressionRest(state) {
|
|
1339
|
+
if (state.tokenize) {
|
|
1340
|
+
return $TOKEN("MemberExpressionRest", state, MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state));
|
|
1341
|
+
} else {
|
|
1342
|
+
return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state);
|
|
1343
|
+
}
|
|
1344
|
+
}
|
|
1345
|
+
var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L24, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
|
|
1346
|
+
function PropertyAccess(state) {
|
|
1347
|
+
if (state.verbose)
|
|
1348
|
+
console.log("ENTER:", "PropertyAccess");
|
|
1349
|
+
if (state.tokenize) {
|
|
1350
|
+
return $TOKEN("PropertyAccess", state, PropertyAccess$0(state));
|
|
1351
|
+
} else {
|
|
1352
|
+
return PropertyAccess$0(state);
|
|
1353
|
+
}
|
|
1354
|
+
}
|
|
1355
|
+
var SuperProperty$0 = $S($EXPECT($L28, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L26, fail, 'SuperProperty "]"'));
|
|
1266
1356
|
function SuperProperty(state) {
|
|
1267
1357
|
if (state.verbose)
|
|
1268
1358
|
console.log("ENTER:", "SuperProperty");
|
|
@@ -1346,7 +1436,7 @@ var require_parser = __commonJS({
|
|
|
1346
1436
|
return ObjectBindingPattern$0(state);
|
|
1347
1437
|
}
|
|
1348
1438
|
}
|
|
1349
|
-
var ArrayBindingPattern$0 = $S($EXPECT($
|
|
1439
|
+
var ArrayBindingPattern$0 = $S($EXPECT($L25, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L26, fail, 'ArrayBindingPattern "]"'));
|
|
1350
1440
|
function ArrayBindingPattern(state) {
|
|
1351
1441
|
if (state.verbose)
|
|
1352
1442
|
console.log("ENTER:", "ArrayBindingPattern");
|
|
@@ -1414,11 +1504,17 @@ var require_parser = __commonJS({
|
|
|
1414
1504
|
return FunctionExpression$0(state) || FunctionExpression$1(state);
|
|
1415
1505
|
}
|
|
1416
1506
|
}
|
|
1417
|
-
var ThinArrowFunction$0 = $
|
|
1418
|
-
var params =
|
|
1419
|
-
var suffix =
|
|
1420
|
-
var
|
|
1421
|
-
|
|
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
|
+
];
|
|
1422
1518
|
});
|
|
1423
1519
|
function ThinArrowFunction(state) {
|
|
1424
1520
|
if (state.verbose)
|
|
@@ -1429,6 +1525,18 @@ var require_parser = __commonJS({
|
|
|
1429
1525
|
return ThinArrowFunction$0(state);
|
|
1430
1526
|
}
|
|
1431
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
|
+
}
|
|
1432
1540
|
var Block$0 = $S(__, $EXPECT($L11, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'Block "}"'));
|
|
1433
1541
|
var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1434
1542
|
var Block$2 = Statement;
|
|
@@ -1440,6 +1548,15 @@ var require_parser = __commonJS({
|
|
|
1440
1548
|
return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
|
|
1441
1549
|
}
|
|
1442
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
|
+
}
|
|
1443
1560
|
var BracedBlock$0 = $S(__, $EXPECT($L11, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L16, fail, 'BracedBlock "}"'));
|
|
1444
1561
|
var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
|
|
1445
1562
|
var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
|
|
@@ -1450,7 +1567,7 @@ var require_parser = __commonJS({
|
|
|
1450
1567
|
return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state);
|
|
1451
1568
|
}
|
|
1452
1569
|
}
|
|
1453
|
-
var SingleNestedExpression$0 = $TS($S(PushIndent, $E($S(Nested, Expression, StatementDelimiter)), $C($S($N($S(Nested, Expression)), PopIndent),
|
|
1570
|
+
var SingleNestedExpression$0 = $TS($S(PushIndent, $E($S(Nested, Expression, StatementDelimiter)), $C($S($N($S(Nested, Expression)), PopIndent), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1454
1571
|
var exp = $2;
|
|
1455
1572
|
if (exp)
|
|
1456
1573
|
return exp;
|
|
@@ -1465,7 +1582,7 @@ var require_parser = __commonJS({
|
|
|
1465
1582
|
return SingleNestedExpression$0(state);
|
|
1466
1583
|
}
|
|
1467
1584
|
}
|
|
1468
|
-
var SingleNestedBlockStatement$0 = $TS($S(PushIndent, $E($S(Nested, StatementListItem)), $C($C($N($S(Nested, StatementListItem)),
|
|
1585
|
+
var SingleNestedBlockStatement$0 = $TS($S(PushIndent, $E($S(Nested, StatementListItem)), $C($C($N($S(Nested, StatementListItem)), PopIndent), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
|
|
1469
1586
|
var exp = $2;
|
|
1470
1587
|
if (exp)
|
|
1471
1588
|
return exp;
|
|
@@ -1505,17 +1622,39 @@ var require_parser = __commonJS({
|
|
|
1505
1622
|
return BlockExpression$0(state);
|
|
1506
1623
|
}
|
|
1507
1624
|
}
|
|
1508
|
-
var Literal$0 =
|
|
1509
|
-
var Literal$1 =
|
|
1510
|
-
var Literal$2 =
|
|
1511
|
-
var Literal$3 =
|
|
1512
|
-
var Literal$4 = $EXPECT($L37, fail, 'Literal "null"');
|
|
1513
|
-
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;
|
|
1514
1629
|
function Literal(state) {
|
|
1515
1630
|
if (state.tokenize) {
|
|
1516
|
-
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));
|
|
1517
1632
|
} else {
|
|
1518
|
-
return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state)
|
|
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));
|
|
1656
|
+
} else {
|
|
1657
|
+
return BooleanLiteral$0(state);
|
|
1519
1658
|
}
|
|
1520
1659
|
}
|
|
1521
1660
|
var Comma$0 = $S($Q(_), $EXPECT($L0, fail, 'Comma ","'), $Q(_));
|
|
@@ -1538,7 +1677,12 @@ var require_parser = __commonJS({
|
|
|
1538
1677
|
return Identifier$0(state);
|
|
1539
1678
|
}
|
|
1540
1679
|
}
|
|
1541
|
-
var IdentifierName$0 = $
|
|
1680
|
+
var IdentifierName$0 = $TR($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
|
|
1681
|
+
return {
|
|
1682
|
+
$loc,
|
|
1683
|
+
token: $0
|
|
1684
|
+
};
|
|
1685
|
+
});
|
|
1542
1686
|
function IdentifierName(state) {
|
|
1543
1687
|
if (state.verbose)
|
|
1544
1688
|
console.log("ENTER:", "IdentifierName");
|
|
@@ -1558,8 +1702,8 @@ var require_parser = __commonJS({
|
|
|
1558
1702
|
return IdentifierReference$0(state);
|
|
1559
1703
|
}
|
|
1560
1704
|
}
|
|
1561
|
-
var ArrayLiteral$0 = $S($EXPECT($
|
|
1562
|
-
var ArrayLiteral$1 = $S($EXPECT($
|
|
1705
|
+
var ArrayLiteral$0 = $S($EXPECT($L25, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L26, fail, 'ArrayLiteral "]"'));
|
|
1706
|
+
var ArrayLiteral$1 = $S($EXPECT($L25, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L26, fail, 'ArrayLiteral "]"'));
|
|
1563
1707
|
function ArrayLiteral(state) {
|
|
1564
1708
|
if (state.tokenize) {
|
|
1565
1709
|
return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
|
|
@@ -1593,8 +1737,8 @@ var require_parser = __commonJS({
|
|
|
1593
1737
|
}
|
|
1594
1738
|
}
|
|
1595
1739
|
var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
|
|
1596
|
-
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
1597
|
-
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($
|
|
1740
|
+
var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
|
|
1741
|
+
var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"'))), function(value) {
|
|
1598
1742
|
return ",";
|
|
1599
1743
|
});
|
|
1600
1744
|
var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -1722,7 +1866,7 @@ var require_parser = __commonJS({
|
|
|
1722
1866
|
var PropertyName$0 = NumericLiteral;
|
|
1723
1867
|
var PropertyName$1 = StringLiteral;
|
|
1724
1868
|
var PropertyName$2 = IdentifierName;
|
|
1725
|
-
var PropertyName$3 = $S($EXPECT($
|
|
1869
|
+
var PropertyName$3 = $S($EXPECT($L25, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L26, fail, 'PropertyName "]"'));
|
|
1726
1870
|
function PropertyName(state) {
|
|
1727
1871
|
if (state.tokenize) {
|
|
1728
1872
|
return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
|
|
@@ -1730,8 +1874,8 @@ var require_parser = __commonJS({
|
|
|
1730
1874
|
return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
|
|
1731
1875
|
}
|
|
1732
1876
|
}
|
|
1733
|
-
var MethodDefinition$0 = $S($EXPECT($
|
|
1734
|
-
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);
|
|
1735
1879
|
var MethodDefinition$2 = AsyncGeneratorMethod;
|
|
1736
1880
|
var MethodDefinition$3 = AsyncMethod;
|
|
1737
1881
|
var MethodDefinition$4 = GeneratorMethod;
|
|
@@ -1752,7 +1896,7 @@ var require_parser = __commonJS({
|
|
|
1752
1896
|
return ClassElementName$0(state) || ClassElementName$1(state);
|
|
1753
1897
|
}
|
|
1754
1898
|
}
|
|
1755
|
-
var PrivateIdentifier$0 = $S($EXPECT($
|
|
1899
|
+
var PrivateIdentifier$0 = $S($EXPECT($L19, fail, 'PrivateIdentifier "#"'), IdentifierName);
|
|
1756
1900
|
function PrivateIdentifier(state) {
|
|
1757
1901
|
if (state.verbose)
|
|
1758
1902
|
console.log("ENTER:", "PrivateIdentifier");
|
|
@@ -1822,80 +1966,104 @@ var require_parser = __commonJS({
|
|
|
1822
1966
|
return AsyncGeneratorBody$0(state);
|
|
1823
1967
|
}
|
|
1824
1968
|
}
|
|
1825
|
-
var AssignmentOp$0 = $
|
|
1826
|
-
|
|
1827
|
-
|
|
1828
|
-
var AssignmentOp$3 = $EXPECT($L44, fail, 'AssignmentOp "%="');
|
|
1829
|
-
var AssignmentOp$4 = $EXPECT($L45, fail, 'AssignmentOp "+="');
|
|
1830
|
-
var AssignmentOp$5 = $EXPECT($L46, fail, 'AssignmentOp "-="');
|
|
1831
|
-
var AssignmentOp$6 = $EXPECT($L47, fail, 'AssignmentOp "<<="');
|
|
1832
|
-
var AssignmentOp$7 = $EXPECT($L48, fail, 'AssignmentOp ">>>="');
|
|
1833
|
-
var AssignmentOp$8 = $EXPECT($L49, fail, 'AssignmentOp ">>="');
|
|
1834
|
-
var AssignmentOp$9 = $EXPECT($L50, fail, 'AssignmentOp "&&="');
|
|
1835
|
-
var AssignmentOp$10 = $EXPECT($L51, fail, 'AssignmentOp "&="');
|
|
1836
|
-
var AssignmentOp$11 = $EXPECT($L52, fail, 'AssignmentOp "^="');
|
|
1837
|
-
var AssignmentOp$12 = $EXPECT($L53, fail, 'AssignmentOp "||="');
|
|
1838
|
-
var AssignmentOp$13 = $EXPECT($L54, fail, 'AssignmentOp "|="');
|
|
1839
|
-
var AssignmentOp$14 = $EXPECT($L55, fail, 'AssignmentOp "??="');
|
|
1840
|
-
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
|
+
});
|
|
1841
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) {
|
|
1842
1998
|
if (state.tokenize) {
|
|
1843
|
-
return $TOKEN("
|
|
1844
|
-
} else {
|
|
1845
|
-
return
|
|
1846
|
-
}
|
|
1847
|
-
}
|
|
1848
|
-
var BinaryOp$0 = $
|
|
1849
|
-
|
|
1850
|
-
|
|
1851
|
-
|
|
1852
|
-
|
|
1853
|
-
|
|
1854
|
-
|
|
1855
|
-
|
|
1856
|
-
|
|
1857
|
-
|
|
1858
|
-
|
|
1859
|
-
|
|
1860
|
-
var
|
|
1861
|
-
var
|
|
1862
|
-
var
|
|
1999
|
+
return $TOKEN("AssignmentOpSymbol", state, AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state));
|
|
2000
|
+
} else {
|
|
2001
|
+
return AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state);
|
|
2002
|
+
}
|
|
2003
|
+
}
|
|
2004
|
+
var BinaryOp$0 = $TS($S(BinaryOpSymbol), function($skip, $loc, $0, $1) {
|
|
2005
|
+
return { $loc, token: $1 };
|
|
2006
|
+
});
|
|
2007
|
+
function BinaryOp(state) {
|
|
2008
|
+
if (state.verbose)
|
|
2009
|
+
console.log("ENTER:", "BinaryOp");
|
|
2010
|
+
if (state.tokenize) {
|
|
2011
|
+
return $TOKEN("BinaryOp", state, BinaryOp$0(state));
|
|
2012
|
+
} else {
|
|
2013
|
+
return BinaryOp$0(state);
|
|
2014
|
+
}
|
|
2015
|
+
}
|
|
2016
|
+
var BinaryOpSymbol$0 = $EXPECT($L56, fail, 'BinaryOpSymbol "**"');
|
|
2017
|
+
var BinaryOpSymbol$1 = $EXPECT($L9, fail, 'BinaryOpSymbol "*"');
|
|
2018
|
+
var BinaryOpSymbol$2 = $EXPECT($L57, fail, 'BinaryOpSymbol "/"');
|
|
2019
|
+
var BinaryOpSymbol$3 = $EXPECT($L58, fail, 'BinaryOpSymbol "%"');
|
|
2020
|
+
var BinaryOpSymbol$4 = $EXPECT($L59, fail, 'BinaryOpSymbol "+"');
|
|
2021
|
+
var BinaryOpSymbol$5 = $EXPECT($L60, fail, 'BinaryOpSymbol "-"');
|
|
2022
|
+
var BinaryOpSymbol$6 = $EXPECT($L61, fail, 'BinaryOpSymbol "<="');
|
|
2023
|
+
var BinaryOpSymbol$7 = $EXPECT($L62, fail, 'BinaryOpSymbol ">="');
|
|
2024
|
+
var BinaryOpSymbol$8 = $EXPECT($L63, fail, 'BinaryOpSymbol "<<"');
|
|
2025
|
+
var BinaryOpSymbol$9 = $EXPECT($L14, fail, 'BinaryOpSymbol "<"');
|
|
2026
|
+
var BinaryOpSymbol$10 = $EXPECT($L64, fail, 'BinaryOpSymbol ">>>"');
|
|
2027
|
+
var BinaryOpSymbol$11 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>"');
|
|
2028
|
+
var BinaryOpSymbol$12 = $EXPECT($L66, fail, 'BinaryOpSymbol ">"');
|
|
2029
|
+
var BinaryOpSymbol$13 = $EXPECT($L67, fail, 'BinaryOpSymbol "!=="');
|
|
2030
|
+
var BinaryOpSymbol$14 = $TV($EXPECT($L68, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
|
|
1863
2031
|
if (global.coffeeCompat)
|
|
1864
2032
|
return "!==";
|
|
1865
2033
|
return $1;
|
|
1866
2034
|
});
|
|
1867
|
-
var
|
|
2035
|
+
var BinaryOpSymbol$15 = $T($S($EXPECT($L69, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
|
|
1868
2036
|
return "===";
|
|
1869
2037
|
});
|
|
1870
|
-
var
|
|
1871
|
-
var
|
|
2038
|
+
var BinaryOpSymbol$16 = $EXPECT($L70, fail, 'BinaryOpSymbol "==="');
|
|
2039
|
+
var BinaryOpSymbol$17 = $TV($EXPECT($L71, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
|
|
1872
2040
|
if (global.coffeeCompat)
|
|
1873
2041
|
return "===";
|
|
1874
2042
|
return $1;
|
|
1875
2043
|
});
|
|
1876
|
-
var
|
|
2044
|
+
var BinaryOpSymbol$18 = $T($S($EXPECT($L72, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
|
|
1877
2045
|
return "&&";
|
|
1878
2046
|
});
|
|
1879
|
-
var
|
|
1880
|
-
var
|
|
2047
|
+
var BinaryOpSymbol$19 = $EXPECT($L73, fail, 'BinaryOpSymbol "&&"');
|
|
2048
|
+
var BinaryOpSymbol$20 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
|
|
1881
2049
|
return "||";
|
|
1882
2050
|
});
|
|
1883
|
-
var
|
|
1884
|
-
var
|
|
1885
|
-
var
|
|
1886
|
-
var
|
|
1887
|
-
var
|
|
1888
|
-
var
|
|
1889
|
-
var
|
|
1890
|
-
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) {
|
|
1891
2059
|
if (state.tokenize) {
|
|
1892
|
-
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));
|
|
1893
2061
|
} else {
|
|
1894
|
-
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);
|
|
1895
2063
|
}
|
|
1896
2064
|
}
|
|
1897
2065
|
var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
|
|
1898
|
-
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, __);
|
|
1899
2067
|
function UnaryOp(state) {
|
|
1900
2068
|
if (state.tokenize) {
|
|
1901
2069
|
return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
|
|
@@ -1929,7 +2097,7 @@ var require_parser = __commonJS({
|
|
|
1929
2097
|
return StatementListItem$0(state);
|
|
1930
2098
|
}
|
|
1931
2099
|
}
|
|
1932
|
-
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) {
|
|
1933
2101
|
var ws = $1;
|
|
1934
2102
|
var cond = $2;
|
|
1935
2103
|
var exp = $4;
|
|
@@ -1962,7 +2130,7 @@ var require_parser = __commonJS({
|
|
|
1962
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);
|
|
1963
2131
|
}
|
|
1964
2132
|
}
|
|
1965
|
-
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($
|
|
2133
|
+
var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L87, fail, 'EmptyStatement ";"')));
|
|
1966
2134
|
function EmptyStatement(state) {
|
|
1967
2135
|
if (state.verbose)
|
|
1968
2136
|
console.log("ENTER:", "EmptyStatement");
|
|
@@ -1982,8 +2150,8 @@ var require_parser = __commonJS({
|
|
|
1982
2150
|
return BlockStatement$0(state);
|
|
1983
2151
|
}
|
|
1984
2152
|
}
|
|
1985
|
-
var IfStatement$0 = $S($EXPECT($
|
|
1986
|
-
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) {
|
|
1987
2155
|
var condition = $2;
|
|
1988
2156
|
var block = $3;
|
|
1989
2157
|
return ["if", condition.map((c) => {
|
|
@@ -2013,7 +2181,7 @@ var require_parser = __commonJS({
|
|
|
2013
2181
|
return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
|
|
2014
2182
|
}
|
|
2015
2183
|
}
|
|
2016
|
-
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) {
|
|
2017
2185
|
var b = $3;
|
|
2018
2186
|
return ["while(true)", b];
|
|
2019
2187
|
});
|
|
@@ -2026,7 +2194,7 @@ var require_parser = __commonJS({
|
|
|
2026
2194
|
return LoopStatement$0(state);
|
|
2027
2195
|
}
|
|
2028
2196
|
}
|
|
2029
|
-
var DoWhileStatement$0 = $S($EXPECT($
|
|
2197
|
+
var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
|
|
2030
2198
|
function DoWhileStatement(state) {
|
|
2031
2199
|
if (state.verbose)
|
|
2032
2200
|
console.log("ENTER:", "DoWhileStatement");
|
|
@@ -2046,7 +2214,7 @@ var require_parser = __commonJS({
|
|
|
2046
2214
|
return WhileStatement$0(state);
|
|
2047
2215
|
}
|
|
2048
2216
|
}
|
|
2049
|
-
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) {
|
|
2050
2218
|
var kind = $1;
|
|
2051
2219
|
var cond = $3;
|
|
2052
2220
|
if (kind === "until") {
|
|
@@ -2065,7 +2233,7 @@ var require_parser = __commonJS({
|
|
|
2065
2233
|
return WhileClause$0(state);
|
|
2066
2234
|
}
|
|
2067
2235
|
}
|
|
2068
|
-
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);
|
|
2069
2237
|
function ForStatement(state) {
|
|
2070
2238
|
if (state.verbose)
|
|
2071
2239
|
console.log("ENTER:", "ForStatement");
|
|
@@ -2075,10 +2243,10 @@ var require_parser = __commonJS({
|
|
|
2075
2243
|
return ForStatement$0(state);
|
|
2076
2244
|
}
|
|
2077
2245
|
}
|
|
2078
|
-
var ForInOfStatement$0 = $S(
|
|
2079
|
-
var ForInOfStatement$1 = $S(
|
|
2080
|
-
var ForInOfStatement$2 = $S(
|
|
2081
|
-
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);
|
|
2082
2250
|
function ForInOfStatement(state) {
|
|
2083
2251
|
if (state.tokenize) {
|
|
2084
2252
|
return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
|
|
@@ -2086,7 +2254,19 @@ var require_parser = __commonJS({
|
|
|
2086
2254
|
return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
|
|
2087
2255
|
}
|
|
2088
2256
|
}
|
|
2089
|
-
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);
|
|
2090
2270
|
function ForDeclaration(state) {
|
|
2091
2271
|
if (state.verbose)
|
|
2092
2272
|
console.log("ENTER:", "ForDeclaration");
|
|
@@ -2096,6 +2276,18 @@ var require_parser = __commonJS({
|
|
|
2096
2276
|
return ForDeclaration$0(state);
|
|
2097
2277
|
}
|
|
2098
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
|
+
}
|
|
2099
2291
|
var ForBinding$0 = BindingIdentifier;
|
|
2100
2292
|
var ForBinding$1 = BindingPattern;
|
|
2101
2293
|
function ForBinding(state) {
|
|
@@ -2105,7 +2297,7 @@ var require_parser = __commonJS({
|
|
|
2105
2297
|
return ForBinding$0(state) || ForBinding$1(state);
|
|
2106
2298
|
}
|
|
2107
2299
|
}
|
|
2108
|
-
var SwitchStatement$0 = $S($EXPECT($
|
|
2300
|
+
var SwitchStatement$0 = $S($EXPECT($L99, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
|
|
2109
2301
|
function SwitchStatement(state) {
|
|
2110
2302
|
if (state.verbose)
|
|
2111
2303
|
console.log("ENTER:", "SwitchStatement");
|
|
@@ -2149,9 +2341,9 @@ var require_parser = __commonJS({
|
|
|
2149
2341
|
return NestedCaseClause$0(state);
|
|
2150
2342
|
}
|
|
2151
2343
|
}
|
|
2152
|
-
var CaseClause$0 = $S($EXPECT($
|
|
2344
|
+
var CaseClause$0 = $S($EXPECT($L100, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
|
|
2153
2345
|
var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
|
|
2154
|
-
var CaseClause$2 = $S($EXPECT($
|
|
2346
|
+
var CaseClause$2 = $S($EXPECT($L101, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
|
|
2155
2347
|
function CaseClause(state) {
|
|
2156
2348
|
if (state.tokenize) {
|
|
2157
2349
|
return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
|
|
@@ -2159,7 +2351,7 @@ var require_parser = __commonJS({
|
|
|
2159
2351
|
return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
|
|
2160
2352
|
}
|
|
2161
2353
|
}
|
|
2162
|
-
var When$0 = $T($S($EXPECT($
|
|
2354
|
+
var When$0 = $T($S($EXPECT($L102, fail, 'When "when"'), NonIdContinue), function(value) {
|
|
2163
2355
|
return "case";
|
|
2164
2356
|
});
|
|
2165
2357
|
function When(state) {
|
|
@@ -2182,7 +2374,7 @@ var require_parser = __commonJS({
|
|
|
2182
2374
|
return ImpliedColon$0(state) || ImpliedColon$1(state);
|
|
2183
2375
|
}
|
|
2184
2376
|
}
|
|
2185
|
-
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) {
|
|
2186
2378
|
var c = $3;
|
|
2187
2379
|
var f = $4;
|
|
2188
2380
|
if (!c && !f) {
|
|
@@ -2199,7 +2391,7 @@ var require_parser = __commonJS({
|
|
|
2199
2391
|
return TryStatement$0(state);
|
|
2200
2392
|
}
|
|
2201
2393
|
}
|
|
2202
|
-
var Catch$0 = $S(__, $EXPECT($
|
|
2394
|
+
var Catch$0 = $S(__, $EXPECT($L104, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
|
|
2203
2395
|
function Catch(state) {
|
|
2204
2396
|
if (state.verbose)
|
|
2205
2397
|
console.log("ENTER:", "Catch");
|
|
@@ -2218,7 +2410,7 @@ var require_parser = __commonJS({
|
|
|
2218
2410
|
return CatchBind$0(state) || CatchBind$1(state);
|
|
2219
2411
|
}
|
|
2220
2412
|
}
|
|
2221
|
-
var Finally$0 = $S(__, $EXPECT($
|
|
2413
|
+
var Finally$0 = $S(__, $EXPECT($L105, fail, 'Finally "finally"'), BracedBlock);
|
|
2222
2414
|
function Finally(state) {
|
|
2223
2415
|
if (state.verbose)
|
|
2224
2416
|
console.log("ENTER:", "Finally");
|
|
@@ -2256,11 +2448,11 @@ var require_parser = __commonJS({
|
|
|
2256
2448
|
return ExpressionStatement$0(state);
|
|
2257
2449
|
}
|
|
2258
2450
|
}
|
|
2259
|
-
var KeywordStatement$0 = $S($EXPECT($
|
|
2260
|
-
var KeywordStatement$1 = $S($EXPECT($
|
|
2261
|
-
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);
|
|
2262
2454
|
var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
|
|
2263
|
-
var KeywordStatement$4 = $S($EXPECT($
|
|
2455
|
+
var KeywordStatement$4 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
|
|
2264
2456
|
function KeywordStatement(state) {
|
|
2265
2457
|
if (state.tokenize) {
|
|
2266
2458
|
return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
|
|
@@ -2269,16 +2461,17 @@ var require_parser = __commonJS({
|
|
|
2269
2461
|
}
|
|
2270
2462
|
}
|
|
2271
2463
|
var MaybeNestedExpression$0 = $S($N(EOS), $Q(TrailingComment), Expression);
|
|
2272
|
-
var MaybeNestedExpression$1 = $S($Y(EOS),
|
|
2273
|
-
var MaybeNestedExpression$2 = $S($Y(EOS), ObjectLiteral);
|
|
2464
|
+
var MaybeNestedExpression$1 = $S($Y(EOS), ObjectLiteral);
|
|
2274
2465
|
function MaybeNestedExpression(state) {
|
|
2275
2466
|
if (state.tokenize) {
|
|
2276
|
-
return $TOKEN("MaybeNestedExpression", state, MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state)
|
|
2467
|
+
return $TOKEN("MaybeNestedExpression", state, MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state));
|
|
2277
2468
|
} else {
|
|
2278
|
-
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state)
|
|
2469
|
+
return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
|
|
2279
2470
|
}
|
|
2280
2471
|
}
|
|
2281
|
-
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
|
+
});
|
|
2282
2475
|
function Return(state) {
|
|
2283
2476
|
if (state.verbose)
|
|
2284
2477
|
console.log("ENTER:", "Return");
|
|
@@ -2288,11 +2481,11 @@ var require_parser = __commonJS({
|
|
|
2288
2481
|
return Return$0(state);
|
|
2289
2482
|
}
|
|
2290
2483
|
}
|
|
2291
|
-
var ImportDeclaration$0 = $T($S($EXPECT($
|
|
2484
|
+
var ImportDeclaration$0 = $T($S($EXPECT($L111, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
|
|
2292
2485
|
return { "ts": true, "children": value };
|
|
2293
2486
|
});
|
|
2294
|
-
var ImportDeclaration$1 = $S(
|
|
2295
|
-
var ImportDeclaration$2 = $S(
|
|
2487
|
+
var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
|
|
2488
|
+
var ImportDeclaration$2 = $S(Import, __, ModuleSpecifier);
|
|
2296
2489
|
function ImportDeclaration(state) {
|
|
2297
2490
|
if (state.tokenize) {
|
|
2298
2491
|
return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
|
|
@@ -2300,6 +2493,18 @@ var require_parser = __commonJS({
|
|
|
2300
2493
|
return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state);
|
|
2301
2494
|
}
|
|
2302
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
|
+
}
|
|
2303
2508
|
var ImportClause$0 = $S(ImportedBinding, $E($S(__, $EXPECT($L0, fail, 'ImportClause ","'), __, $C(NameSpaceImport, NamedImports))));
|
|
2304
2509
|
var ImportClause$1 = NameSpaceImport;
|
|
2305
2510
|
var ImportClause$2 = NamedImports;
|
|
@@ -2330,7 +2535,7 @@ var require_parser = __commonJS({
|
|
|
2330
2535
|
return NamedImports$0(state);
|
|
2331
2536
|
}
|
|
2332
2537
|
}
|
|
2333
|
-
var FromClause$0 = $S(
|
|
2538
|
+
var FromClause$0 = $S(From, __, ModuleSpecifier);
|
|
2334
2539
|
function FromClause(state) {
|
|
2335
2540
|
if (state.verbose)
|
|
2336
2541
|
console.log("ENTER:", "FromClause");
|
|
@@ -2340,6 +2545,18 @@ var require_parser = __commonJS({
|
|
|
2340
2545
|
return FromClause$0(state);
|
|
2341
2546
|
}
|
|
2342
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
|
+
}
|
|
2343
2560
|
var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
|
|
2344
2561
|
var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
|
|
2345
2562
|
function ImportSpecifier(state) {
|
|
@@ -2378,7 +2595,7 @@ var require_parser = __commonJS({
|
|
|
2378
2595
|
return ImportedBinding$0(state);
|
|
2379
2596
|
}
|
|
2380
2597
|
}
|
|
2381
|
-
var ExportDeclaration$0 = $S(Export, __, $EXPECT($
|
|
2598
|
+
var ExportDeclaration$0 = $S(Export, __, $EXPECT($L101, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
|
|
2382
2599
|
var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
|
|
2383
2600
|
var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
|
|
2384
2601
|
function ExportDeclaration(state) {
|
|
@@ -2398,7 +2615,7 @@ var require_parser = __commonJS({
|
|
|
2398
2615
|
return As$0(state);
|
|
2399
2616
|
}
|
|
2400
2617
|
}
|
|
2401
|
-
var Export$0 = $S($EXPECT($
|
|
2618
|
+
var Export$0 = $S($EXPECT($L113, fail, 'Export "export"'), NonIdContinue);
|
|
2402
2619
|
function Export(state) {
|
|
2403
2620
|
if (state.verbose)
|
|
2404
2621
|
console.log("ENTER:", "Export");
|
|
@@ -2458,13 +2675,22 @@ var require_parser = __commonJS({
|
|
|
2458
2675
|
return HoistableDeclaration$0(state);
|
|
2459
2676
|
}
|
|
2460
2677
|
}
|
|
2461
|
-
var LexicalDeclaration$0 = $S(
|
|
2462
|
-
var LexicalDeclaration$1 = $
|
|
2463
|
-
var bind =
|
|
2464
|
-
var suffix =
|
|
2465
|
-
var ws =
|
|
2466
|
-
var
|
|
2467
|
-
|
|
2678
|
+
var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
|
|
2679
|
+
var LexicalDeclaration$1 = $TS($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
|
|
2680
|
+
var bind = $1;
|
|
2681
|
+
var suffix = $2;
|
|
2682
|
+
var ws = $3;
|
|
2683
|
+
var ca = $4;
|
|
2684
|
+
var exp = $5;
|
|
2685
|
+
return [
|
|
2686
|
+
{ token: "const", $loc: ca.$loc },
|
|
2687
|
+
" ",
|
|
2688
|
+
bind,
|
|
2689
|
+
suffix,
|
|
2690
|
+
ws,
|
|
2691
|
+
{ token: "=", $loc: ca.$loc },
|
|
2692
|
+
exp
|
|
2693
|
+
];
|
|
2468
2694
|
});
|
|
2469
2695
|
function LexicalDeclaration(state) {
|
|
2470
2696
|
if (state.tokenize) {
|
|
@@ -2473,6 +2699,18 @@ var require_parser = __commonJS({
|
|
|
2473
2699
|
return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
|
|
2474
2700
|
}
|
|
2475
2701
|
}
|
|
2702
|
+
var ConstAssignment$0 = $TV($EXPECT($L114, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
|
|
2703
|
+
return { $loc, token: $0 };
|
|
2704
|
+
});
|
|
2705
|
+
function ConstAssignment(state) {
|
|
2706
|
+
if (state.verbose)
|
|
2707
|
+
console.log("ENTER:", "ConstAssignment");
|
|
2708
|
+
if (state.tokenize) {
|
|
2709
|
+
return $TOKEN("ConstAssignment", state, ConstAssignment$0(state));
|
|
2710
|
+
} else {
|
|
2711
|
+
return ConstAssignment$0(state);
|
|
2712
|
+
}
|
|
2713
|
+
}
|
|
2476
2714
|
var LexicalBinding$0 = $S(BindingPattern, $E(TypeSuffix), Initializer);
|
|
2477
2715
|
var LexicalBinding$1 = $S(BindingIdentifier, $E(TypeSuffix), $E(Initializer));
|
|
2478
2716
|
function LexicalBinding(state) {
|
|
@@ -2482,7 +2720,7 @@ var require_parser = __commonJS({
|
|
|
2482
2720
|
return LexicalBinding$0(state) || LexicalBinding$1(state);
|
|
2483
2721
|
}
|
|
2484
2722
|
}
|
|
2485
|
-
var Initializer$0 = $S(__, $EXPECT($
|
|
2723
|
+
var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
|
|
2486
2724
|
function Initializer(state) {
|
|
2487
2725
|
if (state.verbose)
|
|
2488
2726
|
console.log("ENTER:", "Initializer");
|
|
@@ -2492,7 +2730,7 @@ var require_parser = __commonJS({
|
|
|
2492
2730
|
return Initializer$0(state);
|
|
2493
2731
|
}
|
|
2494
2732
|
}
|
|
2495
|
-
var VariableStatement$0 = $S($EXPECT($
|
|
2733
|
+
var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
|
|
2496
2734
|
function VariableStatement(state) {
|
|
2497
2735
|
if (state.verbose)
|
|
2498
2736
|
console.log("ENTER:", "VariableStatement");
|
|
@@ -2521,16 +2759,28 @@ var require_parser = __commonJS({
|
|
|
2521
2759
|
return VariableDeclaration$0(state) || VariableDeclaration$1(state);
|
|
2522
2760
|
}
|
|
2523
2761
|
}
|
|
2524
|
-
var NumericLiteral$0 =
|
|
2525
|
-
|
|
2526
|
-
|
|
2527
|
-
var NumericLiteral$3 = HexLiteral;
|
|
2528
|
-
var NumericLiteral$4 = DecimalLiteral;
|
|
2762
|
+
var NumericLiteral$0 = $TS($S(NumericLiteralKind), function($skip, $loc, $0, $1) {
|
|
2763
|
+
return { $loc, token: $1 };
|
|
2764
|
+
});
|
|
2529
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) {
|
|
2530
2780
|
if (state.tokenize) {
|
|
2531
|
-
return $TOKEN("
|
|
2781
|
+
return $TOKEN("NumericLiteralKind", state, NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state));
|
|
2532
2782
|
} else {
|
|
2533
|
-
return
|
|
2783
|
+
return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
|
|
2534
2784
|
}
|
|
2535
2785
|
}
|
|
2536
2786
|
var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R3, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
|
|
@@ -2583,34 +2833,45 @@ var require_parser = __commonJS({
|
|
|
2583
2833
|
return HexLiteral$0(state);
|
|
2584
2834
|
}
|
|
2585
2835
|
}
|
|
2586
|
-
var StringLiteral$0 = $
|
|
2587
|
-
|
|
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 };
|
|
2588
2849
|
});
|
|
2589
|
-
var StringLiteral$1 = $S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'));
|
|
2590
|
-
var StringLiteral$2 = $S($EXPECT($L118, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L118, fail, `StringLiteral "\\\\'"`));
|
|
2591
2850
|
function StringLiteral(state) {
|
|
2592
2851
|
if (state.tokenize) {
|
|
2593
|
-
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));
|
|
2594
2853
|
} else {
|
|
2595
|
-
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
|
|
2854
|
+
return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
|
|
2596
2855
|
}
|
|
2597
2856
|
}
|
|
2598
|
-
var DoubleStringCharacter$0 = $R$0($EXPECT($R8, fail, 'DoubleStringCharacter /[^"
|
|
2599
|
-
var DoubleStringCharacter$1 = EscapeSequence;
|
|
2857
|
+
var DoubleStringCharacter$0 = $R$0($EXPECT($R8, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
|
|
2600
2858
|
function DoubleStringCharacter(state) {
|
|
2859
|
+
if (state.verbose)
|
|
2860
|
+
console.log("ENTER:", "DoubleStringCharacter");
|
|
2601
2861
|
if (state.tokenize) {
|
|
2602
|
-
return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state)
|
|
2862
|
+
return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state));
|
|
2603
2863
|
} else {
|
|
2604
|
-
return DoubleStringCharacter$0(state)
|
|
2864
|
+
return DoubleStringCharacter$0(state);
|
|
2605
2865
|
}
|
|
2606
2866
|
}
|
|
2607
|
-
var SingleStringCharacter$0 = $R$0($EXPECT($R9, fail, "SingleStringCharacter /[^'
|
|
2608
|
-
var SingleStringCharacter$1 = EscapeSequence;
|
|
2867
|
+
var SingleStringCharacter$0 = $R$0($EXPECT($R9, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
|
|
2609
2868
|
function SingleStringCharacter(state) {
|
|
2869
|
+
if (state.verbose)
|
|
2870
|
+
console.log("ENTER:", "SingleStringCharacter");
|
|
2610
2871
|
if (state.tokenize) {
|
|
2611
|
-
return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state)
|
|
2872
|
+
return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state));
|
|
2612
2873
|
} else {
|
|
2613
|
-
return SingleStringCharacter$0(state)
|
|
2874
|
+
return SingleStringCharacter$0(state);
|
|
2614
2875
|
}
|
|
2615
2876
|
}
|
|
2616
2877
|
var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
|
|
@@ -2623,17 +2884,19 @@ var require_parser = __commonJS({
|
|
|
2623
2884
|
return TripleDoubleStringCharacter$0(state);
|
|
2624
2885
|
}
|
|
2625
2886
|
}
|
|
2626
|
-
var
|
|
2627
|
-
function
|
|
2887
|
+
var TripleSingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "TripleSingleStringCharacter /(?:'(?!'')|\\\\.|[^'])+/"));
|
|
2888
|
+
function TripleSingleStringCharacter(state) {
|
|
2628
2889
|
if (state.verbose)
|
|
2629
|
-
console.log("ENTER:", "
|
|
2890
|
+
console.log("ENTER:", "TripleSingleStringCharacter");
|
|
2630
2891
|
if (state.tokenize) {
|
|
2631
|
-
return $TOKEN("
|
|
2892
|
+
return $TOKEN("TripleSingleStringCharacter", state, TripleSingleStringCharacter$0(state));
|
|
2632
2893
|
} else {
|
|
2633
|
-
return
|
|
2894
|
+
return TripleSingleStringCharacter$0(state);
|
|
2634
2895
|
}
|
|
2635
2896
|
}
|
|
2636
|
-
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
|
+
});
|
|
2637
2900
|
function RegularExpressionLiteral(state) {
|
|
2638
2901
|
if (state.verbose)
|
|
2639
2902
|
console.log("ENTER:", "RegularExpressionLiteral");
|
|
@@ -2653,16 +2916,17 @@ var require_parser = __commonJS({
|
|
|
2653
2916
|
return RegularExpressionBody$0(state);
|
|
2654
2917
|
}
|
|
2655
2918
|
}
|
|
2656
|
-
var RegExpCharacter$0 = $R$0($EXPECT($R13, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
|
|
2657
|
-
var RegExpCharacter$1 = EscapeSequence;
|
|
2919
|
+
var RegExpCharacter$0 = $R$0($EXPECT($R13, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
|
|
2658
2920
|
function RegExpCharacter(state) {
|
|
2921
|
+
if (state.verbose)
|
|
2922
|
+
console.log("ENTER:", "RegExpCharacter");
|
|
2659
2923
|
if (state.tokenize) {
|
|
2660
|
-
return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state)
|
|
2924
|
+
return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state));
|
|
2661
2925
|
} else {
|
|
2662
|
-
return RegExpCharacter$0(state)
|
|
2926
|
+
return RegExpCharacter$0(state);
|
|
2663
2927
|
}
|
|
2664
2928
|
}
|
|
2665
|
-
var RegularExpressionFlags$0 = $R$0($EXPECT($R14, fail, "RegularExpressionFlags /(
|
|
2929
|
+
var RegularExpressionFlags$0 = $R$0($EXPECT($R14, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
|
|
2666
2930
|
function RegularExpressionFlags(state) {
|
|
2667
2931
|
if (state.verbose)
|
|
2668
2932
|
console.log("ENTER:", "RegularExpressionFlags");
|
|
@@ -2672,7 +2936,7 @@ var require_parser = __commonJS({
|
|
|
2672
2936
|
return RegularExpressionFlags$0(state);
|
|
2673
2937
|
}
|
|
2674
2938
|
}
|
|
2675
|
-
var TemplateLiteral$0 = $S($EXPECT($
|
|
2939
|
+
var TemplateLiteral$0 = $S($EXPECT($L119, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L119, fail, 'TemplateLiteral "`"'));
|
|
2676
2940
|
function TemplateLiteral(state) {
|
|
2677
2941
|
if (state.verbose)
|
|
2678
2942
|
console.log("ENTER:", "TemplateLiteral");
|
|
@@ -2682,7 +2946,7 @@ var require_parser = __commonJS({
|
|
|
2682
2946
|
return TemplateLiteral$0(state);
|
|
2683
2947
|
}
|
|
2684
2948
|
}
|
|
2685
|
-
var TemplateSubstitution$0 = $S($EXPECT($
|
|
2949
|
+
var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
|
|
2686
2950
|
function TemplateSubstitution(state) {
|
|
2687
2951
|
if (state.verbose)
|
|
2688
2952
|
console.log("ENTER:", "TemplateSubstitution");
|
|
@@ -2739,7 +3003,7 @@ var require_parser = __commonJS({
|
|
|
2739
3003
|
return MultiLineComment$0(state) || MultiLineComment$1(state);
|
|
2740
3004
|
}
|
|
2741
3005
|
}
|
|
2742
|
-
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 "*/"'));
|
|
2743
3007
|
function JSMultiLineComment(state) {
|
|
2744
3008
|
if (state.verbose)
|
|
2745
3009
|
console.log("ENTER:", "JSMultiLineComment");
|
|
@@ -2749,7 +3013,7 @@ var require_parser = __commonJS({
|
|
|
2749
3013
|
return JSMultiLineComment$0(state);
|
|
2750
3014
|
}
|
|
2751
3015
|
}
|
|
2752
|
-
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) {
|
|
2753
3017
|
if (!global.coffeeCompat)
|
|
2754
3018
|
return $skip;
|
|
2755
3019
|
return ["//", $1];
|
|
@@ -2763,7 +3027,7 @@ var require_parser = __commonJS({
|
|
|
2763
3027
|
return CoffeeSingleLineComment$0(state);
|
|
2764
3028
|
}
|
|
2765
3029
|
}
|
|
2766
|
-
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) {
|
|
2767
3031
|
return ["/*", value[1], "*/"];
|
|
2768
3032
|
});
|
|
2769
3033
|
function CoffeeMultiLineComment(state) {
|
|
@@ -2775,7 +3039,7 @@ var require_parser = __commonJS({
|
|
|
2775
3039
|
return CoffeeMultiLineComment$0(state);
|
|
2776
3040
|
}
|
|
2777
3041
|
}
|
|
2778
|
-
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 "*/"'));
|
|
2779
3043
|
function InlineComment(state) {
|
|
2780
3044
|
if (state.verbose)
|
|
2781
3045
|
console.log("ENTER:", "InlineComment");
|
|
@@ -2795,7 +3059,7 @@ var require_parser = __commonJS({
|
|
|
2795
3059
|
return RestOfLine$0(state);
|
|
2796
3060
|
}
|
|
2797
3061
|
}
|
|
2798
|
-
var TrailingComment$0 = $R$0($EXPECT($
|
|
3062
|
+
var TrailingComment$0 = $R$0($EXPECT($R21, fail, "TrailingComment /[\\t ]+/"));
|
|
2799
3063
|
var TrailingComment$1 = InlineComment;
|
|
2800
3064
|
var TrailingComment$2 = SingleLineComment;
|
|
2801
3065
|
function TrailingComment(state) {
|
|
@@ -2805,7 +3069,7 @@ var require_parser = __commonJS({
|
|
|
2805
3069
|
return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
|
|
2806
3070
|
}
|
|
2807
3071
|
}
|
|
2808
|
-
var _$0 = $P($C($R$0($EXPECT($
|
|
3072
|
+
var _$0 = $P($C($R$0($EXPECT($R21, fail, "_ /[\\t ]+/")), Comment));
|
|
2809
3073
|
function _(state) {
|
|
2810
3074
|
if (state.verbose)
|
|
2811
3075
|
console.log("ENTER:", "_");
|
|
@@ -2815,7 +3079,7 @@ var require_parser = __commonJS({
|
|
|
2815
3079
|
return _$0(state);
|
|
2816
3080
|
}
|
|
2817
3081
|
}
|
|
2818
|
-
var __$0 = $Q($C($R$0($EXPECT($
|
|
3082
|
+
var __$0 = $Q($C($R$0($EXPECT($R22, fail, "__ /[\\s]+/")), Comment));
|
|
2819
3083
|
function __(state) {
|
|
2820
3084
|
if (state.verbose)
|
|
2821
3085
|
console.log("ENTER:", "__");
|
|
@@ -2825,7 +3089,7 @@ var require_parser = __commonJS({
|
|
|
2825
3089
|
return __$0(state);
|
|
2826
3090
|
}
|
|
2827
3091
|
}
|
|
2828
|
-
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($
|
|
3092
|
+
var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L87, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
|
|
2829
3093
|
var StatementDelimiter$1 = $T($Y(EOS), function(value) {
|
|
2830
3094
|
return [";", value];
|
|
2831
3095
|
});
|
|
@@ -2836,7 +3100,7 @@ var require_parser = __commonJS({
|
|
|
2836
3100
|
return StatementDelimiter$0(state) || StatementDelimiter$1(state);
|
|
2837
3101
|
}
|
|
2838
3102
|
}
|
|
2839
|
-
var NonIdContinue$0 = $R$0($EXPECT($
|
|
3103
|
+
var NonIdContinue$0 = $R$0($EXPECT($R23, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
|
|
2840
3104
|
function NonIdContinue(state) {
|
|
2841
3105
|
if (state.verbose)
|
|
2842
3106
|
console.log("ENTER:", "NonIdContinue");
|
|
@@ -2860,7 +3124,7 @@ var require_parser = __commonJS({
|
|
|
2860
3124
|
return JSXElement$0(state) || JSXElement$1(state);
|
|
2861
3125
|
}
|
|
2862
3126
|
}
|
|
2863
|
-
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 "/>"'));
|
|
2864
3128
|
function JSXSelfClosingElement(state) {
|
|
2865
3129
|
if (state.verbose)
|
|
2866
3130
|
console.log("ENTER:", "JSXSelfClosingElement");
|
|
@@ -2870,7 +3134,7 @@ var require_parser = __commonJS({
|
|
|
2870
3134
|
return JSXSelfClosingElement$0(state);
|
|
2871
3135
|
}
|
|
2872
3136
|
}
|
|
2873
|
-
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 ">"'));
|
|
2874
3138
|
function JSXOpeningElement(state) {
|
|
2875
3139
|
if (state.verbose)
|
|
2876
3140
|
console.log("ENTER:", "JSXOpeningElement");
|
|
@@ -2880,7 +3144,7 @@ var require_parser = __commonJS({
|
|
|
2880
3144
|
return JSXOpeningElement$0(state);
|
|
2881
3145
|
}
|
|
2882
3146
|
}
|
|
2883
|
-
var JSXClosingElement$0 = $S($EXPECT($
|
|
3147
|
+
var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
|
|
2884
3148
|
function JSXClosingElement(state) {
|
|
2885
3149
|
if (state.verbose)
|
|
2886
3150
|
console.log("ENTER:", "JSXClosingElement");
|
|
@@ -2890,7 +3154,7 @@ var require_parser = __commonJS({
|
|
|
2890
3154
|
return JSXClosingElement$0(state);
|
|
2891
3155
|
}
|
|
2892
3156
|
}
|
|
2893
|
-
var JSXFragment$0 = $S($EXPECT($
|
|
3157
|
+
var JSXFragment$0 = $S($EXPECT($L126, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L127, fail, 'JSXFragment "</>"'));
|
|
2894
3158
|
function JSXFragment(state) {
|
|
2895
3159
|
if (state.verbose)
|
|
2896
3160
|
console.log("ENTER:", "JSXFragment");
|
|
@@ -2900,7 +3164,7 @@ var require_parser = __commonJS({
|
|
|
2900
3164
|
return JSXFragment$0(state);
|
|
2901
3165
|
}
|
|
2902
3166
|
}
|
|
2903
|
-
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($
|
|
3167
|
+
var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L12, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L24, fail, 'JSXElementName "."'), JSXIdentifierName))));
|
|
2904
3168
|
function JSXElementName(state) {
|
|
2905
3169
|
if (state.verbose)
|
|
2906
3170
|
console.log("ENTER:", "JSXElementName");
|
|
@@ -2910,7 +3174,7 @@ var require_parser = __commonJS({
|
|
|
2910
3174
|
return JSXElementName$0(state);
|
|
2911
3175
|
}
|
|
2912
3176
|
}
|
|
2913
|
-
var JSXIdentifierName$0 = $R$0($EXPECT($
|
|
3177
|
+
var JSXIdentifierName$0 = $R$0($EXPECT($R24, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
|
|
2914
3178
|
function JSXIdentifierName(state) {
|
|
2915
3179
|
if (state.verbose)
|
|
2916
3180
|
console.log("ENTER:", "JSXIdentifierName");
|
|
@@ -2949,7 +3213,7 @@ var require_parser = __commonJS({
|
|
|
2949
3213
|
return JSXAttributeName$0(state);
|
|
2950
3214
|
}
|
|
2951
3215
|
}
|
|
2952
|
-
var JSXAttributeInitializer$0 = $S(__, $EXPECT($
|
|
3216
|
+
var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
|
|
2953
3217
|
function JSXAttributeInitializer(state) {
|
|
2954
3218
|
if (state.verbose)
|
|
2955
3219
|
console.log("ENTER:", "JSXAttributeInitializer");
|
|
@@ -2959,8 +3223,8 @@ var require_parser = __commonJS({
|
|
|
2959
3223
|
return JSXAttributeInitializer$0(state);
|
|
2960
3224
|
}
|
|
2961
3225
|
}
|
|
2962
|
-
var JSXAttributeValue$0 = $R$0($EXPECT($
|
|
2963
|
-
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 /'[^']*'/"));
|
|
2964
3228
|
var JSXAttributeValue$2 = $S($EXPECT($L11, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttributeValue "}"'));
|
|
2965
3229
|
var JSXAttributeValue$3 = JSXElement;
|
|
2966
3230
|
var JSXAttributeValue$4 = JSXFragment;
|
|
@@ -2992,7 +3256,7 @@ var require_parser = __commonJS({
|
|
|
2992
3256
|
return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
|
|
2993
3257
|
}
|
|
2994
3258
|
}
|
|
2995
|
-
var JSXText$0 = $R$0($EXPECT($
|
|
3259
|
+
var JSXText$0 = $R$0($EXPECT($R27, fail, "JSXText /[^{}<>]+/"));
|
|
2996
3260
|
function JSXText(state) {
|
|
2997
3261
|
if (state.verbose)
|
|
2998
3262
|
console.log("ENTER:", "JSXText");
|
|
@@ -3012,10 +3276,10 @@ var require_parser = __commonJS({
|
|
|
3012
3276
|
return JSXChildExpression$0(state);
|
|
3013
3277
|
}
|
|
3014
3278
|
}
|
|
3015
|
-
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) {
|
|
3016
3280
|
return { "ts": true, "children": value };
|
|
3017
3281
|
});
|
|
3018
|
-
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) {
|
|
3019
3283
|
return { "ts": true, "children": value };
|
|
3020
3284
|
});
|
|
3021
3285
|
function TypeDeclaration(state) {
|
|
@@ -3070,7 +3334,7 @@ var require_parser = __commonJS({
|
|
|
3070
3334
|
return InterfaceProperty$0(state);
|
|
3071
3335
|
}
|
|
3072
3336
|
}
|
|
3073
|
-
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($
|
|
3337
|
+
var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L87, fail, 'InterfacePropertyDelimiter ";"'));
|
|
3074
3338
|
var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
|
|
3075
3339
|
var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
|
|
3076
3340
|
return ";";
|
|
@@ -3085,7 +3349,7 @@ var require_parser = __commonJS({
|
|
|
3085
3349
|
return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
|
|
3086
3350
|
}
|
|
3087
3351
|
}
|
|
3088
|
-
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 "?"'))));
|
|
3089
3353
|
function TypeIndexSignature(state) {
|
|
3090
3354
|
if (state.verbose)
|
|
3091
3355
|
console.log("ENTER:", "TypeIndexSignature");
|
|
@@ -3096,7 +3360,7 @@ var require_parser = __commonJS({
|
|
|
3096
3360
|
}
|
|
3097
3361
|
}
|
|
3098
3362
|
var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
|
|
3099
|
-
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)));
|
|
3100
3364
|
function TypeIndex(state) {
|
|
3101
3365
|
if (state.tokenize) {
|
|
3102
3366
|
return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
|
|
@@ -3116,7 +3380,7 @@ var require_parser = __commonJS({
|
|
|
3116
3380
|
return TypeSuffix$0(state);
|
|
3117
3381
|
}
|
|
3118
3382
|
}
|
|
3119
|
-
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) {
|
|
3120
3384
|
return { "ts": true, "children": value };
|
|
3121
3385
|
});
|
|
3122
3386
|
function ReturnTypeSuffix(state) {
|
|
@@ -3128,7 +3392,7 @@ var require_parser = __commonJS({
|
|
|
3128
3392
|
return ReturnTypeSuffix$0(state);
|
|
3129
3393
|
}
|
|
3130
3394
|
}
|
|
3131
|
-
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($
|
|
3395
|
+
var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
|
|
3132
3396
|
function TypePredicate(state) {
|
|
3133
3397
|
if (state.verbose)
|
|
3134
3398
|
console.log("ENTER:", "TypePredicate");
|
|
@@ -3178,9 +3442,9 @@ var require_parser = __commonJS({
|
|
|
3178
3442
|
return TypeUnarySuffix$0(state);
|
|
3179
3443
|
}
|
|
3180
3444
|
}
|
|
3181
|
-
var TypeUnaryOp$0 = $EXPECT($
|
|
3182
|
-
var TypeUnaryOp$1 = $EXPECT($
|
|
3183
|
-
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"');
|
|
3184
3448
|
function TypeUnaryOp(state) {
|
|
3185
3449
|
if (state.tokenize) {
|
|
3186
3450
|
return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
|
|
@@ -3188,7 +3452,7 @@ var require_parser = __commonJS({
|
|
|
3188
3452
|
return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
|
|
3189
3453
|
}
|
|
3190
3454
|
}
|
|
3191
|
-
var TypeIndexedAccess$0 = $S(__, $EXPECT($
|
|
3455
|
+
var TypeIndexedAccess$0 = $S(__, $EXPECT($L25, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L26, fail, 'TypeIndexedAccess "]"'));
|
|
3192
3456
|
function TypeIndexedAccess(state) {
|
|
3193
3457
|
if (state.verbose)
|
|
3194
3458
|
console.log("ENTER:", "TypeIndexedAccess");
|
|
@@ -3201,7 +3465,7 @@ var require_parser = __commonJS({
|
|
|
3201
3465
|
var TypePrimary$0 = InterfaceBlock;
|
|
3202
3466
|
var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
|
|
3203
3467
|
var TypePrimary$2 = $S($Q(_), FunctionType);
|
|
3204
|
-
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($
|
|
3468
|
+
var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L24, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
|
|
3205
3469
|
var TypePrimary$4 = $S($Q(_), TypeLiteral);
|
|
3206
3470
|
function TypePrimary(state) {
|
|
3207
3471
|
if (state.tokenize) {
|
|
@@ -3221,8 +3485,8 @@ var require_parser = __commonJS({
|
|
|
3221
3485
|
}
|
|
3222
3486
|
}
|
|
3223
3487
|
var TypeLiteral$0 = Literal;
|
|
3224
|
-
var TypeLiteral$1 = $EXPECT($
|
|
3225
|
-
var TypeLiteral$2 = $EXPECT($
|
|
3488
|
+
var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
|
|
3489
|
+
var TypeLiteral$2 = $EXPECT($L132, fail, 'TypeLiteral "[]"');
|
|
3226
3490
|
function TypeLiteral(state) {
|
|
3227
3491
|
if (state.tokenize) {
|
|
3228
3492
|
return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
|
|
@@ -3230,8 +3494,8 @@ var require_parser = __commonJS({
|
|
|
3230
3494
|
return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
|
|
3231
3495
|
}
|
|
3232
3496
|
}
|
|
3233
|
-
var TypeBinaryOp$0 = $EXPECT($
|
|
3234
|
-
var TypeBinaryOp$1 = $EXPECT($
|
|
3497
|
+
var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
|
|
3498
|
+
var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
|
|
3235
3499
|
function TypeBinaryOp(state) {
|
|
3236
3500
|
if (state.tokenize) {
|
|
3237
3501
|
return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
|
|
@@ -3249,7 +3513,7 @@ var require_parser = __commonJS({
|
|
|
3249
3513
|
return FunctionType$0(state);
|
|
3250
3514
|
}
|
|
3251
3515
|
}
|
|
3252
|
-
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 ">"'));
|
|
3253
3517
|
function TypeArguments(state) {
|
|
3254
3518
|
if (state.verbose)
|
|
3255
3519
|
console.log("ENTER:", "TypeArguments");
|
|
@@ -3259,7 +3523,7 @@ var require_parser = __commonJS({
|
|
|
3259
3523
|
return TypeArguments$0(state);
|
|
3260
3524
|
}
|
|
3261
3525
|
}
|
|
3262
|
-
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 ">"'));
|
|
3263
3527
|
function TypeParameters(state) {
|
|
3264
3528
|
if (state.verbose)
|
|
3265
3529
|
console.log("ENTER:", "TypeParameters");
|
|
@@ -3290,8 +3554,8 @@ var require_parser = __commonJS({
|
|
|
3290
3554
|
}
|
|
3291
3555
|
}
|
|
3292
3556
|
var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
|
|
3293
|
-
var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($
|
|
3294
|
-
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) {
|
|
3295
3559
|
return ",";
|
|
3296
3560
|
});
|
|
3297
3561
|
var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
|
|
@@ -3304,7 +3568,7 @@ var require_parser = __commonJS({
|
|
|
3304
3568
|
return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
|
|
3305
3569
|
}
|
|
3306
3570
|
}
|
|
3307
|
-
var Shebang$0 = $R$0($EXPECT($
|
|
3571
|
+
var Shebang$0 = $R$0($EXPECT($R32, fail, "Shebang /#![^\\r\\n]*/"));
|
|
3308
3572
|
function Shebang(state) {
|
|
3309
3573
|
if (state.verbose)
|
|
3310
3574
|
console.log("ENTER:", "Shebang");
|
|
@@ -3314,7 +3578,7 @@ var require_parser = __commonJS({
|
|
|
3314
3578
|
return Shebang$0(state);
|
|
3315
3579
|
}
|
|
3316
3580
|
}
|
|
3317
|
-
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) {
|
|
3318
3582
|
return $0.map((p) => p.join(""));
|
|
3319
3583
|
});
|
|
3320
3584
|
function DirectivePrologue(state) {
|
|
@@ -3336,7 +3600,7 @@ var require_parser = __commonJS({
|
|
|
3336
3600
|
return EOS$0(state);
|
|
3337
3601
|
}
|
|
3338
3602
|
}
|
|
3339
|
-
var EOL$0 = $R$0($EXPECT($
|
|
3603
|
+
var EOL$0 = $R$0($EXPECT($R34, fail, "EOL /\\r\\n|\\n|\\r|$/"));
|
|
3340
3604
|
function EOL(state) {
|
|
3341
3605
|
if (state.verbose)
|
|
3342
3606
|
console.log("ENTER:", "EOL");
|
|
@@ -3346,7 +3610,7 @@ var require_parser = __commonJS({
|
|
|
3346
3610
|
return EOL$0(state);
|
|
3347
3611
|
}
|
|
3348
3612
|
}
|
|
3349
|
-
var EOF$0 = $R$0($EXPECT($
|
|
3613
|
+
var EOF$0 = $R$0($EXPECT($R35, fail, "EOF /$/"));
|
|
3350
3614
|
function EOF(state) {
|
|
3351
3615
|
if (state.verbose)
|
|
3352
3616
|
console.log("ENTER:", "EOF");
|
|
@@ -3356,6 +3620,18 @@ var require_parser = __commonJS({
|
|
|
3356
3620
|
return EOF$0(state);
|
|
3357
3621
|
}
|
|
3358
3622
|
}
|
|
3623
|
+
var Debugger$0 = $TV($EXPECT($L31, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
|
|
3624
|
+
debugger;
|
|
3625
|
+
});
|
|
3626
|
+
function Debugger(state) {
|
|
3627
|
+
if (state.verbose)
|
|
3628
|
+
console.log("ENTER:", "Debugger");
|
|
3629
|
+
if (state.tokenize) {
|
|
3630
|
+
return $TOKEN("Debugger", state, Debugger$0(state));
|
|
3631
|
+
} else {
|
|
3632
|
+
return Debugger$0(state);
|
|
3633
|
+
}
|
|
3634
|
+
}
|
|
3359
3635
|
var InsertOpenParen$0 = $T($EXPECT($L31, fail, 'InsertOpenParen ""'), function(value) {
|
|
3360
3636
|
return "(";
|
|
3361
3637
|
});
|
|
@@ -3473,6 +3749,15 @@ var require_parser = __commonJS({
|
|
|
3473
3749
|
const compatRe = /use coffee-compat/;
|
|
3474
3750
|
global.coffeeCompat = directives.some((d) => d.match(compatRe));
|
|
3475
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
|
+
};
|
|
3476
3761
|
return $0;
|
|
3477
3762
|
});
|
|
3478
3763
|
function Init(state) {
|
|
@@ -3484,7 +3769,7 @@ var require_parser = __commonJS({
|
|
|
3484
3769
|
return Init$0(state);
|
|
3485
3770
|
}
|
|
3486
3771
|
}
|
|
3487
|
-
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) {
|
|
3488
3773
|
return $1.length;
|
|
3489
3774
|
});
|
|
3490
3775
|
function Indent(state) {
|
|
@@ -3555,6 +3840,31 @@ var require_parser = __commonJS({
|
|
|
3555
3840
|
return Nested$0(state);
|
|
3556
3841
|
}
|
|
3557
3842
|
}
|
|
3843
|
+
var NestedFurther$0 = $TS($S($E(EOS), Indent), function($skip, $loc, $0, $1, $2) {
|
|
3844
|
+
var eos = $1;
|
|
3845
|
+
var indent = $2;
|
|
3846
|
+
const currentIndent = global.indentLevels[global.indentLevels.length - 1];
|
|
3847
|
+
if (global.verbose) {
|
|
3848
|
+
console.log("global indent", global.currentIndent);
|
|
3849
|
+
console.log("Indented", indent, currentIndent);
|
|
3850
|
+
}
|
|
3851
|
+
if (indent !== currentIndent + 1) {
|
|
3852
|
+
if (global.verbose) {
|
|
3853
|
+
console.log("skipped nested");
|
|
3854
|
+
}
|
|
3855
|
+
return $skip;
|
|
3856
|
+
}
|
|
3857
|
+
return [eos, "".padStart(indent * 2)];
|
|
3858
|
+
});
|
|
3859
|
+
function NestedFurther(state) {
|
|
3860
|
+
if (state.verbose)
|
|
3861
|
+
console.log("ENTER:", "NestedFurther");
|
|
3862
|
+
if (state.tokenize) {
|
|
3863
|
+
return $TOKEN("NestedFurther", state, NestedFurther$0(state));
|
|
3864
|
+
} else {
|
|
3865
|
+
return NestedFurther$0(state);
|
|
3866
|
+
}
|
|
3867
|
+
}
|
|
3558
3868
|
module2.exports = {
|
|
3559
3869
|
parse: parse2
|
|
3560
3870
|
};
|
|
@@ -3565,11 +3875,18 @@ var require_parser = __commonJS({
|
|
|
3565
3875
|
var require_generate = __commonJS({
|
|
3566
3876
|
"source/generate.coffee"(exports2, module2) {
|
|
3567
3877
|
var gen2;
|
|
3878
|
+
var prune2;
|
|
3568
3879
|
gen2 = function(node, options) {
|
|
3880
|
+
var $loc, token;
|
|
3569
3881
|
if (node === null || node === void 0) {
|
|
3570
3882
|
return "";
|
|
3571
3883
|
}
|
|
3572
3884
|
if (typeof node === "string") {
|
|
3885
|
+
if (options != null) {
|
|
3886
|
+
if (typeof options.updateSourceMap === "function") {
|
|
3887
|
+
options.updateSourceMap(node);
|
|
3888
|
+
}
|
|
3889
|
+
}
|
|
3573
3890
|
return node;
|
|
3574
3891
|
}
|
|
3575
3892
|
if (Array.isArray(node)) {
|
|
@@ -3578,33 +3895,213 @@ var require_generate = __commonJS({
|
|
|
3578
3895
|
}).join("");
|
|
3579
3896
|
}
|
|
3580
3897
|
if (typeof node === "object") {
|
|
3581
|
-
if (
|
|
3898
|
+
if (options.js && node.ts) {
|
|
3582
3899
|
return "";
|
|
3583
3900
|
}
|
|
3901
|
+
if (node.$loc != null) {
|
|
3902
|
+
({ token, $loc } = node);
|
|
3903
|
+
if (options != null) {
|
|
3904
|
+
if (typeof options.updateSourceMap === "function") {
|
|
3905
|
+
options.updateSourceMap(token, $loc.pos);
|
|
3906
|
+
}
|
|
3907
|
+
}
|
|
3908
|
+
return token;
|
|
3909
|
+
}
|
|
3584
3910
|
if (!node.children) {
|
|
3585
3911
|
throw new Error("Unknown node", JSON.stringify(node));
|
|
3586
3912
|
}
|
|
3587
|
-
return node.children
|
|
3588
|
-
return gen2(child, options);
|
|
3589
|
-
}).join("");
|
|
3913
|
+
return gen2(node.children, options);
|
|
3590
3914
|
}
|
|
3591
3915
|
throw new Error("Unknown node", JSON.stringify(node));
|
|
3592
3916
|
};
|
|
3593
3917
|
module2.exports = gen2;
|
|
3918
|
+
prune2 = function(node) {
|
|
3919
|
+
var a;
|
|
3920
|
+
if (node === null || node === void 0) {
|
|
3921
|
+
return;
|
|
3922
|
+
}
|
|
3923
|
+
if (node.length === 0) {
|
|
3924
|
+
return;
|
|
3925
|
+
}
|
|
3926
|
+
if (Array.isArray(node)) {
|
|
3927
|
+
a = node.map(function(n) {
|
|
3928
|
+
return prune2(n);
|
|
3929
|
+
}).filter(function(n) {
|
|
3930
|
+
return !!n;
|
|
3931
|
+
});
|
|
3932
|
+
if (a.length > 1) {
|
|
3933
|
+
return a;
|
|
3934
|
+
}
|
|
3935
|
+
if (a.length === 1) {
|
|
3936
|
+
return a[0];
|
|
3937
|
+
}
|
|
3938
|
+
return;
|
|
3939
|
+
}
|
|
3940
|
+
if (node.children != null) {
|
|
3941
|
+
node.children = prune2(node.children);
|
|
3942
|
+
return node;
|
|
3943
|
+
}
|
|
3944
|
+
return node;
|
|
3945
|
+
};
|
|
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 };
|
|
3594
4075
|
}
|
|
3595
4076
|
});
|
|
3596
4077
|
|
|
3597
4078
|
// source/main.coffee
|
|
4079
|
+
var SourceMap;
|
|
3598
4080
|
var gen;
|
|
3599
4081
|
var parse;
|
|
4082
|
+
var prune;
|
|
4083
|
+
var util;
|
|
3600
4084
|
({ parse } = require_parser());
|
|
3601
|
-
gen = require_generate();
|
|
4085
|
+
({ prune } = gen = require_generate());
|
|
4086
|
+
({ SourceMap } = util = require_util());
|
|
3602
4087
|
module.exports = {
|
|
3603
4088
|
parse,
|
|
3604
4089
|
compile: function(src, options) {
|
|
3605
|
-
|
|
4090
|
+
var ast, code, sm;
|
|
4091
|
+
ast = prune(parse(src, {
|
|
3606
4092
|
filename: options != null ? options.filename : void 0
|
|
3607
|
-
})
|
|
4093
|
+
}));
|
|
4094
|
+
if (options.sourceMap) {
|
|
4095
|
+
sm = SourceMap(src);
|
|
4096
|
+
options.updateSourceMap = sm.updateSourceMap;
|
|
4097
|
+
code = gen(ast, options);
|
|
4098
|
+
return {
|
|
4099
|
+
code,
|
|
4100
|
+
sourceMap: sm
|
|
4101
|
+
};
|
|
4102
|
+
}
|
|
4103
|
+
return gen(ast, options);
|
|
3608
4104
|
},
|
|
3609
|
-
generate: gen
|
|
4105
|
+
generate: gen,
|
|
4106
|
+
util
|
|
3610
4107
|
};
|