@danielx/civet 0.4.4 → 0.4.6

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 (4) hide show
  1. package/README.md +7 -2
  2. package/dist/browser.js +569 -355
  3. package/dist/main.js +569 -355
  4. package/package.json +1 -1
package/dist/browser.js CHANGED
@@ -505,7 +505,6 @@ var Civet = (() => {
505
505
  PropertyName,
506
506
  MethodDefinition,
507
507
  MethodModifier,
508
- ConstructorShorthand,
509
508
  MethodSignature,
510
509
  ClassElementName,
511
510
  PrivateIdentifier,
@@ -535,6 +534,7 @@ var Civet = (() => {
535
534
  NestedCaseClauses,
536
535
  NestedCaseClause,
537
536
  CaseClause,
537
+ CaseExpressionList,
538
538
  ImpliedColon,
539
539
  TryStatement,
540
540
  CatchClause,
@@ -580,12 +580,15 @@ var Civet = (() => {
580
580
  OctalIntegerLiteral,
581
581
  HexLiteral,
582
582
  StringLiteral,
583
- DoubleStringCharacter,
584
- SingleStringCharacter,
583
+ BasicStringLiteral,
584
+ DoubleStringCharacters,
585
+ SingleStringCharacters,
585
586
  TripleDoubleStringCharacters,
586
587
  TripleSingleStringCharacters,
587
588
  CoffeeStringSubstitution,
588
- CoffeeSubstitutionStart,
589
+ CoffeeCompat,
590
+ CoffeeCompatDoubleQuotedString,
591
+ CoffeeCompatDoubleQuotedStringCharacters,
589
592
  RegularExpressionLiteral,
590
593
  RegularExpressionBody,
591
594
  RegExpCharacter,
@@ -614,13 +617,18 @@ var Civet = (() => {
614
617
  As,
615
618
  Async,
616
619
  Await,
620
+ Case,
617
621
  Catch,
618
622
  Class,
619
623
  CloseBrace,
620
624
  CloseBracket,
621
625
  CloseParen,
626
+ CoffeeSubstitutionStart,
622
627
  Colon,
628
+ ConstructorShorthand,
629
+ Default,
623
630
  Dot,
631
+ DoubleQuote,
624
632
  Else,
625
633
  Equals,
626
634
  Export,
@@ -641,7 +649,10 @@ var Civet = (() => {
641
649
  QuestionMark,
642
650
  Return,
643
651
  Semicolon,
652
+ SingleQuote,
653
+ Star,
644
654
  Static,
655
+ SubstitutionStart,
645
656
  Switch,
646
657
  Target,
647
658
  TripleDoubleQuote,
@@ -651,6 +662,7 @@ var Civet = (() => {
651
662
  Unless,
652
663
  Var,
653
664
  When,
665
+ Yield,
654
666
  JSXElement,
655
667
  JSXSelfClosingElement,
656
668
  JSXOpeningElement,
@@ -719,6 +731,7 @@ var Civet = (() => {
719
731
  InsertSpace,
720
732
  InsertDot,
721
733
  InsertBreak,
734
+ Reset,
722
735
  Init,
723
736
  Indent,
724
737
  TrackIndent,
@@ -732,130 +745,130 @@ var Civet = (() => {
732
745
  var $L1 = $L("");
733
746
  var $L2 = $L("++");
734
747
  var $L3 = $L("--");
735
- var $L4 = $L("yield");
736
- var $L5 = $L("*");
737
- var $L6 = $L("=>");
738
- var $L7 = $L("<");
739
- var $L8 = $L("extends");
740
- var $L9 = $L("this");
741
- var $L10 = $L("#");
742
- var $L11 = $L("@");
743
- var $L12 = $L("super");
744
- var $L13 = $L("import");
745
- var $L14 = $L("!");
746
- var $L15 = $L("::");
747
- var $L16 = $L("super[");
748
- var $L17 = $L("import.meta");
749
- var $L18 = $L(")");
750
- var $L19 = $L("...");
751
- var $L20 = $L("->");
752
- var $L21 = $L("null");
753
- var $L22 = $L("true");
754
- var $L23 = $L("false");
755
- var $L24 = $L(",");
756
- var $L25 = $L("]");
757
- var $L26 = $L("}");
758
- var $L27 = $L("**=");
759
- var $L28 = $L("*=");
760
- var $L29 = $L("/=");
761
- var $L30 = $L("%=");
762
- var $L31 = $L("+=");
763
- var $L32 = $L("-=");
764
- var $L33 = $L("<<=");
765
- var $L34 = $L(">>>=");
766
- var $L35 = $L(">>=");
767
- var $L36 = $L("&&=");
768
- var $L37 = $L("&=");
769
- var $L38 = $L("^=");
770
- var $L39 = $L("||=");
771
- var $L40 = $L("|=");
772
- var $L41 = $L("??=");
773
- var $L42 = $L("?=");
774
- var $L43 = $L("=");
775
- var $L44 = $L("**");
776
- var $L45 = $L("/");
777
- var $L46 = $L("%");
778
- var $L47 = $L("+");
779
- var $L48 = $L("-");
780
- var $L49 = $L("<=");
781
- var $L50 = $L(">=");
782
- var $L51 = $L("<<");
783
- var $L52 = $L(">>>");
784
- var $L53 = $L(">>");
785
- var $L54 = $L(">");
786
- var $L55 = $L("!==");
787
- var $L56 = $L("!=");
788
- var $L57 = $L("is");
789
- var $L58 = $L("===");
790
- var $L59 = $L("==");
791
- var $L60 = $L("and");
792
- var $L61 = $L("&&");
793
- var $L62 = $L("or");
794
- var $L63 = $L("||");
795
- var $L64 = $L("??");
796
- var $L65 = $L("instanceof");
797
- var $L66 = $L("in");
798
- var $L67 = $L("&");
799
- var $L68 = $L("^");
800
- var $L69 = $L("|");
801
- var $L70 = $L("delete");
802
- var $L71 = $L("void");
803
- var $L72 = $L("typeof");
804
- var $L73 = $L(";");
805
- var $L74 = $L("do");
806
- var $L75 = $L("while");
807
- var $L76 = $L("until");
808
- var $L77 = $L("case");
809
- var $L78 = $L("default");
810
- var $L79 = $L("finally");
811
- var $L80 = $L("break");
812
- var $L81 = $L("continue");
813
- var $L82 = $L("debugger");
814
- var $L83 = $L("throw");
815
- var $L84 = $L("import type");
816
- var $L85 = $L(":=");
817
- var $L86 = $L('"');
818
- var $L87 = $L("'");
819
- var $L88 = $L("#{");
820
- var $L89 = $L("${");
821
- var $L90 = $L("/*");
822
- var $L91 = $L("*/");
823
- var $L92 = $L("###");
824
- var $L93 = $L("as");
825
- var $L94 = $L("async");
826
- var $L95 = $L("await");
827
- var $L96 = $L("catch");
828
- var $L97 = $L("class");
829
- var $L98 = $L(":");
830
- var $L99 = $L(".");
831
- var $L100 = $L("else");
832
- var $L101 = $L("export");
833
- var $L102 = $L("for");
834
- var $L103 = $L("from");
835
- var $L104 = $L("function");
836
- var $L105 = $L("get");
837
- var $L106 = $L("set");
838
- var $L107 = $L("if");
839
- var $L108 = $L("let");
840
- var $L109 = $L("const");
841
- var $L110 = $L("loop");
842
- var $L111 = $L("new");
843
- var $L112 = $L("of");
844
- var $L113 = $L("{");
845
- var $L114 = $L("[");
846
- var $L115 = $L("(");
847
- var $L116 = $L("?");
848
- var $L117 = $L("return");
849
- var $L118 = $L("static");
850
- var $L119 = $L("switch");
851
- var $L120 = $L("target");
852
- var $L121 = $L('"""');
853
- var $L122 = $L("'''");
854
- var $L123 = $L("```");
855
- var $L124 = $L("try");
856
- var $L125 = $L("unless");
857
- var $L126 = $L("var");
858
- var $L127 = $L("when");
748
+ var $L4 = $L("=>");
749
+ var $L5 = $L("<");
750
+ var $L6 = $L("extends");
751
+ var $L7 = $L("this");
752
+ var $L8 = $L("#");
753
+ var $L9 = $L("@");
754
+ var $L10 = $L("super");
755
+ var $L11 = $L("import");
756
+ var $L12 = $L("!");
757
+ var $L13 = $L("::");
758
+ var $L14 = $L("super[");
759
+ var $L15 = $L("import.meta");
760
+ var $L16 = $L(")");
761
+ var $L17 = $L("...");
762
+ var $L18 = $L("->");
763
+ var $L19 = $L("null");
764
+ var $L20 = $L("true");
765
+ var $L21 = $L("false");
766
+ var $L22 = $L(",");
767
+ var $L23 = $L("]");
768
+ var $L24 = $L("}");
769
+ var $L25 = $L("**=");
770
+ var $L26 = $L("*=");
771
+ var $L27 = $L("/=");
772
+ var $L28 = $L("%=");
773
+ var $L29 = $L("+=");
774
+ var $L30 = $L("-=");
775
+ var $L31 = $L("<<=");
776
+ var $L32 = $L(">>>=");
777
+ var $L33 = $L(">>=");
778
+ var $L34 = $L("&&=");
779
+ var $L35 = $L("&=");
780
+ var $L36 = $L("^=");
781
+ var $L37 = $L("||=");
782
+ var $L38 = $L("|=");
783
+ var $L39 = $L("??=");
784
+ var $L40 = $L("?=");
785
+ var $L41 = $L("=");
786
+ var $L42 = $L("**");
787
+ var $L43 = $L("*");
788
+ var $L44 = $L("/");
789
+ var $L45 = $L("%");
790
+ var $L46 = $L("+");
791
+ var $L47 = $L("-");
792
+ var $L48 = $L("<=");
793
+ var $L49 = $L(">=");
794
+ var $L50 = $L("<<");
795
+ var $L51 = $L(">>>");
796
+ var $L52 = $L(">>");
797
+ var $L53 = $L(">");
798
+ var $L54 = $L("!==");
799
+ var $L55 = $L("!=");
800
+ var $L56 = $L("is");
801
+ var $L57 = $L("===");
802
+ var $L58 = $L("==");
803
+ var $L59 = $L("and");
804
+ var $L60 = $L("&&");
805
+ var $L61 = $L("or");
806
+ var $L62 = $L("||");
807
+ var $L63 = $L("??");
808
+ var $L64 = $L("instanceof");
809
+ var $L65 = $L("in");
810
+ var $L66 = $L("&");
811
+ var $L67 = $L("^");
812
+ var $L68 = $L("|");
813
+ var $L69 = $L("delete");
814
+ var $L70 = $L("void");
815
+ var $L71 = $L("typeof");
816
+ var $L72 = $L(";");
817
+ var $L73 = $L("do");
818
+ var $L74 = $L("while");
819
+ var $L75 = $L("until");
820
+ var $L76 = $L("finally");
821
+ var $L77 = $L("break");
822
+ var $L78 = $L("continue");
823
+ var $L79 = $L("debugger");
824
+ var $L80 = $L("throw");
825
+ var $L81 = $L("import type");
826
+ var $L82 = $L("default");
827
+ var $L83 = $L(":=");
828
+ var $L84 = $L("/*");
829
+ var $L85 = $L("*/");
830
+ var $L86 = $L("###");
831
+ var $L87 = $L("as");
832
+ var $L88 = $L("async");
833
+ var $L89 = $L("await");
834
+ var $L90 = $L("case");
835
+ var $L91 = $L("catch");
836
+ var $L92 = $L("class");
837
+ var $L93 = $L("#{");
838
+ var $L94 = $L(":");
839
+ var $L95 = $L(".");
840
+ var $L96 = $L('"');
841
+ var $L97 = $L("else");
842
+ var $L98 = $L("export");
843
+ var $L99 = $L("for");
844
+ var $L100 = $L("from");
845
+ var $L101 = $L("function");
846
+ var $L102 = $L("get");
847
+ var $L103 = $L("set");
848
+ var $L104 = $L("if");
849
+ var $L105 = $L("let");
850
+ var $L106 = $L("const");
851
+ var $L107 = $L("loop");
852
+ var $L108 = $L("new");
853
+ var $L109 = $L("of");
854
+ var $L110 = $L("{");
855
+ var $L111 = $L("[");
856
+ var $L112 = $L("(");
857
+ var $L113 = $L("?");
858
+ var $L114 = $L("return");
859
+ var $L115 = $L("'");
860
+ var $L116 = $L("static");
861
+ var $L117 = $L("${");
862
+ var $L118 = $L("switch");
863
+ var $L119 = $L("target");
864
+ var $L120 = $L('"""');
865
+ var $L121 = $L("'''");
866
+ var $L122 = $L("```");
867
+ var $L123 = $L("try");
868
+ var $L124 = $L("unless");
869
+ var $L125 = $L("var");
870
+ var $L126 = $L("when");
871
+ var $L127 = $L("yield");
859
872
  var $L128 = $L("/>");
860
873
  var $L129 = $L("</");
861
874
  var $L130 = $L("<>");
@@ -880,22 +893,22 @@ var Civet = (() => {
880
893
  var $R6 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
881
894
  var $R7 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
882
895
  var $R8 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
883
- var $R9 = $R(new RegExp('(?:\\\\.|[^"])+', "suy"));
884
- var $R10 = $R(new RegExp("(?:\\\\.|[^'])+", "suy"));
896
+ var $R9 = $R(new RegExp('(?:\\\\.|[^"])*', "suy"));
897
+ var $R10 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
885
898
  var $R11 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
886
899
  var $R12 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
887
- var $R13 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
888
- var $R14 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
889
- var $R15 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
890
- var $R16 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
891
- var $R17 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
892
- 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"));
893
- var $R19 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
894
- var $R20 = $R(new RegExp(".", "suy"));
895
- var $R21 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
896
- var $R22 = $R(new RegExp("[^\\r\\n]", "suy"));
897
- var $R23 = $R(new RegExp("[ \\t]+", "suy"));
898
- var $R24 = $R(new RegExp("[\\t ]+", "suy"));
900
+ var $R13 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
901
+ var $R14 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
902
+ var $R15 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
903
+ var $R16 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
904
+ var $R17 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
905
+ var $R18 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
906
+ var $R19 = $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"));
907
+ var $R20 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
908
+ var $R21 = $R(new RegExp(".", "suy"));
909
+ var $R22 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
910
+ var $R23 = $R(new RegExp("[^\\r\\n]", "suy"));
911
+ var $R24 = $R(new RegExp("[ \\t]+", "suy"));
899
912
  var $R25 = $R(new RegExp("[\\s]+", "suy"));
900
913
  var $R26 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
901
914
  var $R27 = $R(new RegExp("\\s", "suy"));
@@ -909,7 +922,7 @@ var Civet = (() => {
909
922
  var $R35 = $R(new RegExp("[\\t ]*", "suy"));
910
923
  var $R36 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
911
924
  var $R37 = $R(new RegExp("$", "suy"));
912
- var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
925
+ var Program$0 = $S(Reset, Init, __, $Q(TopLevelStatement), __);
913
926
  function Program(state) {
914
927
  if (state.verbose)
915
928
  console.log("ENTER:", "Program");
@@ -1008,8 +1021,7 @@ var Civet = (() => {
1008
1021
  }
1009
1022
  var ApplicationStart$0 = $TS($S($N(EOS), _, $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3) {
1010
1023
  var spacing = $2;
1011
- spacing[0].token = spacing[0].token.replace(/^ ?/, "(");
1012
- return spacing;
1024
+ return module.insertTrimmingSpace(spacing, "(");
1013
1025
  });
1014
1026
  var ApplicationStart$1 = $S(IndentedApplicationAllowed, $Y(NestedObjectLiteral), InsertOpenParen);
1015
1027
  function ApplicationStart(state) {
@@ -1134,7 +1146,7 @@ var Civet = (() => {
1134
1146
  return AwaitExpression$0(state);
1135
1147
  }
1136
1148
  }
1137
- var YieldExpression$0 = $S($EXPECT($L4, fail, 'YieldExpression "yield"'), NonIdContinue, $E($S($Q(TrailingComment), $EXPECT($L5, fail, 'YieldExpression "*"'))), AssignmentExpression);
1149
+ var YieldExpression$0 = $S(Yield, $E($S($Q(TrailingComment), Star)), AssignmentExpression);
1138
1150
  function YieldExpression(state) {
1139
1151
  if (state.verbose)
1140
1152
  console.log("ENTER:", "YieldExpression");
@@ -1153,7 +1165,7 @@ var Civet = (() => {
1153
1165
  return ArrowFunction$0(state) || ArrowFunction$1(state);
1154
1166
  }
1155
1167
  }
1156
- var FatArrow$0 = $TS($S(__, $EXPECT($L6, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
1168
+ var FatArrow$0 = $TS($S(__, $EXPECT($L4, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
1157
1169
  var ws = $1;
1158
1170
  if (!ws.length)
1159
1171
  return " =>";
@@ -1249,10 +1261,10 @@ var Civet = (() => {
1249
1261
  return ClassHeritage$0(state);
1250
1262
  }
1251
1263
  }
1252
- var ExtendsToken$0 = $TV($EXPECT($L7, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
1264
+ var ExtendsToken$0 = $TV($EXPECT($L5, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
1253
1265
  return { $loc, token: "extends" };
1254
1266
  });
1255
- var ExtendsToken$1 = $TV($EXPECT($L8, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
1267
+ var ExtendsToken$1 = $TV($EXPECT($L6, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
1256
1268
  return { $loc, token: $1 };
1257
1269
  });
1258
1270
  function ExtendsToken(state) {
@@ -1322,11 +1334,11 @@ var Civet = (() => {
1322
1334
  return FieldDefinition$0(state) || FieldDefinition$1(state);
1323
1335
  }
1324
1336
  }
1325
- var This$0 = $TV($EXPECT($L9, fail, 'This "this"'), function($skip, $loc, $0, $1) {
1337
+ var This$0 = $TV($EXPECT($L7, fail, 'This "this"'), function($skip, $loc, $0, $1) {
1326
1338
  return { $loc, token: $1 };
1327
1339
  });
1328
- var This$1 = $S(AtAccessor, $S($E($EXPECT($L10, fail, 'This "#"')), IdentifierName));
1329
- var This$2 = $TV($EXPECT($L11, fail, 'This "@"'), function($skip, $loc, $0, $1) {
1340
+ var This$1 = $S(AtAccessor, $S($E($EXPECT($L8, fail, 'This "#"')), IdentifierName));
1341
+ var This$2 = $TV($EXPECT($L9, fail, 'This "@"'), function($skip, $loc, $0, $1) {
1330
1342
  return { $loc, token: "this" };
1331
1343
  });
1332
1344
  function This(state) {
@@ -1336,7 +1348,7 @@ var Civet = (() => {
1336
1348
  return This$0(state) || This$1(state) || This$2(state);
1337
1349
  }
1338
1350
  }
1339
- var AtAccessor$0 = $TV($EXPECT($L11, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
1351
+ var AtAccessor$0 = $TV($EXPECT($L9, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
1340
1352
  return { $loc, token: "this." };
1341
1353
  });
1342
1354
  function AtAccessor(state) {
@@ -1367,8 +1379,8 @@ var Civet = (() => {
1367
1379
  return NewExpression$0(state);
1368
1380
  }
1369
1381
  }
1370
- var CallExpression$0 = $S($EXPECT($L12, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
1371
- var CallExpression$1 = $S($EXPECT($L13, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
1382
+ var CallExpression$0 = $S($EXPECT($L10, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
1383
+ var CallExpression$1 = $S($EXPECT($L11, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
1372
1384
  var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
1373
1385
  function CallExpression(state) {
1374
1386
  if (state.tokenize) {
@@ -1397,7 +1409,7 @@ var Civet = (() => {
1397
1409
  return OptionalShorthand$0(state);
1398
1410
  }
1399
1411
  }
1400
- var NonNullAssertion$0 = $T($EXPECT($L14, fail, 'NonNullAssertion "!"'), function(value) {
1412
+ var NonNullAssertion$0 = $T($EXPECT($L12, fail, 'NonNullAssertion "!"'), function(value) {
1401
1413
  return { "ts": true, "children": value };
1402
1414
  });
1403
1415
  function NonNullAssertion(state) {
@@ -1431,7 +1443,7 @@ var Civet = (() => {
1431
1443
  }
1432
1444
  var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), OpenBracket, Expression, __, CloseBracket);
1433
1445
  var MemberExpressionRest$1 = $S($E($S($Y(EOS), IndentedFurther)), PropertyAccess);
1434
- var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L15, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
1446
+ var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L13, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
1435
1447
  var id = $3;
1436
1448
  if (id)
1437
1449
  return [".prototype.", id];
@@ -1455,7 +1467,7 @@ var Civet = (() => {
1455
1467
  return PropertyAccess$0(state);
1456
1468
  }
1457
1469
  }
1458
- var SuperProperty$0 = $S($EXPECT($L16, fail, 'SuperProperty "super["'), Expression, __, CloseBracket);
1470
+ var SuperProperty$0 = $S($EXPECT($L14, fail, 'SuperProperty "super["'), Expression, __, CloseBracket);
1459
1471
  function SuperProperty(state) {
1460
1472
  if (state.verbose)
1461
1473
  console.log("ENTER:", "SuperProperty");
@@ -1466,7 +1478,7 @@ var Civet = (() => {
1466
1478
  }
1467
1479
  }
1468
1480
  var MetaProperty$0 = $S(New, Dot, Target);
1469
- var MetaProperty$1 = $TV($EXPECT($L17, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
1481
+ var MetaProperty$1 = $TV($EXPECT($L15, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
1470
1482
  return { $loc, token: $1 };
1471
1483
  });
1472
1484
  function MetaProperty(state) {
@@ -1498,8 +1510,8 @@ var Civet = (() => {
1498
1510
  }
1499
1511
  }
1500
1512
  var ParameterElementDelimiter$0 = $S($Q(_), Comma);
1501
- var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L18, fail, 'ParameterElementDelimiter ")"')));
1502
- var ParameterElementDelimiter$2 = $TV($Y($S(__, $EXPECT($L18, fail, 'ParameterElementDelimiter ")"'))), function($skip, $loc, $0, $1) {
1513
+ var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'ParameterElementDelimiter ")"')));
1514
+ var ParameterElementDelimiter$2 = $TV($Y($S(__, $EXPECT($L16, fail, 'ParameterElementDelimiter ")"'))), function($skip, $loc, $0, $1) {
1503
1515
  return { $loc, token: "," };
1504
1516
  });
1505
1517
  var ParameterElementDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
@@ -1586,7 +1598,7 @@ var Civet = (() => {
1586
1598
  return BindingProperty$0(state) || BindingProperty$1(state);
1587
1599
  }
1588
1600
  }
1589
- var BindingRestProperty$0 = $S($EXPECT($L19, fail, 'BindingRestProperty "..."'), BindingIdentifier);
1601
+ var BindingRestProperty$0 = $S($EXPECT($L17, fail, 'BindingRestProperty "..."'), BindingIdentifier);
1590
1602
  function BindingRestProperty(state) {
1591
1603
  if (state.verbose)
1592
1604
  console.log("ENTER:", "BindingRestProperty");
@@ -1634,7 +1646,7 @@ var Civet = (() => {
1634
1646
  return BindingElement$0(state);
1635
1647
  }
1636
1648
  }
1637
- var BindingRestElement$0 = $S($EXPECT($L19, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1649
+ var BindingRestElement$0 = $S($EXPECT($L17, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1638
1650
  function BindingRestElement(state) {
1639
1651
  if (state.verbose)
1640
1652
  console.log("ENTER:", "BindingRestElement");
@@ -1655,7 +1667,7 @@ var Civet = (() => {
1655
1667
  }
1656
1668
  }
1657
1669
  var FunctionExpression$0 = ThinArrowFunction;
1658
- var FunctionExpression$1 = $S($E($S(Async, __)), Function, $E($S($EXPECT($L5, fail, 'FunctionExpression "*"'), __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1670
+ var FunctionExpression$1 = $S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1659
1671
  function FunctionExpression(state) {
1660
1672
  if (state.tokenize) {
1661
1673
  return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1684,7 +1696,7 @@ var Civet = (() => {
1684
1696
  return ThinArrowFunction$0(state);
1685
1697
  }
1686
1698
  }
1687
- var Arrow$0 = $TV($EXPECT($L20, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1699
+ var Arrow$0 = $TV($EXPECT($L18, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1688
1700
  return { $loc, token: $1 };
1689
1701
  });
1690
1702
  function Arrow(state) {
@@ -1777,7 +1789,7 @@ var Civet = (() => {
1777
1789
  return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
1778
1790
  }
1779
1791
  }
1780
- var NullLiteral$0 = $TV($EXPECT($L21, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1792
+ var NullLiteral$0 = $TV($EXPECT($L19, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1781
1793
  return { $loc, token: $1 };
1782
1794
  });
1783
1795
  function NullLiteral(state) {
@@ -1789,7 +1801,7 @@ var Civet = (() => {
1789
1801
  return NullLiteral$0(state);
1790
1802
  }
1791
1803
  }
1792
- var BooleanLiteral$0 = $TV($C($EXPECT($L22, fail, 'BooleanLiteral "true"'), $EXPECT($L23, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1804
+ var BooleanLiteral$0 = $TV($C($EXPECT($L20, fail, 'BooleanLiteral "true"'), $EXPECT($L21, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1793
1805
  return { $loc, token: $1 };
1794
1806
  });
1795
1807
  function BooleanLiteral(state) {
@@ -1801,7 +1813,7 @@ var Civet = (() => {
1801
1813
  return BooleanLiteral$0(state);
1802
1814
  }
1803
1815
  }
1804
- var Comma$0 = $TV($EXPECT($L24, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
1816
+ var Comma$0 = $TV($EXPECT($L22, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
1805
1817
  return { $loc, token: $1 };
1806
1818
  });
1807
1819
  function Comma(state) {
@@ -1883,7 +1895,7 @@ var Civet = (() => {
1883
1895
  }
1884
1896
  }
1885
1897
  var ArrayElementDelimiter$0 = $S($Q(_), Comma);
1886
- var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
1898
+ var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L23, fail, 'ArrayElementDelimiter "]"')));
1887
1899
  var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
1888
1900
  return { $loc, token: "," };
1889
1901
  });
@@ -1914,7 +1926,7 @@ var Civet = (() => {
1914
1926
  return InlineElementList$0(state);
1915
1927
  }
1916
1928
  }
1917
- var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L19, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1929
+ var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L17, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1918
1930
  function ArrayElementExpression(state) {
1919
1931
  if (state.verbose)
1920
1932
  console.log("ENTER:", "ArrayElementExpression");
@@ -1981,7 +1993,7 @@ var Civet = (() => {
1981
1993
  }
1982
1994
  }
1983
1995
  var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
1984
- var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ObjectPropertyDelimiter "}"')));
1996
+ var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L24, fail, 'ObjectPropertyDelimiter "}"')));
1985
1997
  var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
1986
1998
  return { $loc, token: "," };
1987
1999
  });
@@ -2004,7 +2016,7 @@ var Civet = (() => {
2004
2016
  }
2005
2017
  var PropertyDefinition$0 = $S(PropertyName, __, Colon, AssignmentExpression);
2006
2018
  var PropertyDefinition$1 = MethodDefinition;
2007
- var PropertyDefinition$2 = $S($EXPECT($L19, fail, 'PropertyDefinition "..."'), AssignmentExpression);
2019
+ var PropertyDefinition$2 = $S($EXPECT($L17, fail, 'PropertyDefinition "..."'), AssignmentExpression);
2008
2020
  var PropertyDefinition$3 = IdentifierReference;
2009
2021
  function PropertyDefinition(state) {
2010
2022
  if (state.tokenize) {
@@ -2016,7 +2028,7 @@ var Civet = (() => {
2016
2028
  var PropertyName$0 = NumericLiteral;
2017
2029
  var PropertyName$1 = StringLiteral;
2018
2030
  var PropertyName$2 = IdentifierName;
2019
- var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L25, fail, 'PropertyName "]"'));
2031
+ var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L23, fail, 'PropertyName "]"'));
2020
2032
  function PropertyName(state) {
2021
2033
  if (state.tokenize) {
2022
2034
  return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -2035,8 +2047,8 @@ var Civet = (() => {
2035
2047
  }
2036
2048
  }
2037
2049
  var MethodModifier$0 = $S(GetOrSet, $Q(TrailingComment));
2038
- var MethodModifier$1 = $S($S(Async, __), $E($S($EXPECT($L5, fail, 'MethodModifier "*"'), __)));
2039
- var MethodModifier$2 = $S($EXPECT($L5, fail, 'MethodModifier "*"'), __);
2050
+ var MethodModifier$1 = $S($S(Async, __), $E($S(Star, __)));
2051
+ var MethodModifier$2 = $S(Star, __);
2040
2052
  var MethodModifier$3 = $S(Async, __);
2041
2053
  function MethodModifier(state) {
2042
2054
  if (state.tokenize) {
@@ -2045,18 +2057,6 @@ var Civet = (() => {
2045
2057
  return MethodModifier$0(state) || MethodModifier$1(state) || MethodModifier$2(state) || MethodModifier$3(state);
2046
2058
  }
2047
2059
  }
2048
- var ConstructorShorthand$0 = $TV($EXPECT($L11, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
2049
- return { $loc, token: "constructor" };
2050
- });
2051
- function ConstructorShorthand(state) {
2052
- if (state.verbose)
2053
- console.log("ENTER:", "ConstructorShorthand");
2054
- if (state.tokenize) {
2055
- return $TOKEN("ConstructorShorthand", state, ConstructorShorthand$0(state));
2056
- } else {
2057
- return ConstructorShorthand$0(state);
2058
- }
2059
- }
2060
2060
  var MethodSignature$0 = $S(ConstructorShorthand, Parameters);
2061
2061
  var MethodSignature$1 = $S($E(MethodModifier), ClassElementName, $Q(_), Parameters);
2062
2062
  function MethodSignature(state) {
@@ -2075,7 +2075,7 @@ var Civet = (() => {
2075
2075
  return ClassElementName$0(state) || ClassElementName$1(state);
2076
2076
  }
2077
2077
  }
2078
- var PrivateIdentifier$0 = $S($EXPECT($L10, fail, 'PrivateIdentifier "#"'), IdentifierName);
2078
+ var PrivateIdentifier$0 = $S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName);
2079
2079
  function PrivateIdentifier(state) {
2080
2080
  if (state.verbose)
2081
2081
  console.log("ENTER:", "PrivateIdentifier");
@@ -2097,25 +2097,25 @@ var Civet = (() => {
2097
2097
  return AssignmentOp$0(state);
2098
2098
  }
2099
2099
  }
2100
- var AssignmentOpSymbol$0 = $EXPECT($L27, fail, 'AssignmentOpSymbol "**="');
2101
- var AssignmentOpSymbol$1 = $EXPECT($L28, fail, 'AssignmentOpSymbol "*="');
2102
- var AssignmentOpSymbol$2 = $EXPECT($L29, fail, 'AssignmentOpSymbol "/="');
2103
- var AssignmentOpSymbol$3 = $EXPECT($L30, fail, 'AssignmentOpSymbol "%="');
2104
- var AssignmentOpSymbol$4 = $EXPECT($L31, fail, 'AssignmentOpSymbol "+="');
2105
- var AssignmentOpSymbol$5 = $EXPECT($L32, fail, 'AssignmentOpSymbol "-="');
2106
- var AssignmentOpSymbol$6 = $EXPECT($L33, fail, 'AssignmentOpSymbol "<<="');
2107
- var AssignmentOpSymbol$7 = $EXPECT($L34, fail, 'AssignmentOpSymbol ">>>="');
2108
- var AssignmentOpSymbol$8 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>="');
2109
- var AssignmentOpSymbol$9 = $EXPECT($L36, fail, 'AssignmentOpSymbol "&&="');
2110
- var AssignmentOpSymbol$10 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&="');
2111
- var AssignmentOpSymbol$11 = $EXPECT($L38, fail, 'AssignmentOpSymbol "^="');
2112
- var AssignmentOpSymbol$12 = $EXPECT($L39, fail, 'AssignmentOpSymbol "||="');
2113
- var AssignmentOpSymbol$13 = $EXPECT($L40, fail, 'AssignmentOpSymbol "|="');
2114
- var AssignmentOpSymbol$14 = $EXPECT($L41, fail, 'AssignmentOpSymbol "??="');
2115
- var AssignmentOpSymbol$15 = $T($EXPECT($L42, fail, 'AssignmentOpSymbol "?="'), function(value) {
2100
+ var AssignmentOpSymbol$0 = $EXPECT($L25, fail, 'AssignmentOpSymbol "**="');
2101
+ var AssignmentOpSymbol$1 = $EXPECT($L26, fail, 'AssignmentOpSymbol "*="');
2102
+ var AssignmentOpSymbol$2 = $EXPECT($L27, fail, 'AssignmentOpSymbol "/="');
2103
+ var AssignmentOpSymbol$3 = $EXPECT($L28, fail, 'AssignmentOpSymbol "%="');
2104
+ var AssignmentOpSymbol$4 = $EXPECT($L29, fail, 'AssignmentOpSymbol "+="');
2105
+ var AssignmentOpSymbol$5 = $EXPECT($L30, fail, 'AssignmentOpSymbol "-="');
2106
+ var AssignmentOpSymbol$6 = $EXPECT($L31, fail, 'AssignmentOpSymbol "<<="');
2107
+ var AssignmentOpSymbol$7 = $EXPECT($L32, fail, 'AssignmentOpSymbol ">>>="');
2108
+ var AssignmentOpSymbol$8 = $EXPECT($L33, fail, 'AssignmentOpSymbol ">>="');
2109
+ var AssignmentOpSymbol$9 = $EXPECT($L34, fail, 'AssignmentOpSymbol "&&="');
2110
+ var AssignmentOpSymbol$10 = $EXPECT($L35, fail, 'AssignmentOpSymbol "&="');
2111
+ var AssignmentOpSymbol$11 = $EXPECT($L36, fail, 'AssignmentOpSymbol "^="');
2112
+ var AssignmentOpSymbol$12 = $EXPECT($L37, fail, 'AssignmentOpSymbol "||="');
2113
+ var AssignmentOpSymbol$13 = $EXPECT($L38, fail, 'AssignmentOpSymbol "|="');
2114
+ var AssignmentOpSymbol$14 = $EXPECT($L39, fail, 'AssignmentOpSymbol "??="');
2115
+ var AssignmentOpSymbol$15 = $T($EXPECT($L40, fail, 'AssignmentOpSymbol "?="'), function(value) {
2116
2116
  return "??=";
2117
2117
  });
2118
- var AssignmentOpSymbol$16 = $EXPECT($L43, fail, 'AssignmentOpSymbol "="');
2118
+ var AssignmentOpSymbol$16 = $EXPECT($L41, fail, 'AssignmentOpSymbol "="');
2119
2119
  function AssignmentOpSymbol(state) {
2120
2120
  if (state.tokenize) {
2121
2121
  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));
@@ -2135,52 +2135,52 @@ var Civet = (() => {
2135
2135
  return BinaryOp$0(state);
2136
2136
  }
2137
2137
  }
2138
- var BinaryOpSymbol$0 = $EXPECT($L44, fail, 'BinaryOpSymbol "**"');
2139
- var BinaryOpSymbol$1 = $EXPECT($L5, fail, 'BinaryOpSymbol "*"');
2140
- var BinaryOpSymbol$2 = $EXPECT($L45, fail, 'BinaryOpSymbol "/"');
2141
- var BinaryOpSymbol$3 = $EXPECT($L46, fail, 'BinaryOpSymbol "%"');
2142
- var BinaryOpSymbol$4 = $EXPECT($L47, fail, 'BinaryOpSymbol "+"');
2143
- var BinaryOpSymbol$5 = $EXPECT($L48, fail, 'BinaryOpSymbol "-"');
2144
- var BinaryOpSymbol$6 = $EXPECT($L49, fail, 'BinaryOpSymbol "<="');
2145
- var BinaryOpSymbol$7 = $EXPECT($L50, fail, 'BinaryOpSymbol ">="');
2146
- var BinaryOpSymbol$8 = $EXPECT($L51, fail, 'BinaryOpSymbol "<<"');
2147
- var BinaryOpSymbol$9 = $EXPECT($L7, fail, 'BinaryOpSymbol "<"');
2148
- var BinaryOpSymbol$10 = $EXPECT($L52, fail, 'BinaryOpSymbol ">>>"');
2149
- var BinaryOpSymbol$11 = $EXPECT($L53, fail, 'BinaryOpSymbol ">>"');
2150
- var BinaryOpSymbol$12 = $EXPECT($L54, fail, 'BinaryOpSymbol ">"');
2151
- var BinaryOpSymbol$13 = $EXPECT($L55, fail, 'BinaryOpSymbol "!=="');
2152
- var BinaryOpSymbol$14 = $TV($EXPECT($L56, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2138
+ var BinaryOpSymbol$0 = $EXPECT($L42, fail, 'BinaryOpSymbol "**"');
2139
+ var BinaryOpSymbol$1 = $EXPECT($L43, fail, 'BinaryOpSymbol "*"');
2140
+ var BinaryOpSymbol$2 = $EXPECT($L44, fail, 'BinaryOpSymbol "/"');
2141
+ var BinaryOpSymbol$3 = $EXPECT($L45, fail, 'BinaryOpSymbol "%"');
2142
+ var BinaryOpSymbol$4 = $EXPECT($L46, fail, 'BinaryOpSymbol "+"');
2143
+ var BinaryOpSymbol$5 = $EXPECT($L47, fail, 'BinaryOpSymbol "-"');
2144
+ var BinaryOpSymbol$6 = $EXPECT($L48, fail, 'BinaryOpSymbol "<="');
2145
+ var BinaryOpSymbol$7 = $EXPECT($L49, fail, 'BinaryOpSymbol ">="');
2146
+ var BinaryOpSymbol$8 = $EXPECT($L50, fail, 'BinaryOpSymbol "<<"');
2147
+ var BinaryOpSymbol$9 = $EXPECT($L5, fail, 'BinaryOpSymbol "<"');
2148
+ var BinaryOpSymbol$10 = $EXPECT($L51, fail, 'BinaryOpSymbol ">>>"');
2149
+ var BinaryOpSymbol$11 = $EXPECT($L52, fail, 'BinaryOpSymbol ">>"');
2150
+ var BinaryOpSymbol$12 = $EXPECT($L53, fail, 'BinaryOpSymbol ">"');
2151
+ var BinaryOpSymbol$13 = $EXPECT($L54, fail, 'BinaryOpSymbol "!=="');
2152
+ var BinaryOpSymbol$14 = $TV($EXPECT($L55, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2153
2153
  if (module.coffeeCompat)
2154
2154
  return "!==";
2155
2155
  return $1;
2156
2156
  });
2157
- var BinaryOpSymbol$15 = $T($S($EXPECT($L57, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2157
+ var BinaryOpSymbol$15 = $T($S($EXPECT($L56, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2158
2158
  return "===";
2159
2159
  });
2160
- var BinaryOpSymbol$16 = $EXPECT($L58, fail, 'BinaryOpSymbol "==="');
2161
- var BinaryOpSymbol$17 = $TV($EXPECT($L59, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2160
+ var BinaryOpSymbol$16 = $EXPECT($L57, fail, 'BinaryOpSymbol "==="');
2161
+ var BinaryOpSymbol$17 = $TV($EXPECT($L58, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2162
2162
  if (module.coffeeCompat)
2163
2163
  return "===";
2164
2164
  return $1;
2165
2165
  });
2166
- var BinaryOpSymbol$18 = $T($S($EXPECT($L60, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2166
+ var BinaryOpSymbol$18 = $T($S($EXPECT($L59, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2167
2167
  return "&&";
2168
2168
  });
2169
- var BinaryOpSymbol$19 = $EXPECT($L61, fail, 'BinaryOpSymbol "&&"');
2170
- var BinaryOpSymbol$20 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2169
+ var BinaryOpSymbol$19 = $EXPECT($L60, fail, 'BinaryOpSymbol "&&"');
2170
+ var BinaryOpSymbol$20 = $T($S($EXPECT($L61, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2171
2171
  return "||";
2172
2172
  });
2173
- var BinaryOpSymbol$21 = $EXPECT($L63, fail, 'BinaryOpSymbol "||"');
2174
- var BinaryOpSymbol$22 = $EXPECT($L64, fail, 'BinaryOpSymbol "??"');
2175
- var BinaryOpSymbol$23 = $TS($S($EXPECT($L65, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2173
+ var BinaryOpSymbol$21 = $EXPECT($L62, fail, 'BinaryOpSymbol "||"');
2174
+ var BinaryOpSymbol$22 = $EXPECT($L63, fail, 'BinaryOpSymbol "??"');
2175
+ var BinaryOpSymbol$23 = $TS($S($EXPECT($L64, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2176
2176
  return $1;
2177
2177
  });
2178
- var BinaryOpSymbol$24 = $TS($S($EXPECT($L66, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2178
+ var BinaryOpSymbol$24 = $TS($S($EXPECT($L65, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2179
2179
  return $1;
2180
2180
  });
2181
- var BinaryOpSymbol$25 = $EXPECT($L67, fail, 'BinaryOpSymbol "&"');
2182
- var BinaryOpSymbol$26 = $EXPECT($L68, fail, 'BinaryOpSymbol "^"');
2183
- var BinaryOpSymbol$27 = $EXPECT($L69, fail, 'BinaryOpSymbol "|"');
2181
+ var BinaryOpSymbol$25 = $EXPECT($L66, fail, 'BinaryOpSymbol "&"');
2182
+ var BinaryOpSymbol$26 = $EXPECT($L67, fail, 'BinaryOpSymbol "^"');
2183
+ var BinaryOpSymbol$27 = $EXPECT($L68, fail, 'BinaryOpSymbol "|"');
2184
2184
  function BinaryOpSymbol(state) {
2185
2185
  if (state.tokenize) {
2186
2186
  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));
@@ -2189,7 +2189,7 @@ var Civet = (() => {
2189
2189
  }
2190
2190
  }
2191
2191
  var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
2192
- var UnaryOp$1 = $S($C($EXPECT($L70, fail, 'UnaryOp "delete"'), $EXPECT($L71, fail, 'UnaryOp "void"'), $EXPECT($L72, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2192
+ var UnaryOp$1 = $S($C($EXPECT($L69, fail, 'UnaryOp "delete"'), $EXPECT($L70, fail, 'UnaryOp "void"'), $EXPECT($L71, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2193
2193
  function UnaryOp(state) {
2194
2194
  if (state.tokenize) {
2195
2195
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -2269,7 +2269,7 @@ var Civet = (() => {
2269
2269
  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);
2270
2270
  }
2271
2271
  }
2272
- var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L73, fail, 'EmptyStatement ";"')));
2272
+ var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L72, fail, 'EmptyStatement ";"')));
2273
2273
  function EmptyStatement(state) {
2274
2274
  if (state.verbose)
2275
2275
  console.log("ENTER:", "EmptyStatement");
@@ -2334,7 +2334,7 @@ var Civet = (() => {
2334
2334
  return LoopStatement$0(state);
2335
2335
  }
2336
2336
  }
2337
- var DoWhileStatement$0 = $S($EXPECT($L74, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2337
+ var DoWhileStatement$0 = $S($EXPECT($L73, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2338
2338
  function DoWhileStatement(state) {
2339
2339
  if (state.verbose)
2340
2340
  console.log("ENTER:", "DoWhileStatement");
@@ -2354,7 +2354,7 @@ var Civet = (() => {
2354
2354
  return WhileStatement$0(state);
2355
2355
  }
2356
2356
  }
2357
- 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) {
2357
+ var WhileClause$0 = $TS($S($C($EXPECT($L74, fail, 'WhileClause "while"'), $EXPECT($L75, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
2358
2358
  var kind = $1;
2359
2359
  var cond = $3;
2360
2360
  if (kind === "until") {
@@ -2413,7 +2413,7 @@ var Civet = (() => {
2413
2413
  return ForBinding$0(state) || ForBinding$1(state);
2414
2414
  }
2415
2415
  }
2416
- var SwitchStatement$0 = $S(Switch, NonIdContinue, Condition, CaseBlock);
2416
+ var SwitchStatement$0 = $S(Switch, Condition, CaseBlock);
2417
2417
  function SwitchStatement(state) {
2418
2418
  if (state.verbose)
2419
2419
  console.log("ENTER:", "SwitchStatement");
@@ -2457,9 +2457,9 @@ var Civet = (() => {
2457
2457
  return NestedCaseClause$0(state);
2458
2458
  }
2459
2459
  }
2460
- var CaseClause$0 = $S($EXPECT($L77, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), ExpressionWithIndentedApplicationSuppressed, ImpliedColon, NestedBlockExpressions);
2461
- var CaseClause$1 = $S(When, $Q(_), ExpressionWithIndentedApplicationSuppressed, ImpliedColon, NestedBlockExpressions, InsertBreak);
2462
- var CaseClause$2 = $S($EXPECT($L78, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2460
+ var CaseClause$0 = $S(Case, CaseExpressionList, NestedBlockExpressions);
2461
+ var CaseClause$1 = $S(When, CaseExpressionList, NestedBlockExpressions, InsertBreak);
2462
+ var CaseClause$2 = $S(Default, ImpliedColon, NestedBlockExpressions);
2463
2463
  function CaseClause(state) {
2464
2464
  if (state.tokenize) {
2465
2465
  return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
@@ -2467,6 +2467,25 @@ var Civet = (() => {
2467
2467
  return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
2468
2468
  }
2469
2469
  }
2470
+ var CaseExpressionList$0 = $TS($S($S($Q(_), ExpressionWithIndentedApplicationSuppressed, ImpliedColon), $Q($S(__, Comma, ExpressionWithIndentedApplicationSuppressed, ImpliedColon))), function($skip, $loc, $0, $1, $2) {
2471
+ const result = $2.map(([ws, _comma, exp, col]) => {
2472
+ module.insertTrimmingSpace(exp, "");
2473
+ if (ws.length)
2474
+ return [module.insertTrimmingSpace("case ", ws), exp, col];
2475
+ return ["case ", exp, col];
2476
+ });
2477
+ result.unshift($1);
2478
+ return result;
2479
+ });
2480
+ function CaseExpressionList(state) {
2481
+ if (state.verbose)
2482
+ console.log("ENTER:", "CaseExpressionList");
2483
+ if (state.tokenize) {
2484
+ return $TOKEN("CaseExpressionList", state, CaseExpressionList$0(state));
2485
+ } else {
2486
+ return CaseExpressionList$0(state);
2487
+ }
2488
+ }
2470
2489
  var ImpliedColon$0 = $S(__, Colon);
2471
2490
  var ImpliedColon$1 = $TV($EXPECT($L1, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
2472
2491
  return { $loc, token: ":" };
@@ -2514,7 +2533,7 @@ var Civet = (() => {
2514
2533
  return CatchBind$0(state) || CatchBind$1(state);
2515
2534
  }
2516
2535
  }
2517
- var Finally$0 = $S(__, $EXPECT($L79, fail, 'Finally "finally"'), BracedBlock);
2536
+ var Finally$0 = $S(__, $EXPECT($L76, fail, 'Finally "finally"'), BracedBlock);
2518
2537
  function Finally(state) {
2519
2538
  if (state.verbose)
2520
2539
  console.log("ENTER:", "Finally");
@@ -2542,7 +2561,7 @@ var Civet = (() => {
2542
2561
  return Condition$0(state) || Condition$1(state);
2543
2562
  }
2544
2563
  }
2545
- var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(Expression)), function($skip, $loc, $0, $1, $2) {
2564
+ var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(AssignmentExpression)), function($skip, $loc, $0, $1, $2) {
2546
2565
  var exp = $2;
2547
2566
  module.suppressIndentedApplication = false;
2548
2567
  if (exp)
@@ -2580,11 +2599,11 @@ var Civet = (() => {
2580
2599
  return ExpressionStatement$0(state);
2581
2600
  }
2582
2601
  }
2583
- var KeywordStatement$0 = $S($EXPECT($L80, fail, 'KeywordStatement "break"'), NonIdContinue);
2584
- var KeywordStatement$1 = $S($EXPECT($L81, fail, 'KeywordStatement "continue"'), NonIdContinue);
2585
- var KeywordStatement$2 = $S($EXPECT($L82, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2602
+ var KeywordStatement$0 = $S($EXPECT($L77, fail, 'KeywordStatement "break"'), NonIdContinue);
2603
+ var KeywordStatement$1 = $S($EXPECT($L78, fail, 'KeywordStatement "continue"'), NonIdContinue);
2604
+ var KeywordStatement$2 = $S($EXPECT($L79, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2586
2605
  var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
2587
- var KeywordStatement$4 = $S($EXPECT($L83, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2606
+ var KeywordStatement$4 = $S($EXPECT($L80, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2588
2607
  function KeywordStatement(state) {
2589
2608
  if (state.tokenize) {
2590
2609
  return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
@@ -2601,7 +2620,7 @@ var Civet = (() => {
2601
2620
  return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
2602
2621
  }
2603
2622
  }
2604
- var ImportDeclaration$0 = $T($S($EXPECT($L84, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2623
+ var ImportDeclaration$0 = $T($S($EXPECT($L81, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2605
2624
  return { "ts": true, "children": value };
2606
2625
  });
2607
2626
  var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
@@ -2646,7 +2665,7 @@ var Civet = (() => {
2646
2665
  return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
2647
2666
  }
2648
2667
  }
2649
- var NameSpaceImport$0 = $S($EXPECT($L5, fail, 'NameSpaceImport "*"'), __, As, NonIdContinue, __, ImportedBinding);
2668
+ var NameSpaceImport$0 = $S(Star, __, As, NonIdContinue, __, ImportedBinding);
2650
2669
  function NameSpaceImport(state) {
2651
2670
  if (state.verbose)
2652
2671
  console.log("ENTER:", "NameSpaceImport");
@@ -2707,7 +2726,7 @@ var Civet = (() => {
2707
2726
  return ModuleSpecifier$0(state);
2708
2727
  }
2709
2728
  }
2710
- var UnprocessedModuleSpecifier$0 = StringLiteral;
2729
+ var UnprocessedModuleSpecifier$0 = BasicStringLiteral;
2711
2730
  var UnprocessedModuleSpecifier$1 = UnquotedSpecifier;
2712
2731
  function UnprocessedModuleSpecifier(state) {
2713
2732
  if (state.tokenize) {
@@ -2739,7 +2758,7 @@ var Civet = (() => {
2739
2758
  return ImportedBinding$0(state);
2740
2759
  }
2741
2760
  }
2742
- var ExportDeclaration$0 = $S(Export, __, $EXPECT($L78, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2761
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L82, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2743
2762
  var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
2744
2763
  var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
2745
2764
  function ExportDeclaration(state) {
@@ -2749,7 +2768,7 @@ var Civet = (() => {
2749
2768
  return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
2750
2769
  }
2751
2770
  }
2752
- var ExportFromClause$0 = $S($EXPECT($L5, fail, 'ExportFromClause "*"'), $E($S(__, As, NonIdContinue, __, ModuleExportName)));
2771
+ var ExportFromClause$0 = $S(Star, $E($S(__, As, NonIdContinue, __, ModuleExportName)));
2753
2772
  var ExportFromClause$1 = NamedExports;
2754
2773
  function ExportFromClause(state) {
2755
2774
  if (state.tokenize) {
@@ -2816,7 +2835,7 @@ var Civet = (() => {
2816
2835
  return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
2817
2836
  }
2818
2837
  }
2819
- var ConstAssignment$0 = $TV($EXPECT($L85, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
2838
+ var ConstAssignment$0 = $TV($EXPECT($L83, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
2820
2839
  return { $loc, token: "=" };
2821
2840
  });
2822
2841
  function ConstAssignment(state) {
@@ -2959,12 +2978,8 @@ var Civet = (() => {
2959
2978
  var e = $3;
2960
2979
  return [s, module.dedentBlockString(str), e];
2961
2980
  });
2962
- var StringLiteral$2 = $TV($TEXT($S($EXPECT($L86, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L86, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
2963
- return { $loc, token: $1 };
2964
- });
2965
- var StringLiteral$3 = $TV($TEXT($S($EXPECT($L87, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L87, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
2966
- return { $loc, token: $1 };
2967
- });
2981
+ var StringLiteral$2 = CoffeeCompatDoubleQuotedString;
2982
+ var StringLiteral$3 = BasicStringLiteral;
2968
2983
  function StringLiteral(state) {
2969
2984
  if (state.tokenize) {
2970
2985
  return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state));
@@ -2972,24 +2987,49 @@ var Civet = (() => {
2972
2987
  return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
2973
2988
  }
2974
2989
  }
2975
- var DoubleStringCharacter$0 = $R$0($EXPECT($R9, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
2976
- function DoubleStringCharacter(state) {
2990
+ var BasicStringLiteral$0 = $TS($S(DoubleQuote, DoubleStringCharacters, DoubleQuote), function($skip, $loc, $0, $1, $2, $3) {
2991
+ var str = $2;
2992
+ return {
2993
+ token: `"${module.modifyString(str.token)}"`,
2994
+ $loc
2995
+ };
2996
+ });
2997
+ var BasicStringLiteral$1 = $TS($S(SingleQuote, SingleStringCharacters, SingleQuote), function($skip, $loc, $0, $1, $2, $3) {
2998
+ var str = $2;
2999
+ return {
3000
+ token: `'${module.modifyString(str.token)}'`,
3001
+ $loc
3002
+ };
3003
+ });
3004
+ function BasicStringLiteral(state) {
3005
+ if (state.tokenize) {
3006
+ return $TOKEN("BasicStringLiteral", state, BasicStringLiteral$0(state) || BasicStringLiteral$1(state));
3007
+ } else {
3008
+ return BasicStringLiteral$0(state) || BasicStringLiteral$1(state);
3009
+ }
3010
+ }
3011
+ var DoubleStringCharacters$0 = $TR($EXPECT($R9, fail, 'DoubleStringCharacters /(?:\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3012
+ return { $loc, token: $0 };
3013
+ });
3014
+ function DoubleStringCharacters(state) {
2977
3015
  if (state.verbose)
2978
- console.log("ENTER:", "DoubleStringCharacter");
3016
+ console.log("ENTER:", "DoubleStringCharacters");
2979
3017
  if (state.tokenize) {
2980
- return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state));
3018
+ return $TOKEN("DoubleStringCharacters", state, DoubleStringCharacters$0(state));
2981
3019
  } else {
2982
- return DoubleStringCharacter$0(state);
3020
+ return DoubleStringCharacters$0(state);
2983
3021
  }
2984
3022
  }
2985
- var SingleStringCharacter$0 = $R$0($EXPECT($R10, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
2986
- function SingleStringCharacter(state) {
3023
+ var SingleStringCharacters$0 = $TR($EXPECT($R10, fail, "SingleStringCharacters /(?:\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3024
+ return { $loc, token: $0 };
3025
+ });
3026
+ function SingleStringCharacters(state) {
2987
3027
  if (state.verbose)
2988
- console.log("ENTER:", "SingleStringCharacter");
3028
+ console.log("ENTER:", "SingleStringCharacters");
2989
3029
  if (state.tokenize) {
2990
- return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state));
3030
+ return $TOKEN("SingleStringCharacters", state, SingleStringCharacters$0(state));
2991
3031
  } else {
2992
- return SingleStringCharacter$0(state);
3032
+ return SingleStringCharacters$0(state);
2993
3033
  }
2994
3034
  }
2995
3035
  var TripleDoubleStringCharacters$0 = $TR($EXPECT($R11, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
@@ -3026,19 +3066,62 @@ var Civet = (() => {
3026
3066
  return CoffeeStringSubstitution$0(state);
3027
3067
  }
3028
3068
  }
3029
- var CoffeeSubstitutionStart$0 = $TV($EXPECT($L88, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
3030
- return { $loc, token: "${" };
3069
+ var CoffeeCompat$0 = $TV($EXPECT($L1, fail, 'CoffeeCompat ""'), function($skip, $loc, $0, $1) {
3070
+ if (module.coffeeCompat)
3071
+ return;
3072
+ return $skip;
3031
3073
  });
3032
- function CoffeeSubstitutionStart(state) {
3074
+ function CoffeeCompat(state) {
3033
3075
  if (state.verbose)
3034
- console.log("ENTER:", "CoffeeSubstitutionStart");
3076
+ console.log("ENTER:", "CoffeeCompat");
3035
3077
  if (state.tokenize) {
3036
- return $TOKEN("CoffeeSubstitutionStart", state, CoffeeSubstitutionStart$0(state));
3078
+ return $TOKEN("CoffeeCompat", state, CoffeeCompat$0(state));
3037
3079
  } else {
3038
- return CoffeeSubstitutionStart$0(state);
3080
+ return CoffeeCompat$0(state);
3039
3081
  }
3040
3082
  }
3041
- var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L45, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L45, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
3083
+ var CoffeeCompatDoubleQuotedString$0 = $TS($S(CoffeeCompat, DoubleQuote, $Q($C(CoffeeCompatDoubleQuotedStringCharacters, CoffeeStringSubstitution)), DoubleQuote), function($skip, $loc, $0, $1, $2, $3, $4) {
3084
+ var s = $2;
3085
+ var parts = $3;
3086
+ var e = $4;
3087
+ const noInterpolations = parts.length === 1 && parts[0].token != null;
3088
+ if (noInterpolations) {
3089
+ return {
3090
+ token: `"${module.modifyString(parts[0].token)}"`,
3091
+ $loc
3092
+ };
3093
+ }
3094
+ parts.forEach((part) => {
3095
+ if (part.token) {
3096
+ const str = part.token.replace(/(`|\$\{)/g, "\\$1");
3097
+ part.token = module.modifyString(str);
3098
+ }
3099
+ });
3100
+ s.token = e.token = "`";
3101
+ return [s, parts, e];
3102
+ });
3103
+ function CoffeeCompatDoubleQuotedString(state) {
3104
+ if (state.verbose)
3105
+ console.log("ENTER:", "CoffeeCompatDoubleQuotedString");
3106
+ if (state.tokenize) {
3107
+ return $TOKEN("CoffeeCompatDoubleQuotedString", state, CoffeeCompatDoubleQuotedString$0(state));
3108
+ } else {
3109
+ return CoffeeCompatDoubleQuotedString$0(state);
3110
+ }
3111
+ }
3112
+ var CoffeeCompatDoubleQuotedStringCharacters$0 = $TR($EXPECT($R13, fail, 'CoffeeCompatDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3113
+ return { $loc, token: $0 };
3114
+ });
3115
+ function CoffeeCompatDoubleQuotedStringCharacters(state) {
3116
+ if (state.verbose)
3117
+ console.log("ENTER:", "CoffeeCompatDoubleQuotedStringCharacters");
3118
+ if (state.tokenize) {
3119
+ return $TOKEN("CoffeeCompatDoubleQuotedStringCharacters", state, CoffeeCompatDoubleQuotedStringCharacters$0(state));
3120
+ } else {
3121
+ return CoffeeCompatDoubleQuotedStringCharacters$0(state);
3122
+ }
3123
+ }
3124
+ var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L44, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L44, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
3042
3125
  return { $loc, token: $1 };
3043
3126
  });
3044
3127
  function RegularExpressionLiteral(state) {
@@ -3050,7 +3133,7 @@ var Civet = (() => {
3050
3133
  return RegularExpressionLiteral$0(state);
3051
3134
  }
3052
3135
  }
3053
- var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R13, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
3136
+ var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R14, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
3054
3137
  function RegularExpressionBody(state) {
3055
3138
  if (state.verbose)
3056
3139
  console.log("ENTER:", "RegularExpressionBody");
@@ -3060,7 +3143,7 @@ var Civet = (() => {
3060
3143
  return RegularExpressionBody$0(state);
3061
3144
  }
3062
3145
  }
3063
- var RegExpCharacter$0 = $R$0($EXPECT($R14, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
3146
+ var RegExpCharacter$0 = $R$0($EXPECT($R15, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
3064
3147
  function RegExpCharacter(state) {
3065
3148
  if (state.verbose)
3066
3149
  console.log("ENTER:", "RegExpCharacter");
@@ -3070,7 +3153,7 @@ var Civet = (() => {
3070
3153
  return RegExpCharacter$0(state);
3071
3154
  }
3072
3155
  }
3073
- var RegularExpressionFlags$0 = $R$0($EXPECT($R15, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
3156
+ var RegularExpressionFlags$0 = $R$0($EXPECT($R16, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
3074
3157
  function RegularExpressionFlags(state) {
3075
3158
  if (state.verbose)
3076
3159
  console.log("ENTER:", "RegularExpressionFlags");
@@ -3091,7 +3174,7 @@ var Civet = (() => {
3091
3174
  return TemplateLiteral$0(state) || TemplateLiteral$1(state);
3092
3175
  }
3093
3176
  }
3094
- var TemplateSubstitution$0 = $S($EXPECT($L89, fail, 'TemplateSubstitution "${"'), Expression, __, CloseBrace);
3177
+ var TemplateSubstitution$0 = $S(SubstitutionStart, Expression, __, CloseBrace);
3095
3178
  function TemplateSubstitution(state) {
3096
3179
  if (state.verbose)
3097
3180
  console.log("ENTER:", "TemplateSubstitution");
@@ -3101,7 +3184,7 @@ var Civet = (() => {
3101
3184
  return TemplateSubstitution$0(state);
3102
3185
  }
3103
3186
  }
3104
- var TemplateCharacters$0 = $TR($EXPECT($R16, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3187
+ var TemplateCharacters$0 = $TR($EXPECT($R17, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3105
3188
  return { $loc, token: $0 };
3106
3189
  });
3107
3190
  function TemplateCharacters(state) {
@@ -3113,7 +3196,7 @@ var Civet = (() => {
3113
3196
  return TemplateCharacters$0(state);
3114
3197
  }
3115
3198
  }
3116
- var TemplateBlockCharacters$0 = $TR($EXPECT($R17, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3199
+ var TemplateBlockCharacters$0 = $TR($EXPECT($R18, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3117
3200
  return { $loc, token: $0 };
3118
3201
  });
3119
3202
  function TemplateBlockCharacters(state) {
@@ -3125,7 +3208,7 @@ var Civet = (() => {
3125
3208
  return TemplateBlockCharacters$0(state);
3126
3209
  }
3127
3210
  }
3128
- 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})/"));
3211
+ var ReservedWord$0 = $R$0($EXPECT($R19, 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})/"));
3129
3212
  function ReservedWord(state) {
3130
3213
  if (state.verbose)
3131
3214
  console.log("ENTER:", "ReservedWord");
@@ -3144,10 +3227,10 @@ var Civet = (() => {
3144
3227
  return Comment$0(state) || Comment$1(state);
3145
3228
  }
3146
3229
  }
3147
- var SingleLineComment$0 = $TR($EXPECT($R19, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3230
+ var SingleLineComment$0 = $TR($EXPECT($R20, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3148
3231
  return { $loc, token: $0 };
3149
3232
  });
3150
- var SingleLineComment$1 = CoffeeSingleLineComment;
3233
+ var SingleLineComment$1 = $S(CoffeeCompat, CoffeeSingleLineComment);
3151
3234
  function SingleLineComment(state) {
3152
3235
  if (state.tokenize) {
3153
3236
  return $TOKEN("SingleLineComment", state, SingleLineComment$0(state) || SingleLineComment$1(state));
@@ -3164,7 +3247,7 @@ var Civet = (() => {
3164
3247
  return MultiLineComment$0(state) || MultiLineComment$1(state);
3165
3248
  }
3166
3249
  }
3167
- var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L90, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L91, fail, 'JSMultiLineComment "*/"')), $EXPECT($R20, fail, "JSMultiLineComment /./"))), $EXPECT($L91, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
3250
+ var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L85, fail, 'JSMultiLineComment "*/"')), $EXPECT($R21, fail, "JSMultiLineComment /./"))), $EXPECT($L85, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
3168
3251
  return { $loc, token: $1 };
3169
3252
  });
3170
3253
  function JSMultiLineComment(state) {
@@ -3176,9 +3259,7 @@ var Civet = (() => {
3176
3259
  return JSMultiLineComment$0(state);
3177
3260
  }
3178
3261
  }
3179
- var CoffeeSingleLineComment$0 = $TR($EXPECT($R21, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3180
- if (!module.coffeeCompat)
3181
- return $skip;
3262
+ var CoffeeSingleLineComment$0 = $TR($EXPECT($R22, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3182
3263
  return { $loc, token: `//${$1}` };
3183
3264
  });
3184
3265
  function CoffeeSingleLineComment(state) {
@@ -3190,7 +3271,7 @@ var Civet = (() => {
3190
3271
  return CoffeeSingleLineComment$0(state);
3191
3272
  }
3192
3273
  }
3193
- var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L92, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L92, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L91, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R20, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L92, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
3274
+ var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L85, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R21, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L86, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
3194
3275
  return { $loc, token: `/*${$2}*/` };
3195
3276
  });
3196
3277
  function CoffeeMultiLineComment(state) {
@@ -3202,7 +3283,7 @@ var Civet = (() => {
3202
3283
  return CoffeeMultiLineComment$0(state);
3203
3284
  }
3204
3285
  }
3205
- var InlineComment$0 = $TV($TEXT($S($EXPECT($L90, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L91, fail, 'InlineComment "*/"')), $EXPECT($R22, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L91, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
3286
+ var InlineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L85, fail, 'InlineComment "*/"')), $EXPECT($R23, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L85, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
3206
3287
  return { $loc, token: $1 };
3207
3288
  });
3208
3289
  function InlineComment(state) {
@@ -3214,7 +3295,7 @@ var Civet = (() => {
3214
3295
  return InlineComment$0(state);
3215
3296
  }
3216
3297
  }
3217
- var RestOfLine$0 = $S($Q($C($R$0($EXPECT($R23, fail, "RestOfLine /[ \\t]+/")), SingleLineComment, MultiLineComment)), EOL);
3298
+ var RestOfLine$0 = $S($Q($C(NonNewlineWhitespace, SingleLineComment, MultiLineComment)), EOL);
3218
3299
  function RestOfLine(state) {
3219
3300
  if (state.verbose)
3220
3301
  console.log("ENTER:", "RestOfLine");
@@ -3224,7 +3305,7 @@ var Civet = (() => {
3224
3305
  return RestOfLine$0(state);
3225
3306
  }
3226
3307
  }
3227
- var TrailingComment$0 = $R$0($EXPECT($R24, fail, "TrailingComment /[\\t ]+/"));
3308
+ var TrailingComment$0 = NonNewlineWhitespace;
3228
3309
  var TrailingComment$1 = InlineComment;
3229
3310
  var TrailingComment$2 = SingleLineComment;
3230
3311
  function TrailingComment(state) {
@@ -3244,7 +3325,7 @@ var Civet = (() => {
3244
3325
  return _$0(state);
3245
3326
  }
3246
3327
  }
3247
- var NonNewlineWhitespace$0 = $TR($EXPECT($R23, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3328
+ var NonNewlineWhitespace$0 = $TR($EXPECT($R24, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3248
3329
  return { $loc, token: $0 };
3249
3330
  });
3250
3331
  function NonNewlineWhitespace(state) {
@@ -3311,7 +3392,7 @@ var Civet = (() => {
3311
3392
  return Loc$0(state);
3312
3393
  }
3313
3394
  }
3314
- var As$0 = $TS($S($EXPECT($L93, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3395
+ var As$0 = $TS($S($EXPECT($L87, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3315
3396
  return { $loc, token: $1 };
3316
3397
  });
3317
3398
  function As(state) {
@@ -3323,7 +3404,7 @@ var Civet = (() => {
3323
3404
  return As$0(state);
3324
3405
  }
3325
3406
  }
3326
- var Async$0 = $TV($EXPECT($L94, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
3407
+ var Async$0 = $TV($EXPECT($L88, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
3327
3408
  return { $loc, token: $1 };
3328
3409
  });
3329
3410
  function Async(state) {
@@ -3335,7 +3416,7 @@ var Civet = (() => {
3335
3416
  return Async$0(state);
3336
3417
  }
3337
3418
  }
3338
- var Await$0 = $TS($S($EXPECT($L95, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3419
+ var Await$0 = $TS($S($EXPECT($L89, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3339
3420
  return { $loc, token: $1 };
3340
3421
  });
3341
3422
  function Await(state) {
@@ -3347,7 +3428,19 @@ var Civet = (() => {
3347
3428
  return Await$0(state);
3348
3429
  }
3349
3430
  }
3350
- var Catch$0 = $TV($EXPECT($L96, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
3431
+ var Case$0 = $TS($S($EXPECT($L90, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3432
+ return { $loc, token: $1 };
3433
+ });
3434
+ function Case(state) {
3435
+ if (state.verbose)
3436
+ console.log("ENTER:", "Case");
3437
+ if (state.tokenize) {
3438
+ return $TOKEN("Case", state, Case$0(state));
3439
+ } else {
3440
+ return Case$0(state);
3441
+ }
3442
+ }
3443
+ var Catch$0 = $TV($EXPECT($L91, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
3351
3444
  return { $loc, token: $1 };
3352
3445
  });
3353
3446
  function Catch(state) {
@@ -3359,7 +3452,7 @@ var Civet = (() => {
3359
3452
  return Catch$0(state);
3360
3453
  }
3361
3454
  }
3362
- var Class$0 = $TV($EXPECT($L97, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
3455
+ var Class$0 = $TV($EXPECT($L92, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
3363
3456
  return { $loc, token: $1 };
3364
3457
  });
3365
3458
  function Class(state) {
@@ -3371,7 +3464,7 @@ var Civet = (() => {
3371
3464
  return Class$0(state);
3372
3465
  }
3373
3466
  }
3374
- var CloseBrace$0 = $TV($EXPECT($L26, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
3467
+ var CloseBrace$0 = $TV($EXPECT($L24, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
3375
3468
  return { $loc, token: $1 };
3376
3469
  });
3377
3470
  function CloseBrace(state) {
@@ -3383,7 +3476,7 @@ var Civet = (() => {
3383
3476
  return CloseBrace$0(state);
3384
3477
  }
3385
3478
  }
3386
- var CloseBracket$0 = $TV($EXPECT($L25, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
3479
+ var CloseBracket$0 = $TV($EXPECT($L23, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
3387
3480
  return { $loc, token: $1 };
3388
3481
  });
3389
3482
  function CloseBracket(state) {
@@ -3395,7 +3488,7 @@ var Civet = (() => {
3395
3488
  return CloseBracket$0(state);
3396
3489
  }
3397
3490
  }
3398
- var CloseParen$0 = $TV($EXPECT($L18, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
3491
+ var CloseParen$0 = $TV($EXPECT($L16, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
3399
3492
  return { $loc, token: $1 };
3400
3493
  });
3401
3494
  function CloseParen(state) {
@@ -3407,7 +3500,19 @@ var Civet = (() => {
3407
3500
  return CloseParen$0(state);
3408
3501
  }
3409
3502
  }
3410
- var Colon$0 = $TV($EXPECT($L98, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
3503
+ var CoffeeSubstitutionStart$0 = $TV($EXPECT($L93, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
3504
+ return { $loc, token: "${" };
3505
+ });
3506
+ function CoffeeSubstitutionStart(state) {
3507
+ if (state.verbose)
3508
+ console.log("ENTER:", "CoffeeSubstitutionStart");
3509
+ if (state.tokenize) {
3510
+ return $TOKEN("CoffeeSubstitutionStart", state, CoffeeSubstitutionStart$0(state));
3511
+ } else {
3512
+ return CoffeeSubstitutionStart$0(state);
3513
+ }
3514
+ }
3515
+ var Colon$0 = $TV($EXPECT($L94, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
3411
3516
  return { $loc, token: $1 };
3412
3517
  });
3413
3518
  function Colon(state) {
@@ -3419,7 +3524,31 @@ var Civet = (() => {
3419
3524
  return Colon$0(state);
3420
3525
  }
3421
3526
  }
3422
- var Dot$0 = $TV($EXPECT($L99, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
3527
+ var ConstructorShorthand$0 = $TV($EXPECT($L9, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
3528
+ return { $loc, token: "constructor" };
3529
+ });
3530
+ function ConstructorShorthand(state) {
3531
+ if (state.verbose)
3532
+ console.log("ENTER:", "ConstructorShorthand");
3533
+ if (state.tokenize) {
3534
+ return $TOKEN("ConstructorShorthand", state, ConstructorShorthand$0(state));
3535
+ } else {
3536
+ return ConstructorShorthand$0(state);
3537
+ }
3538
+ }
3539
+ var Default$0 = $TS($S($EXPECT($L82, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3540
+ return { $loc, token: $1 };
3541
+ });
3542
+ function Default(state) {
3543
+ if (state.verbose)
3544
+ console.log("ENTER:", "Default");
3545
+ if (state.tokenize) {
3546
+ return $TOKEN("Default", state, Default$0(state));
3547
+ } else {
3548
+ return Default$0(state);
3549
+ }
3550
+ }
3551
+ var Dot$0 = $TV($EXPECT($L95, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
3423
3552
  return { $loc, token: $1 };
3424
3553
  });
3425
3554
  function Dot(state) {
@@ -3431,7 +3560,19 @@ var Civet = (() => {
3431
3560
  return Dot$0(state);
3432
3561
  }
3433
3562
  }
3434
- var Else$0 = $TV($EXPECT($L100, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
3563
+ var DoubleQuote$0 = $TV($EXPECT($L96, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
3564
+ return { $loc, token: $1 };
3565
+ });
3566
+ function DoubleQuote(state) {
3567
+ if (state.verbose)
3568
+ console.log("ENTER:", "DoubleQuote");
3569
+ if (state.tokenize) {
3570
+ return $TOKEN("DoubleQuote", state, DoubleQuote$0(state));
3571
+ } else {
3572
+ return DoubleQuote$0(state);
3573
+ }
3574
+ }
3575
+ var Else$0 = $TV($EXPECT($L97, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
3435
3576
  return { $loc, token: $1 };
3436
3577
  });
3437
3578
  function Else(state) {
@@ -3443,7 +3584,7 @@ var Civet = (() => {
3443
3584
  return Else$0(state);
3444
3585
  }
3445
3586
  }
3446
- var Equals$0 = $TV($EXPECT($L43, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
3587
+ var Equals$0 = $TV($EXPECT($L41, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
3447
3588
  return { $loc, token: $1 };
3448
3589
  });
3449
3590
  function Equals(state) {
@@ -3455,7 +3596,7 @@ var Civet = (() => {
3455
3596
  return Equals$0(state);
3456
3597
  }
3457
3598
  }
3458
- var Export$0 = $TS($S($EXPECT($L101, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3599
+ var Export$0 = $TS($S($EXPECT($L98, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3459
3600
  return { $loc, token: $1 };
3460
3601
  });
3461
3602
  function Export(state) {
@@ -3467,7 +3608,7 @@ var Civet = (() => {
3467
3608
  return Export$0(state);
3468
3609
  }
3469
3610
  }
3470
- var For$0 = $TS($S($EXPECT($L102, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3611
+ var For$0 = $TS($S($EXPECT($L99, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3471
3612
  return { $loc, token: $1 };
3472
3613
  });
3473
3614
  function For(state) {
@@ -3479,7 +3620,7 @@ var Civet = (() => {
3479
3620
  return For$0(state);
3480
3621
  }
3481
3622
  }
3482
- var From$0 = $TS($S($EXPECT($L103, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3623
+ var From$0 = $TS($S($EXPECT($L100, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3483
3624
  return { $loc, token: $1 };
3484
3625
  });
3485
3626
  function From(state) {
@@ -3491,7 +3632,7 @@ var Civet = (() => {
3491
3632
  return From$0(state);
3492
3633
  }
3493
3634
  }
3494
- var Function$0 = $TV($EXPECT($L104, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
3635
+ var Function$0 = $TV($EXPECT($L101, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
3495
3636
  return { $loc, token: $1 };
3496
3637
  });
3497
3638
  function Function(state) {
@@ -3503,7 +3644,7 @@ var Civet = (() => {
3503
3644
  return Function$0(state);
3504
3645
  }
3505
3646
  }
3506
- var GetOrSet$0 = $TS($S($C($EXPECT($L105, fail, 'GetOrSet "get"'), $EXPECT($L106, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3647
+ var GetOrSet$0 = $TS($S($C($EXPECT($L102, fail, 'GetOrSet "get"'), $EXPECT($L103, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3507
3648
  return { $loc, token: $1 };
3508
3649
  });
3509
3650
  function GetOrSet(state) {
@@ -3515,7 +3656,7 @@ var Civet = (() => {
3515
3656
  return GetOrSet$0(state);
3516
3657
  }
3517
3658
  }
3518
- var If$0 = $TV($EXPECT($L107, fail, 'If "if"'), function($skip, $loc, $0, $1) {
3659
+ var If$0 = $TV($EXPECT($L104, fail, 'If "if"'), function($skip, $loc, $0, $1) {
3519
3660
  return { $loc, token: $1 };
3520
3661
  });
3521
3662
  function If(state) {
@@ -3527,7 +3668,7 @@ var Civet = (() => {
3527
3668
  return If$0(state);
3528
3669
  }
3529
3670
  }
3530
- var Import$0 = $TS($S($EXPECT($L13, fail, 'Import "import"'), $Y($EXPECT($R27, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
3671
+ var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R27, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
3531
3672
  return { $loc, token: $1 };
3532
3673
  });
3533
3674
  function Import(state) {
@@ -3539,7 +3680,7 @@ var Civet = (() => {
3539
3680
  return Import$0(state);
3540
3681
  }
3541
3682
  }
3542
- var In$0 = $TV($EXPECT($L66, fail, 'In "in"'), function($skip, $loc, $0, $1) {
3683
+ var In$0 = $TV($EXPECT($L65, fail, 'In "in"'), function($skip, $loc, $0, $1) {
3543
3684
  return { $loc, token: $1 };
3544
3685
  });
3545
3686
  function In(state) {
@@ -3551,7 +3692,7 @@ var Civet = (() => {
3551
3692
  return In$0(state);
3552
3693
  }
3553
3694
  }
3554
- var LetOrConst$0 = $TV($C($EXPECT($L108, fail, 'LetOrConst "let"'), $EXPECT($L109, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
3695
+ var LetOrConst$0 = $TV($C($EXPECT($L105, fail, 'LetOrConst "let"'), $EXPECT($L106, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
3555
3696
  return { $loc, token: $1 };
3556
3697
  });
3557
3698
  function LetOrConst(state) {
@@ -3563,7 +3704,7 @@ var Civet = (() => {
3563
3704
  return LetOrConst$0(state);
3564
3705
  }
3565
3706
  }
3566
- var Loop$0 = $TS($S($EXPECT($L110, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3707
+ var Loop$0 = $TS($S($EXPECT($L107, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3567
3708
  return { $loc, token: "while(true)" };
3568
3709
  });
3569
3710
  function Loop(state) {
@@ -3575,7 +3716,7 @@ var Civet = (() => {
3575
3716
  return Loop$0(state);
3576
3717
  }
3577
3718
  }
3578
- var New$0 = $TV($EXPECT($L111, fail, 'New "new"'), function($skip, $loc, $0, $1) {
3719
+ var New$0 = $TV($EXPECT($L108, fail, 'New "new"'), function($skip, $loc, $0, $1) {
3579
3720
  return { $loc, token: $1 };
3580
3721
  });
3581
3722
  function New(state) {
@@ -3587,7 +3728,7 @@ var Civet = (() => {
3587
3728
  return New$0(state);
3588
3729
  }
3589
3730
  }
3590
- var Of$0 = $TV($EXPECT($L112, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
3731
+ var Of$0 = $TV($EXPECT($L109, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
3591
3732
  return { $loc, token: $1 };
3592
3733
  });
3593
3734
  function Of(state) {
@@ -3599,7 +3740,7 @@ var Civet = (() => {
3599
3740
  return Of$0(state);
3600
3741
  }
3601
3742
  }
3602
- var OpenBrace$0 = $TV($EXPECT($L113, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
3743
+ var OpenBrace$0 = $TV($EXPECT($L110, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
3603
3744
  return { $loc, token: $1 };
3604
3745
  });
3605
3746
  function OpenBrace(state) {
@@ -3611,7 +3752,7 @@ var Civet = (() => {
3611
3752
  return OpenBrace$0(state);
3612
3753
  }
3613
3754
  }
3614
- var OpenBracket$0 = $TV($EXPECT($L114, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
3755
+ var OpenBracket$0 = $TV($EXPECT($L111, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
3615
3756
  return { $loc, token: $1 };
3616
3757
  });
3617
3758
  function OpenBracket(state) {
@@ -3623,7 +3764,7 @@ var Civet = (() => {
3623
3764
  return OpenBracket$0(state);
3624
3765
  }
3625
3766
  }
3626
- var OpenParen$0 = $TV($EXPECT($L115, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
3767
+ var OpenParen$0 = $TV($EXPECT($L112, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
3627
3768
  return { $loc, token: $1 };
3628
3769
  });
3629
3770
  function OpenParen(state) {
@@ -3635,7 +3776,7 @@ var Civet = (() => {
3635
3776
  return OpenParen$0(state);
3636
3777
  }
3637
3778
  }
3638
- var QuestionMark$0 = $TV($EXPECT($L116, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
3779
+ var QuestionMark$0 = $TV($EXPECT($L113, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
3639
3780
  return { $loc, token: $1 };
3640
3781
  });
3641
3782
  function QuestionMark(state) {
@@ -3647,7 +3788,7 @@ var Civet = (() => {
3647
3788
  return QuestionMark$0(state);
3648
3789
  }
3649
3790
  }
3650
- var Return$0 = $TS($S($EXPECT($L117, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3791
+ var Return$0 = $TS($S($EXPECT($L114, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3651
3792
  return { $loc, token: $1 };
3652
3793
  });
3653
3794
  function Return(state) {
@@ -3659,7 +3800,7 @@ var Civet = (() => {
3659
3800
  return Return$0(state);
3660
3801
  }
3661
3802
  }
3662
- var Semicolon$0 = $TV($EXPECT($L73, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
3803
+ var Semicolon$0 = $TV($EXPECT($L72, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
3663
3804
  return { $loc, token: $1 };
3664
3805
  });
3665
3806
  function Semicolon(state) {
@@ -3671,10 +3812,34 @@ var Civet = (() => {
3671
3812
  return Semicolon$0(state);
3672
3813
  }
3673
3814
  }
3674
- var Static$0 = $TV($EXPECT($L118, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
3815
+ var SingleQuote$0 = $TV($EXPECT($L115, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
3675
3816
  return { $loc, token: $1 };
3676
3817
  });
3677
- var Static$1 = $TS($S($EXPECT($L11, fail, 'Static "@"'), $N($EXPECT($L115, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
3818
+ function SingleQuote(state) {
3819
+ if (state.verbose)
3820
+ console.log("ENTER:", "SingleQuote");
3821
+ if (state.tokenize) {
3822
+ return $TOKEN("SingleQuote", state, SingleQuote$0(state));
3823
+ } else {
3824
+ return SingleQuote$0(state);
3825
+ }
3826
+ }
3827
+ var Star$0 = $TV($EXPECT($L43, fail, 'Star "*"'), function($skip, $loc, $0, $1) {
3828
+ return { $loc, token: $1 };
3829
+ });
3830
+ function Star(state) {
3831
+ if (state.verbose)
3832
+ console.log("ENTER:", "Star");
3833
+ if (state.tokenize) {
3834
+ return $TOKEN("Star", state, Star$0(state));
3835
+ } else {
3836
+ return Star$0(state);
3837
+ }
3838
+ }
3839
+ var Static$0 = $TV($EXPECT($L116, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
3840
+ return { $loc, token: $1 };
3841
+ });
3842
+ var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L112, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
3678
3843
  return { $loc, token: "static " };
3679
3844
  });
3680
3845
  function Static(state) {
@@ -3684,7 +3849,19 @@ var Civet = (() => {
3684
3849
  return Static$0(state) || Static$1(state);
3685
3850
  }
3686
3851
  }
3687
- var Switch$0 = $TV($EXPECT($L119, fail, 'Switch "switch"'), function($skip, $loc, $0, $1) {
3852
+ var SubstitutionStart$0 = $TV($EXPECT($L117, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
3853
+ return { $loc, token: $1 };
3854
+ });
3855
+ function SubstitutionStart(state) {
3856
+ if (state.verbose)
3857
+ console.log("ENTER:", "SubstitutionStart");
3858
+ if (state.tokenize) {
3859
+ return $TOKEN("SubstitutionStart", state, SubstitutionStart$0(state));
3860
+ } else {
3861
+ return SubstitutionStart$0(state);
3862
+ }
3863
+ }
3864
+ var Switch$0 = $TS($S($EXPECT($L118, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3688
3865
  return { $loc, token: $1 };
3689
3866
  });
3690
3867
  function Switch(state) {
@@ -3696,7 +3873,7 @@ var Civet = (() => {
3696
3873
  return Switch$0(state);
3697
3874
  }
3698
3875
  }
3699
- var Target$0 = $TV($EXPECT($L120, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
3876
+ var Target$0 = $TV($EXPECT($L119, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
3700
3877
  return { $loc, token: $1 };
3701
3878
  });
3702
3879
  function Target(state) {
@@ -3708,7 +3885,7 @@ var Civet = (() => {
3708
3885
  return Target$0(state);
3709
3886
  }
3710
3887
  }
3711
- var TripleDoubleQuote$0 = $TV($EXPECT($L121, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
3888
+ var TripleDoubleQuote$0 = $TV($EXPECT($L120, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
3712
3889
  return { $loc, token: "`" };
3713
3890
  });
3714
3891
  function TripleDoubleQuote(state) {
@@ -3720,7 +3897,7 @@ var Civet = (() => {
3720
3897
  return TripleDoubleQuote$0(state);
3721
3898
  }
3722
3899
  }
3723
- var TripleSingleQuote$0 = $TV($EXPECT($L122, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
3900
+ var TripleSingleQuote$0 = $TV($EXPECT($L121, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
3724
3901
  return { $loc, token: "`" };
3725
3902
  });
3726
3903
  function TripleSingleQuote(state) {
@@ -3732,7 +3909,7 @@ var Civet = (() => {
3732
3909
  return TripleSingleQuote$0(state);
3733
3910
  }
3734
3911
  }
3735
- var TripleTick$0 = $TV($EXPECT($L123, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
3912
+ var TripleTick$0 = $TV($EXPECT($L122, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
3736
3913
  return { $loc, token: "`" };
3737
3914
  });
3738
3915
  function TripleTick(state) {
@@ -3744,7 +3921,7 @@ var Civet = (() => {
3744
3921
  return TripleTick$0(state);
3745
3922
  }
3746
3923
  }
3747
- var Try$0 = $TV($EXPECT($L124, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
3924
+ var Try$0 = $TV($EXPECT($L123, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
3748
3925
  return { $loc, token: $1 };
3749
3926
  });
3750
3927
  function Try(state) {
@@ -3756,7 +3933,7 @@ var Civet = (() => {
3756
3933
  return Try$0(state);
3757
3934
  }
3758
3935
  }
3759
- var Unless$0 = $TV($EXPECT($L125, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
3936
+ var Unless$0 = $TV($EXPECT($L124, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
3760
3937
  return { $loc, token: $1 };
3761
3938
  });
3762
3939
  function Unless(state) {
@@ -3768,7 +3945,7 @@ var Civet = (() => {
3768
3945
  return Unless$0(state);
3769
3946
  }
3770
3947
  }
3771
- var Var$0 = $TV($EXPECT($L126, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
3948
+ var Var$0 = $TV($EXPECT($L125, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
3772
3949
  return { $loc, token: $1 };
3773
3950
  });
3774
3951
  function Var(state) {
@@ -3780,7 +3957,7 @@ var Civet = (() => {
3780
3957
  return Var$0(state);
3781
3958
  }
3782
3959
  }
3783
- var When$0 = $TS($S($EXPECT($L127, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3960
+ var When$0 = $TS($S($EXPECT($L126, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3784
3961
  return { $loc, token: "case" };
3785
3962
  });
3786
3963
  function When(state) {
@@ -3792,6 +3969,18 @@ var Civet = (() => {
3792
3969
  return When$0(state);
3793
3970
  }
3794
3971
  }
3972
+ var Yield$0 = $TS($S($EXPECT($L127, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3973
+ return { $loc, token: $1 };
3974
+ });
3975
+ function Yield(state) {
3976
+ if (state.verbose)
3977
+ console.log("ENTER:", "Yield");
3978
+ if (state.tokenize) {
3979
+ return $TOKEN("Yield", state, Yield$0(state));
3980
+ } else {
3981
+ return Yield$0(state);
3982
+ }
3983
+ }
3795
3984
  var JSXElement$0 = JSXSelfClosingElement;
3796
3985
  var JSXElement$1 = $TS($S(JSXOpeningElement, $Q(JSXChildren), __, JSXClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
3797
3986
  if ($1[1] !== $4[2]) {
@@ -3806,7 +3995,7 @@ var Civet = (() => {
3806
3995
  return JSXElement$0(state) || JSXElement$1(state);
3807
3996
  }
3808
3997
  }
3809
- var JSXSelfClosingElement$0 = $S($EXPECT($L7, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L128, fail, 'JSXSelfClosingElement "/>"'));
3998
+ var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L128, fail, 'JSXSelfClosingElement "/>"'));
3810
3999
  function JSXSelfClosingElement(state) {
3811
4000
  if (state.verbose)
3812
4001
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -3816,7 +4005,7 @@ var Civet = (() => {
3816
4005
  return JSXSelfClosingElement$0(state);
3817
4006
  }
3818
4007
  }
3819
- var JSXOpeningElement$0 = $S($EXPECT($L7, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L54, fail, 'JSXOpeningElement ">"'));
4008
+ var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L53, fail, 'JSXOpeningElement ">"'));
3820
4009
  function JSXOpeningElement(state) {
3821
4010
  if (state.verbose)
3822
4011
  console.log("ENTER:", "JSXOpeningElement");
@@ -3826,7 +4015,7 @@ var Civet = (() => {
3826
4015
  return JSXOpeningElement$0(state);
3827
4016
  }
3828
4017
  }
3829
- var JSXClosingElement$0 = $S($EXPECT($L129, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L54, fail, 'JSXClosingElement ">"'));
4018
+ var JSXClosingElement$0 = $S($EXPECT($L129, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L53, fail, 'JSXClosingElement ">"'));
3830
4019
  function JSXClosingElement(state) {
3831
4020
  if (state.verbose)
3832
4021
  console.log("ENTER:", "JSXClosingElement");
@@ -3876,7 +4065,7 @@ var Civet = (() => {
3876
4065
  return JSXAttributes$0(state);
3877
4066
  }
3878
4067
  }
3879
- var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($L19, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, CloseBrace);
4068
+ var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($L17, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, CloseBrace);
3880
4069
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
3881
4070
  function JSXAttribute(state) {
3882
4071
  if (state.tokenize) {
@@ -3948,7 +4137,7 @@ var Civet = (() => {
3948
4137
  return JSXText$0(state);
3949
4138
  }
3950
4139
  }
3951
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L19, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
4140
+ var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L17, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3952
4141
  function JSXChildExpression(state) {
3953
4142
  if (state.verbose)
3954
4143
  console.log("ENTER:", "JSXChildExpression");
@@ -4156,7 +4345,7 @@ var Civet = (() => {
4156
4345
  return ReturnTypeSuffix$0(state);
4157
4346
  }
4158
4347
  }
4159
- var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L57, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
4348
+ var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L56, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
4160
4349
  function TypePredicate(state) {
4161
4350
  if (state.verbose)
4162
4351
  console.log("ENTER:", "TypePredicate");
@@ -4207,7 +4396,7 @@ var Civet = (() => {
4207
4396
  }
4208
4397
  }
4209
4398
  var TypeUnaryOp$0 = $EXPECT($L138, fail, 'TypeUnaryOp "keyof"');
4210
- var TypeUnaryOp$1 = $EXPECT($L72, fail, 'TypeUnaryOp "typeof"');
4399
+ var TypeUnaryOp$1 = $EXPECT($L71, fail, 'TypeUnaryOp "typeof"');
4211
4400
  var TypeUnaryOp$2 = $EXPECT($L139, fail, 'TypeUnaryOp "infer"');
4212
4401
  function TypeUnaryOp(state) {
4213
4402
  if (state.tokenize) {
@@ -4238,7 +4427,7 @@ var Civet = (() => {
4238
4427
  return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
4239
4428
  }
4240
4429
  }
4241
- var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L8, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type)))));
4430
+ var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type)))));
4242
4431
  function TypeConditional(state) {
4243
4432
  if (state.verbose)
4244
4433
  console.log("ENTER:", "TypeConditional");
@@ -4249,7 +4438,7 @@ var Civet = (() => {
4249
4438
  }
4250
4439
  }
4251
4440
  var TypeLiteral$0 = Literal;
4252
- var TypeLiteral$1 = $EXPECT($L71, fail, 'TypeLiteral "void"');
4441
+ var TypeLiteral$1 = $EXPECT($L70, fail, 'TypeLiteral "void"');
4253
4442
  var TypeLiteral$2 = $EXPECT($L140, fail, 'TypeLiteral "[]"');
4254
4443
  function TypeLiteral(state) {
4255
4444
  if (state.tokenize) {
@@ -4258,8 +4447,8 @@ var Civet = (() => {
4258
4447
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
4259
4448
  }
4260
4449
  }
4261
- var TypeBinaryOp$0 = $EXPECT($L69, fail, 'TypeBinaryOp "|"');
4262
- var TypeBinaryOp$1 = $EXPECT($L67, fail, 'TypeBinaryOp "&"');
4450
+ var TypeBinaryOp$0 = $EXPECT($L68, fail, 'TypeBinaryOp "|"');
4451
+ var TypeBinaryOp$1 = $EXPECT($L66, fail, 'TypeBinaryOp "&"');
4263
4452
  function TypeBinaryOp(state) {
4264
4453
  if (state.tokenize) {
4265
4454
  return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -4267,7 +4456,7 @@ var Civet = (() => {
4267
4456
  return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
4268
4457
  }
4269
4458
  }
4270
- var FunctionType$0 = $S(Parameters, __, $EXPECT($L6, fail, 'FunctionType "=>"'), Type);
4459
+ var FunctionType$0 = $S(Parameters, __, $EXPECT($L4, fail, 'FunctionType "=>"'), Type);
4271
4460
  function FunctionType(state) {
4272
4461
  if (state.verbose)
4273
4462
  console.log("ENTER:", "FunctionType");
@@ -4277,7 +4466,7 @@ var Civet = (() => {
4277
4466
  return FunctionType$0(state);
4278
4467
  }
4279
4468
  }
4280
- var TypeArguments$0 = $S(__, $EXPECT($L7, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L54, fail, 'TypeArguments ">"'));
4469
+ var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L53, fail, 'TypeArguments ">"'));
4281
4470
  function TypeArguments(state) {
4282
4471
  if (state.verbose)
4283
4472
  console.log("ENTER:", "TypeArguments");
@@ -4287,7 +4476,7 @@ var Civet = (() => {
4287
4476
  return TypeArguments$0(state);
4288
4477
  }
4289
4478
  }
4290
- 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) {
4479
+ var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L53, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
4291
4480
  return { ts: true, children: $0 };
4292
4481
  });
4293
4482
  function TypeParameters(state) {
@@ -4309,7 +4498,7 @@ var Civet = (() => {
4309
4498
  return TypeParameter$0(state);
4310
4499
  }
4311
4500
  }
4312
- var TypeConstraint$0 = $S(__, $EXPECT($L8, fail, 'TypeConstraint "extends"'), Type);
4501
+ var TypeConstraint$0 = $S(__, $EXPECT($L6, fail, 'TypeConstraint "extends"'), Type);
4313
4502
  function TypeConstraint(state) {
4314
4503
  if (state.verbose)
4315
4504
  console.log("ENTER:", "TypeConstraint");
@@ -4320,8 +4509,8 @@ var Civet = (() => {
4320
4509
  }
4321
4510
  }
4322
4511
  var TypeParameterDelimiter$0 = $S($Q(_), Comma);
4323
- var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L54, fail, 'TypeParameterDelimiter ">"')));
4324
- var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L54, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
4512
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L53, fail, 'TypeParameterDelimiter ">"')));
4513
+ var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L53, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
4325
4514
  return { $loc, token: "," };
4326
4515
  });
4327
4516
  var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
@@ -4528,11 +4717,23 @@ var Civet = (() => {
4528
4717
  return InsertBreak$0(state);
4529
4718
  }
4530
4719
  }
4531
- var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
4532
- var directives = $2;
4720
+ var Reset$0 = $TV($EXPECT($L1, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
4533
4721
  module.currentIndent = 0;
4534
4722
  module.indentLevels = [0];
4535
4723
  module.verbose = false;
4724
+ module.coffeeCompat = false;
4725
+ });
4726
+ function Reset(state) {
4727
+ if (state.verbose)
4728
+ console.log("ENTER:", "Reset");
4729
+ if (state.tokenize) {
4730
+ return $TOKEN("Reset", state, Reset$0(state));
4731
+ } else {
4732
+ return Reset$0(state);
4733
+ }
4734
+ }
4735
+ var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
4736
+ var directives = $2;
4536
4737
  if (directives) {
4537
4738
  const compatRe = /use coffee-compat/;
4538
4739
  module.coffeeCompat = directives.some((d) => d[1].token?.match(compatRe));
@@ -4544,6 +4745,19 @@ var Civet = (() => {
4544
4745
  s = s.slice(1, s.indexOf("Program") + 1);
4545
4746
  return s;
4546
4747
  };
4748
+ module.insertTrimmingSpace = function(spacing, c) {
4749
+ let target = spacing;
4750
+ while (Array.isArray(target)) {
4751
+ target = target[0];
4752
+ }
4753
+ if (target.token) {
4754
+ target.token = target.token.replace(/^ ?/, c);
4755
+ }
4756
+ return spacing;
4757
+ };
4758
+ module.modifyString = function(str) {
4759
+ return str.replace(/(?<!\\)(\\\\)*\n/g, "$1\\n");
4760
+ };
4547
4761
  module.dedentBlockSubstitutions = function($02) {
4548
4762
  const [s, strWithSubstitutions, e] = $02;
4549
4763
  if (strWithSubstitutions.length === 0) {
@@ -4587,7 +4801,7 @@ var Civet = (() => {
4587
4801
  if (trim) {
4588
4802
  str = str.replace(/^(\r?\n|\n)/, "").replace(/(\r?\n|\n)[ \t]*$/, "");
4589
4803
  }
4590
- str = str.replace(/(`|\$)/g, "\\$1");
4804
+ str = str.replace(/(`|\$\{)/g, "\\$1");
4591
4805
  return {
4592
4806
  $loc: $loc2,
4593
4807
  token: str