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