@danielx/civet 0.3.16 → 0.4.1

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.
Files changed (6) hide show
  1. package/README.md +106 -0
  2. package/dist/browser.js +1570 -799
  3. package/dist/esbuild-plugin.js +11 -10
  4. package/dist/esm.mjs +77 -12
  5. package/dist/main.js +1570 -799
  6. package/package.json +20 -2
package/dist/main.js CHANGED
@@ -408,9 +408,13 @@ var require_parser = __commonJS({
408
408
  TopLevelStatement,
409
409
  Expression,
410
410
  Arguments,
411
+ ArgumentsWithTrailingCallExpressions,
411
412
  ArgumentList,
412
413
  NestedArgumentList,
413
414
  NestedArgument,
415
+ ImplicitApplication,
416
+ ApplicationStart,
417
+ IndentedApplicationAllowed,
414
418
  CommaExpression,
415
419
  BinaryOpExpression,
416
420
  UnaryExpression,
@@ -429,14 +433,12 @@ var require_parser = __commonJS({
429
433
  PrimaryExpression,
430
434
  ClassDeclaration,
431
435
  ClassExpression,
432
- Class,
433
436
  ClassHeritage,
434
437
  ExtendsToken,
435
438
  ClassBody,
436
439
  NestedClassElements,
437
440
  NestedClassElement,
438
441
  ClassElement,
439
- Static,
440
442
  FieldDefinition,
441
443
  This,
442
444
  AtAccessor,
@@ -446,8 +448,6 @@ var require_parser = __commonJS({
446
448
  CallExpressionRest,
447
449
  OptionalShorthand,
448
450
  NonNullAssertion,
449
- SpacedApplication,
450
- ApplicationStart,
451
451
  AdditionalReservedWords,
452
452
  MemberExpression,
453
453
  MemberExpressionRest,
@@ -461,8 +461,12 @@ var require_parser = __commonJS({
461
461
  BindingPattern,
462
462
  ObjectBindingPattern,
463
463
  ArrayBindingPattern,
464
+ NestedBindingProperties,
465
+ NestedBindingProperty,
464
466
  BindingProperty,
465
467
  BindingRestProperty,
468
+ NestedBindingElements,
469
+ NestedBindingElement,
466
470
  BindingElement,
467
471
  BindingRestElement,
468
472
  FunctionDeclaration,
@@ -491,6 +495,7 @@ var require_parser = __commonJS({
491
495
  ArrayElementExpression,
492
496
  Elision,
493
497
  ObjectLiteral,
498
+ NestedObjectLiteral,
494
499
  NestedPropertyDefinitions,
495
500
  NestedPropertyDefinition,
496
501
  ObjectPropertyDelimiter,
@@ -502,12 +507,6 @@ var require_parser = __commonJS({
502
507
  MethodSignature,
503
508
  ClassElementName,
504
509
  PrivateIdentifier,
505
- GeneratorMethod,
506
- GeneratorBody,
507
- AsyncMethod,
508
- AsyncFunctionBody,
509
- AsyncGeneratorMethod,
510
- AsyncGeneratorBody,
511
510
  AssignmentOp,
512
511
  AssignmentOpSymbol,
513
512
  BinaryOp,
@@ -527,35 +526,31 @@ var require_parser = __commonJS({
527
526
  WhileClause,
528
527
  ForStatement,
529
528
  ForInOfStatement,
530
- For,
531
529
  ForDeclaration,
532
- LetOrConst,
533
530
  ForBinding,
534
531
  SwitchStatement,
535
532
  CaseBlock,
536
533
  NestedCaseClauses,
537
534
  NestedCaseClause,
538
535
  CaseClause,
539
- When,
540
536
  ImpliedColon,
541
537
  TryStatement,
542
- Catch,
538
+ CatchClause,
543
539
  CatchBind,
544
540
  Finally,
545
541
  CatchParameter,
546
542
  Condition,
543
+ ExpressionWithIndentedApplicationSuppressed,
544
+ SuppressIndentedApplication,
547
545
  ExpressionStatement,
548
546
  KeywordStatement,
549
547
  MaybeNestedExpression,
550
- Return,
551
548
  ImportDeclaration,
552
549
  ImpliedImport,
553
- Import,
554
550
  ImportClause,
555
551
  NameSpaceImport,
556
552
  NamedImports,
557
553
  FromClause,
558
- From,
559
554
  ImportSpecifier,
560
555
  ModuleExportName,
561
556
  ModuleSpecifier,
@@ -563,8 +558,6 @@ var require_parser = __commonJS({
563
558
  UnquotedSpecifier,
564
559
  ImportedBinding,
565
560
  ExportDeclaration,
566
- As,
567
- Export,
568
561
  ExportFromClause,
569
562
  NamedExports,
570
563
  ExportSpecifier,
@@ -587,8 +580,8 @@ var require_parser = __commonJS({
587
580
  StringLiteral,
588
581
  DoubleStringCharacter,
589
582
  SingleStringCharacter,
590
- TripleDoubleStringCharacter,
591
- TripleSingleStringCharacter,
583
+ TripleDoubleStringCharacters,
584
+ TripleSingleStringCharacters,
592
585
  RegularExpressionLiteral,
593
586
  RegularExpressionBody,
594
587
  RegExpCharacter,
@@ -607,9 +600,51 @@ var require_parser = __commonJS({
607
600
  RestOfLine,
608
601
  TrailingComment,
609
602
  _,
603
+ NonNewlineWhitespace,
610
604
  __,
605
+ Whitespace,
611
606
  StatementDelimiter,
612
607
  NonIdContinue,
608
+ Loc,
609
+ As,
610
+ Async,
611
+ Await,
612
+ Catch,
613
+ Class,
614
+ CloseBrace,
615
+ CloseBracket,
616
+ CloseParen,
617
+ Colon,
618
+ Dot,
619
+ Else,
620
+ Equals,
621
+ Export,
622
+ For,
623
+ From,
624
+ Function,
625
+ GetOrSet,
626
+ If,
627
+ Import,
628
+ In,
629
+ LetOrConst,
630
+ Loop,
631
+ New,
632
+ Of,
633
+ OpenBrace,
634
+ OpenBracket,
635
+ OpenParen,
636
+ QuestionMark,
637
+ Return,
638
+ Semicolon,
639
+ Static,
640
+ Switch,
641
+ Target,
642
+ TripleDoubleQuote,
643
+ TripleSingleQuote,
644
+ Try,
645
+ Unless,
646
+ Var,
647
+ When,
613
648
  JSXElement,
614
649
  JSXSelfClosingElement,
615
650
  JSXOpeningElement,
@@ -680,137 +715,140 @@ var require_parser = __commonJS({
680
715
  InsertBreak,
681
716
  Init,
682
717
  Indent,
718
+ TrackIndent,
719
+ RestoreIndent,
720
+ Samedent,
721
+ IndentedFurther,
683
722
  PushIndent,
684
723
  PopIndent,
685
- Nested,
686
- NestedFurther
687
- });
688
- var $L0 = $L(",");
689
- var $L1 = $L("(");
690
- var $L2 = $L(")");
691
- var $L3 = $L("?");
692
- var $L4 = $L("as");
693
- var $L5 = $L("++");
694
- var $L6 = $L("--");
695
- var $L7 = $L("async");
696
- var $L8 = $L("await");
697
- var $L9 = $L("yield");
698
- var $L10 = $L("*");
699
- var $L11 = $L("=>");
700
- var $L12 = $L("{");
701
- var $L13 = $L("}");
702
- var $L14 = $L(":");
703
- var $L15 = $L("class");
704
- var $L16 = $L("<");
705
- var $L17 = $L("extends");
706
- var $L18 = $L("static");
707
- var $L19 = $L("this");
708
- var $L20 = $L("#");
709
- var $L21 = $L("@");
710
- var $L22 = $L("new");
711
- var $L23 = $L("super");
712
- var $L24 = $L("import");
713
- var $L25 = $L(".");
714
- var $L26 = $L("!");
715
- var $L27 = $L("[");
716
- var $L28 = $L("]");
717
- var $L29 = $L("::");
718
- var $L30 = $L("super[");
719
- var $L31 = $L("new.target");
720
- var $L32 = $L("import.meta");
721
- var $L33 = $L("");
722
- var $L34 = $L("...");
723
- var $L35 = $L("function");
724
- var $L36 = $L("->");
725
- var $L37 = $L("null");
726
- var $L38 = $L("true");
727
- var $L39 = $L("false");
728
- var $L40 = $L("get");
729
- var $L41 = $L("set");
730
- var $L42 = $L("**=");
731
- var $L43 = $L("*=");
732
- var $L44 = $L("/=");
733
- var $L45 = $L("%=");
734
- var $L46 = $L("+=");
735
- var $L47 = $L("-=");
736
- var $L48 = $L("<<=");
737
- var $L49 = $L(">>>=");
738
- var $L50 = $L(">>=");
739
- var $L51 = $L("&&=");
740
- var $L52 = $L("&=");
741
- var $L53 = $L("^=");
742
- var $L54 = $L("||=");
743
- var $L55 = $L("|=");
744
- var $L56 = $L("??=");
745
- var $L57 = $L("?=");
746
- var $L58 = $L("=");
747
- var $L59 = $L("**");
748
- var $L60 = $L("/");
749
- var $L61 = $L("%");
750
- var $L62 = $L("+");
751
- var $L63 = $L("-");
752
- var $L64 = $L("<=");
753
- var $L65 = $L(">=");
754
- var $L66 = $L("<<");
755
- var $L67 = $L(">>>");
756
- var $L68 = $L(">>");
757
- var $L69 = $L(">");
758
- var $L70 = $L("!==");
759
- var $L71 = $L("!=");
760
- var $L72 = $L("is");
761
- var $L73 = $L("===");
762
- var $L74 = $L("==");
763
- var $L75 = $L("and");
764
- var $L76 = $L("&&");
765
- var $L77 = $L("or");
766
- var $L78 = $L("||");
767
- var $L79 = $L("??");
768
- var $L80 = $L("instanceof");
769
- var $L81 = $L("in");
770
- var $L82 = $L("&");
771
- var $L83 = $L("^");
772
- var $L84 = $L("|");
773
- var $L85 = $L("delete");
774
- var $L86 = $L("void");
775
- var $L87 = $L("typeof");
776
- var $L88 = $L("if");
777
- var $L89 = $L("unless");
778
- var $L90 = $L(";");
779
- var $L91 = $L("else");
780
- var $L92 = $L("loop");
781
- var $L93 = $L("do");
782
- var $L94 = $L("while");
783
- var $L95 = $L("until");
784
- var $L96 = $L("var");
785
- var $L97 = $L("of");
786
- var $L98 = $L("for");
787
- var $L99 = $L("let");
788
- var $L100 = $L("const");
789
- var $L101 = $L("switch");
790
- var $L102 = $L("case");
791
- var $L103 = $L("default");
792
- var $L104 = $L("when");
793
- var $L105 = $L("try");
794
- var $L106 = $L("catch");
795
- var $L107 = $L("finally");
796
- var $L108 = $L("break");
797
- var $L109 = $L("continue");
798
- var $L110 = $L("debugger");
799
- var $L111 = $L("throw");
800
- var $L112 = $L("return");
801
- var $L113 = $L("import type");
802
- var $L114 = $L("from");
803
- var $L115 = $L("export");
804
- var $L116 = $L(":=");
805
- var $L117 = $L('"""');
806
- var $L118 = $L("'''");
807
- var $L119 = $L('"');
808
- var $L120 = $L("'");
809
- var $L121 = $L("`");
810
- var $L122 = $L("${");
811
- var $L123 = $L("/*");
812
- var $L124 = $L("*/");
813
- var $L125 = $L("###");
724
+ Nested
725
+ });
726
+ var $L0 = $L("`");
727
+ var $L1 = $L("");
728
+ var $L2 = $L("++");
729
+ var $L3 = $L("--");
730
+ var $L4 = $L("yield");
731
+ var $L5 = $L("*");
732
+ var $L6 = $L("=>");
733
+ var $L7 = $L("<");
734
+ var $L8 = $L("extends");
735
+ var $L9 = $L("this");
736
+ var $L10 = $L("#");
737
+ var $L11 = $L("@");
738
+ var $L12 = $L("super");
739
+ var $L13 = $L("import");
740
+ var $L14 = $L("!");
741
+ var $L15 = $L("::");
742
+ var $L16 = $L("super[");
743
+ var $L17 = $L("import.meta");
744
+ var $L18 = $L(")");
745
+ var $L19 = $L("...");
746
+ var $L20 = $L("->");
747
+ var $L21 = $L("null");
748
+ var $L22 = $L("true");
749
+ var $L23 = $L("false");
750
+ var $L24 = $L(",");
751
+ var $L25 = $L("]");
752
+ var $L26 = $L("}");
753
+ var $L27 = $L("**=");
754
+ var $L28 = $L("*=");
755
+ var $L29 = $L("/=");
756
+ var $L30 = $L("%=");
757
+ var $L31 = $L("+=");
758
+ var $L32 = $L("-=");
759
+ var $L33 = $L("<<=");
760
+ var $L34 = $L(">>>=");
761
+ var $L35 = $L(">>=");
762
+ var $L36 = $L("&&=");
763
+ var $L37 = $L("&=");
764
+ var $L38 = $L("^=");
765
+ var $L39 = $L("||=");
766
+ var $L40 = $L("|=");
767
+ var $L41 = $L("??=");
768
+ var $L42 = $L("?=");
769
+ var $L43 = $L("=");
770
+ var $L44 = $L("**");
771
+ var $L45 = $L("/");
772
+ var $L46 = $L("%");
773
+ var $L47 = $L("+");
774
+ var $L48 = $L("-");
775
+ var $L49 = $L("<=");
776
+ var $L50 = $L(">=");
777
+ var $L51 = $L("<<");
778
+ var $L52 = $L(">>>");
779
+ var $L53 = $L(">>");
780
+ var $L54 = $L(">");
781
+ var $L55 = $L("!==");
782
+ var $L56 = $L("!=");
783
+ var $L57 = $L("is");
784
+ var $L58 = $L("===");
785
+ var $L59 = $L("==");
786
+ var $L60 = $L("and");
787
+ var $L61 = $L("&&");
788
+ var $L62 = $L("or");
789
+ var $L63 = $L("||");
790
+ var $L64 = $L("??");
791
+ var $L65 = $L("instanceof");
792
+ var $L66 = $L("in");
793
+ var $L67 = $L("&");
794
+ var $L68 = $L("^");
795
+ var $L69 = $L("|");
796
+ var $L70 = $L("delete");
797
+ var $L71 = $L("void");
798
+ var $L72 = $L("typeof");
799
+ var $L73 = $L(";");
800
+ var $L74 = $L("do");
801
+ var $L75 = $L("while");
802
+ var $L76 = $L("until");
803
+ var $L77 = $L("case");
804
+ var $L78 = $L("default");
805
+ var $L79 = $L("finally");
806
+ var $L80 = $L("break");
807
+ var $L81 = $L("continue");
808
+ var $L82 = $L("debugger");
809
+ var $L83 = $L("throw");
810
+ var $L84 = $L("import type");
811
+ var $L85 = $L(":=");
812
+ var $L86 = $L('"');
813
+ var $L87 = $L("'");
814
+ var $L88 = $L("${");
815
+ var $L89 = $L("/*");
816
+ var $L90 = $L("*/");
817
+ var $L91 = $L("###");
818
+ var $L92 = $L("as");
819
+ var $L93 = $L("async");
820
+ var $L94 = $L("await");
821
+ var $L95 = $L("catch");
822
+ var $L96 = $L("class");
823
+ var $L97 = $L(":");
824
+ var $L98 = $L(".");
825
+ var $L99 = $L("else");
826
+ var $L100 = $L("export");
827
+ var $L101 = $L("for");
828
+ var $L102 = $L("from");
829
+ var $L103 = $L("function");
830
+ var $L104 = $L("get");
831
+ var $L105 = $L("set");
832
+ var $L106 = $L("if");
833
+ var $L107 = $L("let");
834
+ var $L108 = $L("const");
835
+ var $L109 = $L("loop");
836
+ var $L110 = $L("new");
837
+ var $L111 = $L("of");
838
+ var $L112 = $L("{");
839
+ var $L113 = $L("[");
840
+ var $L114 = $L("(");
841
+ var $L115 = $L("?");
842
+ var $L116 = $L("return");
843
+ var $L117 = $L("static");
844
+ var $L118 = $L("switch");
845
+ var $L119 = $L("target");
846
+ var $L120 = $L('"""');
847
+ var $L121 = $L("'''");
848
+ var $L122 = $L("try");
849
+ var $L123 = $L("unless");
850
+ var $L124 = $L("var");
851
+ var $L125 = $L("when");
814
852
  var $L126 = $L("/>");
815
853
  var $L127 = $L("</");
816
854
  var $L128 = $L("<>");
@@ -829,30 +867,30 @@ var require_parser = __commonJS({
829
867
  var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
830
868
  var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
831
869
  var $R2 = $R(new RegExp("[!~+-]", "suy"));
832
- var $R3 = $R(new RegExp("\\s", "suy"));
833
- var $R4 = $R(new RegExp('[^;"\\s]+', "suy"));
834
- var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
835
- var $R6 = $R(new RegExp("\\d+(?:\\.\\d*)?", "suy"));
836
- var $R7 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
837
- var $R8 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
838
- var $R9 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
839
- var $R10 = $R(new RegExp('(?:\\\\.|[^"])+', "suy"));
840
- var $R11 = $R(new RegExp("(?:\\\\.|[^'])+", "suy"));
841
- var $R12 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
842
- var $R13 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])+", "suy"));
843
- var $R14 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
844
- var $R15 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
845
- var $R16 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
846
- var $R17 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
847
- var $R18 = $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|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
848
- var $R19 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
849
- var $R20 = $R(new RegExp(".", "suy"));
850
- var $R21 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
851
- var $R22 = $R(new RegExp("[^\\r\\n]", "suy"));
852
- var $R23 = $R(new RegExp("[ \\t]+", "suy"));
853
- var $R24 = $R(new RegExp("[\\t ]+", "suy"));
854
- var $R25 = $R(new RegExp("[\\s]+", "suy"));
855
- var $R26 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
870
+ var $R3 = $R(new RegExp('[^;"\\s]+', "suy"));
871
+ var $R4 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
872
+ var $R5 = $R(new RegExp("\\d+(?:\\.\\d*)?", "suy"));
873
+ var $R6 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
874
+ var $R7 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
875
+ var $R8 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
876
+ var $R9 = $R(new RegExp('(?:\\\\.|[^"])+', "suy"));
877
+ var $R10 = $R(new RegExp("(?:\\\\.|[^'])+", "suy"));
878
+ var $R11 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])*', "suy"));
879
+ var $R12 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
880
+ var $R13 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
881
+ var $R14 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
882
+ var $R15 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
883
+ var $R16 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
884
+ var $R17 = $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|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
885
+ var $R18 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
886
+ var $R19 = $R(new RegExp(".", "suy"));
887
+ var $R20 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
888
+ var $R21 = $R(new RegExp("[^\\r\\n]", "suy"));
889
+ var $R22 = $R(new RegExp("[ \\t]+", "suy"));
890
+ var $R23 = $R(new RegExp("[\\t ]+", "suy"));
891
+ var $R24 = $R(new RegExp("[\\s]+", "suy"));
892
+ var $R25 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
893
+ var $R26 = $R(new RegExp("\\s", "suy"));
856
894
  var $R27 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
857
895
  var $R28 = $R(new RegExp('"[^"]*"', "suy"));
858
896
  var $R29 = $R(new RegExp("'[^']*'", "suy"));
@@ -883,7 +921,7 @@ var require_parser = __commonJS({
883
921
  return TopLevelStatement$0(state);
884
922
  }
885
923
  }
886
- var Expression$0 = $S(AssignmentExpression, $Q($S(__, $EXPECT($L0, fail, 'Expression ","'), AssignmentExpression)));
924
+ var Expression$0 = $S(AssignmentExpression, $Q($S(__, Comma, AssignmentExpression)));
887
925
  function Expression(state) {
888
926
  if (state.verbose)
889
927
  console.log("ENTER:", "Expression");
@@ -893,18 +931,31 @@ var require_parser = __commonJS({
893
931
  return Expression$0(state);
894
932
  }
895
933
  }
896
- var Arguments$0 = $S($EXPECT($L1, fail, 'Arguments "("'), $E(ArgumentList), $E($S(__, $EXPECT($L0, fail, 'Arguments ","'))), __, $EXPECT($L2, fail, 'Arguments ")"'));
934
+ var Arguments$0 = $S(OpenParen, $E(ArgumentList), $E($S(__, Comma)), __, CloseParen);
935
+ var Arguments$1 = ImplicitApplication;
897
936
  function Arguments(state) {
937
+ if (state.tokenize) {
938
+ return $TOKEN("Arguments", state, Arguments$0(state) || Arguments$1(state));
939
+ } else {
940
+ return Arguments$0(state) || Arguments$1(state);
941
+ }
942
+ }
943
+ var ArgumentsWithTrailingCallExpressions$0 = $TS($S(TrackIndent, $C($S(Arguments, $Q($S($Y(EOS), Samedent, $N($EXPECT($L0, fail, 'ArgumentsWithTrailingCallExpressions "`"')), CallExpressionRest)), RestoreIndent), RestoreIndent)), function($skip, $loc, $0, $1, $2) {
944
+ if (!$2)
945
+ return $skip;
946
+ return $2;
947
+ });
948
+ function ArgumentsWithTrailingCallExpressions(state) {
898
949
  if (state.verbose)
899
- console.log("ENTER:", "Arguments");
950
+ console.log("ENTER:", "ArgumentsWithTrailingCallExpressions");
900
951
  if (state.tokenize) {
901
- return $TOKEN("Arguments", state, Arguments$0(state));
952
+ return $TOKEN("ArgumentsWithTrailingCallExpressions", state, ArgumentsWithTrailingCallExpressions$0(state));
902
953
  } else {
903
- return Arguments$0(state);
954
+ return ArgumentsWithTrailingCallExpressions$0(state);
904
955
  }
905
956
  }
906
957
  var ArgumentList$0 = $S($Y(EOS), NestedArgumentList);
907
- var ArgumentList$1 = $S(__, Expression, $Q(CommaExpression));
958
+ var ArgumentList$1 = $S(Expression, $Q(CommaExpression));
908
959
  function ArgumentList(state) {
909
960
  if (state.tokenize) {
910
961
  return $TOKEN("ArgumentList", state, ArgumentList$0(state) || ArgumentList$1(state));
@@ -937,7 +988,44 @@ var require_parser = __commonJS({
937
988
  return NestedArgument$0(state);
938
989
  }
939
990
  }
940
- var CommaExpression$0 = $S(__, $EXPECT($L0, fail, 'CommaExpression ","'), __, Expression);
991
+ var ImplicitApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen);
992
+ function ImplicitApplication(state) {
993
+ if (state.verbose)
994
+ console.log("ENTER:", "ImplicitApplication");
995
+ if (state.tokenize) {
996
+ return $TOKEN("ImplicitApplication", state, ImplicitApplication$0(state));
997
+ } else {
998
+ return ImplicitApplication$0(state);
999
+ }
1000
+ }
1001
+ var ApplicationStart$0 = $TS($S($N(EOS), _, $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3) {
1002
+ var spacing = $2;
1003
+ spacing[0].token = spacing[0].token.replace(/^ ?/, "(");
1004
+ return spacing;
1005
+ });
1006
+ var ApplicationStart$1 = $S(IndentedApplicationAllowed, $Y(NestedObjectLiteral), InsertOpenParen);
1007
+ function ApplicationStart(state) {
1008
+ if (state.tokenize) {
1009
+ return $TOKEN("ApplicationStart", state, ApplicationStart$0(state) || ApplicationStart$1(state));
1010
+ } else {
1011
+ return ApplicationStart$0(state) || ApplicationStart$1(state);
1012
+ }
1013
+ }
1014
+ var IndentedApplicationAllowed$0 = $TV($EXPECT($L1, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
1015
+ if (module2.suppressIndentedApplication)
1016
+ return $skip;
1017
+ return;
1018
+ });
1019
+ function IndentedApplicationAllowed(state) {
1020
+ if (state.verbose)
1021
+ console.log("ENTER:", "IndentedApplicationAllowed");
1022
+ if (state.tokenize) {
1023
+ return $TOKEN("IndentedApplicationAllowed", state, IndentedApplicationAllowed$0(state));
1024
+ } else {
1025
+ return IndentedApplicationAllowed$0(state);
1026
+ }
1027
+ }
1028
+ var CommaExpression$0 = $S(__, Comma, Expression);
941
1029
  function CommaExpression(state) {
942
1030
  if (state.verbose)
943
1031
  console.log("ENTER:", "CommaExpression");
@@ -961,7 +1049,7 @@ var require_parser = __commonJS({
961
1049
  var pre = $1;
962
1050
  var exp = $2;
963
1051
  var post = $3;
964
- if (post === "?") {
1052
+ if (post?.token === "?") {
965
1053
  return ["(", pre, , "(", exp, ") != null)"];
966
1054
  }
967
1055
  return [pre, exp, post];
@@ -975,8 +1063,8 @@ var require_parser = __commonJS({
975
1063
  return UnaryExpression$0(state);
976
1064
  }
977
1065
  }
978
- var UnaryPostfix$0 = $EXPECT($L3, fail, 'UnaryPostfix "?"');
979
- var UnaryPostfix$1 = $T($S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), NonIdContinue, Type), function(value) {
1066
+ var UnaryPostfix$0 = QuestionMark;
1067
+ var UnaryPostfix$1 = $T($S(__, As, NonIdContinue, Type), function(value) {
980
1068
  return { "ts": true, "children": value };
981
1069
  });
982
1070
  function UnaryPostfix(state) {
@@ -995,7 +1083,7 @@ var require_parser = __commonJS({
995
1083
  return UpdateExpression$0(state) || UpdateExpression$1(state);
996
1084
  }
997
1085
  }
998
- var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L5, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L6, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
1086
+ var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L2, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L3, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
999
1087
  return { $loc, token: $1 };
1000
1088
  });
1001
1089
  function UpdateExpressionSymbol(state) {
@@ -1018,7 +1106,7 @@ var require_parser = __commonJS({
1018
1106
  }
1019
1107
  var AssignmentExpressionRest$0 = AwaitExpression;
1020
1108
  var AssignmentExpressionRest$1 = YieldExpression;
1021
- var AssignmentExpressionRest$2 = $S($E($S($EXPECT($L7, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
1109
+ var AssignmentExpressionRest$2 = $S($E($S(Async, __)), ArrowFunction);
1022
1110
  var AssignmentExpressionRest$3 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), Expression);
1023
1111
  var AssignmentExpressionRest$4 = ConditionalExpression;
1024
1112
  function AssignmentExpressionRest(state) {
@@ -1028,7 +1116,7 @@ var require_parser = __commonJS({
1028
1116
  return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state) || AssignmentExpressionRest$4(state);
1029
1117
  }
1030
1118
  }
1031
- var AwaitExpression$0 = $S($EXPECT($L8, fail, 'AwaitExpression "await"'), NonIdContinue, $Q(TrailingComment), AssignmentExpression);
1119
+ var AwaitExpression$0 = $S(Await, $Q(TrailingComment), AssignmentExpression);
1032
1120
  function AwaitExpression(state) {
1033
1121
  if (state.verbose)
1034
1122
  console.log("ENTER:", "AwaitExpression");
@@ -1038,7 +1126,7 @@ var require_parser = __commonJS({
1038
1126
  return AwaitExpression$0(state);
1039
1127
  }
1040
1128
  }
1041
- var YieldExpression$0 = $S($EXPECT($L9, fail, 'YieldExpression "yield"'), NonIdContinue, $E($S($Q(TrailingComment), $EXPECT($L10, fail, 'YieldExpression "*"'))), AssignmentExpression);
1129
+ var YieldExpression$0 = $S($EXPECT($L4, fail, 'YieldExpression "yield"'), NonIdContinue, $E($S($Q(TrailingComment), $EXPECT($L5, fail, 'YieldExpression "*"'))), AssignmentExpression);
1042
1130
  function YieldExpression(state) {
1043
1131
  if (state.verbose)
1044
1132
  console.log("ENTER:", "YieldExpression");
@@ -1057,7 +1145,7 @@ var require_parser = __commonJS({
1057
1145
  return ArrowFunction$0(state) || ArrowFunction$1(state);
1058
1146
  }
1059
1147
  }
1060
- var FatArrow$0 = $TS($S(__, $EXPECT($L11, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
1148
+ var FatArrow$0 = $TS($S(__, $EXPECT($L6, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
1061
1149
  var ws = $1;
1062
1150
  if (!ws.length)
1063
1151
  return " =>";
@@ -1072,16 +1160,8 @@ var require_parser = __commonJS({
1072
1160
  return FatArrow$0(state);
1073
1161
  }
1074
1162
  }
1075
- var FatArrowBody$0 = $S(__, $EXPECT($L12, fail, 'FatArrowBody "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L13, fail, 'FatArrowBody "}"'));
1076
- var FatArrowBody$1 = $TS($S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
1077
- var eos = $2;
1078
- var exps = $3;
1079
- if (exps.length == 1) {
1080
- exps[0].pop();
1081
- return [eos, exps];
1082
- }
1083
- return $0;
1084
- });
1163
+ var FatArrowBody$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
1164
+ var FatArrowBody$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
1085
1165
  var FatArrowBody$2 = AssignmentExpression;
1086
1166
  var FatArrowBody$3 = $S(__, AssignmentExpression);
1087
1167
  var FatArrowBody$4 = $S(InsertOpenBrace, InsertCloseBrace);
@@ -1092,7 +1172,7 @@ var require_parser = __commonJS({
1092
1172
  return FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state) || FatArrowBody$4(state);
1093
1173
  }
1094
1174
  }
1095
- var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L14, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
1175
+ var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, QuestionMark, AssignmentExpression, __, Colon, AssignmentExpression)));
1096
1176
  function ConditionalExpression(state) {
1097
1177
  if (state.verbose)
1098
1178
  console.log("ENTER:", "ConditionalExpression");
@@ -1121,7 +1201,7 @@ var require_parser = __commonJS({
1121
1201
  var PrimaryExpression$6 = ClassExpression;
1122
1202
  var PrimaryExpression$7 = RegularExpressionLiteral;
1123
1203
  var PrimaryExpression$8 = TemplateLiteral;
1124
- var PrimaryExpression$9 = $S($EXPECT($L1, fail, 'PrimaryExpression "("'), __, Expression, __, $EXPECT($L2, fail, 'PrimaryExpression ")"'));
1204
+ var PrimaryExpression$9 = $S(OpenParen, Expression, __, CloseParen);
1125
1205
  var PrimaryExpression$10 = JSXElement;
1126
1206
  var PrimaryExpression$11 = JSXFragment;
1127
1207
  function PrimaryExpression(state) {
@@ -1141,7 +1221,7 @@ var require_parser = __commonJS({
1141
1221
  return ClassDeclaration$0(state);
1142
1222
  }
1143
1223
  }
1144
- var ClassExpression$0 = $S(Class, $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
1224
+ var ClassExpression$0 = $S(Class, $E(BindingIdentifier), $E($S(__, ClassHeritage)), ClassBody);
1145
1225
  function ClassExpression(state) {
1146
1226
  if (state.verbose)
1147
1227
  console.log("ENTER:", "ClassExpression");
@@ -1151,18 +1231,6 @@ var require_parser = __commonJS({
1151
1231
  return ClassExpression$0(state);
1152
1232
  }
1153
1233
  }
1154
- var Class$0 = $TV($EXPECT($L15, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
1155
- return { $loc, token: $1 };
1156
- });
1157
- function Class(state) {
1158
- if (state.verbose)
1159
- console.log("ENTER:", "Class");
1160
- if (state.tokenize) {
1161
- return $TOKEN("Class", state, Class$0(state));
1162
- } else {
1163
- return Class$0(state);
1164
- }
1165
- }
1166
1234
  var ClassHeritage$0 = $S(ExtendsToken, __, MemberExpression);
1167
1235
  function ClassHeritage(state) {
1168
1236
  if (state.verbose)
@@ -1173,10 +1241,10 @@ var require_parser = __commonJS({
1173
1241
  return ClassHeritage$0(state);
1174
1242
  }
1175
1243
  }
1176
- var ExtendsToken$0 = $TV($EXPECT($L16, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
1244
+ var ExtendsToken$0 = $TV($EXPECT($L7, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
1177
1245
  return { $loc, token: "extends" };
1178
1246
  });
1179
- var ExtendsToken$1 = $TV($EXPECT($L17, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
1247
+ var ExtendsToken$1 = $TV($EXPECT($L8, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
1180
1248
  return { $loc, token: $1 };
1181
1249
  });
1182
1250
  function ExtendsToken(state) {
@@ -1186,7 +1254,7 @@ var require_parser = __commonJS({
1186
1254
  return ExtendsToken$0(state) || ExtendsToken$1(state);
1187
1255
  }
1188
1256
  }
1189
- var ClassBody$0 = $S(__, $EXPECT($L12, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L13, fail, 'ClassBody "}"'));
1257
+ var ClassBody$0 = $S(__, OpenBrace, $E($S(EOS, NestedClassElements)), __, CloseBrace);
1190
1258
  var ClassBody$1 = $S(InsertOpenBrace, EOS, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
1191
1259
  function ClassBody(state) {
1192
1260
  if (state.tokenize) {
@@ -1229,19 +1297,15 @@ var require_parser = __commonJS({
1229
1297
  return ClassElement$0(state) || ClassElement$1(state);
1230
1298
  }
1231
1299
  }
1232
- var Static$0 = $TV($EXPECT($L18, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
1233
- return { $loc, token: $1 };
1300
+ var FieldDefinition$0 = $TS($S(InsertReadonly, ClassElementName, $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
1301
+ var r = $1;
1302
+ var ca = $5;
1303
+ r.children[0].$loc = {
1304
+ pos: ca.$loc.pos - 1,
1305
+ length: ca.$loc.length + 1
1306
+ };
1307
+ return $0;
1234
1308
  });
1235
- function Static(state) {
1236
- if (state.verbose)
1237
- console.log("ENTER:", "Static");
1238
- if (state.tokenize) {
1239
- return $TOKEN("Static", state, Static$0(state));
1240
- } else {
1241
- return Static$0(state);
1242
- }
1243
- }
1244
- var FieldDefinition$0 = $S(InsertReadonly, ClassElementName, $E(TypeSuffix), __, ConstAssignment, AssignmentExpression);
1245
1309
  var FieldDefinition$1 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
1246
1310
  function FieldDefinition(state) {
1247
1311
  if (state.tokenize) {
@@ -1250,11 +1314,11 @@ var require_parser = __commonJS({
1250
1314
  return FieldDefinition$0(state) || FieldDefinition$1(state);
1251
1315
  }
1252
1316
  }
1253
- var This$0 = $TV($EXPECT($L19, fail, 'This "this"'), function($skip, $loc, $0, $1) {
1317
+ var This$0 = $TV($EXPECT($L9, fail, 'This "this"'), function($skip, $loc, $0, $1) {
1254
1318
  return { $loc, token: $1 };
1255
1319
  });
1256
- var This$1 = $S(AtAccessor, $S($E($EXPECT($L20, fail, 'This "#"')), IdentifierName));
1257
- var This$2 = $TV($EXPECT($L21, fail, 'This "@"'), function($skip, $loc, $0, $1) {
1320
+ var This$1 = $S(AtAccessor, $S($E($EXPECT($L10, fail, 'This "#"')), IdentifierName));
1321
+ var This$2 = $TV($EXPECT($L11, fail, 'This "@"'), function($skip, $loc, $0, $1) {
1258
1322
  return { $loc, token: "this" };
1259
1323
  });
1260
1324
  function This(state) {
@@ -1264,7 +1328,7 @@ var require_parser = __commonJS({
1264
1328
  return This$0(state) || This$1(state) || This$2(state);
1265
1329
  }
1266
1330
  }
1267
- var AtAccessor$0 = $TV($EXPECT($L21, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
1331
+ var AtAccessor$0 = $TV($EXPECT($L11, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
1268
1332
  return { $loc, token: "this." };
1269
1333
  });
1270
1334
  function AtAccessor(state) {
@@ -1285,7 +1349,7 @@ var require_parser = __commonJS({
1285
1349
  return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
1286
1350
  }
1287
1351
  }
1288
- var NewExpression$0 = $S($P($S($EXPECT($L22, fail, 'NewExpression "new"'), __)), CallExpression);
1352
+ var NewExpression$0 = $S($P($S(New, __)), CallExpression);
1289
1353
  function NewExpression(state) {
1290
1354
  if (state.verbose)
1291
1355
  console.log("ENTER:", "NewExpression");
@@ -1295,8 +1359,8 @@ var require_parser = __commonJS({
1295
1359
  return NewExpression$0(state);
1296
1360
  }
1297
1361
  }
1298
- var CallExpression$0 = $S($EXPECT($L23, fail, 'CallExpression "super"'), __, Arguments);
1299
- var CallExpression$1 = $S($EXPECT($L24, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
1362
+ var CallExpression$0 = $S($EXPECT($L12, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
1363
+ var CallExpression$1 = $S($EXPECT($L13, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
1300
1364
  var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
1301
1365
  function CallExpression(state) {
1302
1366
  if (state.tokenize) {
@@ -1305,18 +1369,17 @@ var require_parser = __commonJS({
1305
1369
  return CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state);
1306
1370
  }
1307
1371
  }
1308
- var CallExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), Arguments);
1309
- var CallExpressionRest$1 = MemberExpressionRest;
1310
- var CallExpressionRest$2 = SpacedApplication;
1311
- var CallExpressionRest$3 = TemplateLiteral;
1372
+ var CallExpressionRest$0 = MemberExpressionRest;
1373
+ var CallExpressionRest$1 = TemplateLiteral;
1374
+ var CallExpressionRest$2 = $S($E($C(OptionalShorthand, NonNullAssertion)), ArgumentsWithTrailingCallExpressions);
1312
1375
  function CallExpressionRest(state) {
1313
1376
  if (state.tokenize) {
1314
- return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state));
1377
+ return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state));
1315
1378
  } else {
1316
- return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
1379
+ return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state);
1317
1380
  }
1318
1381
  }
1319
- var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L25, fail, 'OptionalShorthand "."'), InsertDot));
1382
+ var OptionalShorthand$0 = $S(QuestionMark, $C(Dot, InsertDot));
1320
1383
  function OptionalShorthand(state) {
1321
1384
  if (state.verbose)
1322
1385
  console.log("ENTER:", "OptionalShorthand");
@@ -1326,7 +1389,7 @@ var require_parser = __commonJS({
1326
1389
  return OptionalShorthand$0(state);
1327
1390
  }
1328
1391
  }
1329
- var NonNullAssertion$0 = $T($EXPECT($L26, fail, 'NonNullAssertion "!"'), function(value) {
1392
+ var NonNullAssertion$0 = $T($EXPECT($L14, fail, 'NonNullAssertion "!"'), function(value) {
1330
1393
  return { "ts": true, "children": value };
1331
1394
  });
1332
1395
  function NonNullAssertion(state) {
@@ -1338,30 +1401,6 @@ var require_parser = __commonJS({
1338
1401
  return NonNullAssertion$0(state);
1339
1402
  }
1340
1403
  }
1341
- var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen, $Q($S($Y(EOS), Nested, CallExpressionRest)));
1342
- function SpacedApplication(state) {
1343
- if (state.verbose)
1344
- console.log("ENTER:", "SpacedApplication");
1345
- if (state.tokenize) {
1346
- return $TOKEN("SpacedApplication", state, SpacedApplication$0(state));
1347
- } else {
1348
- return SpacedApplication$0(state);
1349
- }
1350
- }
1351
- var ApplicationStart$0 = $TS($S($E(OptionalShorthand), $N(EOS), $TEXT($P(_)), $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3, $4) {
1352
- var opt = $1;
1353
- var spacing = $3;
1354
- return [opt, "(", spacing.replace(/^ /, "")];
1355
- });
1356
- function ApplicationStart(state) {
1357
- if (state.verbose)
1358
- console.log("ENTER:", "ApplicationStart");
1359
- if (state.tokenize) {
1360
- return $TOKEN("ApplicationStart", state, ApplicationStart$0(state));
1361
- } else {
1362
- return ApplicationStart$0(state);
1363
- }
1364
- }
1365
1404
  var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue})/"));
1366
1405
  function AdditionalReservedWords(state) {
1367
1406
  if (state.verbose)
@@ -1382,10 +1421,10 @@ var require_parser = __commonJS({
1382
1421
  return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
1383
1422
  }
1384
1423
  }
1385
- var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), $EXPECT($L27, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L28, fail, 'MemberExpressionRest "]"'));
1386
- var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
1387
- var MemberExpressionRest$2 = $TS($S($EXPECT($L29, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
1388
- var id = $2;
1424
+ var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), OpenBracket, Expression, __, CloseBracket);
1425
+ var MemberExpressionRest$1 = $S($E($S($Y(EOS), IndentedFurther)), PropertyAccess);
1426
+ var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L15, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
1427
+ var id = $3;
1389
1428
  if (id)
1390
1429
  return [".prototype.", id];
1391
1430
  return ".prototype";
@@ -1398,7 +1437,7 @@ var require_parser = __commonJS({
1398
1437
  return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state);
1399
1438
  }
1400
1439
  }
1401
- var PropertyAccess$0 = $S($E($C($EXPECT($L3, fail, 'PropertyAccess "?"'), NonNullAssertion)), $EXPECT($L25, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
1440
+ var PropertyAccess$0 = $S($E($C(QuestionMark, NonNullAssertion)), Dot, $C(IdentifierName, PrivateIdentifier));
1402
1441
  function PropertyAccess(state) {
1403
1442
  if (state.verbose)
1404
1443
  console.log("ENTER:", "PropertyAccess");
@@ -1408,7 +1447,7 @@ var require_parser = __commonJS({
1408
1447
  return PropertyAccess$0(state);
1409
1448
  }
1410
1449
  }
1411
- var SuperProperty$0 = $S($EXPECT($L30, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L28, fail, 'SuperProperty "]"'));
1450
+ var SuperProperty$0 = $S($EXPECT($L16, fail, 'SuperProperty "super["'), Expression, __, CloseBracket);
1412
1451
  function SuperProperty(state) {
1413
1452
  if (state.verbose)
1414
1453
  console.log("ENTER:", "SuperProperty");
@@ -1418,8 +1457,10 @@ var require_parser = __commonJS({
1418
1457
  return SuperProperty$0(state);
1419
1458
  }
1420
1459
  }
1421
- var MetaProperty$0 = $EXPECT($L31, fail, 'MetaProperty "new.target"');
1422
- var MetaProperty$1 = $EXPECT($L32, fail, 'MetaProperty "import.meta"');
1460
+ var MetaProperty$0 = $S(New, Dot, Target);
1461
+ var MetaProperty$1 = $TV($EXPECT($L17, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
1462
+ return { $loc, token: $1 };
1463
+ });
1423
1464
  function MetaProperty(state) {
1424
1465
  if (state.tokenize) {
1425
1466
  return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
@@ -1427,9 +1468,9 @@ var require_parser = __commonJS({
1427
1468
  return MetaProperty$0(state) || MetaProperty$1(state);
1428
1469
  }
1429
1470
  }
1430
- var Parameters$0 = $S($E(TypeParameters), $EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
1431
- var Parameters$1 = $T($EXPECT($L33, fail, 'Parameters ""'), function(value) {
1432
- return "()";
1471
+ var Parameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), __, CloseParen);
1472
+ var Parameters$1 = $TV($EXPECT($L1, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
1473
+ return { $loc, token: "()" };
1433
1474
  });
1434
1475
  function Parameters(state) {
1435
1476
  if (state.tokenize) {
@@ -1448,13 +1489,13 @@ var require_parser = __commonJS({
1448
1489
  return ParameterElement$0(state);
1449
1490
  }
1450
1491
  }
1451
- var ParameterElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ParameterElementDelimiter ","'));
1452
- var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L2, fail, 'ParameterElementDelimiter ")"')));
1453
- var ParameterElementDelimiter$2 = $T($Y($S(__, $EXPECT($L2, fail, 'ParameterElementDelimiter ")"'))), function(value) {
1454
- return ",";
1492
+ var ParameterElementDelimiter$0 = $S($Q(_), Comma);
1493
+ var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L18, fail, 'ParameterElementDelimiter ")"')));
1494
+ var ParameterElementDelimiter$2 = $TV($Y($S(__, $EXPECT($L18, fail, 'ParameterElementDelimiter ")"'))), function($skip, $loc, $0, $1) {
1495
+ return { $loc, token: "," };
1455
1496
  });
1456
- var ParameterElementDelimiter$3 = $T($Y(EOS), function(value) {
1457
- return ",";
1497
+ var ParameterElementDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
1498
+ return { $loc, token: "," };
1458
1499
  });
1459
1500
  function ParameterElementDelimiter(state) {
1460
1501
  if (state.tokenize) {
@@ -1463,7 +1504,7 @@ var require_parser = __commonJS({
1463
1504
  return ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state) || ParameterElementDelimiter$3(state);
1464
1505
  }
1465
1506
  }
1466
- var BindingIdentifier$0 = Identifier;
1507
+ var BindingIdentifier$0 = $S(__, Identifier);
1467
1508
  function BindingIdentifier(state) {
1468
1509
  if (state.verbose)
1469
1510
  console.log("ENTER:", "BindingIdentifier");
@@ -1473,8 +1514,8 @@ var require_parser = __commonJS({
1473
1514
  return BindingIdentifier$0(state);
1474
1515
  }
1475
1516
  }
1476
- var BindingPattern$0 = ObjectBindingPattern;
1477
- var BindingPattern$1 = ArrayBindingPattern;
1517
+ var BindingPattern$0 = $S(__, ObjectBindingPattern);
1518
+ var BindingPattern$1 = $S(__, ArrayBindingPattern);
1478
1519
  function BindingPattern(state) {
1479
1520
  if (state.tokenize) {
1480
1521
  return $TOKEN("BindingPattern", state, BindingPattern$0(state) || BindingPattern$1(state));
@@ -1482,28 +1523,54 @@ var require_parser = __commonJS({
1482
1523
  return BindingPattern$0(state) || BindingPattern$1(state);
1483
1524
  }
1484
1525
  }
1485
- var ObjectBindingPattern$0 = $S($EXPECT($L12, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L13, fail, 'ObjectBindingPattern "}"'));
1526
+ var ObjectBindingPattern$0 = $S(OpenBrace, $Y(EOS), NestedBindingProperties, __, CloseBrace);
1527
+ var ObjectBindingPattern$1 = $S(OpenBrace, $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, CloseBrace);
1486
1528
  function ObjectBindingPattern(state) {
1487
- if (state.verbose)
1488
- console.log("ENTER:", "ObjectBindingPattern");
1489
1529
  if (state.tokenize) {
1490
- return $TOKEN("ObjectBindingPattern", state, ObjectBindingPattern$0(state));
1530
+ return $TOKEN("ObjectBindingPattern", state, ObjectBindingPattern$0(state) || ObjectBindingPattern$1(state));
1491
1531
  } else {
1492
- return ObjectBindingPattern$0(state);
1532
+ return ObjectBindingPattern$0(state) || ObjectBindingPattern$1(state);
1493
1533
  }
1494
1534
  }
1495
- var ArrayBindingPattern$0 = $S($EXPECT($L27, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L28, fail, 'ArrayBindingPattern "]"'));
1535
+ var ArrayBindingPattern$0 = $S(OpenBracket, $Y(EOS), NestedBindingElements, __, CloseBracket);
1536
+ var ArrayBindingPattern$1 = $S(OpenBracket, $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, CloseBracket);
1496
1537
  function ArrayBindingPattern(state) {
1538
+ if (state.tokenize) {
1539
+ return $TOKEN("ArrayBindingPattern", state, ArrayBindingPattern$0(state) || ArrayBindingPattern$1(state));
1540
+ } else {
1541
+ return ArrayBindingPattern$0(state) || ArrayBindingPattern$1(state);
1542
+ }
1543
+ }
1544
+ var NestedBindingProperties$0 = $TS($S(PushIndent, $Q(NestedBindingProperty), $E($S(Nested, BindingRestProperty)), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
1545
+ var props = $2;
1546
+ var rest = $3;
1547
+ if (!props.length)
1548
+ return $skip;
1549
+ if (rest)
1550
+ props.push(rest);
1551
+ return props;
1552
+ });
1553
+ function NestedBindingProperties(state) {
1554
+ if (state.verbose)
1555
+ console.log("ENTER:", "NestedBindingProperties");
1556
+ if (state.tokenize) {
1557
+ return $TOKEN("NestedBindingProperties", state, NestedBindingProperties$0(state));
1558
+ } else {
1559
+ return NestedBindingProperties$0(state);
1560
+ }
1561
+ }
1562
+ var NestedBindingProperty$0 = $S(Nested, BindingProperty);
1563
+ function NestedBindingProperty(state) {
1497
1564
  if (state.verbose)
1498
- console.log("ENTER:", "ArrayBindingPattern");
1565
+ console.log("ENTER:", "NestedBindingProperty");
1499
1566
  if (state.tokenize) {
1500
- return $TOKEN("ArrayBindingPattern", state, ArrayBindingPattern$0(state));
1567
+ return $TOKEN("NestedBindingProperty", state, NestedBindingProperty$0(state));
1501
1568
  } else {
1502
- return ArrayBindingPattern$0(state);
1569
+ return NestedBindingProperty$0(state);
1503
1570
  }
1504
1571
  }
1505
- var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L14, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
1506
- var BindingProperty$1 = $S(__, BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
1572
+ var BindingProperty$0 = $S(__, PropertyName, __, Colon, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
1573
+ var BindingProperty$1 = $S(BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
1507
1574
  function BindingProperty(state) {
1508
1575
  if (state.tokenize) {
1509
1576
  return $TOKEN("BindingProperty", state, BindingProperty$0(state) || BindingProperty$1(state));
@@ -1511,7 +1578,7 @@ var require_parser = __commonJS({
1511
1578
  return BindingProperty$0(state) || BindingProperty$1(state);
1512
1579
  }
1513
1580
  }
1514
- var BindingRestProperty$0 = $S($EXPECT($L34, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1581
+ var BindingRestProperty$0 = $S($EXPECT($L19, fail, 'BindingRestProperty "..."'), BindingIdentifier);
1515
1582
  function BindingRestProperty(state) {
1516
1583
  if (state.verbose)
1517
1584
  console.log("ENTER:", "BindingRestProperty");
@@ -1521,6 +1588,34 @@ var require_parser = __commonJS({
1521
1588
  return BindingRestProperty$0(state);
1522
1589
  }
1523
1590
  }
1591
+ var NestedBindingElements$0 = $TS($S(PushIndent, $Q(NestedBindingElement), $E($S(Nested, BindingRestElement)), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
1592
+ var props = $2;
1593
+ var rest = $3;
1594
+ if (!props.length)
1595
+ return $skip;
1596
+ if (rest)
1597
+ props.push(rest);
1598
+ return props;
1599
+ });
1600
+ function NestedBindingElements(state) {
1601
+ if (state.verbose)
1602
+ console.log("ENTER:", "NestedBindingElements");
1603
+ if (state.tokenize) {
1604
+ return $TOKEN("NestedBindingElements", state, NestedBindingElements$0(state));
1605
+ } else {
1606
+ return NestedBindingElements$0(state);
1607
+ }
1608
+ }
1609
+ var NestedBindingElement$0 = $S(Nested, BindingElement);
1610
+ function NestedBindingElement(state) {
1611
+ if (state.verbose)
1612
+ console.log("ENTER:", "NestedBindingElement");
1613
+ if (state.tokenize) {
1614
+ return $TOKEN("NestedBindingElement", state, NestedBindingElement$0(state));
1615
+ } else {
1616
+ return NestedBindingElement$0(state);
1617
+ }
1618
+ }
1524
1619
  var BindingElement$0 = $S(__, $C(BindingIdentifier, BindingPattern), $E(Initializer), ArrayElementDelimiter);
1525
1620
  function BindingElement(state) {
1526
1621
  if (state.verbose)
@@ -1531,7 +1626,7 @@ var require_parser = __commonJS({
1531
1626
  return BindingElement$0(state);
1532
1627
  }
1533
1628
  }
1534
- var BindingRestElement$0 = $S($EXPECT($L34, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1629
+ var BindingRestElement$0 = $S($EXPECT($L19, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1535
1630
  function BindingRestElement(state) {
1536
1631
  if (state.verbose)
1537
1632
  console.log("ENTER:", "BindingRestElement");
@@ -1552,7 +1647,7 @@ var require_parser = __commonJS({
1552
1647
  }
1553
1648
  }
1554
1649
  var FunctionExpression$0 = ThinArrowFunction;
1555
- var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L35, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L10, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1650
+ var FunctionExpression$1 = $S($E($S(Async, __)), Function, $E($S($EXPECT($L5, fail, 'FunctionExpression "*"'), __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1556
1651
  function FunctionExpression(state) {
1557
1652
  if (state.tokenize) {
1558
1653
  return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1581,7 +1676,7 @@ var require_parser = __commonJS({
1581
1676
  return ThinArrowFunction$0(state);
1582
1677
  }
1583
1678
  }
1584
- var Arrow$0 = $TV($EXPECT($L36, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1679
+ var Arrow$0 = $TV($EXPECT($L20, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1585
1680
  return { $loc, token: $1 };
1586
1681
  });
1587
1682
  function Arrow(state) {
@@ -1593,7 +1688,7 @@ var require_parser = __commonJS({
1593
1688
  return Arrow$0(state);
1594
1689
  }
1595
1690
  }
1596
- var Block$0 = $S(__, $EXPECT($L12, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L13, fail, 'Block "}"'));
1691
+ var Block$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
1597
1692
  var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
1598
1693
  var Block$2 = Statement;
1599
1694
  var Block$3 = $S(__, Statement);
@@ -1613,7 +1708,7 @@ var require_parser = __commonJS({
1613
1708
  return BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state);
1614
1709
  }
1615
1710
  }
1616
- var BracedBlock$0 = $S(__, $EXPECT($L12, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L13, fail, 'BracedBlock "}"'));
1711
+ var BracedBlock$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
1617
1712
  var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
1618
1713
  var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
1619
1714
  function BracedBlock(state) {
@@ -1674,7 +1769,7 @@ var require_parser = __commonJS({
1674
1769
  return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
1675
1770
  }
1676
1771
  }
1677
- var NullLiteral$0 = $TV($EXPECT($L37, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1772
+ var NullLiteral$0 = $TV($EXPECT($L21, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1678
1773
  return { $loc, token: $1 };
1679
1774
  });
1680
1775
  function NullLiteral(state) {
@@ -1686,7 +1781,7 @@ var require_parser = __commonJS({
1686
1781
  return NullLiteral$0(state);
1687
1782
  }
1688
1783
  }
1689
- var BooleanLiteral$0 = $TV($C($EXPECT($L38, fail, 'BooleanLiteral "true"'), $EXPECT($L39, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1784
+ var BooleanLiteral$0 = $TV($C($EXPECT($L22, fail, 'BooleanLiteral "true"'), $EXPECT($L23, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1690
1785
  return { $loc, token: $1 };
1691
1786
  });
1692
1787
  function BooleanLiteral(state) {
@@ -1698,7 +1793,9 @@ var require_parser = __commonJS({
1698
1793
  return BooleanLiteral$0(state);
1699
1794
  }
1700
1795
  }
1701
- var Comma$0 = $S($Q(_), $EXPECT($L0, fail, 'Comma ","'), $Q(_));
1796
+ var Comma$0 = $TV($EXPECT($L24, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
1797
+ return { $loc, token: $1 };
1798
+ });
1702
1799
  function Comma(state) {
1703
1800
  if (state.verbose)
1704
1801
  console.log("ENTER:", "Comma");
@@ -1743,8 +1840,8 @@ var require_parser = __commonJS({
1743
1840
  return IdentifierReference$0(state);
1744
1841
  }
1745
1842
  }
1746
- var ArrayLiteral$0 = $S($EXPECT($L27, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L28, fail, 'ArrayLiteral "]"'));
1747
- var ArrayLiteral$1 = $S($EXPECT($L27, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L28, fail, 'ArrayLiteral "]"'));
1843
+ var ArrayLiteral$0 = $S(OpenBracket, NestedElementList, __, CloseBracket);
1844
+ var ArrayLiteral$1 = $S(OpenBracket, ElementList, __, CloseBracket);
1748
1845
  function ArrayLiteral(state) {
1749
1846
  if (state.tokenize) {
1750
1847
  return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
@@ -1777,10 +1874,10 @@ var require_parser = __commonJS({
1777
1874
  return NestedElement$0(state);
1778
1875
  }
1779
1876
  }
1780
- var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
1781
- var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L28, fail, 'ArrayElementDelimiter "]"')));
1782
- var ArrayElementDelimiter$2 = $T($Y(EOS), function(value) {
1783
- return ",";
1877
+ var ArrayElementDelimiter$0 = $S($Q(_), Comma);
1878
+ var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
1879
+ var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
1880
+ return { $loc, token: "," };
1784
1881
  });
1785
1882
  function ArrayElementDelimiter(state) {
1786
1883
  if (state.tokenize) {
@@ -1789,7 +1886,7 @@ var require_parser = __commonJS({
1789
1886
  return ArrayElementDelimiter$0(state) || ArrayElementDelimiter$1(state) || ArrayElementDelimiter$2(state);
1790
1887
  }
1791
1888
  }
1792
- var ElementList$0 = $S(ArrayElementExpression, $Q($S(__, $EXPECT($L0, fail, 'ElementList ","'), __, ArrayElementExpression)));
1889
+ var ElementList$0 = $S(ArrayElementExpression, $Q($S(__, Comma, __, ArrayElementExpression)));
1793
1890
  function ElementList(state) {
1794
1891
  if (state.verbose)
1795
1892
  console.log("ENTER:", "ElementList");
@@ -1799,7 +1896,7 @@ var require_parser = __commonJS({
1799
1896
  return ElementList$0(state);
1800
1897
  }
1801
1898
  }
1802
- var InlineElementList$0 = $S(ArrayElementExpression, $Q($S($Q(_), $EXPECT($L0, fail, 'InlineElementList ","'), $Q(_), ArrayElementExpression)));
1899
+ var InlineElementList$0 = $S(ArrayElementExpression, $Q($S($Q(_), Comma, $Q(_), ArrayElementExpression)));
1803
1900
  function InlineElementList(state) {
1804
1901
  if (state.verbose)
1805
1902
  console.log("ENTER:", "InlineElementList");
@@ -1809,7 +1906,7 @@ var require_parser = __commonJS({
1809
1906
  return InlineElementList$0(state);
1810
1907
  }
1811
1908
  }
1812
- var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L34, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1909
+ var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L19, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1813
1910
  function ArrayElementExpression(state) {
1814
1911
  if (state.verbose)
1815
1912
  console.log("ENTER:", "ArrayElementExpression");
@@ -1819,7 +1916,7 @@ var require_parser = __commonJS({
1819
1916
  return ArrayElementExpression$0(state);
1820
1917
  }
1821
1918
  }
1822
- var Elision$0 = $S(__, $EXPECT($L0, fail, 'Elision ","'));
1919
+ var Elision$0 = $S(__, Comma);
1823
1920
  function Elision(state) {
1824
1921
  if (state.verbose)
1825
1922
  console.log("ENTER:", "Elision");
@@ -1829,10 +1926,10 @@ var require_parser = __commonJS({
1829
1926
  return Elision$0(state);
1830
1927
  }
1831
1928
  }
1832
- var ObjectLiteral$0 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L13, fail, 'ObjectLiteral "}"'));
1833
- var ObjectLiteral$1 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L13, fail, 'ObjectLiteral "}"'));
1834
- var ObjectLiteral$2 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), __, $EXPECT($L13, fail, 'ObjectLiteral "}"'));
1835
- var ObjectLiteral$3 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
1929
+ var ObjectLiteral$0 = $S(OpenBrace, $Y(EOS), NestedPropertyDefinitions, __, CloseBrace);
1930
+ var ObjectLiteral$1 = $S(OpenBrace, __, PropertyDefinitionList, __, $E($S(Comma, __)), CloseBrace);
1931
+ var ObjectLiteral$2 = $S(OpenBrace, __, CloseBrace);
1932
+ var ObjectLiteral$3 = NestedObjectLiteral;
1836
1933
  function ObjectLiteral(state) {
1837
1934
  if (state.tokenize) {
1838
1935
  return $TOKEN("ObjectLiteral", state, ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state) || ObjectLiteral$3(state));
@@ -1840,6 +1937,16 @@ var require_parser = __commonJS({
1840
1937
  return ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state) || ObjectLiteral$3(state);
1841
1938
  }
1842
1939
  }
1940
+ var NestedObjectLiteral$0 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
1941
+ function NestedObjectLiteral(state) {
1942
+ if (state.verbose)
1943
+ console.log("ENTER:", "NestedObjectLiteral");
1944
+ if (state.tokenize) {
1945
+ return $TOKEN("NestedObjectLiteral", state, NestedObjectLiteral$0(state));
1946
+ } else {
1947
+ return NestedObjectLiteral$0(state);
1948
+ }
1949
+ }
1843
1950
  var NestedPropertyDefinitions$0 = $TS($S(PushIndent, $Q(NestedPropertyDefinition), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
1844
1951
  var defs = $2;
1845
1952
  if (!defs.length)
@@ -1865,22 +1972,19 @@ var require_parser = __commonJS({
1865
1972
  return NestedPropertyDefinition$0(state);
1866
1973
  }
1867
1974
  }
1868
- var ObjectPropertyDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ObjectPropertyDelimiter ","'));
1869
- var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L13, fail, 'ObjectPropertyDelimiter "}"')));
1870
- var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L13, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
1871
- return ",";
1872
- });
1873
- var ObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
1874
- return ",";
1975
+ var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
1976
+ var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ObjectPropertyDelimiter "}"')));
1977
+ var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
1978
+ return { $loc, token: "," };
1875
1979
  });
1876
1980
  function ObjectPropertyDelimiter(state) {
1877
1981
  if (state.tokenize) {
1878
- return $TOKEN("ObjectPropertyDelimiter", state, ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state) || ObjectPropertyDelimiter$3(state));
1982
+ return $TOKEN("ObjectPropertyDelimiter", state, ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state));
1879
1983
  } else {
1880
- return ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state) || ObjectPropertyDelimiter$3(state);
1984
+ return ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state);
1881
1985
  }
1882
1986
  }
1883
- var PropertyDefinitionList$0 = $S(PropertyDefinition, $Q($S(__, $EXPECT($L0, fail, 'PropertyDefinitionList ","'), __, PropertyDefinition)));
1987
+ var PropertyDefinitionList$0 = $S(PropertyDefinition, $Q($S(__, Comma, __, PropertyDefinition)));
1884
1988
  function PropertyDefinitionList(state) {
1885
1989
  if (state.verbose)
1886
1990
  console.log("ENTER:", "PropertyDefinitionList");
@@ -1890,9 +1994,9 @@ var require_parser = __commonJS({
1890
1994
  return PropertyDefinitionList$0(state);
1891
1995
  }
1892
1996
  }
1893
- var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L14, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1997
+ var PropertyDefinition$0 = $S(PropertyName, __, Colon, AssignmentExpression);
1894
1998
  var PropertyDefinition$1 = MethodDefinition;
1895
- var PropertyDefinition$2 = $S($EXPECT($L34, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1999
+ var PropertyDefinition$2 = $S($EXPECT($L19, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1896
2000
  var PropertyDefinition$3 = IdentifierReference;
1897
2001
  function PropertyDefinition(state) {
1898
2002
  if (state.tokenize) {
@@ -1904,7 +2008,7 @@ var require_parser = __commonJS({
1904
2008
  var PropertyName$0 = NumericLiteral;
1905
2009
  var PropertyName$1 = StringLiteral;
1906
2010
  var PropertyName$2 = IdentifierName;
1907
- var PropertyName$3 = $S($EXPECT($L27, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L28, fail, 'PropertyName "]"'));
2011
+ var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L25, fail, 'PropertyName "]"'));
1908
2012
  function PropertyName(state) {
1909
2013
  if (state.tokenize) {
1910
2014
  return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -1912,27 +2016,25 @@ var require_parser = __commonJS({
1912
2016
  return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
1913
2017
  }
1914
2018
  }
1915
- var MethodDefinition$0 = $S($EXPECT($L40, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1916
- var MethodDefinition$1 = $S($EXPECT($L41, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1917
- var MethodDefinition$2 = AsyncGeneratorMethod;
1918
- var MethodDefinition$3 = AsyncMethod;
1919
- var MethodDefinition$4 = GeneratorMethod;
1920
- var MethodDefinition$5 = $S(ClassElementName, $Q(_), Parameters, BracedBlock);
2019
+ var MethodDefinition$0 = $S(MethodSignature, BracedBlock);
1921
2020
  function MethodDefinition(state) {
2021
+ if (state.verbose)
2022
+ console.log("ENTER:", "MethodDefinition");
1922
2023
  if (state.tokenize) {
1923
- return $TOKEN("MethodDefinition", state, MethodDefinition$0(state) || MethodDefinition$1(state) || MethodDefinition$2(state) || MethodDefinition$3(state) || MethodDefinition$4(state) || MethodDefinition$5(state));
2024
+ return $TOKEN("MethodDefinition", state, MethodDefinition$0(state));
1924
2025
  } else {
1925
- return MethodDefinition$0(state) || MethodDefinition$1(state) || MethodDefinition$2(state) || MethodDefinition$3(state) || MethodDefinition$4(state) || MethodDefinition$5(state);
2026
+ return MethodDefinition$0(state);
1926
2027
  }
1927
2028
  }
1928
- var MethodModifier$0 = $S($C($EXPECT($L40, fail, 'MethodModifier "get"'), $EXPECT($L41, fail, 'MethodModifier "set"')), NonIdContinue, $Q(TrailingComment));
2029
+ var MethodModifier$0 = $S(GetOrSet, $Q(TrailingComment));
2030
+ var MethodModifier$1 = $S($S(Async, __), $E($S($EXPECT($L5, fail, 'MethodModifier "*"'), __)));
2031
+ var MethodModifier$2 = $S($EXPECT($L5, fail, 'MethodModifier "*"'), __);
2032
+ var MethodModifier$3 = $S(Async, __);
1929
2033
  function MethodModifier(state) {
1930
- if (state.verbose)
1931
- console.log("ENTER:", "MethodModifier");
1932
2034
  if (state.tokenize) {
1933
- return $TOKEN("MethodModifier", state, MethodModifier$0(state));
2035
+ return $TOKEN("MethodModifier", state, MethodModifier$0(state) || MethodModifier$1(state) || MethodModifier$2(state) || MethodModifier$3(state));
1934
2036
  } else {
1935
- return MethodModifier$0(state);
2037
+ return MethodModifier$0(state) || MethodModifier$1(state) || MethodModifier$2(state) || MethodModifier$3(state);
1936
2038
  }
1937
2039
  }
1938
2040
  var MethodSignature$0 = $S($E(MethodModifier), ClassElementName, $Q(_), Parameters);
@@ -1954,7 +2056,7 @@ var require_parser = __commonJS({
1954
2056
  return ClassElementName$0(state) || ClassElementName$1(state);
1955
2057
  }
1956
2058
  }
1957
- var PrivateIdentifier$0 = $S($EXPECT($L20, fail, 'PrivateIdentifier "#"'), IdentifierName);
2059
+ var PrivateIdentifier$0 = $S($EXPECT($L10, fail, 'PrivateIdentifier "#"'), IdentifierName);
1958
2060
  function PrivateIdentifier(state) {
1959
2061
  if (state.verbose)
1960
2062
  console.log("ENTER:", "PrivateIdentifier");
@@ -1964,66 +2066,6 @@ var require_parser = __commonJS({
1964
2066
  return PrivateIdentifier$0(state);
1965
2067
  }
1966
2068
  }
1967
- var GeneratorMethod$0 = $S($EXPECT($L10, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
1968
- function GeneratorMethod(state) {
1969
- if (state.verbose)
1970
- console.log("ENTER:", "GeneratorMethod");
1971
- if (state.tokenize) {
1972
- return $TOKEN("GeneratorMethod", state, GeneratorMethod$0(state));
1973
- } else {
1974
- return GeneratorMethod$0(state);
1975
- }
1976
- }
1977
- var GeneratorBody$0 = BracedBlock;
1978
- function GeneratorBody(state) {
1979
- if (state.verbose)
1980
- console.log("ENTER:", "GeneratorBody");
1981
- if (state.tokenize) {
1982
- return $TOKEN("GeneratorBody", state, GeneratorBody$0(state));
1983
- } else {
1984
- return GeneratorBody$0(state);
1985
- }
1986
- }
1987
- var AsyncMethod$0 = $S($EXPECT($L7, fail, 'AsyncMethod "async"'), $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
1988
- function AsyncMethod(state) {
1989
- if (state.verbose)
1990
- console.log("ENTER:", "AsyncMethod");
1991
- if (state.tokenize) {
1992
- return $TOKEN("AsyncMethod", state, AsyncMethod$0(state));
1993
- } else {
1994
- return AsyncMethod$0(state);
1995
- }
1996
- }
1997
- var AsyncFunctionBody$0 = BracedBlock;
1998
- function AsyncFunctionBody(state) {
1999
- if (state.verbose)
2000
- console.log("ENTER:", "AsyncFunctionBody");
2001
- if (state.tokenize) {
2002
- return $TOKEN("AsyncFunctionBody", state, AsyncFunctionBody$0(state));
2003
- } else {
2004
- return AsyncFunctionBody$0(state);
2005
- }
2006
- }
2007
- var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L10, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
2008
- function AsyncGeneratorMethod(state) {
2009
- if (state.verbose)
2010
- console.log("ENTER:", "AsyncGeneratorMethod");
2011
- if (state.tokenize) {
2012
- return $TOKEN("AsyncGeneratorMethod", state, AsyncGeneratorMethod$0(state));
2013
- } else {
2014
- return AsyncGeneratorMethod$0(state);
2015
- }
2016
- }
2017
- var AsyncGeneratorBody$0 = BracedBlock;
2018
- function AsyncGeneratorBody(state) {
2019
- if (state.verbose)
2020
- console.log("ENTER:", "AsyncGeneratorBody");
2021
- if (state.tokenize) {
2022
- return $TOKEN("AsyncGeneratorBody", state, AsyncGeneratorBody$0(state));
2023
- } else {
2024
- return AsyncGeneratorBody$0(state);
2025
- }
2026
- }
2027
2069
  var AssignmentOp$0 = $TS($S(AssignmentOpSymbol), function($skip, $loc, $0, $1) {
2028
2070
  return { $loc, token: $1 };
2029
2071
  });
@@ -2036,25 +2078,25 @@ var require_parser = __commonJS({
2036
2078
  return AssignmentOp$0(state);
2037
2079
  }
2038
2080
  }
2039
- var AssignmentOpSymbol$0 = $EXPECT($L42, fail, 'AssignmentOpSymbol "**="');
2040
- var AssignmentOpSymbol$1 = $EXPECT($L43, fail, 'AssignmentOpSymbol "*="');
2041
- var AssignmentOpSymbol$2 = $EXPECT($L44, fail, 'AssignmentOpSymbol "/="');
2042
- var AssignmentOpSymbol$3 = $EXPECT($L45, fail, 'AssignmentOpSymbol "%="');
2043
- var AssignmentOpSymbol$4 = $EXPECT($L46, fail, 'AssignmentOpSymbol "+="');
2044
- var AssignmentOpSymbol$5 = $EXPECT($L47, fail, 'AssignmentOpSymbol "-="');
2045
- var AssignmentOpSymbol$6 = $EXPECT($L48, fail, 'AssignmentOpSymbol "<<="');
2046
- var AssignmentOpSymbol$7 = $EXPECT($L49, fail, 'AssignmentOpSymbol ">>>="');
2047
- var AssignmentOpSymbol$8 = $EXPECT($L50, fail, 'AssignmentOpSymbol ">>="');
2048
- var AssignmentOpSymbol$9 = $EXPECT($L51, fail, 'AssignmentOpSymbol "&&="');
2049
- var AssignmentOpSymbol$10 = $EXPECT($L52, fail, 'AssignmentOpSymbol "&="');
2050
- var AssignmentOpSymbol$11 = $EXPECT($L53, fail, 'AssignmentOpSymbol "^="');
2051
- var AssignmentOpSymbol$12 = $EXPECT($L54, fail, 'AssignmentOpSymbol "||="');
2052
- var AssignmentOpSymbol$13 = $EXPECT($L55, fail, 'AssignmentOpSymbol "|="');
2053
- var AssignmentOpSymbol$14 = $EXPECT($L56, fail, 'AssignmentOpSymbol "??="');
2054
- var AssignmentOpSymbol$15 = $T($EXPECT($L57, fail, 'AssignmentOpSymbol "?="'), function(value) {
2081
+ var AssignmentOpSymbol$0 = $EXPECT($L27, fail, 'AssignmentOpSymbol "**="');
2082
+ var AssignmentOpSymbol$1 = $EXPECT($L28, fail, 'AssignmentOpSymbol "*="');
2083
+ var AssignmentOpSymbol$2 = $EXPECT($L29, fail, 'AssignmentOpSymbol "/="');
2084
+ var AssignmentOpSymbol$3 = $EXPECT($L30, fail, 'AssignmentOpSymbol "%="');
2085
+ var AssignmentOpSymbol$4 = $EXPECT($L31, fail, 'AssignmentOpSymbol "+="');
2086
+ var AssignmentOpSymbol$5 = $EXPECT($L32, fail, 'AssignmentOpSymbol "-="');
2087
+ var AssignmentOpSymbol$6 = $EXPECT($L33, fail, 'AssignmentOpSymbol "<<="');
2088
+ var AssignmentOpSymbol$7 = $EXPECT($L34, fail, 'AssignmentOpSymbol ">>>="');
2089
+ var AssignmentOpSymbol$8 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>="');
2090
+ var AssignmentOpSymbol$9 = $EXPECT($L36, fail, 'AssignmentOpSymbol "&&="');
2091
+ var AssignmentOpSymbol$10 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&="');
2092
+ var AssignmentOpSymbol$11 = $EXPECT($L38, fail, 'AssignmentOpSymbol "^="');
2093
+ var AssignmentOpSymbol$12 = $EXPECT($L39, fail, 'AssignmentOpSymbol "||="');
2094
+ var AssignmentOpSymbol$13 = $EXPECT($L40, fail, 'AssignmentOpSymbol "|="');
2095
+ var AssignmentOpSymbol$14 = $EXPECT($L41, fail, 'AssignmentOpSymbol "??="');
2096
+ var AssignmentOpSymbol$15 = $T($EXPECT($L42, fail, 'AssignmentOpSymbol "?="'), function(value) {
2055
2097
  return "??=";
2056
2098
  });
2057
- var AssignmentOpSymbol$16 = $EXPECT($L58, fail, 'AssignmentOpSymbol "="');
2099
+ var AssignmentOpSymbol$16 = $EXPECT($L43, fail, 'AssignmentOpSymbol "="');
2058
2100
  function AssignmentOpSymbol(state) {
2059
2101
  if (state.tokenize) {
2060
2102
  return $TOKEN("AssignmentOpSymbol", state, AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state) || AssignmentOpSymbol$16(state));
@@ -2074,52 +2116,52 @@ var require_parser = __commonJS({
2074
2116
  return BinaryOp$0(state);
2075
2117
  }
2076
2118
  }
2077
- var BinaryOpSymbol$0 = $EXPECT($L59, fail, 'BinaryOpSymbol "**"');
2078
- var BinaryOpSymbol$1 = $EXPECT($L10, fail, 'BinaryOpSymbol "*"');
2079
- var BinaryOpSymbol$2 = $EXPECT($L60, fail, 'BinaryOpSymbol "/"');
2080
- var BinaryOpSymbol$3 = $EXPECT($L61, fail, 'BinaryOpSymbol "%"');
2081
- var BinaryOpSymbol$4 = $EXPECT($L62, fail, 'BinaryOpSymbol "+"');
2082
- var BinaryOpSymbol$5 = $EXPECT($L63, fail, 'BinaryOpSymbol "-"');
2083
- var BinaryOpSymbol$6 = $EXPECT($L64, fail, 'BinaryOpSymbol "<="');
2084
- var BinaryOpSymbol$7 = $EXPECT($L65, fail, 'BinaryOpSymbol ">="');
2085
- var BinaryOpSymbol$8 = $EXPECT($L66, fail, 'BinaryOpSymbol "<<"');
2086
- var BinaryOpSymbol$9 = $EXPECT($L16, fail, 'BinaryOpSymbol "<"');
2087
- var BinaryOpSymbol$10 = $EXPECT($L67, fail, 'BinaryOpSymbol ">>>"');
2088
- var BinaryOpSymbol$11 = $EXPECT($L68, fail, 'BinaryOpSymbol ">>"');
2089
- var BinaryOpSymbol$12 = $EXPECT($L69, fail, 'BinaryOpSymbol ">"');
2090
- var BinaryOpSymbol$13 = $EXPECT($L70, fail, 'BinaryOpSymbol "!=="');
2091
- var BinaryOpSymbol$14 = $TV($EXPECT($L71, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2119
+ var BinaryOpSymbol$0 = $EXPECT($L44, fail, 'BinaryOpSymbol "**"');
2120
+ var BinaryOpSymbol$1 = $EXPECT($L5, fail, 'BinaryOpSymbol "*"');
2121
+ var BinaryOpSymbol$2 = $EXPECT($L45, fail, 'BinaryOpSymbol "/"');
2122
+ var BinaryOpSymbol$3 = $EXPECT($L46, fail, 'BinaryOpSymbol "%"');
2123
+ var BinaryOpSymbol$4 = $EXPECT($L47, fail, 'BinaryOpSymbol "+"');
2124
+ var BinaryOpSymbol$5 = $EXPECT($L48, fail, 'BinaryOpSymbol "-"');
2125
+ var BinaryOpSymbol$6 = $EXPECT($L49, fail, 'BinaryOpSymbol "<="');
2126
+ var BinaryOpSymbol$7 = $EXPECT($L50, fail, 'BinaryOpSymbol ">="');
2127
+ var BinaryOpSymbol$8 = $EXPECT($L51, fail, 'BinaryOpSymbol "<<"');
2128
+ var BinaryOpSymbol$9 = $EXPECT($L7, fail, 'BinaryOpSymbol "<"');
2129
+ var BinaryOpSymbol$10 = $EXPECT($L52, fail, 'BinaryOpSymbol ">>>"');
2130
+ var BinaryOpSymbol$11 = $EXPECT($L53, fail, 'BinaryOpSymbol ">>"');
2131
+ var BinaryOpSymbol$12 = $EXPECT($L54, fail, 'BinaryOpSymbol ">"');
2132
+ var BinaryOpSymbol$13 = $EXPECT($L55, fail, 'BinaryOpSymbol "!=="');
2133
+ var BinaryOpSymbol$14 = $TV($EXPECT($L56, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2092
2134
  if (module2.coffeeCompat)
2093
2135
  return "!==";
2094
2136
  return $1;
2095
2137
  });
2096
- var BinaryOpSymbol$15 = $T($S($EXPECT($L72, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2138
+ var BinaryOpSymbol$15 = $T($S($EXPECT($L57, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2097
2139
  return "===";
2098
2140
  });
2099
- var BinaryOpSymbol$16 = $EXPECT($L73, fail, 'BinaryOpSymbol "==="');
2100
- var BinaryOpSymbol$17 = $TV($EXPECT($L74, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2141
+ var BinaryOpSymbol$16 = $EXPECT($L58, fail, 'BinaryOpSymbol "==="');
2142
+ var BinaryOpSymbol$17 = $TV($EXPECT($L59, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2101
2143
  if (module2.coffeeCompat)
2102
2144
  return "===";
2103
2145
  return $1;
2104
2146
  });
2105
- var BinaryOpSymbol$18 = $T($S($EXPECT($L75, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2147
+ var BinaryOpSymbol$18 = $T($S($EXPECT($L60, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2106
2148
  return "&&";
2107
2149
  });
2108
- var BinaryOpSymbol$19 = $EXPECT($L76, fail, 'BinaryOpSymbol "&&"');
2109
- var BinaryOpSymbol$20 = $T($S($EXPECT($L77, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2150
+ var BinaryOpSymbol$19 = $EXPECT($L61, fail, 'BinaryOpSymbol "&&"');
2151
+ var BinaryOpSymbol$20 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2110
2152
  return "||";
2111
2153
  });
2112
- var BinaryOpSymbol$21 = $EXPECT($L78, fail, 'BinaryOpSymbol "||"');
2113
- var BinaryOpSymbol$22 = $EXPECT($L79, fail, 'BinaryOpSymbol "??"');
2114
- var BinaryOpSymbol$23 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2154
+ var BinaryOpSymbol$21 = $EXPECT($L63, fail, 'BinaryOpSymbol "||"');
2155
+ var BinaryOpSymbol$22 = $EXPECT($L64, fail, 'BinaryOpSymbol "??"');
2156
+ var BinaryOpSymbol$23 = $TS($S($EXPECT($L65, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2115
2157
  return $1;
2116
2158
  });
2117
- var BinaryOpSymbol$24 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2159
+ var BinaryOpSymbol$24 = $TS($S($EXPECT($L66, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2118
2160
  return $1;
2119
2161
  });
2120
- var BinaryOpSymbol$25 = $EXPECT($L82, fail, 'BinaryOpSymbol "&"');
2121
- var BinaryOpSymbol$26 = $EXPECT($L83, fail, 'BinaryOpSymbol "^"');
2122
- var BinaryOpSymbol$27 = $EXPECT($L84, fail, 'BinaryOpSymbol "|"');
2162
+ var BinaryOpSymbol$25 = $EXPECT($L67, fail, 'BinaryOpSymbol "&"');
2163
+ var BinaryOpSymbol$26 = $EXPECT($L68, fail, 'BinaryOpSymbol "^"');
2164
+ var BinaryOpSymbol$27 = $EXPECT($L69, fail, 'BinaryOpSymbol "|"');
2123
2165
  function BinaryOpSymbol(state) {
2124
2166
  if (state.tokenize) {
2125
2167
  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));
@@ -2128,7 +2170,7 @@ var require_parser = __commonJS({
2128
2170
  }
2129
2171
  }
2130
2172
  var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
2131
- var UnaryOp$1 = $S($C($EXPECT($L85, fail, 'UnaryOp "delete"'), $EXPECT($L86, fail, 'UnaryOp "void"'), $EXPECT($L87, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2173
+ var UnaryOp$1 = $S($C($EXPECT($L70, fail, 'UnaryOp "delete"'), $EXPECT($L71, fail, 'UnaryOp "void"'), $EXPECT($L72, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2132
2174
  function UnaryOp(state) {
2133
2175
  if (state.tokenize) {
2134
2176
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -2146,11 +2188,13 @@ var require_parser = __commonJS({
2146
2188
  return ModuleItem$0(state) || ModuleItem$1(state) || ModuleItem$2(state);
2147
2189
  }
2148
2190
  }
2149
- var StatementListItem$0 = $TS($S($C(Declaration, Statement), $E(PostfixConditional)), function($skip, $loc, $0, $1, $2) {
2191
+ var StatementListItem$0 = $TS($S($C(Declaration, Statement), $E(PostfixConditional), Loc), function($skip, $loc, $0, $1, $2, $3) {
2150
2192
  var statement = $1;
2151
2193
  var cond = $2;
2194
+ var l = $3;
2152
2195
  if (cond)
2153
- return [cond, statement, "}"];
2196
+ return [cond, statement, { $loc: l.$loc, token: "}" }];
2197
+ $0.pop();
2154
2198
  return $0;
2155
2199
  });
2156
2200
  function StatementListItem(state) {
@@ -2162,13 +2206,24 @@ var require_parser = __commonJS({
2162
2206
  return StatementListItem$0(state);
2163
2207
  }
2164
2208
  }
2165
- var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($L88, fail, 'PostfixConditional "if"'), $EXPECT($L89, fail, 'PostfixConditional "unless"')), NonIdContinue, Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
2209
+ var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C(If, Unless), NonIdContinue, Loc, ExpressionWithIndentedApplicationSuppressed, Loc), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
2166
2210
  var ws = $1;
2167
2211
  var cond = $2;
2168
- var exp = $4;
2169
- if (cond === "if")
2170
- return [ws, "if(", exp, ") {"];
2171
- return [ws, "if(!(", exp, ")) {"];
2212
+ var l1 = $4;
2213
+ var exp = $5;
2214
+ var l2 = $6;
2215
+ let openParens = { $loc: l1.$loc, token: "(!(" };
2216
+ let closingParens = { $loc: l2.$loc, token: "))" };
2217
+ let space = { $loc: l2.$loc, token: " " };
2218
+ let openingBrace = { $loc: l2.$loc, token: "{" };
2219
+ if (cond.token === "if") {
2220
+ cond.token = "if";
2221
+ closingParens.token = ")";
2222
+ openParens.token = "(";
2223
+ } else {
2224
+ cond.token = "if";
2225
+ }
2226
+ return [ws, cond, openParens, exp, closingParens, space, openingBrace];
2172
2227
  });
2173
2228
  function PostfixConditional(state) {
2174
2229
  if (state.verbose)
@@ -2195,7 +2250,7 @@ var require_parser = __commonJS({
2195
2250
  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);
2196
2251
  }
2197
2252
  }
2198
- var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L90, fail, 'EmptyStatement ";"')));
2253
+ var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L73, fail, 'EmptyStatement ";"')));
2199
2254
  function EmptyStatement(state) {
2200
2255
  if (state.verbose)
2201
2256
  console.log("ENTER:", "EmptyStatement");
@@ -2205,7 +2260,7 @@ var require_parser = __commonJS({
2205
2260
  return EmptyStatement$0(state);
2206
2261
  }
2207
2262
  }
2208
- var BlockStatement$0 = $S(__, $EXPECT($L12, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L13, fail, 'BlockStatement "}"'));
2263
+ var BlockStatement$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
2209
2264
  function BlockStatement(state) {
2210
2265
  if (state.verbose)
2211
2266
  console.log("ENTER:", "BlockStatement");
@@ -2215,17 +2270,21 @@ var require_parser = __commonJS({
2215
2270
  return BlockStatement$0(state);
2216
2271
  }
2217
2272
  }
2218
- var IfStatement$0 = $S($EXPECT($L88, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L91, fail, 'IfStatement "else"'), Block)));
2219
- var IfStatement$1 = $TS($S($EXPECT($L89, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
2273
+ var IfStatement$0 = $S(If, Condition, Block, $E($S(__, Else, Block)));
2274
+ var IfStatement$1 = $TS($S(Unless, Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
2275
+ var kind = $1;
2220
2276
  var condition = $2;
2221
2277
  var block = $3;
2222
- return ["if", condition.map((c) => {
2223
- if (c === "(")
2224
- return "(!(";
2225
- if (c === ")")
2226
- return "))";
2227
- return c;
2228
- }), block];
2278
+ condition.forEach((c) => {
2279
+ if (!c)
2280
+ return;
2281
+ if (c.token === "(")
2282
+ c.token = "(!(";
2283
+ if (c.token === ")")
2284
+ c.token = "))";
2285
+ });
2286
+ kind.token = "if";
2287
+ return [kind, condition, block];
2229
2288
  });
2230
2289
  function IfStatement(state) {
2231
2290
  if (state.tokenize) {
@@ -2246,10 +2305,7 @@ var require_parser = __commonJS({
2246
2305
  return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
2247
2306
  }
2248
2307
  }
2249
- var LoopStatement$0 = $TS($S($EXPECT($L92, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
2250
- var b = $3;
2251
- return ["while(true)", b];
2252
- });
2308
+ var LoopStatement$0 = $S(Loop, Block);
2253
2309
  function LoopStatement(state) {
2254
2310
  if (state.verbose)
2255
2311
  console.log("ENTER:", "LoopStatement");
@@ -2259,7 +2315,7 @@ var require_parser = __commonJS({
2259
2315
  return LoopStatement$0(state);
2260
2316
  }
2261
2317
  }
2262
- var DoWhileStatement$0 = $S($EXPECT($L93, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2318
+ var DoWhileStatement$0 = $S($EXPECT($L74, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2263
2319
  function DoWhileStatement(state) {
2264
2320
  if (state.verbose)
2265
2321
  console.log("ENTER:", "DoWhileStatement");
@@ -2279,12 +2335,12 @@ var require_parser = __commonJS({
2279
2335
  return WhileStatement$0(state);
2280
2336
  }
2281
2337
  }
2282
- var WhileClause$0 = $TS($S($C($EXPECT($L94, fail, 'WhileClause "while"'), $EXPECT($L95, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
2338
+ var WhileClause$0 = $TS($S($C($EXPECT($L75, fail, 'WhileClause "while"'), $EXPECT($L76, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
2283
2339
  var kind = $1;
2284
2340
  var cond = $3;
2285
2341
  if (kind === "until") {
2286
2342
  cond[1] = "(!(";
2287
- cond[5] = "))";
2343
+ cond[4] = "))";
2288
2344
  return ["while", cond];
2289
2345
  }
2290
2346
  return $0;
@@ -2298,7 +2354,7 @@ var require_parser = __commonJS({
2298
2354
  return WhileClause$0(state);
2299
2355
  }
2300
2356
  }
2301
- var ForStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L90, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L90, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
2357
+ var ForStatement$0 = $S(For, __, OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E(Expression), CloseParen, Block);
2302
2358
  function ForStatement(state) {
2303
2359
  if (state.verbose)
2304
2360
  console.log("ENTER:", "ForStatement");
@@ -2308,10 +2364,10 @@ var require_parser = __commonJS({
2308
2364
  return ForStatement$0(state);
2309
2365
  }
2310
2366
  }
2311
- var ForInOfStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L96, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L81, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2312
- var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L96, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L81, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2313
- var ForInOfStatement$2 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L96, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L97, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2314
- var ForInOfStatement$3 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L96, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L97, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
2367
+ var ForInOfStatement$0 = $S(For, __, OpenParen, __, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, In, Expression, __, CloseParen, Block);
2368
+ var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, In, Expression, InsertCloseParen, Block);
2369
+ var ForInOfStatement$2 = $S(For, $E($S(__, Await)), __, OpenParen, __, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, Of, AssignmentExpression, __, CloseParen, Block);
2370
+ var ForInOfStatement$3 = $S(For, $E($S(__, Await)), __, InsertOpenParen, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, Of, AssignmentExpression, InsertCloseParen, Block);
2315
2371
  function ForInOfStatement(state) {
2316
2372
  if (state.tokenize) {
2317
2373
  return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
@@ -2319,18 +2375,6 @@ var require_parser = __commonJS({
2319
2375
  return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
2320
2376
  }
2321
2377
  }
2322
- var For$0 = $TS($S($EXPECT($L98, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2323
- return { $loc, token: $1 };
2324
- });
2325
- function For(state) {
2326
- if (state.verbose)
2327
- console.log("ENTER:", "For");
2328
- if (state.tokenize) {
2329
- return $TOKEN("For", state, For$0(state));
2330
- } else {
2331
- return For$0(state);
2332
- }
2333
- }
2334
2378
  var ForDeclaration$0 = $S(LetOrConst, NonIdContinue, __, ForBinding);
2335
2379
  function ForDeclaration(state) {
2336
2380
  if (state.verbose)
@@ -2341,18 +2385,6 @@ var require_parser = __commonJS({
2341
2385
  return ForDeclaration$0(state);
2342
2386
  }
2343
2387
  }
2344
- var LetOrConst$0 = $TV($C($EXPECT($L99, fail, 'LetOrConst "let"'), $EXPECT($L100, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
2345
- return { $loc, token: $1 };
2346
- });
2347
- function LetOrConst(state) {
2348
- if (state.verbose)
2349
- console.log("ENTER:", "LetOrConst");
2350
- if (state.tokenize) {
2351
- return $TOKEN("LetOrConst", state, LetOrConst$0(state));
2352
- } else {
2353
- return LetOrConst$0(state);
2354
- }
2355
- }
2356
2388
  var ForBinding$0 = BindingIdentifier;
2357
2389
  var ForBinding$1 = BindingPattern;
2358
2390
  function ForBinding(state) {
@@ -2362,7 +2394,7 @@ var require_parser = __commonJS({
2362
2394
  return ForBinding$0(state) || ForBinding$1(state);
2363
2395
  }
2364
2396
  }
2365
- var SwitchStatement$0 = $S($EXPECT($L101, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
2397
+ var SwitchStatement$0 = $S(Switch, NonIdContinue, Condition, CaseBlock);
2366
2398
  function SwitchStatement(state) {
2367
2399
  if (state.verbose)
2368
2400
  console.log("ENTER:", "SwitchStatement");
@@ -2372,7 +2404,7 @@ var require_parser = __commonJS({
2372
2404
  return SwitchStatement$0(state);
2373
2405
  }
2374
2406
  }
2375
- var CaseBlock$0 = $S(__, $EXPECT($L12, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L13, fail, 'CaseBlock "}"'));
2407
+ var CaseBlock$0 = $S(__, OpenBrace, $Y(EOS), NestedCaseClauses, __, CloseBrace);
2376
2408
  var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
2377
2409
  function CaseBlock(state) {
2378
2410
  if (state.tokenize) {
@@ -2406,9 +2438,9 @@ var require_parser = __commonJS({
2406
2438
  return NestedCaseClause$0(state);
2407
2439
  }
2408
2440
  }
2409
- var CaseClause$0 = $S($EXPECT($L102, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2410
- var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
2411
- var CaseClause$2 = $S($EXPECT($L103, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2441
+ var CaseClause$0 = $S($EXPECT($L77, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), ExpressionWithIndentedApplicationSuppressed, ImpliedColon, NestedBlockExpressions);
2442
+ var CaseClause$1 = $S(When, $Q(_), ExpressionWithIndentedApplicationSuppressed, ImpliedColon, NestedBlockExpressions, InsertBreak);
2443
+ var CaseClause$2 = $S($EXPECT($L78, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2412
2444
  function CaseClause(state) {
2413
2445
  if (state.tokenize) {
2414
2446
  return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
@@ -2416,21 +2448,9 @@ var require_parser = __commonJS({
2416
2448
  return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
2417
2449
  }
2418
2450
  }
2419
- var When$0 = $T($S($EXPECT($L104, fail, 'When "when"'), NonIdContinue), function(value) {
2420
- return "case";
2421
- });
2422
- function When(state) {
2423
- if (state.verbose)
2424
- console.log("ENTER:", "When");
2425
- if (state.tokenize) {
2426
- return $TOKEN("When", state, When$0(state));
2427
- } else {
2428
- return When$0(state);
2429
- }
2430
- }
2431
- var ImpliedColon$0 = $S(__, $EXPECT($L14, fail, 'ImpliedColon ":"'));
2432
- var ImpliedColon$1 = $T($EXPECT($L33, fail, 'ImpliedColon ""'), function(value) {
2433
- return ":";
2451
+ var ImpliedColon$0 = $S(__, Colon);
2452
+ var ImpliedColon$1 = $TV($EXPECT($L1, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
2453
+ return { $loc, token: ":" };
2434
2454
  });
2435
2455
  function ImpliedColon(state) {
2436
2456
  if (state.tokenize) {
@@ -2439,7 +2459,7 @@ var require_parser = __commonJS({
2439
2459
  return ImpliedColon$0(state) || ImpliedColon$1(state);
2440
2460
  }
2441
2461
  }
2442
- var TryStatement$0 = $TS($S($EXPECT($L105, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2462
+ var TryStatement$0 = $TS($S(Try, BracedBlock, $E(CatchClause), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2443
2463
  var c = $3;
2444
2464
  var f = $4;
2445
2465
  if (!c && !f) {
@@ -2456,17 +2476,17 @@ var require_parser = __commonJS({
2456
2476
  return TryStatement$0(state);
2457
2477
  }
2458
2478
  }
2459
- var Catch$0 = $S(__, $EXPECT($L106, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2460
- function Catch(state) {
2479
+ var CatchClause$0 = $S(__, Catch, $E(CatchBind), BracedBlock);
2480
+ function CatchClause(state) {
2461
2481
  if (state.verbose)
2462
- console.log("ENTER:", "Catch");
2482
+ console.log("ENTER:", "CatchClause");
2463
2483
  if (state.tokenize) {
2464
- return $TOKEN("Catch", state, Catch$0(state));
2484
+ return $TOKEN("CatchClause", state, CatchClause$0(state));
2465
2485
  } else {
2466
- return Catch$0(state);
2486
+ return CatchClause$0(state);
2467
2487
  }
2468
2488
  }
2469
- var CatchBind$0 = $S(__, $EXPECT($L1, fail, 'CatchBind "("'), __, CatchParameter, __, $EXPECT($L2, fail, 'CatchBind ")"'));
2489
+ var CatchBind$0 = $S(__, OpenParen, __, CatchParameter, __, CloseParen);
2470
2490
  var CatchBind$1 = $S(__, InsertOpenParen, CatchParameter, InsertCloseParen);
2471
2491
  function CatchBind(state) {
2472
2492
  if (state.tokenize) {
@@ -2475,7 +2495,7 @@ var require_parser = __commonJS({
2475
2495
  return CatchBind$0(state) || CatchBind$1(state);
2476
2496
  }
2477
2497
  }
2478
- var Finally$0 = $S(__, $EXPECT($L107, fail, 'Finally "finally"'), BracedBlock);
2498
+ var Finally$0 = $S(__, $EXPECT($L79, fail, 'Finally "finally"'), BracedBlock);
2479
2499
  function Finally(state) {
2480
2500
  if (state.verbose)
2481
2501
  console.log("ENTER:", "Finally");
@@ -2494,8 +2514,8 @@ var require_parser = __commonJS({
2494
2514
  return CatchParameter$0(state) || CatchParameter$1(state);
2495
2515
  }
2496
2516
  }
2497
- var Condition$0 = $S(__, $EXPECT($L1, fail, 'Condition "("'), __, Expression, __, $EXPECT($L2, fail, 'Condition ")"'));
2498
- var Condition$1 = $S($N(EOS), __, InsertOpenParen, Expression, InsertCloseParen);
2517
+ var Condition$0 = $S(__, OpenParen, Expression, __, CloseParen);
2518
+ var Condition$1 = $S($N(EOS), __, InsertOpenParen, ExpressionWithIndentedApplicationSuppressed, InsertCloseParen);
2499
2519
  function Condition(state) {
2500
2520
  if (state.tokenize) {
2501
2521
  return $TOKEN("Condition", state, Condition$0(state) || Condition$1(state));
@@ -2503,6 +2523,34 @@ var require_parser = __commonJS({
2503
2523
  return Condition$0(state) || Condition$1(state);
2504
2524
  }
2505
2525
  }
2526
+ var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(Expression)), function($skip, $loc, $0, $1, $2) {
2527
+ var exp = $2;
2528
+ module2.suppressIndentedApplication = false;
2529
+ if (exp)
2530
+ return exp;
2531
+ return $skip;
2532
+ });
2533
+ function ExpressionWithIndentedApplicationSuppressed(state) {
2534
+ if (state.verbose)
2535
+ console.log("ENTER:", "ExpressionWithIndentedApplicationSuppressed");
2536
+ if (state.tokenize) {
2537
+ return $TOKEN("ExpressionWithIndentedApplicationSuppressed", state, ExpressionWithIndentedApplicationSuppressed$0(state));
2538
+ } else {
2539
+ return ExpressionWithIndentedApplicationSuppressed$0(state);
2540
+ }
2541
+ }
2542
+ var SuppressIndentedApplication$0 = $TV($EXPECT($L1, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
2543
+ module2.suppressIndentedApplication = true;
2544
+ });
2545
+ function SuppressIndentedApplication(state) {
2546
+ if (state.verbose)
2547
+ console.log("ENTER:", "SuppressIndentedApplication");
2548
+ if (state.tokenize) {
2549
+ return $TOKEN("SuppressIndentedApplication", state, SuppressIndentedApplication$0(state));
2550
+ } else {
2551
+ return SuppressIndentedApplication$0(state);
2552
+ }
2553
+ }
2506
2554
  var ExpressionStatement$0 = Expression;
2507
2555
  function ExpressionStatement(state) {
2508
2556
  if (state.verbose)
@@ -2513,11 +2561,11 @@ var require_parser = __commonJS({
2513
2561
  return ExpressionStatement$0(state);
2514
2562
  }
2515
2563
  }
2516
- var KeywordStatement$0 = $S($EXPECT($L108, fail, 'KeywordStatement "break"'), NonIdContinue);
2517
- var KeywordStatement$1 = $S($EXPECT($L109, fail, 'KeywordStatement "continue"'), NonIdContinue);
2518
- var KeywordStatement$2 = $S($EXPECT($L110, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2564
+ var KeywordStatement$0 = $S($EXPECT($L80, fail, 'KeywordStatement "break"'), NonIdContinue);
2565
+ var KeywordStatement$1 = $S($EXPECT($L81, fail, 'KeywordStatement "continue"'), NonIdContinue);
2566
+ var KeywordStatement$2 = $S($EXPECT($L82, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2519
2567
  var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
2520
- var KeywordStatement$4 = $S($EXPECT($L111, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2568
+ var KeywordStatement$4 = $S($EXPECT($L83, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2521
2569
  function KeywordStatement(state) {
2522
2570
  if (state.tokenize) {
2523
2571
  return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
@@ -2534,24 +2582,22 @@ var require_parser = __commonJS({
2534
2582
  return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
2535
2583
  }
2536
2584
  }
2537
- var Return$0 = $TS($S($EXPECT($L112, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2538
- return { $loc, token: $1 };
2539
- });
2540
- function Return(state) {
2541
- if (state.verbose)
2542
- console.log("ENTER:", "Return");
2543
- if (state.tokenize) {
2544
- return $TOKEN("Return", state, Return$0(state));
2545
- } else {
2546
- return Return$0(state);
2547
- }
2548
- }
2549
- var ImportDeclaration$0 = $T($S($EXPECT($L113, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2585
+ var ImportDeclaration$0 = $T($S($EXPECT($L84, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2550
2586
  return { "ts": true, "children": value };
2551
2587
  });
2552
2588
  var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
2553
2589
  var ImportDeclaration$2 = $S(Import, __, ModuleSpecifier);
2554
- var ImportDeclaration$3 = $S(ImpliedImport, ImportClause, __, FromClause);
2590
+ var ImportDeclaration$3 = $TS($S(ImpliedImport, ImportClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4) {
2591
+ var i = $1;
2592
+ var c = $2;
2593
+ var w = $3;
2594
+ var f = $4;
2595
+ i.$loc = {
2596
+ pos: f[0].$loc.pos - 1,
2597
+ length: f[0].$loc.length + 1
2598
+ };
2599
+ return [i, c, w, f];
2600
+ });
2555
2601
  function ImportDeclaration(state) {
2556
2602
  if (state.tokenize) {
2557
2603
  return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state));
@@ -2559,8 +2605,8 @@ var require_parser = __commonJS({
2559
2605
  return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state);
2560
2606
  }
2561
2607
  }
2562
- var ImpliedImport$0 = $T($EXPECT($L33, fail, 'ImpliedImport ""'), function(value) {
2563
- return "import ";
2608
+ var ImpliedImport$0 = $TV($EXPECT($L1, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
2609
+ return { $loc, token: "import " };
2564
2610
  });
2565
2611
  function ImpliedImport(state) {
2566
2612
  if (state.verbose)
@@ -2571,19 +2617,7 @@ var require_parser = __commonJS({
2571
2617
  return ImpliedImport$0(state);
2572
2618
  }
2573
2619
  }
2574
- var Import$0 = $TS($S($EXPECT($L24, fail, 'Import "import"'), $Y($EXPECT($R3, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
2575
- return { $loc, token: $1 };
2576
- });
2577
- function Import(state) {
2578
- if (state.verbose)
2579
- console.log("ENTER:", "Import");
2580
- if (state.tokenize) {
2581
- return $TOKEN("Import", state, Import$0(state));
2582
- } else {
2583
- return Import$0(state);
2584
- }
2585
- }
2586
- var ImportClause$0 = $S(ImportedBinding, $E($S(__, $EXPECT($L0, fail, 'ImportClause ","'), __, $C(NameSpaceImport, NamedImports))));
2620
+ var ImportClause$0 = $S(ImportedBinding, $E($S(__, Comma, __, $C(NameSpaceImport, NamedImports))));
2587
2621
  var ImportClause$1 = NameSpaceImport;
2588
2622
  var ImportClause$2 = NamedImports;
2589
2623
  function ImportClause(state) {
@@ -2593,7 +2627,7 @@ var require_parser = __commonJS({
2593
2627
  return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
2594
2628
  }
2595
2629
  }
2596
- var NameSpaceImport$0 = $S($EXPECT($L10, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), NonIdContinue, __, ImportedBinding);
2630
+ var NameSpaceImport$0 = $S($EXPECT($L5, fail, 'NameSpaceImport "*"'), __, As, NonIdContinue, __, ImportedBinding);
2597
2631
  function NameSpaceImport(state) {
2598
2632
  if (state.verbose)
2599
2633
  console.log("ENTER:", "NameSpaceImport");
@@ -2603,7 +2637,7 @@ var require_parser = __commonJS({
2603
2637
  return NameSpaceImport$0(state);
2604
2638
  }
2605
2639
  }
2606
- var NamedImports$0 = $S($EXPECT($L12, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L13, fail, 'NamedImports "}"'));
2640
+ var NamedImports$0 = $S(OpenBrace, $Q(ImportSpecifier), $E($S(__, Comma)), __, CloseBrace);
2607
2641
  function NamedImports(state) {
2608
2642
  if (state.verbose)
2609
2643
  console.log("ENTER:", "NamedImports");
@@ -2623,19 +2657,7 @@ var require_parser = __commonJS({
2623
2657
  return FromClause$0(state);
2624
2658
  }
2625
2659
  }
2626
- var From$0 = $TS($S($EXPECT($L114, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2627
- return { $loc, token: $1 };
2628
- });
2629
- function From(state) {
2630
- if (state.verbose)
2631
- console.log("ENTER:", "From");
2632
- if (state.tokenize) {
2633
- return $TOKEN("From", state, From$0(state));
2634
- } else {
2635
- return From$0(state);
2636
- }
2637
- }
2638
- var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
2660
+ var ImportSpecifier$0 = $S(__, ModuleExportName, __, As, NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
2639
2661
  var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
2640
2662
  function ImportSpecifier(state) {
2641
2663
  if (state.tokenize) {
@@ -2675,7 +2697,7 @@ var require_parser = __commonJS({
2675
2697
  return UnprocessedModuleSpecifier$0(state) || UnprocessedModuleSpecifier$1(state);
2676
2698
  }
2677
2699
  }
2678
- var UnquotedSpecifier$0 = $TV($EXPECT($R4, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
2700
+ var UnquotedSpecifier$0 = $TV($EXPECT($R3, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
2679
2701
  var spec = $0;
2680
2702
  return { $loc, token: `"${spec}"` };
2681
2703
  });
@@ -2698,7 +2720,7 @@ var require_parser = __commonJS({
2698
2720
  return ImportedBinding$0(state);
2699
2721
  }
2700
2722
  }
2701
- var ExportDeclaration$0 = $S(Export, __, $EXPECT($L103, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2723
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L78, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2702
2724
  var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
2703
2725
  var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
2704
2726
  function ExportDeclaration(state) {
@@ -2708,37 +2730,17 @@ var require_parser = __commonJS({
2708
2730
  return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
2709
2731
  }
2710
2732
  }
2711
- var As$0 = $S($EXPECT($L4, fail, 'As "as"'), NonIdContinue);
2712
- function As(state) {
2713
- if (state.verbose)
2714
- console.log("ENTER:", "As");
2733
+ var ExportFromClause$0 = $S($EXPECT($L5, fail, 'ExportFromClause "*"'), $E($S(__, As, NonIdContinue, __, ModuleExportName)));
2734
+ var ExportFromClause$1 = NamedExports;
2735
+ function ExportFromClause(state) {
2715
2736
  if (state.tokenize) {
2716
- return $TOKEN("As", state, As$0(state));
2737
+ return $TOKEN("ExportFromClause", state, ExportFromClause$0(state) || ExportFromClause$1(state));
2717
2738
  } else {
2718
- return As$0(state);
2739
+ return ExportFromClause$0(state) || ExportFromClause$1(state);
2719
2740
  }
2720
2741
  }
2721
- var Export$0 = $S($EXPECT($L115, fail, 'Export "export"'), NonIdContinue);
2722
- function Export(state) {
2723
- if (state.verbose)
2724
- console.log("ENTER:", "Export");
2725
- if (state.tokenize) {
2726
- return $TOKEN("Export", state, Export$0(state));
2727
- } else {
2728
- return Export$0(state);
2729
- }
2730
- }
2731
- var ExportFromClause$0 = $S($EXPECT($L10, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), NonIdContinue, __, ModuleExportName)));
2732
- var ExportFromClause$1 = NamedExports;
2733
- function ExportFromClause(state) {
2734
- if (state.tokenize) {
2735
- return $TOKEN("ExportFromClause", state, ExportFromClause$0(state) || ExportFromClause$1(state));
2736
- } else {
2737
- return ExportFromClause$0(state) || ExportFromClause$1(state);
2738
- }
2739
- }
2740
- var NamedExports$0 = $S($EXPECT($L12, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L13, fail, 'NamedExports "}"'));
2741
- function NamedExports(state) {
2742
+ var NamedExports$0 = $S(OpenBrace, $Q(ExportSpecifier), $E($S(__, Comma)), __, CloseBrace);
2743
+ function NamedExports(state) {
2742
2744
  if (state.verbose)
2743
2745
  console.log("ENTER:", "NamedExports");
2744
2746
  if (state.tokenize) {
@@ -2747,7 +2749,7 @@ var require_parser = __commonJS({
2747
2749
  return NamedExports$0(state);
2748
2750
  }
2749
2751
  }
2750
- var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, $EXPECT($L4, fail, 'ExportSpecifier "as"'), __, ModuleExportName)), ObjectPropertyDelimiter);
2752
+ var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, As, __, ModuleExportName)), ObjectPropertyDelimiter);
2751
2753
  function ExportSpecifier(state) {
2752
2754
  if (state.verbose)
2753
2755
  console.log("ENTER:", "ExportSpecifier");
@@ -2778,8 +2780,16 @@ var require_parser = __commonJS({
2778
2780
  return HoistableDeclaration$0(state);
2779
2781
  }
2780
2782
  }
2781
- var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
2782
- var LexicalDeclaration$1 = $S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression);
2783
+ var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__, Comma, __, LexicalBinding)));
2784
+ var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
2785
+ var c = $1;
2786
+ var ca = $5;
2787
+ c.$loc = {
2788
+ pos: ca.$loc.pos - 1,
2789
+ length: ca.$loc.length + 1
2790
+ };
2791
+ return $0;
2792
+ });
2783
2793
  function LexicalDeclaration(state) {
2784
2794
  if (state.tokenize) {
2785
2795
  return $TOKEN("LexicalDeclaration", state, LexicalDeclaration$0(state) || LexicalDeclaration$1(state));
@@ -2787,7 +2797,7 @@ var require_parser = __commonJS({
2787
2797
  return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
2788
2798
  }
2789
2799
  }
2790
- var ConstAssignment$0 = $TV($EXPECT($L116, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
2800
+ var ConstAssignment$0 = $TV($EXPECT($L85, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
2791
2801
  return { $loc, token: "=" };
2792
2802
  });
2793
2803
  function ConstAssignment(state) {
@@ -2808,7 +2818,7 @@ var require_parser = __commonJS({
2808
2818
  return LexicalBinding$0(state) || LexicalBinding$1(state);
2809
2819
  }
2810
2820
  }
2811
- var Initializer$0 = $S(__, $EXPECT($L58, fail, 'Initializer "="'), AssignmentExpression);
2821
+ var Initializer$0 = $S(__, Equals, AssignmentExpression);
2812
2822
  function Initializer(state) {
2813
2823
  if (state.verbose)
2814
2824
  console.log("ENTER:", "Initializer");
@@ -2818,7 +2828,7 @@ var require_parser = __commonJS({
2818
2828
  return Initializer$0(state);
2819
2829
  }
2820
2830
  }
2821
- var VariableStatement$0 = $S($EXPECT($L96, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2831
+ var VariableStatement$0 = $S(Var, __, VariableDeclarationList);
2822
2832
  function VariableStatement(state) {
2823
2833
  if (state.verbose)
2824
2834
  console.log("ENTER:", "VariableStatement");
@@ -2828,7 +2838,7 @@ var require_parser = __commonJS({
2828
2838
  return VariableStatement$0(state);
2829
2839
  }
2830
2840
  }
2831
- var VariableDeclarationList$0 = $S(VariableDeclaration, $Q($S(__, $EXPECT($L0, fail, 'VariableDeclarationList ","'), __, VariableDeclaration)));
2841
+ var VariableDeclarationList$0 = $S(VariableDeclaration, $Q($S(__, Comma, __, VariableDeclaration)));
2832
2842
  function VariableDeclarationList(state) {
2833
2843
  if (state.verbose)
2834
2844
  console.log("ENTER:", "VariableDeclarationList");
@@ -2871,7 +2881,7 @@ var require_parser = __commonJS({
2871
2881
  return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
2872
2882
  }
2873
2883
  }
2874
- var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
2884
+ var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R4, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
2875
2885
  function DecimalBigIntegerLiteral(state) {
2876
2886
  if (state.verbose)
2877
2887
  console.log("ENTER:", "DecimalBigIntegerLiteral");
@@ -2881,7 +2891,7 @@ var require_parser = __commonJS({
2881
2891
  return DecimalBigIntegerLiteral$0(state);
2882
2892
  }
2883
2893
  }
2884
- var DecimalLiteral$0 = $R$0($EXPECT($R6, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
2894
+ var DecimalLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
2885
2895
  function DecimalLiteral(state) {
2886
2896
  if (state.verbose)
2887
2897
  console.log("ENTER:", "DecimalLiteral");
@@ -2891,7 +2901,7 @@ var require_parser = __commonJS({
2891
2901
  return DecimalLiteral$0(state);
2892
2902
  }
2893
2903
  }
2894
- var BinaryIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
2904
+ var BinaryIntegerLiteral$0 = $R$0($EXPECT($R6, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
2895
2905
  function BinaryIntegerLiteral(state) {
2896
2906
  if (state.verbose)
2897
2907
  console.log("ENTER:", "BinaryIntegerLiteral");
@@ -2901,7 +2911,7 @@ var require_parser = __commonJS({
2901
2911
  return BinaryIntegerLiteral$0(state);
2902
2912
  }
2903
2913
  }
2904
- var OctalIntegerLiteral$0 = $R$0($EXPECT($R8, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*/"));
2914
+ var OctalIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*/"));
2905
2915
  function OctalIntegerLiteral(state) {
2906
2916
  if (state.verbose)
2907
2917
  console.log("ENTER:", "OctalIntegerLiteral");
@@ -2911,7 +2921,7 @@ var require_parser = __commonJS({
2911
2921
  return OctalIntegerLiteral$0(state);
2912
2922
  }
2913
2923
  }
2914
- var HexLiteral$0 = $R$0($EXPECT($R9, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*/"));
2924
+ var HexLiteral$0 = $R$0($EXPECT($R8, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*/"));
2915
2925
  function HexLiteral(state) {
2916
2926
  if (state.verbose)
2917
2927
  console.log("ENTER:", "HexLiteral");
@@ -2921,18 +2931,22 @@ var require_parser = __commonJS({
2921
2931
  return HexLiteral$0(state);
2922
2932
  }
2923
2933
  }
2924
- var StringLiteral$0 = $TS($S($EXPECT($L117, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L117, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function($skip, $loc, $0, $1, $2, $3) {
2934
+ var StringLiteral$0 = $TS($S(TripleDoubleQuote, TripleDoubleStringCharacters, TripleDoubleQuote), function($skip, $loc, $0, $1, $2, $3) {
2935
+ var s = $1;
2925
2936
  var str = $2;
2926
- return { $loc, token: "`" + module2.dedentBlockString(str) + "`" };
2937
+ var e = $3;
2938
+ return [s, module2.dedentBlockString(str), e];
2927
2939
  });
2928
- var StringLiteral$1 = $TS($S($EXPECT($L118, fail, `StringLiteral "'''"`), $TEXT($Q(TripleSingleStringCharacter)), $EXPECT($L118, fail, `StringLiteral "'''"`)), function($skip, $loc, $0, $1, $2, $3) {
2940
+ var StringLiteral$1 = $TS($S(TripleSingleQuote, TripleSingleStringCharacters, TripleSingleQuote), function($skip, $loc, $0, $1, $2, $3) {
2941
+ var s = $1;
2929
2942
  var str = $2;
2930
- return { $loc, token: "`" + module2.dedentBlockString(str) + "`" };
2943
+ var e = $3;
2944
+ return [s, module2.dedentBlockString(str), e];
2931
2945
  });
2932
- var StringLiteral$2 = $TV($TEXT($S($EXPECT($L119, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L119, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
2946
+ var StringLiteral$2 = $TV($TEXT($S($EXPECT($L86, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L86, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
2933
2947
  return { $loc, token: $1 };
2934
2948
  });
2935
- var StringLiteral$3 = $TV($TEXT($S($EXPECT($L120, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L120, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
2949
+ var StringLiteral$3 = $TV($TEXT($S($EXPECT($L87, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L87, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
2936
2950
  return { $loc, token: $1 };
2937
2951
  });
2938
2952
  function StringLiteral(state) {
@@ -2942,7 +2956,7 @@ var require_parser = __commonJS({
2942
2956
  return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
2943
2957
  }
2944
2958
  }
2945
- var DoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
2959
+ var DoubleStringCharacter$0 = $R$0($EXPECT($R9, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
2946
2960
  function DoubleStringCharacter(state) {
2947
2961
  if (state.verbose)
2948
2962
  console.log("ENTER:", "DoubleStringCharacter");
@@ -2952,7 +2966,7 @@ var require_parser = __commonJS({
2952
2966
  return DoubleStringCharacter$0(state);
2953
2967
  }
2954
2968
  }
2955
- var SingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
2969
+ var SingleStringCharacter$0 = $R$0($EXPECT($R10, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
2956
2970
  function SingleStringCharacter(state) {
2957
2971
  if (state.verbose)
2958
2972
  console.log("ENTER:", "SingleStringCharacter");
@@ -2962,27 +2976,31 @@ var require_parser = __commonJS({
2962
2976
  return SingleStringCharacter$0(state);
2963
2977
  }
2964
2978
  }
2965
- var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R12, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
2966
- function TripleDoubleStringCharacter(state) {
2979
+ var TripleDoubleStringCharacters$0 = $TR($EXPECT($R11, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
2980
+ return { $loc, token: $0 };
2981
+ });
2982
+ function TripleDoubleStringCharacters(state) {
2967
2983
  if (state.verbose)
2968
- console.log("ENTER:", "TripleDoubleStringCharacter");
2984
+ console.log("ENTER:", "TripleDoubleStringCharacters");
2969
2985
  if (state.tokenize) {
2970
- return $TOKEN("TripleDoubleStringCharacter", state, TripleDoubleStringCharacter$0(state));
2986
+ return $TOKEN("TripleDoubleStringCharacters", state, TripleDoubleStringCharacters$0(state));
2971
2987
  } else {
2972
- return TripleDoubleStringCharacter$0(state);
2988
+ return TripleDoubleStringCharacters$0(state);
2973
2989
  }
2974
2990
  }
2975
- var TripleSingleStringCharacter$0 = $R$0($EXPECT($R13, fail, "TripleSingleStringCharacter /(?:'(?!'')|\\\\.|[^'])+/"));
2976
- function TripleSingleStringCharacter(state) {
2991
+ var TripleSingleStringCharacters$0 = $TR($EXPECT($R12, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
2992
+ return { $loc, token: $0 };
2993
+ });
2994
+ function TripleSingleStringCharacters(state) {
2977
2995
  if (state.verbose)
2978
- console.log("ENTER:", "TripleSingleStringCharacter");
2996
+ console.log("ENTER:", "TripleSingleStringCharacters");
2979
2997
  if (state.tokenize) {
2980
- return $TOKEN("TripleSingleStringCharacter", state, TripleSingleStringCharacter$0(state));
2998
+ return $TOKEN("TripleSingleStringCharacters", state, TripleSingleStringCharacters$0(state));
2981
2999
  } else {
2982
- return TripleSingleStringCharacter$0(state);
3000
+ return TripleSingleStringCharacters$0(state);
2983
3001
  }
2984
3002
  }
2985
- var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L60, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L60, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
3003
+ var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L45, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L45, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
2986
3004
  return { $loc, token: $1 };
2987
3005
  });
2988
3006
  function RegularExpressionLiteral(state) {
@@ -2994,7 +3012,7 @@ var require_parser = __commonJS({
2994
3012
  return RegularExpressionLiteral$0(state);
2995
3013
  }
2996
3014
  }
2997
- var RegularExpressionBody$0 = $S($R$0($EXPECT($R14, fail, "RegularExpressionBody /[^*\\/\\r\\n]/")), $Q(RegExpCharacter));
3015
+ var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R13, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
2998
3016
  function RegularExpressionBody(state) {
2999
3017
  if (state.verbose)
3000
3018
  console.log("ENTER:", "RegularExpressionBody");
@@ -3004,7 +3022,7 @@ var require_parser = __commonJS({
3004
3022
  return RegularExpressionBody$0(state);
3005
3023
  }
3006
3024
  }
3007
- var RegExpCharacter$0 = $R$0($EXPECT($R15, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
3025
+ var RegExpCharacter$0 = $R$0($EXPECT($R14, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
3008
3026
  function RegExpCharacter(state) {
3009
3027
  if (state.verbose)
3010
3028
  console.log("ENTER:", "RegExpCharacter");
@@ -3014,7 +3032,7 @@ var require_parser = __commonJS({
3014
3032
  return RegExpCharacter$0(state);
3015
3033
  }
3016
3034
  }
3017
- var RegularExpressionFlags$0 = $R$0($EXPECT($R16, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
3035
+ var RegularExpressionFlags$0 = $R$0($EXPECT($R15, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
3018
3036
  function RegularExpressionFlags(state) {
3019
3037
  if (state.verbose)
3020
3038
  console.log("ENTER:", "RegularExpressionFlags");
@@ -3024,7 +3042,7 @@ var require_parser = __commonJS({
3024
3042
  return RegularExpressionFlags$0(state);
3025
3043
  }
3026
3044
  }
3027
- var TemplateLiteral$0 = $S($EXPECT($L121, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L121, fail, 'TemplateLiteral "`"'));
3045
+ var TemplateLiteral$0 = $S($EXPECT($L0, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L0, fail, 'TemplateLiteral "`"'));
3028
3046
  function TemplateLiteral(state) {
3029
3047
  if (state.verbose)
3030
3048
  console.log("ENTER:", "TemplateLiteral");
@@ -3034,7 +3052,7 @@ var require_parser = __commonJS({
3034
3052
  return TemplateLiteral$0(state);
3035
3053
  }
3036
3054
  }
3037
- var TemplateSubstitution$0 = $S($EXPECT($L122, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L13, fail, 'TemplateSubstitution "}"'));
3055
+ var TemplateSubstitution$0 = $S($EXPECT($L88, fail, 'TemplateSubstitution "${"'), Expression, __, CloseBrace);
3038
3056
  function TemplateSubstitution(state) {
3039
3057
  if (state.verbose)
3040
3058
  console.log("ENTER:", "TemplateSubstitution");
@@ -3044,7 +3062,7 @@ var require_parser = __commonJS({
3044
3062
  return TemplateSubstitution$0(state);
3045
3063
  }
3046
3064
  }
3047
- var TemplateCharacters$0 = $R$0($EXPECT($R17, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
3065
+ var TemplateCharacters$0 = $R$0($EXPECT($R16, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
3048
3066
  function TemplateCharacters(state) {
3049
3067
  if (state.verbose)
3050
3068
  console.log("ENTER:", "TemplateCharacters");
@@ -3054,7 +3072,7 @@ var require_parser = __commonJS({
3054
3072
  return TemplateCharacters$0(state);
3055
3073
  }
3056
3074
  }
3057
- var ReservedWord$0 = $R$0($EXPECT($R18, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
3075
+ var ReservedWord$0 = $R$0($EXPECT($R17, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
3058
3076
  function ReservedWord(state) {
3059
3077
  if (state.verbose)
3060
3078
  console.log("ENTER:", "ReservedWord");
@@ -3073,7 +3091,9 @@ var require_parser = __commonJS({
3073
3091
  return Comment$0(state) || Comment$1(state);
3074
3092
  }
3075
3093
  }
3076
- var SingleLineComment$0 = $R$0($EXPECT($R19, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"));
3094
+ var SingleLineComment$0 = $TR($EXPECT($R18, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3095
+ return { $loc, token: $0 };
3096
+ });
3077
3097
  var SingleLineComment$1 = CoffeeSingleLineComment;
3078
3098
  function SingleLineComment(state) {
3079
3099
  if (state.tokenize) {
@@ -3091,7 +3111,9 @@ var require_parser = __commonJS({
3091
3111
  return MultiLineComment$0(state) || MultiLineComment$1(state);
3092
3112
  }
3093
3113
  }
3094
- var JSMultiLineComment$0 = $S($EXPECT($L123, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L124, fail, 'JSMultiLineComment "*/"')), $EXPECT($R20, fail, "JSMultiLineComment /./")))), $EXPECT($L124, fail, 'JSMultiLineComment "*/"'));
3114
+ var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L89, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L90, fail, 'JSMultiLineComment "*/"')), $EXPECT($R19, fail, "JSMultiLineComment /./"))), $EXPECT($L90, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
3115
+ return { $loc, token: $1 };
3116
+ });
3095
3117
  function JSMultiLineComment(state) {
3096
3118
  if (state.verbose)
3097
3119
  console.log("ENTER:", "JSMultiLineComment");
@@ -3101,10 +3123,10 @@ var require_parser = __commonJS({
3101
3123
  return JSMultiLineComment$0(state);
3102
3124
  }
3103
3125
  }
3104
- var CoffeeSingleLineComment$0 = $TR($EXPECT($R21, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3126
+ var CoffeeSingleLineComment$0 = $TR($EXPECT($R20, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3105
3127
  if (!module2.coffeeCompat)
3106
3128
  return $skip;
3107
- return ["//", $1];
3129
+ return { $loc, token: `//${$1}` };
3108
3130
  });
3109
3131
  function CoffeeSingleLineComment(state) {
3110
3132
  if (state.verbose)
@@ -3115,8 +3137,8 @@ var require_parser = __commonJS({
3115
3137
  return CoffeeSingleLineComment$0(state);
3116
3138
  }
3117
3139
  }
3118
- var CoffeeMultiLineComment$0 = $T($S($EXPECT($L125, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L125, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R20, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L125, fail, 'CoffeeMultiLineComment "###"')), function(value) {
3119
- return ["/*", value[1], "*/"];
3140
+ var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L91, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L91, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L90, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R19, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L91, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
3141
+ return { $loc, token: `/*${$2}*/` };
3120
3142
  });
3121
3143
  function CoffeeMultiLineComment(state) {
3122
3144
  if (state.verbose)
@@ -3127,7 +3149,9 @@ var require_parser = __commonJS({
3127
3149
  return CoffeeMultiLineComment$0(state);
3128
3150
  }
3129
3151
  }
3130
- var InlineComment$0 = $S($EXPECT($L123, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L124, fail, 'InlineComment "*/"')), $EXPECT($R22, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L124, fail, 'InlineComment "*/"'));
3152
+ var InlineComment$0 = $TV($TEXT($S($EXPECT($L89, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L90, fail, 'InlineComment "*/"')), $EXPECT($R21, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L90, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
3153
+ return { $loc, token: $1 };
3154
+ });
3131
3155
  function InlineComment(state) {
3132
3156
  if (state.verbose)
3133
3157
  console.log("ENTER:", "InlineComment");
@@ -3137,7 +3161,7 @@ var require_parser = __commonJS({
3137
3161
  return InlineComment$0(state);
3138
3162
  }
3139
3163
  }
3140
- var RestOfLine$0 = $S($Q($C($R$0($EXPECT($R23, fail, "RestOfLine /[ \\t]+/")), SingleLineComment, MultiLineComment)), EOL);
3164
+ var RestOfLine$0 = $S($Q($C($R$0($EXPECT($R22, fail, "RestOfLine /[ \\t]+/")), SingleLineComment, MultiLineComment)), EOL);
3141
3165
  function RestOfLine(state) {
3142
3166
  if (state.verbose)
3143
3167
  console.log("ENTER:", "RestOfLine");
@@ -3147,7 +3171,7 @@ var require_parser = __commonJS({
3147
3171
  return RestOfLine$0(state);
3148
3172
  }
3149
3173
  }
3150
- var TrailingComment$0 = $R$0($EXPECT($R24, fail, "TrailingComment /[\\t ]+/"));
3174
+ var TrailingComment$0 = $R$0($EXPECT($R23, fail, "TrailingComment /[\\t ]+/"));
3151
3175
  var TrailingComment$1 = InlineComment;
3152
3176
  var TrailingComment$2 = SingleLineComment;
3153
3177
  function TrailingComment(state) {
@@ -3157,7 +3181,7 @@ var require_parser = __commonJS({
3157
3181
  return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
3158
3182
  }
3159
3183
  }
3160
- var _$0 = $P($C($R$0($EXPECT($R24, fail, "_ /[\\t ]+/")), Comment));
3184
+ var _$0 = $P($C(NonNewlineWhitespace, Comment));
3161
3185
  function _(state) {
3162
3186
  if (state.verbose)
3163
3187
  console.log("ENTER:", "_");
@@ -3167,7 +3191,19 @@ var require_parser = __commonJS({
3167
3191
  return _$0(state);
3168
3192
  }
3169
3193
  }
3170
- var __$0 = $Q($C($R$0($EXPECT($R25, fail, "__ /[\\s]+/")), Comment));
3194
+ var NonNewlineWhitespace$0 = $TR($EXPECT($R22, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3195
+ return { $loc, token: $0 };
3196
+ });
3197
+ function NonNewlineWhitespace(state) {
3198
+ if (state.verbose)
3199
+ console.log("ENTER:", "NonNewlineWhitespace");
3200
+ if (state.tokenize) {
3201
+ return $TOKEN("NonNewlineWhitespace", state, NonNewlineWhitespace$0(state));
3202
+ } else {
3203
+ return NonNewlineWhitespace$0(state);
3204
+ }
3205
+ }
3206
+ var __$0 = $Q($C(Whitespace, Comment));
3171
3207
  function __(state) {
3172
3208
  if (state.verbose)
3173
3209
  console.log("ENTER:", "__");
@@ -3177,9 +3213,21 @@ var require_parser = __commonJS({
3177
3213
  return __$0(state);
3178
3214
  }
3179
3215
  }
3180
- var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L90, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
3181
- var StatementDelimiter$1 = $T($Y(EOS), function(value) {
3182
- return [";", value];
3216
+ var Whitespace$0 = $TR($EXPECT($R24, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3217
+ return { $loc, token: $0 };
3218
+ });
3219
+ function Whitespace(state) {
3220
+ if (state.verbose)
3221
+ console.log("ENTER:", "Whitespace");
3222
+ if (state.tokenize) {
3223
+ return $TOKEN("Whitespace", state, Whitespace$0(state));
3224
+ } else {
3225
+ return Whitespace$0(state);
3226
+ }
3227
+ }
3228
+ var StatementDelimiter$0 = $S($Q(TrailingComment), Semicolon, $Q(TrailingComment));
3229
+ var StatementDelimiter$1 = $TS($S($EXPECT($L1, fail, 'StatementDelimiter ""'), $Y(EOS)), function($skip, $loc, $0, $1, $2) {
3230
+ return { $loc, token: ";" };
3183
3231
  });
3184
3232
  function StatementDelimiter(state) {
3185
3233
  if (state.tokenize) {
@@ -3188,7 +3236,7 @@ var require_parser = __commonJS({
3188
3236
  return StatementDelimiter$0(state) || StatementDelimiter$1(state);
3189
3237
  }
3190
3238
  }
3191
- var NonIdContinue$0 = $R$0($EXPECT($R26, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
3239
+ var NonIdContinue$0 = $R$0($EXPECT($R25, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
3192
3240
  function NonIdContinue(state) {
3193
3241
  if (state.verbose)
3194
3242
  console.log("ENTER:", "NonIdContinue");
@@ -3198,6 +3246,487 @@ var require_parser = __commonJS({
3198
3246
  return NonIdContinue$0(state);
3199
3247
  }
3200
3248
  }
3249
+ var Loc$0 = $TV($EXPECT($L1, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
3250
+ return { $loc, token: "" };
3251
+ });
3252
+ function Loc(state) {
3253
+ if (state.verbose)
3254
+ console.log("ENTER:", "Loc");
3255
+ if (state.tokenize) {
3256
+ return $TOKEN("Loc", state, Loc$0(state));
3257
+ } else {
3258
+ return Loc$0(state);
3259
+ }
3260
+ }
3261
+ var As$0 = $TS($S($EXPECT($L92, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3262
+ return { $loc, token: $1 };
3263
+ });
3264
+ function As(state) {
3265
+ if (state.verbose)
3266
+ console.log("ENTER:", "As");
3267
+ if (state.tokenize) {
3268
+ return $TOKEN("As", state, As$0(state));
3269
+ } else {
3270
+ return As$0(state);
3271
+ }
3272
+ }
3273
+ var Async$0 = $TV($EXPECT($L93, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
3274
+ return { $loc, token: $1 };
3275
+ });
3276
+ function Async(state) {
3277
+ if (state.verbose)
3278
+ console.log("ENTER:", "Async");
3279
+ if (state.tokenize) {
3280
+ return $TOKEN("Async", state, Async$0(state));
3281
+ } else {
3282
+ return Async$0(state);
3283
+ }
3284
+ }
3285
+ var Await$0 = $TS($S($EXPECT($L94, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3286
+ return { $loc, token: $1 };
3287
+ });
3288
+ function Await(state) {
3289
+ if (state.verbose)
3290
+ console.log("ENTER:", "Await");
3291
+ if (state.tokenize) {
3292
+ return $TOKEN("Await", state, Await$0(state));
3293
+ } else {
3294
+ return Await$0(state);
3295
+ }
3296
+ }
3297
+ var Catch$0 = $TV($EXPECT($L95, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
3298
+ return { $loc, token: $1 };
3299
+ });
3300
+ function Catch(state) {
3301
+ if (state.verbose)
3302
+ console.log("ENTER:", "Catch");
3303
+ if (state.tokenize) {
3304
+ return $TOKEN("Catch", state, Catch$0(state));
3305
+ } else {
3306
+ return Catch$0(state);
3307
+ }
3308
+ }
3309
+ var Class$0 = $TV($EXPECT($L96, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
3310
+ return { $loc, token: $1 };
3311
+ });
3312
+ function Class(state) {
3313
+ if (state.verbose)
3314
+ console.log("ENTER:", "Class");
3315
+ if (state.tokenize) {
3316
+ return $TOKEN("Class", state, Class$0(state));
3317
+ } else {
3318
+ return Class$0(state);
3319
+ }
3320
+ }
3321
+ var CloseBrace$0 = $TV($EXPECT($L26, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
3322
+ return { $loc, token: $1 };
3323
+ });
3324
+ function CloseBrace(state) {
3325
+ if (state.verbose)
3326
+ console.log("ENTER:", "CloseBrace");
3327
+ if (state.tokenize) {
3328
+ return $TOKEN("CloseBrace", state, CloseBrace$0(state));
3329
+ } else {
3330
+ return CloseBrace$0(state);
3331
+ }
3332
+ }
3333
+ var CloseBracket$0 = $TV($EXPECT($L25, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
3334
+ return { $loc, token: $1 };
3335
+ });
3336
+ function CloseBracket(state) {
3337
+ if (state.verbose)
3338
+ console.log("ENTER:", "CloseBracket");
3339
+ if (state.tokenize) {
3340
+ return $TOKEN("CloseBracket", state, CloseBracket$0(state));
3341
+ } else {
3342
+ return CloseBracket$0(state);
3343
+ }
3344
+ }
3345
+ var CloseParen$0 = $TV($EXPECT($L18, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
3346
+ return { $loc, token: $1 };
3347
+ });
3348
+ function CloseParen(state) {
3349
+ if (state.verbose)
3350
+ console.log("ENTER:", "CloseParen");
3351
+ if (state.tokenize) {
3352
+ return $TOKEN("CloseParen", state, CloseParen$0(state));
3353
+ } else {
3354
+ return CloseParen$0(state);
3355
+ }
3356
+ }
3357
+ var Colon$0 = $TV($EXPECT($L97, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
3358
+ return { $loc, token: $1 };
3359
+ });
3360
+ function Colon(state) {
3361
+ if (state.verbose)
3362
+ console.log("ENTER:", "Colon");
3363
+ if (state.tokenize) {
3364
+ return $TOKEN("Colon", state, Colon$0(state));
3365
+ } else {
3366
+ return Colon$0(state);
3367
+ }
3368
+ }
3369
+ var Dot$0 = $TV($EXPECT($L98, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
3370
+ return { $loc, token: $1 };
3371
+ });
3372
+ function Dot(state) {
3373
+ if (state.verbose)
3374
+ console.log("ENTER:", "Dot");
3375
+ if (state.tokenize) {
3376
+ return $TOKEN("Dot", state, Dot$0(state));
3377
+ } else {
3378
+ return Dot$0(state);
3379
+ }
3380
+ }
3381
+ var Else$0 = $TV($EXPECT($L99, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
3382
+ return { $loc, token: $1 };
3383
+ });
3384
+ function Else(state) {
3385
+ if (state.verbose)
3386
+ console.log("ENTER:", "Else");
3387
+ if (state.tokenize) {
3388
+ return $TOKEN("Else", state, Else$0(state));
3389
+ } else {
3390
+ return Else$0(state);
3391
+ }
3392
+ }
3393
+ var Equals$0 = $TV($EXPECT($L43, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
3394
+ return { $loc, token: $1 };
3395
+ });
3396
+ function Equals(state) {
3397
+ if (state.verbose)
3398
+ console.log("ENTER:", "Equals");
3399
+ if (state.tokenize) {
3400
+ return $TOKEN("Equals", state, Equals$0(state));
3401
+ } else {
3402
+ return Equals$0(state);
3403
+ }
3404
+ }
3405
+ var Export$0 = $TS($S($EXPECT($L100, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3406
+ return { $loc, token: $1 };
3407
+ });
3408
+ function Export(state) {
3409
+ if (state.verbose)
3410
+ console.log("ENTER:", "Export");
3411
+ if (state.tokenize) {
3412
+ return $TOKEN("Export", state, Export$0(state));
3413
+ } else {
3414
+ return Export$0(state);
3415
+ }
3416
+ }
3417
+ var For$0 = $TS($S($EXPECT($L101, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3418
+ return { $loc, token: $1 };
3419
+ });
3420
+ function For(state) {
3421
+ if (state.verbose)
3422
+ console.log("ENTER:", "For");
3423
+ if (state.tokenize) {
3424
+ return $TOKEN("For", state, For$0(state));
3425
+ } else {
3426
+ return For$0(state);
3427
+ }
3428
+ }
3429
+ var From$0 = $TS($S($EXPECT($L102, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3430
+ return { $loc, token: $1 };
3431
+ });
3432
+ function From(state) {
3433
+ if (state.verbose)
3434
+ console.log("ENTER:", "From");
3435
+ if (state.tokenize) {
3436
+ return $TOKEN("From", state, From$0(state));
3437
+ } else {
3438
+ return From$0(state);
3439
+ }
3440
+ }
3441
+ var Function$0 = $TV($EXPECT($L103, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
3442
+ return { $loc, token: $1 };
3443
+ });
3444
+ function Function(state) {
3445
+ if (state.verbose)
3446
+ console.log("ENTER:", "Function");
3447
+ if (state.tokenize) {
3448
+ return $TOKEN("Function", state, Function$0(state));
3449
+ } else {
3450
+ return Function$0(state);
3451
+ }
3452
+ }
3453
+ var GetOrSet$0 = $TS($S($C($EXPECT($L104, fail, 'GetOrSet "get"'), $EXPECT($L105, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3454
+ return { $loc, token: $1 };
3455
+ });
3456
+ function GetOrSet(state) {
3457
+ if (state.verbose)
3458
+ console.log("ENTER:", "GetOrSet");
3459
+ if (state.tokenize) {
3460
+ return $TOKEN("GetOrSet", state, GetOrSet$0(state));
3461
+ } else {
3462
+ return GetOrSet$0(state);
3463
+ }
3464
+ }
3465
+ var If$0 = $TV($EXPECT($L106, fail, 'If "if"'), function($skip, $loc, $0, $1) {
3466
+ return { $loc, token: $1 };
3467
+ });
3468
+ function If(state) {
3469
+ if (state.verbose)
3470
+ console.log("ENTER:", "If");
3471
+ if (state.tokenize) {
3472
+ return $TOKEN("If", state, If$0(state));
3473
+ } else {
3474
+ return If$0(state);
3475
+ }
3476
+ }
3477
+ var Import$0 = $TS($S($EXPECT($L13, fail, 'Import "import"'), $Y($EXPECT($R26, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
3478
+ return { $loc, token: $1 };
3479
+ });
3480
+ function Import(state) {
3481
+ if (state.verbose)
3482
+ console.log("ENTER:", "Import");
3483
+ if (state.tokenize) {
3484
+ return $TOKEN("Import", state, Import$0(state));
3485
+ } else {
3486
+ return Import$0(state);
3487
+ }
3488
+ }
3489
+ var In$0 = $TV($EXPECT($L66, fail, 'In "in"'), function($skip, $loc, $0, $1) {
3490
+ return { $loc, token: $1 };
3491
+ });
3492
+ function In(state) {
3493
+ if (state.verbose)
3494
+ console.log("ENTER:", "In");
3495
+ if (state.tokenize) {
3496
+ return $TOKEN("In", state, In$0(state));
3497
+ } else {
3498
+ return In$0(state);
3499
+ }
3500
+ }
3501
+ var LetOrConst$0 = $TV($C($EXPECT($L107, fail, 'LetOrConst "let"'), $EXPECT($L108, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
3502
+ return { $loc, token: $1 };
3503
+ });
3504
+ function LetOrConst(state) {
3505
+ if (state.verbose)
3506
+ console.log("ENTER:", "LetOrConst");
3507
+ if (state.tokenize) {
3508
+ return $TOKEN("LetOrConst", state, LetOrConst$0(state));
3509
+ } else {
3510
+ return LetOrConst$0(state);
3511
+ }
3512
+ }
3513
+ var Loop$0 = $TS($S($EXPECT($L109, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3514
+ return { $loc, token: "while(true)" };
3515
+ });
3516
+ function Loop(state) {
3517
+ if (state.verbose)
3518
+ console.log("ENTER:", "Loop");
3519
+ if (state.tokenize) {
3520
+ return $TOKEN("Loop", state, Loop$0(state));
3521
+ } else {
3522
+ return Loop$0(state);
3523
+ }
3524
+ }
3525
+ var New$0 = $TV($EXPECT($L110, fail, 'New "new"'), function($skip, $loc, $0, $1) {
3526
+ return { $loc, token: $1 };
3527
+ });
3528
+ function New(state) {
3529
+ if (state.verbose)
3530
+ console.log("ENTER:", "New");
3531
+ if (state.tokenize) {
3532
+ return $TOKEN("New", state, New$0(state));
3533
+ } else {
3534
+ return New$0(state);
3535
+ }
3536
+ }
3537
+ var Of$0 = $TV($EXPECT($L111, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
3538
+ return { $loc, token: $1 };
3539
+ });
3540
+ function Of(state) {
3541
+ if (state.verbose)
3542
+ console.log("ENTER:", "Of");
3543
+ if (state.tokenize) {
3544
+ return $TOKEN("Of", state, Of$0(state));
3545
+ } else {
3546
+ return Of$0(state);
3547
+ }
3548
+ }
3549
+ var OpenBrace$0 = $TV($EXPECT($L112, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
3550
+ return { $loc, token: $1 };
3551
+ });
3552
+ function OpenBrace(state) {
3553
+ if (state.verbose)
3554
+ console.log("ENTER:", "OpenBrace");
3555
+ if (state.tokenize) {
3556
+ return $TOKEN("OpenBrace", state, OpenBrace$0(state));
3557
+ } else {
3558
+ return OpenBrace$0(state);
3559
+ }
3560
+ }
3561
+ var OpenBracket$0 = $TV($EXPECT($L113, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
3562
+ return { $loc, token: $1 };
3563
+ });
3564
+ function OpenBracket(state) {
3565
+ if (state.verbose)
3566
+ console.log("ENTER:", "OpenBracket");
3567
+ if (state.tokenize) {
3568
+ return $TOKEN("OpenBracket", state, OpenBracket$0(state));
3569
+ } else {
3570
+ return OpenBracket$0(state);
3571
+ }
3572
+ }
3573
+ var OpenParen$0 = $TV($EXPECT($L114, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
3574
+ return { $loc, token: $1 };
3575
+ });
3576
+ function OpenParen(state) {
3577
+ if (state.verbose)
3578
+ console.log("ENTER:", "OpenParen");
3579
+ if (state.tokenize) {
3580
+ return $TOKEN("OpenParen", state, OpenParen$0(state));
3581
+ } else {
3582
+ return OpenParen$0(state);
3583
+ }
3584
+ }
3585
+ var QuestionMark$0 = $TV($EXPECT($L115, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
3586
+ return { $loc, token: $1 };
3587
+ });
3588
+ function QuestionMark(state) {
3589
+ if (state.verbose)
3590
+ console.log("ENTER:", "QuestionMark");
3591
+ if (state.tokenize) {
3592
+ return $TOKEN("QuestionMark", state, QuestionMark$0(state));
3593
+ } else {
3594
+ return QuestionMark$0(state);
3595
+ }
3596
+ }
3597
+ var Return$0 = $TS($S($EXPECT($L116, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3598
+ return { $loc, token: $1 };
3599
+ });
3600
+ function Return(state) {
3601
+ if (state.verbose)
3602
+ console.log("ENTER:", "Return");
3603
+ if (state.tokenize) {
3604
+ return $TOKEN("Return", state, Return$0(state));
3605
+ } else {
3606
+ return Return$0(state);
3607
+ }
3608
+ }
3609
+ var Semicolon$0 = $TV($EXPECT($L73, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
3610
+ return { $loc, token: $1 };
3611
+ });
3612
+ function Semicolon(state) {
3613
+ if (state.verbose)
3614
+ console.log("ENTER:", "Semicolon");
3615
+ if (state.tokenize) {
3616
+ return $TOKEN("Semicolon", state, Semicolon$0(state));
3617
+ } else {
3618
+ return Semicolon$0(state);
3619
+ }
3620
+ }
3621
+ var Static$0 = $TV($EXPECT($L117, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
3622
+ return { $loc, token: $1 };
3623
+ });
3624
+ var Static$1 = $TV($EXPECT($L11, fail, 'Static "@"'), function($skip, $loc, $0, $1) {
3625
+ return { $loc, token: "static " };
3626
+ });
3627
+ function Static(state) {
3628
+ if (state.tokenize) {
3629
+ return $TOKEN("Static", state, Static$0(state) || Static$1(state));
3630
+ } else {
3631
+ return Static$0(state) || Static$1(state);
3632
+ }
3633
+ }
3634
+ var Switch$0 = $TV($EXPECT($L118, fail, 'Switch "switch"'), function($skip, $loc, $0, $1) {
3635
+ return { $loc, token: $1 };
3636
+ });
3637
+ function Switch(state) {
3638
+ if (state.verbose)
3639
+ console.log("ENTER:", "Switch");
3640
+ if (state.tokenize) {
3641
+ return $TOKEN("Switch", state, Switch$0(state));
3642
+ } else {
3643
+ return Switch$0(state);
3644
+ }
3645
+ }
3646
+ var Target$0 = $TV($EXPECT($L119, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
3647
+ return { $loc, token: $1 };
3648
+ });
3649
+ function Target(state) {
3650
+ if (state.verbose)
3651
+ console.log("ENTER:", "Target");
3652
+ if (state.tokenize) {
3653
+ return $TOKEN("Target", state, Target$0(state));
3654
+ } else {
3655
+ return Target$0(state);
3656
+ }
3657
+ }
3658
+ var TripleDoubleQuote$0 = $TV($EXPECT($L120, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
3659
+ return { $loc, token: "`" };
3660
+ });
3661
+ function TripleDoubleQuote(state) {
3662
+ if (state.verbose)
3663
+ console.log("ENTER:", "TripleDoubleQuote");
3664
+ if (state.tokenize) {
3665
+ return $TOKEN("TripleDoubleQuote", state, TripleDoubleQuote$0(state));
3666
+ } else {
3667
+ return TripleDoubleQuote$0(state);
3668
+ }
3669
+ }
3670
+ var TripleSingleQuote$0 = $TV($EXPECT($L121, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
3671
+ return { $loc, token: "`" };
3672
+ });
3673
+ function TripleSingleQuote(state) {
3674
+ if (state.verbose)
3675
+ console.log("ENTER:", "TripleSingleQuote");
3676
+ if (state.tokenize) {
3677
+ return $TOKEN("TripleSingleQuote", state, TripleSingleQuote$0(state));
3678
+ } else {
3679
+ return TripleSingleQuote$0(state);
3680
+ }
3681
+ }
3682
+ var Try$0 = $TV($EXPECT($L122, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
3683
+ return { $loc, token: $1 };
3684
+ });
3685
+ function Try(state) {
3686
+ if (state.verbose)
3687
+ console.log("ENTER:", "Try");
3688
+ if (state.tokenize) {
3689
+ return $TOKEN("Try", state, Try$0(state));
3690
+ } else {
3691
+ return Try$0(state);
3692
+ }
3693
+ }
3694
+ var Unless$0 = $TV($EXPECT($L123, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
3695
+ return { $loc, token: $1 };
3696
+ });
3697
+ function Unless(state) {
3698
+ if (state.verbose)
3699
+ console.log("ENTER:", "Unless");
3700
+ if (state.tokenize) {
3701
+ return $TOKEN("Unless", state, Unless$0(state));
3702
+ } else {
3703
+ return Unless$0(state);
3704
+ }
3705
+ }
3706
+ var Var$0 = $TV($EXPECT($L124, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
3707
+ return { $loc, token: $1 };
3708
+ });
3709
+ function Var(state) {
3710
+ if (state.verbose)
3711
+ console.log("ENTER:", "Var");
3712
+ if (state.tokenize) {
3713
+ return $TOKEN("Var", state, Var$0(state));
3714
+ } else {
3715
+ return Var$0(state);
3716
+ }
3717
+ }
3718
+ var When$0 = $TS($S($EXPECT($L125, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3719
+ return { $loc, token: "case" };
3720
+ });
3721
+ function When(state) {
3722
+ if (state.verbose)
3723
+ console.log("ENTER:", "When");
3724
+ if (state.tokenize) {
3725
+ return $TOKEN("When", state, When$0(state));
3726
+ } else {
3727
+ return When$0(state);
3728
+ }
3729
+ }
3201
3730
  var JSXElement$0 = JSXSelfClosingElement;
3202
3731
  var JSXElement$1 = $TS($S(JSXOpeningElement, $Q(JSXChildren), __, JSXClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
3203
3732
  if ($1[1] !== $4[2]) {
@@ -3212,7 +3741,7 @@ var require_parser = __commonJS({
3212
3741
  return JSXElement$0(state) || JSXElement$1(state);
3213
3742
  }
3214
3743
  }
3215
- var JSXSelfClosingElement$0 = $S($EXPECT($L16, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L126, fail, 'JSXSelfClosingElement "/>"'));
3744
+ var JSXSelfClosingElement$0 = $S($EXPECT($L7, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L126, fail, 'JSXSelfClosingElement "/>"'));
3216
3745
  function JSXSelfClosingElement(state) {
3217
3746
  if (state.verbose)
3218
3747
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -3222,7 +3751,7 @@ var require_parser = __commonJS({
3222
3751
  return JSXSelfClosingElement$0(state);
3223
3752
  }
3224
3753
  }
3225
- var JSXOpeningElement$0 = $S($EXPECT($L16, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L69, fail, 'JSXOpeningElement ">"'));
3754
+ var JSXOpeningElement$0 = $S($EXPECT($L7, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L54, fail, 'JSXOpeningElement ">"'));
3226
3755
  function JSXOpeningElement(state) {
3227
3756
  if (state.verbose)
3228
3757
  console.log("ENTER:", "JSXOpeningElement");
@@ -3232,7 +3761,7 @@ var require_parser = __commonJS({
3232
3761
  return JSXOpeningElement$0(state);
3233
3762
  }
3234
3763
  }
3235
- var JSXClosingElement$0 = $S($EXPECT($L127, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L69, fail, 'JSXClosingElement ">"'));
3764
+ var JSXClosingElement$0 = $S($EXPECT($L127, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L54, fail, 'JSXClosingElement ">"'));
3236
3765
  function JSXClosingElement(state) {
3237
3766
  if (state.verbose)
3238
3767
  console.log("ENTER:", "JSXClosingElement");
@@ -3252,7 +3781,7 @@ var require_parser = __commonJS({
3252
3781
  return JSXFragment$0(state);
3253
3782
  }
3254
3783
  }
3255
- var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L14, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L25, fail, 'JSXElementName "."'), JSXIdentifierName))));
3784
+ var JSXElementName$0 = $S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName))));
3256
3785
  function JSXElementName(state) {
3257
3786
  if (state.verbose)
3258
3787
  console.log("ENTER:", "JSXElementName");
@@ -3282,7 +3811,7 @@ var require_parser = __commonJS({
3282
3811
  return JSXAttributes$0(state);
3283
3812
  }
3284
3813
  }
3285
- var JSXAttribute$0 = $S($EXPECT($L12, fail, 'JSXAttribute "{"'), __, $EXPECT($L34, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L13, fail, 'JSXAttribute "}"'));
3814
+ var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($L19, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, CloseBrace);
3286
3815
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
3287
3816
  function JSXAttribute(state) {
3288
3817
  if (state.tokenize) {
@@ -3291,7 +3820,7 @@ var require_parser = __commonJS({
3291
3820
  return JSXAttribute$0(state) || JSXAttribute$1(state);
3292
3821
  }
3293
3822
  }
3294
- var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L14, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
3823
+ var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S(Colon, JSXIdentifierName)));
3295
3824
  function JSXAttributeName(state) {
3296
3825
  if (state.verbose)
3297
3826
  console.log("ENTER:", "JSXAttributeName");
@@ -3301,7 +3830,7 @@ var require_parser = __commonJS({
3301
3830
  return JSXAttributeName$0(state);
3302
3831
  }
3303
3832
  }
3304
- var JSXAttributeInitializer$0 = $S(__, $EXPECT($L58, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
3833
+ var JSXAttributeInitializer$0 = $S(__, Equals, __, JSXAttributeValue);
3305
3834
  function JSXAttributeInitializer(state) {
3306
3835
  if (state.verbose)
3307
3836
  console.log("ENTER:", "JSXAttributeInitializer");
@@ -3313,7 +3842,7 @@ var require_parser = __commonJS({
3313
3842
  }
3314
3843
  var JSXAttributeValue$0 = $R$0($EXPECT($R28, fail, 'JSXAttributeValue /"[^"]*"/'));
3315
3844
  var JSXAttributeValue$1 = $R$0($EXPECT($R29, fail, "JSXAttributeValue /'[^']*'/"));
3316
- var JSXAttributeValue$2 = $S($EXPECT($L12, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L13, fail, 'JSXAttributeValue "}"'));
3845
+ var JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
3317
3846
  var JSXAttributeValue$3 = JSXElement;
3318
3847
  var JSXAttributeValue$4 = JSXFragment;
3319
3848
  function JSXAttributeValue(state) {
@@ -3336,7 +3865,7 @@ var require_parser = __commonJS({
3336
3865
  var JSXChild$0 = JSXText;
3337
3866
  var JSXChild$1 = JSXElement;
3338
3867
  var JSXChild$2 = JSXFragment;
3339
- var JSXChild$3 = $S($EXPECT($L12, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L13, fail, 'JSXChild "}"'));
3868
+ var JSXChild$3 = $S(OpenBrace, $E(JSXChildExpression), __, CloseBrace);
3340
3869
  function JSXChild(state) {
3341
3870
  if (state.tokenize) {
3342
3871
  return $TOKEN("JSXChild", state, JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state));
@@ -3354,7 +3883,7 @@ var require_parser = __commonJS({
3354
3883
  return JSXText$0(state);
3355
3884
  }
3356
3885
  }
3357
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L34, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3886
+ var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L19, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3358
3887
  function JSXChildExpression(state) {
3359
3888
  if (state.verbose)
3360
3889
  console.log("ENTER:", "JSXChildExpression");
@@ -3377,7 +3906,7 @@ var require_parser = __commonJS({
3377
3906
  }
3378
3907
  }
3379
3908
  var TypeDeclarationModifier$0 = $S($EXPECT($L130, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
3380
- var TypeDeclarationModifier$1 = $S($EXPECT($L115, fail, 'TypeDeclarationModifier "export"'), NonIdContinue);
3909
+ var TypeDeclarationModifier$1 = Export;
3381
3910
  function TypeDeclarationModifier(state) {
3382
3911
  if (state.tokenize) {
3383
3912
  return $TOKEN("TypeDeclarationModifier", state, TypeDeclarationModifier$0(state) || TypeDeclarationModifier$1(state));
@@ -3385,7 +3914,7 @@ var require_parser = __commonJS({
3385
3914
  return TypeDeclarationModifier$0(state) || TypeDeclarationModifier$1(state);
3386
3915
  }
3387
3916
  }
3388
- var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L58, fail, 'TypeDeclarationRest "="'), __, Type);
3917
+ var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, Equals, __, Type);
3389
3918
  var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, InterfaceBlock);
3390
3919
  var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
3391
3920
  function TypeDeclarationRest(state) {
@@ -3425,8 +3954,8 @@ var require_parser = __commonJS({
3425
3954
  return Namespace$0(state);
3426
3955
  }
3427
3956
  }
3428
- var InterfaceBlock$0 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L13, fail, 'InterfaceBlock "}"'));
3429
- var InterfaceBlock$1 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), $Q($S(__, InterfaceProperty)), __, $EXPECT($L13, fail, 'InterfaceBlock "}"'));
3957
+ var InterfaceBlock$0 = $S(__, OpenBrace, EOS, NestedInterfaceProperties, __, CloseBrace);
3958
+ var InterfaceBlock$1 = $S(__, OpenBrace, $Q($S(__, InterfaceProperty)), __, CloseBrace);
3430
3959
  var InterfaceBlock$2 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
3431
3960
  function InterfaceBlock(state) {
3432
3961
  if (state.tokenize) {
@@ -3469,13 +3998,13 @@ var require_parser = __commonJS({
3469
3998
  return InterfaceProperty$0(state) || InterfaceProperty$1(state);
3470
3999
  }
3471
4000
  }
3472
- var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L90, fail, 'InterfacePropertyDelimiter ";"'));
3473
- var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L13, fail, 'InterfacePropertyDelimiter "}"')));
3474
- var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L13, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
3475
- return ";";
4001
+ var InterfacePropertyDelimiter$0 = $S($Q(_), Semicolon);
4002
+ var InterfacePropertyDelimiter$1 = $Y($S($Q(_), CloseBrace));
4003
+ var InterfacePropertyDelimiter$2 = $TV($Y($S(__, CloseBrace)), function($skip, $loc, $0, $1) {
4004
+ return { $loc, token: ";" };
3476
4005
  });
3477
- var InterfacePropertyDelimiter$3 = $T($Y(EOS), function(value) {
3478
- return ";";
4006
+ var InterfacePropertyDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
4007
+ return { $loc, token: ";" };
3479
4008
  });
3480
4009
  function InterfacePropertyDelimiter(state) {
3481
4010
  if (state.tokenize) {
@@ -3484,8 +4013,8 @@ var require_parser = __commonJS({
3484
4013
  return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
3485
4014
  }
3486
4015
  }
3487
- var NamespaceBlock$0 = $S(__, $EXPECT($L12, fail, 'NamespaceBlock "{"'), EOS, NestedTypeDeclarations, __, $EXPECT($L13, fail, 'NamespaceBlock "}"'));
3488
- var NamespaceBlock$1 = $S(__, $EXPECT($L12, fail, 'NamespaceBlock "{"'), $Q($S(__, TypeDeclaration, InterfacePropertyDelimiter)), __, $EXPECT($L13, fail, 'NamespaceBlock "}"'));
4016
+ var NamespaceBlock$0 = $S(__, OpenBrace, EOS, NestedTypeDeclarations, __, CloseBrace);
4017
+ var NamespaceBlock$1 = $S(__, OpenBrace, $Q($S(__, TypeDeclaration, InterfacePropertyDelimiter)), __, CloseBrace);
3489
4018
  var NamespaceBlock$2 = $S(InsertOpenBrace, EOS, NestedTypeDeclarations, InsertNewline, InsertIndent, InsertCloseBrace);
3490
4019
  function NamespaceBlock(state) {
3491
4020
  if (state.tokenize) {
@@ -3519,7 +4048,7 @@ var require_parser = __commonJS({
3519
4048
  return NestedTypeDeclaration$0(state);
3520
4049
  }
3521
4050
  }
3522
- var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L134, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L27, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L28, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R32, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
4051
+ var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L134, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R32, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
3523
4052
  function TypeIndexSignature(state) {
3524
4053
  if (state.verbose)
3525
4054
  console.log("ENTER:", "TypeIndexSignature");
@@ -3530,7 +4059,7 @@ var require_parser = __commonJS({
3530
4059
  }
3531
4060
  }
3532
4061
  var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
3533
- var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L81, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
4062
+ var TypeIndex$1 = $S(__, PropertyName, __, In, Type, $E($S(__, As, Type)));
3534
4063
  function TypeIndex(state) {
3535
4064
  if (state.tokenize) {
3536
4065
  return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
@@ -3538,7 +4067,7 @@ var require_parser = __commonJS({
3538
4067
  return TypeIndex$0(state) || TypeIndex$1(state);
3539
4068
  }
3540
4069
  }
3541
- var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L14, fail, 'TypeSuffix ":"'), Type), function(value) {
4070
+ var TypeSuffix$0 = $T($S($E(QuestionMark), __, Colon, Type), function(value) {
3542
4071
  return { "ts": true, "children": value };
3543
4072
  });
3544
4073
  function TypeSuffix(state) {
@@ -3550,7 +4079,7 @@ var require_parser = __commonJS({
3550
4079
  return TypeSuffix$0(state);
3551
4080
  }
3552
4081
  }
3553
- var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L14, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L135, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
4082
+ var ReturnTypeSuffix$0 = $T($S(__, Colon, $E($S(__, $EXPECT($L135, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3554
4083
  return { "ts": true, "children": value };
3555
4084
  });
3556
4085
  function ReturnTypeSuffix(state) {
@@ -3562,7 +4091,7 @@ var require_parser = __commonJS({
3562
4091
  return ReturnTypeSuffix$0(state);
3563
4092
  }
3564
4093
  }
3565
- var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L72, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
4094
+ var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L57, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3566
4095
  function TypePredicate(state) {
3567
4096
  if (state.verbose)
3568
4097
  console.log("ENTER:", "TypePredicate");
@@ -3613,7 +4142,7 @@ var require_parser = __commonJS({
3613
4142
  }
3614
4143
  }
3615
4144
  var TypeUnaryOp$0 = $EXPECT($L136, fail, 'TypeUnaryOp "keyof"');
3616
- var TypeUnaryOp$1 = $EXPECT($L87, fail, 'TypeUnaryOp "typeof"');
4145
+ var TypeUnaryOp$1 = $EXPECT($L72, fail, 'TypeUnaryOp "typeof"');
3617
4146
  var TypeUnaryOp$2 = $EXPECT($L137, fail, 'TypeUnaryOp "infer"');
3618
4147
  function TypeUnaryOp(state) {
3619
4148
  if (state.tokenize) {
@@ -3622,7 +4151,7 @@ var require_parser = __commonJS({
3622
4151
  return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
3623
4152
  }
3624
4153
  }
3625
- var TypeIndexedAccess$0 = $S(__, $EXPECT($L27, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L28, fail, 'TypeIndexedAccess "]"'));
4154
+ var TypeIndexedAccess$0 = $S(__, OpenBracket, $E(Type), __, CloseBracket);
3626
4155
  function TypeIndexedAccess(state) {
3627
4156
  if (state.verbose)
3628
4157
  console.log("ENTER:", "TypeIndexedAccess");
@@ -3633,9 +4162,9 @@ var require_parser = __commonJS({
3633
4162
  }
3634
4163
  }
3635
4164
  var TypePrimary$0 = InterfaceBlock;
3636
- var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
4165
+ var TypePrimary$1 = $S(__, OpenParen, Type, __, CloseParen);
3637
4166
  var TypePrimary$2 = $S($Q(_), FunctionType);
3638
- var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L25, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
4167
+ var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
3639
4168
  var TypePrimary$4 = $S($Q(_), TypeLiteral);
3640
4169
  function TypePrimary(state) {
3641
4170
  if (state.tokenize) {
@@ -3644,7 +4173,7 @@ var require_parser = __commonJS({
3644
4173
  return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
3645
4174
  }
3646
4175
  }
3647
- var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L17, fail, 'TypeConditional "extends"'), Type, $E($S(__, $EXPECT($L3, fail, 'TypeConditional "?"'), Type, __, $EXPECT($L14, fail, 'TypeConditional ":"'), Type)))));
4176
+ var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L8, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type)))));
3648
4177
  function TypeConditional(state) {
3649
4178
  if (state.verbose)
3650
4179
  console.log("ENTER:", "TypeConditional");
@@ -3655,7 +4184,7 @@ var require_parser = __commonJS({
3655
4184
  }
3656
4185
  }
3657
4186
  var TypeLiteral$0 = Literal;
3658
- var TypeLiteral$1 = $EXPECT($L86, fail, 'TypeLiteral "void"');
4187
+ var TypeLiteral$1 = $EXPECT($L71, fail, 'TypeLiteral "void"');
3659
4188
  var TypeLiteral$2 = $EXPECT($L138, fail, 'TypeLiteral "[]"');
3660
4189
  function TypeLiteral(state) {
3661
4190
  if (state.tokenize) {
@@ -3664,8 +4193,8 @@ var require_parser = __commonJS({
3664
4193
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
3665
4194
  }
3666
4195
  }
3667
- var TypeBinaryOp$0 = $EXPECT($L84, fail, 'TypeBinaryOp "|"');
3668
- var TypeBinaryOp$1 = $EXPECT($L82, fail, 'TypeBinaryOp "&"');
4196
+ var TypeBinaryOp$0 = $EXPECT($L69, fail, 'TypeBinaryOp "|"');
4197
+ var TypeBinaryOp$1 = $EXPECT($L67, fail, 'TypeBinaryOp "&"');
3669
4198
  function TypeBinaryOp(state) {
3670
4199
  if (state.tokenize) {
3671
4200
  return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -3673,7 +4202,7 @@ var require_parser = __commonJS({
3673
4202
  return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
3674
4203
  }
3675
4204
  }
3676
- var FunctionType$0 = $S(Parameters, __, $EXPECT($L11, fail, 'FunctionType "=>"'), Type);
4205
+ var FunctionType$0 = $S(Parameters, __, $EXPECT($L6, fail, 'FunctionType "=>"'), Type);
3677
4206
  function FunctionType(state) {
3678
4207
  if (state.verbose)
3679
4208
  console.log("ENTER:", "FunctionType");
@@ -3683,7 +4212,7 @@ var require_parser = __commonJS({
3683
4212
  return FunctionType$0(state);
3684
4213
  }
3685
4214
  }
3686
- var TypeArguments$0 = $S(__, $EXPECT($L16, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L69, fail, 'TypeArguments ">"'));
4215
+ var TypeArguments$0 = $S(__, $EXPECT($L7, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L54, fail, 'TypeArguments ">"'));
3687
4216
  function TypeArguments(state) {
3688
4217
  if (state.verbose)
3689
4218
  console.log("ENTER:", "TypeArguments");
@@ -3693,7 +4222,7 @@ var require_parser = __commonJS({
3693
4222
  return TypeArguments$0(state);
3694
4223
  }
3695
4224
  }
3696
- var TypeParameters$0 = $TS($S(__, $EXPECT($L16, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L69, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
4225
+ var TypeParameters$0 = $TS($S(__, $EXPECT($L7, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L54, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
3697
4226
  return { ts: true, children: $0 };
3698
4227
  });
3699
4228
  function TypeParameters(state) {
@@ -3715,7 +4244,7 @@ var require_parser = __commonJS({
3715
4244
  return TypeParameter$0(state);
3716
4245
  }
3717
4246
  }
3718
- var TypeConstraint$0 = $S(__, $EXPECT($L17, fail, 'TypeConstraint "extends"'), Type);
4247
+ var TypeConstraint$0 = $S(__, $EXPECT($L8, fail, 'TypeConstraint "extends"'), Type);
3719
4248
  function TypeConstraint(state) {
3720
4249
  if (state.verbose)
3721
4250
  console.log("ENTER:", "TypeConstraint");
@@ -3725,13 +4254,13 @@ var require_parser = __commonJS({
3725
4254
  return TypeConstraint$0(state);
3726
4255
  }
3727
4256
  }
3728
- var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
3729
- var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L69, fail, 'TypeParameterDelimiter ">"')));
3730
- var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L69, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3731
- return ",";
4257
+ var TypeParameterDelimiter$0 = $S($Q(_), Comma);
4258
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L54, fail, 'TypeParameterDelimiter ">"')));
4259
+ var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L54, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
4260
+ return { $loc, token: "," };
3732
4261
  });
3733
- var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
3734
- return ",";
4262
+ var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
4263
+ return { $loc, token: "," };
3735
4264
  });
3736
4265
  function TypeParameterDelimiter(state) {
3737
4266
  if (state.tokenize) {
@@ -3790,7 +4319,7 @@ var require_parser = __commonJS({
3790
4319
  return EOF$0(state);
3791
4320
  }
3792
4321
  }
3793
- var Debugger$0 = $TV($EXPECT($L33, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
4322
+ var Debugger$0 = $TV($EXPECT($L1, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
3794
4323
  debugger;
3795
4324
  });
3796
4325
  function Debugger(state) {
@@ -3802,8 +4331,8 @@ var require_parser = __commonJS({
3802
4331
  return Debugger$0(state);
3803
4332
  }
3804
4333
  }
3805
- var InsertOpenParen$0 = $T($EXPECT($L33, fail, 'InsertOpenParen ""'), function(value) {
3806
- return "(";
4334
+ var InsertOpenParen$0 = $TV($EXPECT($L1, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
4335
+ return { $loc, token: "(" };
3807
4336
  });
3808
4337
  function InsertOpenParen(state) {
3809
4338
  if (state.verbose)
@@ -3814,8 +4343,8 @@ var require_parser = __commonJS({
3814
4343
  return InsertOpenParen$0(state);
3815
4344
  }
3816
4345
  }
3817
- var InsertCloseParen$0 = $T($EXPECT($L33, fail, 'InsertCloseParen ""'), function(value) {
3818
- return ")";
4346
+ var InsertCloseParen$0 = $TV($EXPECT($L1, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
4347
+ return { $loc, token: ")" };
3819
4348
  });
3820
4349
  function InsertCloseParen(state) {
3821
4350
  if (state.verbose)
@@ -3826,8 +4355,8 @@ var require_parser = __commonJS({
3826
4355
  return InsertCloseParen$0(state);
3827
4356
  }
3828
4357
  }
3829
- var InsertOpenBrace$0 = $T($EXPECT($L33, fail, 'InsertOpenBrace ""'), function(value) {
3830
- return " {";
4358
+ var InsertOpenBrace$0 = $TV($EXPECT($L1, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
4359
+ return [{ $loc, token: " " }, { $loc, token: "{" }];
3831
4360
  });
3832
4361
  function InsertOpenBrace(state) {
3833
4362
  if (state.verbose)
@@ -3838,8 +4367,8 @@ var require_parser = __commonJS({
3838
4367
  return InsertOpenBrace$0(state);
3839
4368
  }
3840
4369
  }
3841
- var InsertCloseBrace$0 = $T($EXPECT($L33, fail, 'InsertCloseBrace ""'), function(value) {
3842
- return "}";
4370
+ var InsertCloseBrace$0 = $TV($EXPECT($L1, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
4371
+ return { $loc, token: "}" };
3843
4372
  });
3844
4373
  function InsertCloseBrace(state) {
3845
4374
  if (state.verbose)
@@ -3850,8 +4379,8 @@ var require_parser = __commonJS({
3850
4379
  return InsertCloseBrace$0(state);
3851
4380
  }
3852
4381
  }
3853
- var InsertConst$0 = $T($EXPECT($L33, fail, 'InsertConst ""'), function(value) {
3854
- return "const ";
4382
+ var InsertConst$0 = $TV($EXPECT($L1, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
4383
+ return { $loc, token: "const " };
3855
4384
  });
3856
4385
  function InsertConst(state) {
3857
4386
  if (state.verbose)
@@ -3862,8 +4391,8 @@ var require_parser = __commonJS({
3862
4391
  return InsertConst$0(state);
3863
4392
  }
3864
4393
  }
3865
- var InsertReadonly$0 = $T($EXPECT($L33, fail, 'InsertReadonly ""'), function(value) {
3866
- return { "ts": true, "children": ["readonly "] };
4394
+ var InsertReadonly$0 = $TV($EXPECT($L1, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
4395
+ return { ts: true, children: [{ $loc, token: "readonly " }] };
3867
4396
  });
3868
4397
  function InsertReadonly(state) {
3869
4398
  if (state.verbose)
@@ -3874,7 +4403,7 @@ var require_parser = __commonJS({
3874
4403
  return InsertReadonly$0(state);
3875
4404
  }
3876
4405
  }
3877
- var InsertNewline$0 = $TV($EXPECT($L33, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
4406
+ var InsertNewline$0 = $TV($EXPECT($L1, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3878
4407
  return "\n";
3879
4408
  });
3880
4409
  function InsertNewline(state) {
@@ -3886,8 +4415,8 @@ var require_parser = __commonJS({
3886
4415
  return InsertNewline$0(state);
3887
4416
  }
3888
4417
  }
3889
- var InsertIndent$0 = $TV($EXPECT($L33, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3890
- return "".padStart(global.currentIndent * 2);
4418
+ var InsertIndent$0 = $TV($EXPECT($L1, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
4419
+ return "".padStart(module2.currentIndent * 2);
3891
4420
  });
3892
4421
  function InsertIndent(state) {
3893
4422
  if (state.verbose)
@@ -3898,8 +4427,8 @@ var require_parser = __commonJS({
3898
4427
  return InsertIndent$0(state);
3899
4428
  }
3900
4429
  }
3901
- var InsertSpace$0 = $T($EXPECT($L33, fail, 'InsertSpace ""'), function(value) {
3902
- return " ";
4430
+ var InsertSpace$0 = $TV($EXPECT($L1, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
4431
+ return { $loc, token: " " };
3903
4432
  });
3904
4433
  function InsertSpace(state) {
3905
4434
  if (state.verbose)
@@ -3910,8 +4439,8 @@ var require_parser = __commonJS({
3910
4439
  return InsertSpace$0(state);
3911
4440
  }
3912
4441
  }
3913
- var InsertDot$0 = $T($EXPECT($L33, fail, 'InsertDot ""'), function(value) {
3914
- return ".";
4442
+ var InsertDot$0 = $TV($EXPECT($L1, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
4443
+ return { $loc, token: "." };
3915
4444
  });
3916
4445
  function InsertDot(state) {
3917
4446
  if (state.verbose)
@@ -3922,8 +4451,8 @@ var require_parser = __commonJS({
3922
4451
  return InsertDot$0(state);
3923
4452
  }
3924
4453
  }
3925
- var InsertBreak$0 = $T($EXPECT($L33, fail, 'InsertBreak ""'), function(value) {
3926
- return "break;";
4454
+ var InsertBreak$0 = $TV($EXPECT($L1, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
4455
+ return { $loc, token: "break;" };
3927
4456
  });
3928
4457
  function InsertBreak(state) {
3929
4458
  if (state.verbose)
@@ -3934,22 +4463,30 @@ var require_parser = __commonJS({
3934
4463
  return InsertBreak$0(state);
3935
4464
  }
3936
4465
  }
3937
- var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L33, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
4466
+ var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3938
4467
  var directives = $2;
3939
- global.currentIndent = 0;
3940
- global.indentLevels = [0];
3941
- global.verbose = false;
4468
+ module2.lastIndent = 0;
4469
+ module2.trackedIndents = [0];
4470
+ module2.currentIndent = 0;
4471
+ module2.indentLevels = [0];
4472
+ module2.verbose = false;
3942
4473
  if (directives) {
3943
4474
  const compatRe = /use coffee-compat/;
3944
4475
  module2.coffeeCompat = directives.some((d) => d[1].token?.match(compatRe));
3945
4476
  }
3946
- module2.dedentBlockString = function(str) {
4477
+ module2.dedentBlockString = function({ $loc: $loc2, token: str }) {
3947
4478
  const spacing = str.match(/^(\r?\n|\n)\s+/);
3948
4479
  if (spacing) {
3949
4480
  str = str.replaceAll(spacing[0], "\n");
4481
+ const l = spacing.length;
4482
+ $loc2.pos += l;
4483
+ $loc2.length -= l;
3950
4484
  }
3951
4485
  str = str.replace(/^(\r?\n|\n)/, "").replace(/(\r?\n|\n)[ \t]*$/, "").replace(/(`|\$)/g, "\\$1");
3952
- return str;
4486
+ return {
4487
+ $loc: $loc2,
4488
+ token: str
4489
+ };
3953
4490
  };
3954
4491
  return $0;
3955
4492
  });
@@ -3963,7 +4500,13 @@ var require_parser = __commonJS({
3963
4500
  }
3964
4501
  }
3965
4502
  var Indent$0 = $TV($Q($C($EXPECT($L139, fail, 'Indent " "'), $EXPECT($L140, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3966
- return $1.length;
4503
+ const level = $1.length;
4504
+ module2.lastIndent = level;
4505
+ return {
4506
+ $loc,
4507
+ token: "".padStart(level * 2),
4508
+ level
4509
+ };
3967
4510
  });
3968
4511
  function Indent(state) {
3969
4512
  if (state.verbose)
@@ -3974,13 +4517,70 @@ var require_parser = __commonJS({
3974
4517
  return Indent$0(state);
3975
4518
  }
3976
4519
  }
3977
- var PushIndent$0 = $TV($EXPECT($L33, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3978
- global.currentIndent++;
3979
- if (global.verbose) {
3980
- console.log("pushing indent", global.currentIndent);
4520
+ var TrackIndent$0 = $TV($EXPECT($L1, fail, 'TrackIndent ""'), function($skip, $loc, $0, $1) {
4521
+ module2.trackedIndents.push(module2.lastIndent);
4522
+ });
4523
+ function TrackIndent(state) {
4524
+ if (state.verbose)
4525
+ console.log("ENTER:", "TrackIndent");
4526
+ if (state.tokenize) {
4527
+ return $TOKEN("TrackIndent", state, TrackIndent$0(state));
4528
+ } else {
4529
+ return TrackIndent$0(state);
4530
+ }
4531
+ }
4532
+ var RestoreIndent$0 = $TV($EXPECT($L1, fail, 'RestoreIndent ""'), function($skip, $loc, $0, $1) {
4533
+ const topLevel = module2.trackedIndents.pop();
4534
+ module2.lastIndent = topLevel;
4535
+ });
4536
+ function RestoreIndent(state) {
4537
+ if (state.verbose)
4538
+ console.log("ENTER:", "RestoreIndent");
4539
+ if (state.tokenize) {
4540
+ return $TOKEN("RestoreIndent", state, RestoreIndent$0(state));
4541
+ } else {
4542
+ return RestoreIndent$0(state);
4543
+ }
4544
+ }
4545
+ var Samedent$0 = $TS($S($E(EOS), Indent), function($skip, $loc, $0, $1, $2) {
4546
+ var indent = $2;
4547
+ if (indent.level === module2.trackedIndents[module2.trackedIndents.length - 1]) {
4548
+ return $0;
4549
+ }
4550
+ return $skip;
4551
+ });
4552
+ function Samedent(state) {
4553
+ if (state.verbose)
4554
+ console.log("ENTER:", "Samedent");
4555
+ if (state.tokenize) {
4556
+ return $TOKEN("Samedent", state, Samedent$0(state));
4557
+ } else {
4558
+ return Samedent$0(state);
4559
+ }
4560
+ }
4561
+ var IndentedFurther$0 = $TS($S($E(EOS), Indent), function($skip, $loc, $0, $1, $2) {
4562
+ var indent = $2;
4563
+ if (indent.level > module2.trackedIndents[module2.trackedIndents.length - 1]) {
4564
+ return $0;
4565
+ }
4566
+ return $skip;
4567
+ });
4568
+ function IndentedFurther(state) {
4569
+ if (state.verbose)
4570
+ console.log("ENTER:", "IndentedFurther");
4571
+ if (state.tokenize) {
4572
+ return $TOKEN("IndentedFurther", state, IndentedFurther$0(state));
4573
+ } else {
4574
+ return IndentedFurther$0(state);
4575
+ }
4576
+ }
4577
+ var PushIndent$0 = $TV($EXPECT($L1, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
4578
+ module2.currentIndent++;
4579
+ if (module2.verbose) {
4580
+ console.log("pushing indent", module2.currentIndent);
3981
4581
  }
3982
- global.indentLevels.push(global.currentIndent);
3983
- return global.currentIndent;
4582
+ module2.indentLevels.push(module2.currentIndent);
4583
+ return module2.currentIndent;
3984
4584
  });
3985
4585
  function PushIndent(state) {
3986
4586
  if (state.verbose)
@@ -3991,13 +4591,13 @@ var require_parser = __commonJS({
3991
4591
  return PushIndent$0(state);
3992
4592
  }
3993
4593
  }
3994
- var PopIndent$0 = $TV($EXPECT($L33, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3995
- if (global.verbose) {
3996
- console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
4594
+ var PopIndent$0 = $TV($EXPECT($L1, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
4595
+ if (module2.verbose) {
4596
+ console.log("popping indent", module2.indentLevels[module2.indentLevels.length - 1], "->", module2.indentLevels[module2.indentLevels.length - 2]);
3997
4597
  }
3998
- global.indentLevels.pop();
3999
- global.currentIndent = global.indentLevels[global.indentLevels.length - 1];
4000
- return global.currentIndent;
4598
+ module2.indentLevels.pop();
4599
+ module2.currentIndent = module2.indentLevels[module2.indentLevels.length - 1];
4600
+ return module2.currentIndent;
4001
4601
  });
4002
4602
  function PopIndent(state) {
4003
4603
  if (state.verbose)
@@ -4011,18 +4611,19 @@ var require_parser = __commonJS({
4011
4611
  var Nested$0 = $TS($S($E(EOS), Indent), function($skip, $loc, $0, $1, $2) {
4012
4612
  var eos = $1;
4013
4613
  var indent = $2;
4014
- const currentIndent = global.indentLevels[global.indentLevels.length - 1];
4015
- if (global.verbose) {
4016
- console.log("global indent", global.currentIndent);
4017
- console.log("Indented", indent, currentIndent);
4018
- }
4019
- if (indent !== currentIndent) {
4020
- if (global.verbose) {
4614
+ const { level } = indent;
4615
+ const currentIndent = module2.indentLevels[module2.indentLevels.length - 1];
4616
+ if (module2.verbose) {
4617
+ console.log("global indent", module2.currentIndent);
4618
+ console.log("Indented", level, currentIndent);
4619
+ }
4620
+ if (level !== currentIndent) {
4621
+ if (module2.verbose) {
4021
4622
  console.log("skipped nested");
4022
4623
  }
4023
4624
  return $skip;
4024
4625
  }
4025
- return [eos, "".padStart(indent * 2)];
4626
+ return $0;
4026
4627
  });
4027
4628
  function Nested(state) {
4028
4629
  if (state.verbose)
@@ -4033,31 +4634,6 @@ var require_parser = __commonJS({
4033
4634
  return Nested$0(state);
4034
4635
  }
4035
4636
  }
4036
- var NestedFurther$0 = $TS($S($E(EOS), Indent), function($skip, $loc, $0, $1, $2) {
4037
- var eos = $1;
4038
- var indent = $2;
4039
- const currentIndent = global.indentLevels[global.indentLevels.length - 1];
4040
- if (global.verbose) {
4041
- console.log("global indent", global.currentIndent);
4042
- console.log("Indented", indent, currentIndent);
4043
- }
4044
- if (indent !== currentIndent + 1) {
4045
- if (global.verbose) {
4046
- console.log("skipped nested");
4047
- }
4048
- return $skip;
4049
- }
4050
- return [eos, "".padStart(indent * 2)];
4051
- });
4052
- function NestedFurther(state) {
4053
- if (state.verbose)
4054
- console.log("ENTER:", "NestedFurther");
4055
- if (state.tokenize) {
4056
- return $TOKEN("NestedFurther", state, NestedFurther$0(state));
4057
- } else {
4058
- return NestedFurther$0(state);
4059
- }
4060
- }
4061
4637
  module2.exports = {
4062
4638
  parse: parse2
4063
4639
  };
@@ -4143,15 +4719,24 @@ var require_generate = __commonJS({
4143
4719
  // source/util.coffee
4144
4720
  var require_util = __commonJS({
4145
4721
  "source/util.coffee"(exports2, module2) {
4722
+ "use strict";
4146
4723
  var BASE64_CHARS;
4147
4724
  var SourceMap2;
4148
4725
  var VLQ_CONTINUATION_BIT;
4149
4726
  var VLQ_SHIFT;
4150
4727
  var VLQ_VALUE_MASK;
4728
+ var base64Encode2;
4729
+ var decodeError;
4730
+ var decodeVLQ;
4151
4731
  var encodeBase64;
4152
4732
  var encodeVlq;
4153
4733
  var locationTable;
4154
4734
  var lookupLineColumn;
4735
+ var prettySourceExcerpt;
4736
+ var remapPosition;
4737
+ var smRegexp;
4738
+ var vlqChars;
4739
+ var vlqTable;
4155
4740
  locationTable = function(input) {
4156
4741
  var line, lines, linesRe, pos, result;
4157
4742
  linesRe = /([^\r\n]*)(\r\n|\r|\n|$)/y;
@@ -4188,6 +4773,9 @@ var require_util = __commonJS({
4188
4773
  EOL = /\r?\n|\r/;
4189
4774
  return {
4190
4775
  data: sm,
4776
+ source: function() {
4777
+ return sourceString;
4778
+ },
4191
4779
  renderMappings: function() {
4192
4780
  var lastSourceColumn, lastSourceLine;
4193
4781
  lastSourceLine = 0;
@@ -4219,20 +4807,23 @@ var require_util = __commonJS({
4219
4807
  };
4220
4808
  },
4221
4809
  updateSourceMap: function(outputStr, inputPos) {
4222
- var outLines;
4810
+ var outLines, srcCol, srcLine;
4223
4811
  outLines = outputStr.split(EOL);
4812
+ if (inputPos != null) {
4813
+ [srcLine, srcCol] = lookupLineColumn(srcTable, inputPos);
4814
+ }
4224
4815
  outLines.forEach(function(line, i) {
4225
- var l, srcCol, srcLine;
4816
+ var l;
4226
4817
  if (i > 0) {
4227
4818
  sm.lineNum++;
4228
4819
  sm.colOffset = 0;
4229
4820
  sm.lines[sm.lineNum] = [];
4821
+ srcCol = 0;
4230
4822
  }
4231
4823
  l = sm.colOffset;
4232
4824
  sm.colOffset = line.length;
4233
4825
  if (inputPos != null) {
4234
- [srcLine, srcCol] = lookupLineColumn(srcTable, inputPos);
4235
- return sm.lines[sm.lineNum].push([l, 0, srcLine, srcCol]);
4826
+ return sm.lines[sm.lineNum].push([l, 0, srcLine + i, srcCol]);
4236
4827
  } else if (l !== 0) {
4237
4828
  return sm.lines[sm.lineNum].push([l]);
4238
4829
  }
@@ -4240,6 +4831,95 @@ var require_util = __commonJS({
4240
4831
  }
4241
4832
  };
4242
4833
  };
4834
+ SourceMap2.parseWithLines = function(base64encodedJSONstr) {
4835
+ var json, lines, sourceColumn, sourceLine;
4836
+ json = JSON.parse(Buffer.from(base64encodedJSONstr, "base64").toString("utf8"));
4837
+ sourceLine = 0;
4838
+ sourceColumn = 0;
4839
+ lines = json.mappings.split(";").map(function(line) {
4840
+ if (line.length === 0) {
4841
+ return [];
4842
+ }
4843
+ return line.split(",").map(function(entry) {
4844
+ var result;
4845
+ result = decodeVLQ(entry);
4846
+ switch (result.length) {
4847
+ case 1:
4848
+ return [result[0]];
4849
+ case 4:
4850
+ return [result[0], result[1], sourceLine += result[2], sourceColumn += result[3]];
4851
+ case 5:
4852
+ return [result[0], result[1], sourceLine += result[2], sourceColumn += result[3], result[4]];
4853
+ default:
4854
+ throw new Error("Unknown source map entry", result);
4855
+ }
4856
+ });
4857
+ });
4858
+ json.lines = lines;
4859
+ return json;
4860
+ };
4861
+ smRegexp = /\n\/\/# sourceMappingURL=data:application\/json;charset=utf-8;base64,([+a-zA-Z0-9\/]*=?=?)$/;
4862
+ SourceMap2.remap = function(codeWithSourceMap, upstreamMap, sourcePath, targetPath) {
4863
+ var codeWithoutSourceMap, composedLines, newSourceMap, parsed, remappedCodeWithSourceMap, remappedSourceMapJSON, sourceMapText;
4864
+ sourceMapText = codeWithSourceMap.match(smRegexp);
4865
+ if (sourceMapText) {
4866
+ parsed = SourceMap2.parseWithLines(sourceMapText[1]);
4867
+ } else {
4868
+ console.warn("No source map found in code");
4869
+ return codeWithSourceMap;
4870
+ }
4871
+ debugger;
4872
+ composedLines = SourceMap2.composeLines(upstreamMap.data.lines, parsed.lines);
4873
+ upstreamMap.data.lines = composedLines;
4874
+ remappedSourceMapJSON = upstreamMap.json(sourcePath, targetPath);
4875
+ codeWithoutSourceMap = codeWithSourceMap.replace(smRegexp, "");
4876
+ newSourceMap = `${"sourceMapping"}URL=data:application/json;charset=utf-8;base64,${base64Encode2(JSON.stringify(remappedSourceMapJSON))}`;
4877
+ remappedCodeWithSourceMap = `${codeWithoutSourceMap}
4878
+ //# ${newSourceMap}`;
4879
+ return remappedCodeWithSourceMap;
4880
+ };
4881
+ SourceMap2.composeLines = function(upstreamMapping, lines) {
4882
+ return lines.map(function(line, l) {
4883
+ return line.map(function(entry) {
4884
+ var colDelta, sourceFileIndex, srcCol, srcLine, srcPos, upstreamCol, upstreamLine;
4885
+ if (entry.length === 1) {
4886
+ return entry;
4887
+ }
4888
+ [colDelta, sourceFileIndex, srcLine, srcCol] = entry;
4889
+ srcPos = remapPosition([srcLine, srcCol], upstreamMapping);
4890
+ if (!srcPos) {
4891
+ return [entry[0]];
4892
+ }
4893
+ [upstreamLine, upstreamCol] = srcPos;
4894
+ if (entry.length === 4) {
4895
+ return [colDelta, sourceFileIndex, upstreamLine, upstreamCol];
4896
+ }
4897
+ return [colDelta, sourceFileIndex, upstreamLine, upstreamCol, entry[4]];
4898
+ });
4899
+ });
4900
+ };
4901
+ prettySourceExcerpt = function(source, location, length) {
4902
+ var colNum, i, j, line, lineNum, lineNumStr, lines, ref, ref1;
4903
+ lines = source.split(/\r?\n|\r/);
4904
+ lineNum = location.line;
4905
+ colNum = location.column;
4906
+ for (i = j = ref = lineNum - 2, ref1 = lineNum + 2; ref <= ref1 ? j <= ref1 : j >= ref1; i = ref <= ref1 ? ++j : --j) {
4907
+ if (i < 0 || i >= lines.length) {
4908
+ continue;
4909
+ }
4910
+ line = lines[i];
4911
+ lineNumStr = (i + 1).toString();
4912
+ while (lineNumStr.length < 4) {
4913
+ lineNumStr = " " + lineNumStr;
4914
+ }
4915
+ if (i === lineNum) {
4916
+ console.log(`${lineNumStr}: ${line}`);
4917
+ console.log(" ".repeat(lineNumStr.length + 2 + colNum) + "^".repeat(length));
4918
+ } else {
4919
+ console.log(`${lineNumStr}: ${line}`);
4920
+ }
4921
+ }
4922
+ };
4243
4923
  VLQ_SHIFT = 5;
4244
4924
  VLQ_CONTINUATION_BIT = 1 << VLQ_SHIFT;
4245
4925
  VLQ_VALUE_MASK = VLQ_CONTINUATION_BIT - 1;
@@ -4264,7 +4944,101 @@ var require_util = __commonJS({
4264
4944
  throw new Error(`Cannot Base64 encode value: ${value}`);
4265
4945
  }();
4266
4946
  };
4267
- module2.exports = { locationTable, lookupLineColumn, SourceMap: SourceMap2 };
4947
+ base64Encode2 = function(src) {
4948
+ return Buffer.from(src).toString("base64");
4949
+ };
4950
+ module2.exports = { base64Encode: base64Encode2, locationTable, lookupLineColumn, SourceMap: SourceMap2 };
4951
+ vlqTable = new Uint8Array(128);
4952
+ vlqChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
4953
+ (function() {
4954
+ var i, l, results;
4955
+ i = 0;
4956
+ l = vlqTable.length;
4957
+ while (i < l) {
4958
+ vlqTable[i] = 255;
4959
+ i++;
4960
+ }
4961
+ i = 0;
4962
+ l = vlqChars.length;
4963
+ results = [];
4964
+ while (i < l) {
4965
+ vlqTable[vlqChars.charCodeAt(i)] = i;
4966
+ results.push(i++);
4967
+ }
4968
+ return results;
4969
+ })();
4970
+ decodeError = function(message) {
4971
+ throw new Error(message);
4972
+ };
4973
+ decodeVLQ = function(mapping) {
4974
+ var c, i, index, l, result, shift, v, vlq;
4975
+ i = 0;
4976
+ l = mapping.length;
4977
+ result = [];
4978
+ while (i < l) {
4979
+ shift = 0;
4980
+ vlq = 0;
4981
+ while (true) {
4982
+ if (i >= l) {
4983
+ decodeError("Unexpected early end of mapping data");
4984
+ }
4985
+ c = mapping.charCodeAt(i);
4986
+ if ((c & 127) !== c) {
4987
+ decodeError(`Invalid mapping character: ${JSON.stringify(String.fromCharCode(c))}`);
4988
+ }
4989
+ index = vlqTable[c & 127];
4990
+ if (index === 255) {
4991
+ decodeError(`Invalid mapping character: ${JSON.stringify(String.fromCharCode(c))}`);
4992
+ }
4993
+ i++;
4994
+ vlq |= (index & 31) << shift;
4995
+ shift += 5;
4996
+ if ((index & 32) === 0) {
4997
+ break;
4998
+ }
4999
+ }
5000
+ if (vlq & 1) {
5001
+ v = -(vlq >> 1);
5002
+ } else {
5003
+ v = vlq >> 1;
5004
+ }
5005
+ result.push(v);
5006
+ }
5007
+ return result;
5008
+ };
5009
+ remapPosition = function(position, sourcemapLines) {
5010
+ var character, i, l, lastMapping, lastMappingPosition, line, mapping, p, textLine;
5011
+ [line, character] = position;
5012
+ textLine = sourcemapLines[line];
5013
+ if (!(textLine != null ? textLine.length : void 0)) {
5014
+ return void 0;
5015
+ }
5016
+ i = 0;
5017
+ p = 0;
5018
+ l = textLine.length;
5019
+ lastMapping = void 0;
5020
+ lastMappingPosition = 0;
5021
+ while (i < l) {
5022
+ mapping = textLine[i];
5023
+ p += mapping[0];
5024
+ if (mapping.length === 4) {
5025
+ lastMapping = mapping;
5026
+ lastMappingPosition = p;
5027
+ }
5028
+ if (p >= character) {
5029
+ break;
5030
+ }
5031
+ i++;
5032
+ }
5033
+ if (character - lastMappingPosition !== 0) {
5034
+ return void 0;
5035
+ }
5036
+ if (lastMapping) {
5037
+ return [lastMapping[2], lastMapping[3]];
5038
+ } else {
5039
+ return void 0;
5040
+ }
5041
+ };
4268
5042
  }
4269
5043
  });
4270
5044
 
@@ -4278,7 +5052,7 @@ var prune;
4278
5052
  var util;
4279
5053
  ({ parse } = require_parser());
4280
5054
  ({ prune } = gen = require_generate());
4281
- ({ SourceMap } = util = require_util());
5055
+ ({ SourceMap, base64Encode } = util = require_util());
4282
5056
  defaultOptions = {};
4283
5057
  module.exports = {
4284
5058
  parse,
@@ -4296,9 +5070,9 @@ module.exports = {
4296
5070
  options.updateSourceMap = sm.updateSourceMap;
4297
5071
  code = gen(ast, options);
4298
5072
  if (options.inlineMap) {
4299
- srcMapJSON = sm.json(filename, filename.replace(/(?:\.civet$)?/, ".ts"));
5073
+ srcMapJSON = sm.json(filename, "");
4300
5074
  return `${code}
4301
- //# sourceMappingURL=data:application/json;base64,${base64Encode(JSON.stringify(srcMapJSON))}
5075
+ ${"//#"} sourceMappingURL=data:application/json;base64,${base64Encode(JSON.stringify(srcMapJSON))}
4302
5076
  `;
4303
5077
  } else {
4304
5078
  return {
@@ -4312,6 +5086,3 @@ module.exports = {
4312
5086
  generate: gen,
4313
5087
  util
4314
5088
  };
4315
- base64Encode = function(src) {
4316
- return Buffer.from(src).toString("base64");
4317
- };