@danielx/civet 0.4.5 → 0.4.7

package/dist/browser.js

@@ -535,6 +535,7 @@ var Civet = (() => {
         NestedCaseClause,
         CaseClause,
         CaseExpressionList,
+        NoExpressions,
         ImpliedColon,
         TryStatement,
         CatchClause,
@@ -586,6 +587,9 @@ var Civet = (() => {
         TripleDoubleStringCharacters,
         TripleSingleStringCharacters,
         CoffeeStringSubstitution,
+        CoffeeCompat,
+        CoffeeCompatDoubleQuotedString,
+        CoffeeCompatDoubleQuotedStringCharacters,
         RegularExpressionLiteral,
         RegularExpressionBody,
         RegExpCharacter,
@@ -652,6 +656,7 @@ var Civet = (() => {
         SubstitutionStart,
         Switch,
         Target,
+        Throw,
         TripleDoubleQuote,
         TripleSingleQuote,
         TripleTick,
@@ -728,6 +733,7 @@ var Civet = (() => {
         InsertSpace,
         InsertDot,
         InsertBreak,
+        Reset,
         Init,
         Indent,
         TrackIndent,
@@ -817,46 +823,46 @@ var Civet = (() => {
       var $L77 = $L("break");
       var $L78 = $L("continue");
       var $L79 = $L("debugger");
-      var $L80 = $L("throw");
-      var $L81 = $L("import type");
-      var $L82 = $L("default");
-      var $L83 = $L(":=");
-      var $L84 = $L("/*");
-      var $L85 = $L("*/");
-      var $L86 = $L("###");
-      var $L87 = $L("as");
-      var $L88 = $L("async");
-      var $L89 = $L("await");
-      var $L90 = $L("case");
-      var $L91 = $L("catch");
-      var $L92 = $L("class");
-      var $L93 = $L("#{");
-      var $L94 = $L(":");
-      var $L95 = $L(".");
-      var $L96 = $L('"');
-      var $L97 = $L("else");
-      var $L98 = $L("export");
-      var $L99 = $L("for");
-      var $L100 = $L("from");
-      var $L101 = $L("function");
-      var $L102 = $L("get");
-      var $L103 = $L("set");
-      var $L104 = $L("if");
-      var $L105 = $L("let");
-      var $L106 = $L("const");
-      var $L107 = $L("loop");
-      var $L108 = $L("new");
-      var $L109 = $L("of");
-      var $L110 = $L("{");
-      var $L111 = $L("[");
-      var $L112 = $L("(");
-      var $L113 = $L("?");
-      var $L114 = $L("return");
-      var $L115 = $L("'");
-      var $L116 = $L("static");
-      var $L117 = $L("${");
-      var $L118 = $L("switch");
-      var $L119 = $L("target");
+      var $L80 = $L("import type");
+      var $L81 = $L("default");
+      var $L82 = $L(":=");
+      var $L83 = $L("/*");
+      var $L84 = $L("*/");
+      var $L85 = $L("###");
+      var $L86 = $L("as");
+      var $L87 = $L("async");
+      var $L88 = $L("await");
+      var $L89 = $L("case");
+      var $L90 = $L("catch");
+      var $L91 = $L("class");
+      var $L92 = $L("#{");
+      var $L93 = $L(":");
+      var $L94 = $L(".");
+      var $L95 = $L('"');
+      var $L96 = $L("else");
+      var $L97 = $L("export");
+      var $L98 = $L("for");
+      var $L99 = $L("from");
+      var $L100 = $L("function");
+      var $L101 = $L("get");
+      var $L102 = $L("set");
+      var $L103 = $L("if");
+      var $L104 = $L("let");
+      var $L105 = $L("const");
+      var $L106 = $L("loop");
+      var $L107 = $L("new");
+      var $L108 = $L("of");
+      var $L109 = $L("{");
+      var $L110 = $L("[");
+      var $L111 = $L("(");
+      var $L112 = $L("?");
+      var $L113 = $L("return");
+      var $L114 = $L("'");
+      var $L115 = $L("static");
+      var $L116 = $L("${");
+      var $L117 = $L("switch");
+      var $L118 = $L("target");
+      var $L119 = $L("throw");
       var $L120 = $L('"""');
       var $L121 = $L("'''");
       var $L122 = $L("```");
@@ -893,31 +899,32 @@ var Civet = (() => {
       var $R10 = $R(new RegExp("(?:\\\\.|[^'])*", "suy"));
       var $R11 = $R(new RegExp('(?:"(?!"")|#(?!\\{)|\\\\.|[^#"])+', "suy"));
       var $R12 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
-      var $R13 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
-      var $R14 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
-      var $R15 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
-      var $R16 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
-      var $R17 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
-      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"));
-      var $R19 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
-      var $R20 = $R(new RegExp(".", "suy"));
-      var $R21 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
-      var $R22 = $R(new RegExp("[^\\r\\n]", "suy"));
-      var $R23 = $R(new RegExp("[ \\t]+", "suy"));
-      var $R24 = $R(new RegExp("[\\s]+", "suy"));
-      var $R25 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
-      var $R26 = $R(new RegExp("\\s", "suy"));
-      var $R27 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
-      var $R28 = $R(new RegExp('"[^"]*"', "suy"));
-      var $R29 = $R(new RegExp("'[^']*'", "suy"));
-      var $R30 = $R(new RegExp("[^{}<>]+", "suy"));
-      var $R31 = $R(new RegExp("[+-]?", "suy"));
-      var $R32 = $R(new RegExp("[+-]", "suy"));
-      var $R33 = $R(new RegExp("#![^\\r\\n]*", "suy"));
-      var $R34 = $R(new RegExp("[\\t ]*", "suy"));
-      var $R35 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
-      var $R36 = $R(new RegExp("$", "suy"));
-      var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
+      var $R13 = $R(new RegExp('(?:\\\\.|#(?!\\{)|[^"#])+', "suy"));
+      var $R14 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
+      var $R15 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
+      var $R16 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
+      var $R17 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
+      var $R18 = $R(new RegExp("(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+", "suy"));
+      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"));
+      var $R20 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
+      var $R21 = $R(new RegExp(".", "suy"));
+      var $R22 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
+      var $R23 = $R(new RegExp("[^\\r\\n]", "suy"));
+      var $R24 = $R(new RegExp("[ \\t]+", "suy"));
+      var $R25 = $R(new RegExp("[\\s]+", "suy"));
+      var $R26 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
+      var $R27 = $R(new RegExp("\\s", "suy"));
+      var $R28 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
+      var $R29 = $R(new RegExp('"[^"]*"', "suy"));
+      var $R30 = $R(new RegExp("'[^']*'", "suy"));
+      var $R31 = $R(new RegExp("[^{}<>]+", "suy"));
+      var $R32 = $R(new RegExp("[+-]?", "suy"));
+      var $R33 = $R(new RegExp("[+-]", "suy"));
+      var $R34 = $R(new RegExp("#![^\\r\\n]*", "suy"));
+      var $R35 = $R(new RegExp("[\\t ]*", "suy"));
+      var $R36 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
+      var $R37 = $R(new RegExp("$", "suy"));
+      var Program$0 = $S(Reset, Init, __, $Q(TopLevelStatement), __);
       function Program(state) {
         if (state.verbose)
           console.log("ENTER:", "Program");
@@ -937,7 +944,11 @@ var Civet = (() => {
           return TopLevelStatement$0(state);
         }
       }
-      var Expression$0 = $S(AssignmentExpression, $Q($S(__, Comma, AssignmentExpression)));
+      var Expression$0 = $TS($S(AssignmentExpression, $Q($S(__, Comma, AssignmentExpression))), function($skip, $loc, $0, $1, $2) {
+        if ($2.length == 0)
+          return $1;
+        return $0;
+      });
       function Expression(state) {
         if (state.verbose)
           console.log("ENTER:", "Expression");
@@ -1018,7 +1029,9 @@ var Civet = (() => {
         var spacing = $2;
         return module.insertTrimmingSpace(spacing, "(");
       });
-      var ApplicationStart$1 = $S(IndentedApplicationAllowed, $Y(NestedObjectLiteral), InsertOpenParen);
+      var ApplicationStart$1 = $T($S(IndentedApplicationAllowed, $Y(NestedObjectLiteral), InsertOpenParen), function(value) {
+        return value[2];
+      });
       function ApplicationStart(state) {
         if (state.tokenize) {
           return $TOKEN("ApplicationStart", state, ApplicationStart$0(state) || ApplicationStart$1(state));
@@ -1050,7 +1063,11 @@ var Civet = (() => {
           return CommaExpression$0(state);
         }
       }
-      var BinaryOpExpression$0 = $S(UnaryExpression, $Q($S(__, BinaryOp, __, UnaryExpression)));
+      var BinaryOpExpression$0 = $TS($S(UnaryExpression, $Q($S(__, BinaryOp, __, UnaryExpression))), function($skip, $loc, $0, $1, $2) {
+        if ($2.length)
+          return $0;
+        return $1;
+      });
       function BinaryOpExpression(state) {
         if (state.verbose)
           console.log("ENTER:", "BinaryOpExpression");
@@ -1090,7 +1107,11 @@ var Civet = (() => {
         }
       }
       var UpdateExpression$0 = $S(UpdateExpressionSymbol, UnaryExpression);
-      var UpdateExpression$1 = $S(LeftHandSideExpression, $E(UpdateExpressionSymbol));
+      var UpdateExpression$1 = $TS($S(LeftHandSideExpression, $E(UpdateExpressionSymbol)), function($skip, $loc, $0, $1, $2) {
+        if ($2)
+          return $0;
+        return $1;
+      });
       function UpdateExpression(state) {
         if (state.tokenize) {
           return $TOKEN("UpdateExpression", state, UpdateExpression$0(state) || UpdateExpression$1(state));
@@ -1110,7 +1131,11 @@ var Civet = (() => {
           return UpdateExpressionSymbol$0(state);
         }
       }
-      var AssignmentExpression$0 = $S($Q(TrailingComment), AssignmentExpressionRest);
+      var AssignmentExpression$0 = $TS($S($Q(TrailingComment), AssignmentExpressionRest), function($skip, $loc, $0, $1, $2) {
+        if ($1.length)
+          return $0;
+        return $2;
+      });
       var AssignmentExpression$1 = $S(__, AssignmentExpressionRest);
       function AssignmentExpression(state) {
         if (state.tokenize) {
@@ -1122,7 +1147,9 @@ var Civet = (() => {
       var AssignmentExpressionRest$0 = AwaitExpression;
       var AssignmentExpressionRest$1 = YieldExpression;
       var AssignmentExpressionRest$2 = $S($E($S(Async, __)), ArrowFunction);
-      var AssignmentExpressionRest$3 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), Expression);
+      var AssignmentExpressionRest$3 = $T($S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), Expression), function(value) {
+        return { "type": "AssignmentExpression", "children": value };
+      });
       var AssignmentExpressionRest$4 = ConditionalExpression;
       function AssignmentExpressionRest(state) {
         if (state.tokenize) {
@@ -1187,7 +1214,11 @@ var Civet = (() => {
           return FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state) || FatArrowBody$4(state);
         }
       }
-      var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, QuestionMark, AssignmentExpression, __, Colon, AssignmentExpression)));
+      var ConditionalExpression$0 = $TS($S(ShortCircuitExpression, $E($S(__, QuestionMark, AssignmentExpression, __, Colon, AssignmentExpression))), function($skip, $loc, $0, $1, $2) {
+        if ($2)
+          return $0;
+        return $1;
+      });
       function ConditionalExpression(state) {
         if (state.verbose)
           console.log("ENTER:", "ConditionalExpression");
@@ -1376,7 +1407,11 @@ var Civet = (() => {
       }
       var CallExpression$0 = $S($EXPECT($L10, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
       var CallExpression$1 = $S($EXPECT($L11, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
-      var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
+      var CallExpression$2 = $TS($S(MemberExpression, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2) {
+        if ($2.length)
+          return $0;
+        return $1;
+      });
       function CallExpression(state) {
         if (state.tokenize) {
           return $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state));
@@ -1426,7 +1461,11 @@ var Civet = (() => {
           return AdditionalReservedWords$0(state);
         }
       }
-      var MemberExpression$0 = $S(PrimaryExpression, $Q(MemberExpressionRest));
+      var MemberExpression$0 = $TS($S(PrimaryExpression, $Q(MemberExpressionRest)), function($skip, $loc, $0, $1, $2) {
+        if ($2.length)
+          return $0;
+        return $1;
+      });
       var MemberExpression$1 = $S($Q(TrailingComment), SuperProperty);
       var MemberExpression$2 = $S($Q(TrailingComment), MetaProperty);
       function MemberExpression(state) {
@@ -1662,7 +1701,9 @@ var Civet = (() => {
         }
       }
       var FunctionExpression$0 = ThinArrowFunction;
-      var FunctionExpression$1 = $S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
+      var FunctionExpression$1 = $T($S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock), function(value) {
+        return { "type": "FunctionExpression", "children": value };
+      });
       function FunctionExpression(state) {
         if (state.tokenize) {
           return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1670,17 +1711,23 @@ var Civet = (() => {
           return FunctionExpression$0(state) || FunctionExpression$1(state);
         }
       }
-      var ThinArrowFunction$0 = $TS($S(Parameters, $E(ReturnTypeSuffix), __, Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var ThinArrowFunction$0 = $TS($S(Parameters, $E(ReturnTypeSuffix), $Q(_), Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var params = $1;
         var suffix = $2;
         var arrow = $4;
         var block = $5;
-        return [
-          { $loc: arrow.$loc, token: "function" },
-          params,
-          suffix,
-          block
-        ];
+        if (module.implicitReturns && suffix?.children[3] !== "void") {
+          block = module.addImplicitReturns(block);
+        }
+        return {
+          type: "FunctionExpression",
+          children: [
+            { $loc: arrow.$loc, token: "function" },
+            params,
+            suffix,
+            block
+          ]
+        };
       });
       function ThinArrowFunction(state) {
         if (state.verbose)
@@ -1703,8 +1750,14 @@ var Civet = (() => {
           return Arrow$0(state);
         }
       }
-      var Block$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
-      var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
+      var Block$0 = $T($S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace), function(value) {
+        var exps = value[3];
+        return { "type": "BlockStatement", "expressions": exps, "children": value };
+      });
+      var Block$1 = $T($S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace), function(value) {
+        var exps = value[2];
+        return { "type": "BlockStatement", "expressions": exps, "children": value };
+      });
       var Block$2 = Statement;
       var Block$3 = $S(__, Statement);
       function Block(state) {
@@ -1715,7 +1768,9 @@ var Civet = (() => {
         }
       }
       var BracedOrEmptyBlock$0 = BracedBlock;
-      var BracedOrEmptyBlock$1 = $S(InsertOpenBrace, InsertCloseBrace);
+      var BracedOrEmptyBlock$1 = $T($S(InsertOpenBrace, InsertCloseBrace), function(value) {
+        return { "type": "BlockStatement", "expressions": [], "children": value };
+      });
       function BracedOrEmptyBlock(state) {
         if (state.tokenize) {
           return $TOKEN("BracedOrEmptyBlock", state, BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state));
@@ -1723,9 +1778,22 @@ var Civet = (() => {
           return BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state);
         }
       }
-      var BracedBlock$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
-      var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
-      var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
+      var BracedBlock$0 = $T($S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace), function(value) {
+        var exps = value[3];
+        return { "type": "BlockStatement", "expressions": exps, "children": value };
+      });
+      var BracedBlock$1 = $T($S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace), function(value) {
+        var exps = value[2];
+        return { "type": "BlockStatement", "expressions": exps, "children": value };
+      });
+      var BracedBlock$2 = $TS($S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+        var s = $4;
+        return {
+          type: "BlockStatement",
+          expressions: [s],
+          children: $0
+        };
+      });
       function BracedBlock(state) {
         if (state.tokenize) {
           return $TOKEN("BracedBlock", state, BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state));
@@ -1820,7 +1888,9 @@ var Civet = (() => {
           return Comma$0(state);
         }
       }
-      var Identifier$0 = $S($N(ReservedWord), IdentifierName);
+      var Identifier$0 = $T($S($N(ReservedWord), IdentifierName), function(value) {
+        return value[1];
+      });
       function Identifier(state) {
         if (state.verbose)
           console.log("ENTER:", "Identifier");
@@ -2208,8 +2278,7 @@ var Civet = (() => {
         var l = $3;
         if (cond)
           return [cond, statement, { $loc: l.$loc, token: "}" }];
-        $0.pop();
-        return $0;
+        return statement;
       });
       function StatementListItem(state) {
         if (state.verbose)
@@ -2264,7 +2333,9 @@ var Civet = (() => {
           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);
         }
       }
-      var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L72, fail, 'EmptyStatement ";"')));
+      var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L72, fail, 'EmptyStatement ";"'))), function(value) {
+        return { "type": "EmptyStatement", "children": value[0] };
+      });
       function EmptyStatement(state) {
         if (state.verbose)
           console.log("ENTER:", "EmptyStatement");
@@ -2284,7 +2355,9 @@ var Civet = (() => {
           return BlockStatement$0(state);
         }
       }
-      var IfStatement$0 = $S(If, Condition, Block, $E($S(__, Else, Block)));
+      var IfStatement$0 = $T($S(If, Condition, Block, $E($S(__, Else, Block))), function(value) {
+        return { "type": "IfStatement", "children": value };
+      });
       var IfStatement$1 = $TS($S(Unless, Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
         var kind = $1;
         var condition = $2;
@@ -2298,7 +2371,10 @@ var Civet = (() => {
             c.token = "))";
         });
         kind.token = "if";
-        return [kind, condition, block];
+        return {
+          type: "IfStatement",
+          children: [kind, condition, block]
+        };
       });
       function IfStatement(state) {
         if (state.tokenize) {
@@ -2310,8 +2386,12 @@ var Civet = (() => {
       var IterationStatement$0 = LoopStatement;
       var IterationStatement$1 = DoWhileStatement;
       var IterationStatement$2 = WhileStatement;
-      var IterationStatement$3 = ForStatement;
-      var IterationStatement$4 = ForInOfStatement;
+      var IterationStatement$3 = $T($S(ForStatement), function(value) {
+        return { "type": "IterationStatement", "children": value };
+      });
+      var IterationStatement$4 = $T($S(ForInOfStatement), function(value) {
+        return { "type": "IterationStatement", "children": value };
+      });
       function IterationStatement(state) {
         if (state.tokenize) {
           return $TOKEN("IterationStatement", state, IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state));
@@ -2319,7 +2399,9 @@ var Civet = (() => {
           return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
         }
       }
-      var LoopStatement$0 = $S(Loop, Block);
+      var LoopStatement$0 = $T($S(Loop, Block), function(value) {
+        return { "type": "IterationStatement", "children": value };
+      });
       function LoopStatement(state) {
         if (state.verbose)
           console.log("ENTER:", "LoopStatement");
@@ -2329,7 +2411,9 @@ var Civet = (() => {
           return LoopStatement$0(state);
         }
       }
-      var DoWhileStatement$0 = $S($EXPECT($L73, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
+      var DoWhileStatement$0 = $T($S($EXPECT($L73, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause), function(value) {
+        return { "type": "IterationStatement", "children": value };
+      });
       function DoWhileStatement(state) {
         if (state.verbose)
           console.log("ENTER:", "DoWhileStatement");
@@ -2339,7 +2423,9 @@ var Civet = (() => {
           return DoWhileStatement$0(state);
         }
       }
-      var WhileStatement$0 = $S(WhileClause, Block);
+      var WhileStatement$0 = $T($S(WhileClause, Block), function(value) {
+        return { "type": "IterationStatement", "children": value };
+      });
       function WhileStatement(state) {
         if (state.verbose)
           console.log("ENTER:", "WhileStatement");
@@ -2408,7 +2494,9 @@ var Civet = (() => {
           return ForBinding$0(state) || ForBinding$1(state);
         }
       }
-      var SwitchStatement$0 = $S(Switch, Condition, CaseBlock);
+      var SwitchStatement$0 = $T($S(Switch, Condition, CaseBlock), function(value) {
+        return { "type": "SwitchStatement", "children": value };
+      });
       function SwitchStatement(state) {
         if (state.verbose)
           console.log("ENTER:", "SwitchStatement");
@@ -2418,8 +2506,24 @@ var Civet = (() => {
           return SwitchStatement$0(state);
         }
       }
-      var CaseBlock$0 = $S(__, OpenBrace, $Y(EOS), NestedCaseClauses, __, CloseBrace);
-      var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
+      var CaseBlock$0 = $TS($S(__, OpenBrace, $Y(EOS), NestedCaseClauses, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+        var clauses = $4;
+        $0.splice(2, 1);
+        return {
+          type: "CaseBlock",
+          clauses,
+          children: $0
+        };
+      });
+      var CaseBlock$1 = $TS($S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+        var clauses = $3;
+        $0.shift();
+        return {
+          type: "CaseBlock",
+          clauses,
+          children: $0
+        };
+      });
       function CaseBlock(state) {
         if (state.tokenize) {
           return $TOKEN("CaseBlock", state, CaseBlock$0(state) || CaseBlock$1(state));
@@ -2442,7 +2546,10 @@ var Civet = (() => {
           return NestedCaseClauses$0(state);
         }
       }
-      var NestedCaseClause$0 = $S(Nested, CaseClause);
+      var NestedCaseClause$0 = $TS($S(Nested, CaseClause), function($skip, $loc, $0, $1, $2) {
+        $2.children.unshift($1);
+        return $2;
+      });
       function NestedCaseClause(state) {
         if (state.verbose)
           console.log("ENTER:", "NestedCaseClause");
@@ -2452,14 +2559,32 @@ var Civet = (() => {
           return NestedCaseClause$0(state);
         }
       }
-      var CaseClause$0 = $S(Case, CaseExpressionList, NestedBlockExpressions);
-      var CaseClause$1 = $S(When, CaseExpressionList, NestedBlockExpressions, InsertBreak);
-      var CaseClause$2 = $S(Default, ImpliedColon, NestedBlockExpressions);
+      var CaseClause$0 = $T($S(Case, CaseExpressionList, $C(NestedBlockExpressions, NoExpressions)), function(value) {
+        var exps = value[2];
+        return { "type": "CaseClause", "expressions": exps, "children": value };
+      });
+      var CaseClause$1 = $T($S(When, CaseExpressionList, NestedBlockExpressions, InsertBreak), function(value) {
+        var exps = value[2];
+        return { "type": "WhenClause", "expressions": exps, "children": value };
+      });
+      var CaseClause$2 = $T($S(Default, ImpliedColon, $C(NestedBlockExpressions, NoExpressions)), function(value) {
+        var exps = value[2];
+        return { "type": "DefaultClause", "expressions": exps, "children": value };
+      });
+      var CaseClause$3 = $TS($S(Else, ImpliedColon, NestedBlockExpressions), function($skip, $loc, $0, $1, $2, $3) {
+        var exps = $3;
+        $1.token = "default";
+        return {
+          type: "DefaultClause",
+          expressions: exps,
+          children: $0
+        };
+      });
       function CaseClause(state) {
         if (state.tokenize) {
-          return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
+          return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state) || CaseClause$3(state));
         } else {
-          return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
+          return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state) || CaseClause$3(state);
         }
       }
       var CaseExpressionList$0 = $TS($S($S($Q(_), ExpressionWithIndentedApplicationSuppressed, ImpliedColon), $Q($S(__, Comma, ExpressionWithIndentedApplicationSuppressed, ImpliedColon))), function($skip, $loc, $0, $1, $2) {
@@ -2481,6 +2606,18 @@ var Civet = (() => {
           return CaseExpressionList$0(state);
         }
       }
+      var NoExpressions$0 = $T($EXPECT($L1, fail, 'NoExpressions ""'), function(value) {
+        return [];
+      });
+      function NoExpressions(state) {
+        if (state.verbose)
+          console.log("ENTER:", "NoExpressions");
+        if (state.tokenize) {
+          return $TOKEN("NoExpressions", state, NoExpressions$0(state));
+        } else {
+          return NoExpressions$0(state);
+        }
+      }
       var ImpliedColon$0 = $S(__, Colon);
       var ImpliedColon$1 = $TV($EXPECT($L1, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
         return { $loc, token: ":" };
@@ -2493,12 +2630,20 @@ var Civet = (() => {
         }
       }
       var TryStatement$0 = $TS($S(Try, BracedBlock, $E(CatchClause), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var t = $1;
+        var b = $2;
         var c = $3;
         var f = $4;
         if (!c && !f) {
-          return [$1, $2, " catch {}"];
+          return {
+            type: "TryStatement",
+            children: [t, b, " catch(e) {}"]
+          };
         }
-        return [$1, $2, c, f];
+        return {
+          type: "TryStatement",
+          children: [t, b, c, f]
+        };
       });
       function TryStatement(state) {
         if (state.verbose)
@@ -2520,7 +2665,7 @@ var Civet = (() => {
         }
       }
       var CatchBind$0 = $S(__, OpenParen, __, CatchParameter, __, CloseParen);
-      var CatchBind$1 = $S(__, InsertOpenParen, CatchParameter, InsertCloseParen);
+      var CatchBind$1 = $S($N(EOS), $Q(TrailingComment), InsertOpenParen, CatchParameter, InsertCloseParen);
       function CatchBind(state) {
         if (state.tokenize) {
           return $TOKEN("CatchBind", state, CatchBind$0(state) || CatchBind$1(state));
@@ -2594,11 +2739,21 @@ var Civet = (() => {
           return ExpressionStatement$0(state);
         }
       }
-      var KeywordStatement$0 = $S($EXPECT($L77, fail, 'KeywordStatement "break"'), NonIdContinue);
-      var KeywordStatement$1 = $S($EXPECT($L78, fail, 'KeywordStatement "continue"'), NonIdContinue);
-      var KeywordStatement$2 = $S($EXPECT($L79, fail, 'KeywordStatement "debugger"'), NonIdContinue);
-      var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
-      var KeywordStatement$4 = $S($EXPECT($L80, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
+      var KeywordStatement$0 = $T($S($EXPECT($L77, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
+        return { "type": "BreakStatement", "children": value };
+      });
+      var KeywordStatement$1 = $T($S($EXPECT($L78, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
+        return { "type": "ContinueStatement", "children": value };
+      });
+      var KeywordStatement$2 = $T($S($EXPECT($L79, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
+        return { "type": "DebuggerStatement", "children": value };
+      });
+      var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
+        return { "type": "ReturnStatement", "children": value };
+      });
+      var KeywordStatement$4 = $T($S(Throw, Expression), function(value) {
+        return { "type": "ThrowStatement", "children": value };
+      });
       function KeywordStatement(state) {
         if (state.tokenize) {
           return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
@@ -2615,7 +2770,7 @@ var Civet = (() => {
           return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
         }
       }
-      var ImportDeclaration$0 = $T($S($EXPECT($L81, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
+      var ImportDeclaration$0 = $T($S($EXPECT($L80, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
         return { "ts": true, "children": value };
       });
       var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
@@ -2753,7 +2908,7 @@ var Civet = (() => {
           return ImportedBinding$0(state);
         }
       }
-      var ExportDeclaration$0 = $S(Export, __, $EXPECT($L82, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
+      var ExportDeclaration$0 = $S(Export, __, $EXPECT($L81, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
       var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
       var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
       function ExportDeclaration(state) {
@@ -2813,7 +2968,9 @@ var Civet = (() => {
           return HoistableDeclaration$0(state);
         }
       }
-      var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__, Comma, __, LexicalBinding)));
+      var LexicalDeclaration$0 = $T($S(LetOrConst, __, LexicalBinding, $Q($S(__, Comma, __, LexicalBinding))), function(value) {
+        return { "type": "VariableDeclaration", "children": value };
+      });
       var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
         var c = $1;
         var ca = $5;
@@ -2821,7 +2978,10 @@ var Civet = (() => {
           pos: ca.$loc.pos - 1,
           length: ca.$loc.length + 1
         };
-        return $0;
+        return {
+          type: "VariableDeclaration",
+          children: $0
+        };
       });
       function LexicalDeclaration(state) {
         if (state.tokenize) {
@@ -2830,7 +2990,7 @@ var Civet = (() => {
           return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
         }
       }
-      var ConstAssignment$0 = $TV($EXPECT($L83, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
+      var ConstAssignment$0 = $TV($EXPECT($L82, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
         return { $loc, token: "=" };
       });
       function ConstAssignment(state) {
@@ -2861,7 +3021,9 @@ var Civet = (() => {
           return Initializer$0(state);
         }
       }
-      var VariableStatement$0 = $S(Var, __, VariableDeclarationList);
+      var VariableStatement$0 = $T($S(Var, __, VariableDeclarationList), function(value) {
+        return { "type": "VariableDeclaration", "children": value };
+      });
       function VariableStatement(state) {
         if (state.verbose)
           console.log("ENTER:", "VariableStatement");
@@ -2973,12 +3135,13 @@ var Civet = (() => {
         var e = $3;
         return [s, module.dedentBlockString(str), e];
       });
-      var StringLiteral$2 = BasicStringLiteral;
+      var StringLiteral$2 = CoffeeCompatDoubleQuotedString;
+      var StringLiteral$3 = BasicStringLiteral;
       function StringLiteral(state) {
         if (state.tokenize) {
-          return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state));
+          return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state));
         } else {
-          return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
+          return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
         }
       }
       var BasicStringLiteral$0 = $TS($S(DoubleQuote, DoubleStringCharacters, DoubleQuote), function($skip, $loc, $0, $1, $2, $3) {
@@ -3060,6 +3223,61 @@ var Civet = (() => {
           return CoffeeStringSubstitution$0(state);
         }
       }
+      var CoffeeCompat$0 = $TV($EXPECT($L1, fail, 'CoffeeCompat ""'), function($skip, $loc, $0, $1) {
+        if (module.coffeeCompat)
+          return;
+        return $skip;
+      });
+      function CoffeeCompat(state) {
+        if (state.verbose)
+          console.log("ENTER:", "CoffeeCompat");
+        if (state.tokenize) {
+          return $TOKEN("CoffeeCompat", state, CoffeeCompat$0(state));
+        } else {
+          return CoffeeCompat$0(state);
+        }
+      }
+      var CoffeeCompatDoubleQuotedString$0 = $TS($S(CoffeeCompat, DoubleQuote, $Q($C(CoffeeCompatDoubleQuotedStringCharacters, CoffeeStringSubstitution)), DoubleQuote), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var s = $2;
+        var parts = $3;
+        var e = $4;
+        const noInterpolations = parts.length === 1 && parts[0].token != null;
+        if (noInterpolations) {
+          return {
+            token: `"${module.modifyString(parts[0].token)}"`,
+            $loc
+          };
+        }
+        parts.forEach((part) => {
+          if (part.token) {
+            const str = part.token.replace(/(`|\$\{)/g, "\\$1");
+            part.token = module.modifyString(str);
+          }
+        });
+        s.token = e.token = "`";
+        return [s, parts, e];
+      });
+      function CoffeeCompatDoubleQuotedString(state) {
+        if (state.verbose)
+          console.log("ENTER:", "CoffeeCompatDoubleQuotedString");
+        if (state.tokenize) {
+          return $TOKEN("CoffeeCompatDoubleQuotedString", state, CoffeeCompatDoubleQuotedString$0(state));
+        } else {
+          return CoffeeCompatDoubleQuotedString$0(state);
+        }
+      }
+      var CoffeeCompatDoubleQuotedStringCharacters$0 = $TR($EXPECT($R13, fail, 'CoffeeCompatDoubleQuotedStringCharacters /(?:\\\\.|#(?!\\{)|[^"#])+/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+        return { $loc, token: $0 };
+      });
+      function CoffeeCompatDoubleQuotedStringCharacters(state) {
+        if (state.verbose)
+          console.log("ENTER:", "CoffeeCompatDoubleQuotedStringCharacters");
+        if (state.tokenize) {
+          return $TOKEN("CoffeeCompatDoubleQuotedStringCharacters", state, CoffeeCompatDoubleQuotedStringCharacters$0(state));
+        } else {
+          return CoffeeCompatDoubleQuotedStringCharacters$0(state);
+        }
+      }
       var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L44, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L44, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
@@ -3072,7 +3290,7 @@ var Civet = (() => {
           return RegularExpressionLiteral$0(state);
         }
       }
-      var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R13, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
+      var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R14, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
       function RegularExpressionBody(state) {
         if (state.verbose)
           console.log("ENTER:", "RegularExpressionBody");
@@ -3082,7 +3300,7 @@ var Civet = (() => {
           return RegularExpressionBody$0(state);
         }
       }
-      var RegExpCharacter$0 = $R$0($EXPECT($R14, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
+      var RegExpCharacter$0 = $R$0($EXPECT($R15, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
       function RegExpCharacter(state) {
         if (state.verbose)
           console.log("ENTER:", "RegExpCharacter");
@@ -3092,7 +3310,7 @@ var Civet = (() => {
           return RegExpCharacter$0(state);
         }
       }
-      var RegularExpressionFlags$0 = $R$0($EXPECT($R15, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
+      var RegularExpressionFlags$0 = $R$0($EXPECT($R16, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
       function RegularExpressionFlags(state) {
         if (state.verbose)
           console.log("ENTER:", "RegularExpressionFlags");
@@ -3123,7 +3341,7 @@ var Civet = (() => {
           return TemplateSubstitution$0(state);
         }
       }
-      var TemplateCharacters$0 = $TR($EXPECT($R16, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var TemplateCharacters$0 = $TR($EXPECT($R17, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function TemplateCharacters(state) {
@@ -3135,7 +3353,7 @@ var Civet = (() => {
           return TemplateCharacters$0(state);
         }
       }
-      var TemplateBlockCharacters$0 = $TR($EXPECT($R17, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var TemplateBlockCharacters$0 = $TR($EXPECT($R18, fail, "TemplateBlockCharacters /(?:\\$(?!\\{)|`(?!``)|\\\\.|[^$`])+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function TemplateBlockCharacters(state) {
@@ -3147,7 +3365,7 @@ var Civet = (() => {
           return TemplateBlockCharacters$0(state);
         }
       }
-      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})/"));
+      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})/"));
       function ReservedWord(state) {
         if (state.verbose)
           console.log("ENTER:", "ReservedWord");
@@ -3166,10 +3384,10 @@ var Civet = (() => {
           return Comment$0(state) || Comment$1(state);
         }
       }
-      var SingleLineComment$0 = $TR($EXPECT($R19, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var SingleLineComment$0 = $TR($EXPECT($R20, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
-      var SingleLineComment$1 = CoffeeSingleLineComment;
+      var SingleLineComment$1 = $S(CoffeeCompat, CoffeeSingleLineComment);
       function SingleLineComment(state) {
         if (state.tokenize) {
           return $TOKEN("SingleLineComment", state, SingleLineComment$0(state) || SingleLineComment$1(state));
@@ -3186,7 +3404,7 @@ var Civet = (() => {
           return MultiLineComment$0(state) || MultiLineComment$1(state);
         }
       }
-      var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L85, fail, 'JSMultiLineComment "*/"')), $EXPECT($R20, fail, "JSMultiLineComment /./"))), $EXPECT($L85, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
+      var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L83, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L84, fail, 'JSMultiLineComment "*/"')), $EXPECT($R21, fail, "JSMultiLineComment /./"))), $EXPECT($L84, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function JSMultiLineComment(state) {
@@ -3198,9 +3416,7 @@ var Civet = (() => {
           return JSMultiLineComment$0(state);
         }
       }
-      var CoffeeSingleLineComment$0 = $TR($EXPECT($R21, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
-        if (!module.coffeeCompat)
-          return $skip;
+      var CoffeeSingleLineComment$0 = $TR($EXPECT($R22, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: `//${$1}` };
       });
       function CoffeeSingleLineComment(state) {
@@ -3212,7 +3428,7 @@ var Civet = (() => {
           return CoffeeSingleLineComment$0(state);
         }
       }
-      var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L86, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L85, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R20, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L86, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
+      var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L85, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L85, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L84, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R21, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L85, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
         return { $loc, token: `/*${$2}*/` };
       });
       function CoffeeMultiLineComment(state) {
@@ -3224,7 +3440,7 @@ var Civet = (() => {
           return CoffeeMultiLineComment$0(state);
         }
       }
-      var InlineComment$0 = $TV($TEXT($S($EXPECT($L84, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L85, fail, 'InlineComment "*/"')), $EXPECT($R22, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L85, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
+      var InlineComment$0 = $TV($TEXT($S($EXPECT($L83, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L84, fail, 'InlineComment "*/"')), $EXPECT($R23, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L84, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function InlineComment(state) {
@@ -3266,7 +3482,7 @@ var Civet = (() => {
           return _$0(state);
         }
       }
-      var NonNewlineWhitespace$0 = $TR($EXPECT($R23, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var NonNewlineWhitespace$0 = $TR($EXPECT($R24, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function NonNewlineWhitespace(state) {
@@ -3288,7 +3504,7 @@ var Civet = (() => {
           return __$0(state);
         }
       }
-      var Whitespace$0 = $TR($EXPECT($R24, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var Whitespace$0 = $TR($EXPECT($R25, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       function Whitespace(state) {
@@ -3311,7 +3527,7 @@ var Civet = (() => {
           return StatementDelimiter$0(state) || StatementDelimiter$1(state);
         }
       }
-      var NonIdContinue$0 = $R$0($EXPECT($R25, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
+      var NonIdContinue$0 = $R$0($EXPECT($R26, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
       function NonIdContinue(state) {
         if (state.verbose)
           console.log("ENTER:", "NonIdContinue");
@@ -3333,7 +3549,7 @@ var Civet = (() => {
           return Loc$0(state);
         }
       }
-      var As$0 = $TS($S($EXPECT($L87, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var As$0 = $TS($S($EXPECT($L86, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function As(state) {
@@ -3345,7 +3561,7 @@ var Civet = (() => {
           return As$0(state);
         }
       }
-      var Async$0 = $TV($EXPECT($L88, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
+      var Async$0 = $TV($EXPECT($L87, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function Async(state) {
@@ -3357,7 +3573,7 @@ var Civet = (() => {
           return Async$0(state);
         }
       }
-      var Await$0 = $TS($S($EXPECT($L89, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Await$0 = $TS($S($EXPECT($L88, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Await(state) {
@@ -3369,7 +3585,7 @@ var Civet = (() => {
           return Await$0(state);
         }
       }
-      var Case$0 = $TS($S($EXPECT($L90, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Case$0 = $TS($S($EXPECT($L89, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Case(state) {
@@ -3381,7 +3597,7 @@ var Civet = (() => {
           return Case$0(state);
         }
       }
-      var Catch$0 = $TV($EXPECT($L91, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
+      var Catch$0 = $TV($EXPECT($L90, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function Catch(state) {
@@ -3393,7 +3609,7 @@ var Civet = (() => {
           return Catch$0(state);
         }
       }
-      var Class$0 = $TV($EXPECT($L92, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
+      var Class$0 = $TV($EXPECT($L91, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function Class(state) {
@@ -3441,7 +3657,7 @@ var Civet = (() => {
           return CloseParen$0(state);
         }
       }
-      var CoffeeSubstitutionStart$0 = $TV($EXPECT($L93, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
+      var CoffeeSubstitutionStart$0 = $TV($EXPECT($L92, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
         return { $loc, token: "${" };
       });
       function CoffeeSubstitutionStart(state) {
@@ -3453,7 +3669,7 @@ var Civet = (() => {
           return CoffeeSubstitutionStart$0(state);
         }
       }
-      var Colon$0 = $TV($EXPECT($L94, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
+      var Colon$0 = $TV($EXPECT($L93, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function Colon(state) {
@@ -3477,7 +3693,7 @@ var Civet = (() => {
           return ConstructorShorthand$0(state);
         }
       }
-      var Default$0 = $TS($S($EXPECT($L82, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Default$0 = $TS($S($EXPECT($L81, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Default(state) {
@@ -3489,7 +3705,7 @@ var Civet = (() => {
           return Default$0(state);
         }
       }
-      var Dot$0 = $TV($EXPECT($L95, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
+      var Dot$0 = $TV($EXPECT($L94, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function Dot(state) {
@@ -3501,7 +3717,7 @@ var Civet = (() => {
           return Dot$0(state);
         }
       }
-      var DoubleQuote$0 = $TV($EXPECT($L96, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
+      var DoubleQuote$0 = $TV($EXPECT($L95, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function DoubleQuote(state) {
@@ -3513,7 +3729,7 @@ var Civet = (() => {
           return DoubleQuote$0(state);
         }
       }
-      var Else$0 = $TV($EXPECT($L97, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
+      var Else$0 = $TV($EXPECT($L96, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function Else(state) {
@@ -3537,7 +3753,7 @@ var Civet = (() => {
           return Equals$0(state);
         }
       }
-      var Export$0 = $TS($S($EXPECT($L98, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Export$0 = $TS($S($EXPECT($L97, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Export(state) {
@@ -3549,7 +3765,7 @@ var Civet = (() => {
           return Export$0(state);
         }
       }
-      var For$0 = $TS($S($EXPECT($L99, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var For$0 = $TS($S($EXPECT($L98, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function For(state) {
@@ -3561,7 +3777,7 @@ var Civet = (() => {
           return For$0(state);
         }
       }
-      var From$0 = $TS($S($EXPECT($L100, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var From$0 = $TS($S($EXPECT($L99, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function From(state) {
@@ -3573,7 +3789,7 @@ var Civet = (() => {
           return From$0(state);
         }
       }
-      var Function$0 = $TV($EXPECT($L101, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
+      var Function$0 = $TV($EXPECT($L100, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function Function(state) {
@@ -3585,7 +3801,7 @@ var Civet = (() => {
           return Function$0(state);
         }
       }
-      var GetOrSet$0 = $TS($S($C($EXPECT($L102, fail, 'GetOrSet "get"'), $EXPECT($L103, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var GetOrSet$0 = $TS($S($C($EXPECT($L101, fail, 'GetOrSet "get"'), $EXPECT($L102, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function GetOrSet(state) {
@@ -3597,7 +3813,7 @@ var Civet = (() => {
           return GetOrSet$0(state);
         }
       }
-      var If$0 = $TV($EXPECT($L104, fail, 'If "if"'), function($skip, $loc, $0, $1) {
+      var If$0 = $TV($EXPECT($L103, fail, 'If "if"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function If(state) {
@@ -3609,7 +3825,7 @@ var Civet = (() => {
           return If$0(state);
         }
       }
-      var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R26, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
+      var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R27, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Import(state) {
@@ -3633,7 +3849,7 @@ var Civet = (() => {
           return In$0(state);
         }
       }
-      var LetOrConst$0 = $TV($C($EXPECT($L105, fail, 'LetOrConst "let"'), $EXPECT($L106, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
+      var LetOrConst$0 = $TV($C($EXPECT($L104, fail, 'LetOrConst "let"'), $EXPECT($L105, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function LetOrConst(state) {
@@ -3645,7 +3861,7 @@ var Civet = (() => {
           return LetOrConst$0(state);
         }
       }
-      var Loop$0 = $TS($S($EXPECT($L107, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Loop$0 = $TS($S($EXPECT($L106, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: "while(true)" };
       });
       function Loop(state) {
@@ -3657,7 +3873,7 @@ var Civet = (() => {
           return Loop$0(state);
         }
       }
-      var New$0 = $TV($EXPECT($L108, fail, 'New "new"'), function($skip, $loc, $0, $1) {
+      var New$0 = $TV($EXPECT($L107, fail, 'New "new"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function New(state) {
@@ -3669,7 +3885,7 @@ var Civet = (() => {
           return New$0(state);
         }
       }
-      var Of$0 = $TV($EXPECT($L109, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
+      var Of$0 = $TV($EXPECT($L108, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function Of(state) {
@@ -3681,7 +3897,7 @@ var Civet = (() => {
           return Of$0(state);
         }
       }
-      var OpenBrace$0 = $TV($EXPECT($L110, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
+      var OpenBrace$0 = $TV($EXPECT($L109, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function OpenBrace(state) {
@@ -3693,7 +3909,7 @@ var Civet = (() => {
           return OpenBrace$0(state);
         }
       }
-      var OpenBracket$0 = $TV($EXPECT($L111, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
+      var OpenBracket$0 = $TV($EXPECT($L110, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function OpenBracket(state) {
@@ -3705,7 +3921,7 @@ var Civet = (() => {
           return OpenBracket$0(state);
         }
       }
-      var OpenParen$0 = $TV($EXPECT($L112, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
+      var OpenParen$0 = $TV($EXPECT($L111, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function OpenParen(state) {
@@ -3717,7 +3933,7 @@ var Civet = (() => {
           return OpenParen$0(state);
         }
       }
-      var QuestionMark$0 = $TV($EXPECT($L113, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
+      var QuestionMark$0 = $TV($EXPECT($L112, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function QuestionMark(state) {
@@ -3729,7 +3945,7 @@ var Civet = (() => {
           return QuestionMark$0(state);
         }
       }
-      var Return$0 = $TS($S($EXPECT($L114, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Return$0 = $TS($S($EXPECT($L113, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Return(state) {
@@ -3753,7 +3969,7 @@ var Civet = (() => {
           return Semicolon$0(state);
         }
       }
-      var SingleQuote$0 = $TV($EXPECT($L115, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
+      var SingleQuote$0 = $TV($EXPECT($L114, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function SingleQuote(state) {
@@ -3777,10 +3993,10 @@ var Civet = (() => {
           return Star$0(state);
         }
       }
-      var Static$0 = $TV($EXPECT($L116, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
+      var Static$0 = $TV($EXPECT($L115, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
-      var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L112, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
+      var Static$1 = $TS($S($EXPECT($L9, fail, 'Static "@"'), $N($EXPECT($L111, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: "static " };
       });
       function Static(state) {
@@ -3790,7 +4006,7 @@ var Civet = (() => {
           return Static$0(state) || Static$1(state);
         }
       }
-      var SubstitutionStart$0 = $TV($EXPECT($L117, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
+      var SubstitutionStart$0 = $TV($EXPECT($L116, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function SubstitutionStart(state) {
@@ -3802,7 +4018,7 @@ var Civet = (() => {
           return SubstitutionStart$0(state);
         }
       }
-      var Switch$0 = $TS($S($EXPECT($L118, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var Switch$0 = $TS($S($EXPECT($L117, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function Switch(state) {
@@ -3814,7 +4030,7 @@ var Civet = (() => {
           return Switch$0(state);
         }
       }
-      var Target$0 = $TV($EXPECT($L119, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
+      var Target$0 = $TV($EXPECT($L118, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function Target(state) {
@@ -3826,6 +4042,18 @@ var Civet = (() => {
           return Target$0(state);
         }
       }
+      var Throw$0 = $TS($S($EXPECT($L119, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+        return { $loc, token: $1 };
+      });
+      function Throw(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Throw");
+        if (state.tokenize) {
+          return $TOKEN("Throw", state, Throw$0(state));
+        } else {
+          return Throw$0(state);
+        }
+      }
       var TripleDoubleQuote$0 = $TV($EXPECT($L120, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
         return { $loc, token: "`" };
       });
@@ -3986,7 +4214,7 @@ var Civet = (() => {
           return JSXElementName$0(state);
         }
       }
-      var JSXIdentifierName$0 = $R$0($EXPECT($R27, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
+      var JSXIdentifierName$0 = $R$0($EXPECT($R28, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
       function JSXIdentifierName(state) {
         if (state.verbose)
           console.log("ENTER:", "JSXIdentifierName");
@@ -4035,8 +4263,8 @@ var Civet = (() => {
           return JSXAttributeInitializer$0(state);
         }
       }
-      var JSXAttributeValue$0 = $R$0($EXPECT($R28, fail, 'JSXAttributeValue /"[^"]*"/'));
-      var JSXAttributeValue$1 = $R$0($EXPECT($R29, fail, "JSXAttributeValue /'[^']*'/"));
+      var JSXAttributeValue$0 = $R$0($EXPECT($R29, fail, 'JSXAttributeValue /"[^"]*"/'));
+      var JSXAttributeValue$1 = $R$0($EXPECT($R30, fail, "JSXAttributeValue /'[^']*'/"));
       var JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
       var JSXAttributeValue$3 = JSXElement;
       var JSXAttributeValue$4 = JSXFragment;
@@ -4068,7 +4296,7 @@ var Civet = (() => {
           return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
         }
       }
-      var JSXText$0 = $R$0($EXPECT($R30, fail, "JSXText /[^{}<>]+/"));
+      var JSXText$0 = $R$0($EXPECT($R31, fail, "JSXText /[^{}<>]+/"));
       function JSXText(state) {
         if (state.verbose)
           console.log("ENTER:", "JSXText");
@@ -4243,7 +4471,7 @@ var Civet = (() => {
           return NestedTypeDeclaration$0(state);
         }
       }
-      var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L136, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R32, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
+      var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R32, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L136, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R33, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
       function TypeIndexSignature(state) {
         if (state.verbose)
           console.log("ENTER:", "TypeIndexSignature");
@@ -4464,7 +4692,7 @@ var Civet = (() => {
           return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
         }
       }
-      var Shebang$0 = $S($R$0($EXPECT($R33, fail, "Shebang /#![^\\r\\n]*/")), EOL);
+      var Shebang$0 = $S($R$0($EXPECT($R34, fail, "Shebang /#![^\\r\\n]*/")), EOL);
       function Shebang(state) {
         if (state.verbose)
           console.log("ENTER:", "Shebang");
@@ -4474,7 +4702,7 @@ var Civet = (() => {
           return Shebang$0(state);
         }
       }
-      var DirectivePrologue$0 = $Q($S($R$0($EXPECT($R34, fail, "DirectivePrologue /[\\t ]*/")), StringLiteral, $TEXT(StatementDelimiter), EOS));
+      var DirectivePrologue$0 = $Q($S($R$0($EXPECT($R35, fail, "DirectivePrologue /[\\t ]*/")), StringLiteral, $TEXT(StatementDelimiter), EOS));
       function DirectivePrologue(state) {
         if (state.verbose)
           console.log("ENTER:", "DirectivePrologue");
@@ -4494,7 +4722,7 @@ var Civet = (() => {
           return EOS$0(state);
         }
       }
-      var EOL$0 = $R$0($EXPECT($R35, fail, "EOL /\\r\\n|\\n|\\r|$/"));
+      var EOL$0 = $R$0($EXPECT($R36, fail, "EOL /\\r\\n|\\n|\\r|$/"));
       function EOL(state) {
         if (state.verbose)
           console.log("ENTER:", "EOL");
@@ -4504,7 +4732,7 @@ var Civet = (() => {
           return EOL$0(state);
         }
       }
-      var EOF$0 = $R$0($EXPECT($R36, fail, "EOF /$/"));
+      var EOF$0 = $R$0($EXPECT($R37, fail, "EOF /$/"));
       function EOF(state) {
         if (state.verbose)
           console.log("ENTER:", "EOF");
@@ -4658,15 +4886,103 @@ var Civet = (() => {
           return InsertBreak$0(state);
         }
       }
-      var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
-        var directives = $2;
+      var Reset$0 = $TV($EXPECT($L1, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
         module.currentIndent = 0;
         module.indentLevels = [0];
         module.verbose = false;
+        module.coffeeCompat = false;
+        module.implicitReturns = true;
+      });
+      function Reset(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Reset");
+        if (state.tokenize) {
+          return $TOKEN("Reset", state, Reset$0(state));
+        } else {
+          return Reset$0(state);
+        }
+      }
+      var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
+        var directives = $2;
         if (directives) {
           const compatRe = /use coffee-compat/;
           module.coffeeCompat = directives.some((d) => d[1].token?.match(compatRe));
         }
+        function hasReturnStatement(node) {
+          if (!node)
+            return false;
+          if (Array.isArray(node))
+            return node.some(hasReturnStatement);
+          if (node.type === "ReturnStatement")
+            return true;
+          if (node.type === "FunctionExpression")
+            return false;
+          if (node.children)
+            return hasReturnStatement(node.children);
+          return false;
+        }
+        function insertReturn(node) {
+          if (!node)
+            return;
+          switch (node.type) {
+            case "AssignmentExpression":
+              node.children.unshift("return ");
+              return;
+            case "BlockStatement":
+              insertReturn(node.expressions[node.expressions.length - 1]);
+              return;
+            case "CaseBlock":
+              node.clauses.forEach((clause) => {
+                insertReturn(clause);
+              });
+              return;
+            case "CaseClause":
+              return;
+            case "WhenClause":
+              node.children.pop();
+              insertReturn(node.expressions[node.expressions.length - 1]);
+              return;
+            case "DefaultClause":
+              insertReturn(node.expressions[node.expressions.length - 1]);
+              return;
+          }
+          if (!Array.isArray(node))
+            return;
+          const [, exp] = node;
+          debugger;
+          if (!exp)
+            return;
+          switch (exp.type) {
+            case "BreakStatement":
+            case "ContinueStatement":
+            case "DebuggerStatement":
+            case "EmptyStatement":
+            case "IterationStatement":
+            case "ThrowStatement":
+            case "VariableDeclaration":
+              return;
+            case "IfStatement":
+              debugger;
+              insertReturn(exp.children[2]);
+              if (exp.children[3])
+                insertReturn(exp.children[3][2]);
+              return;
+            case "SwitchStatement":
+              insertReturn(exp.children[2]);
+              return;
+            case "TryStatement":
+              insertReturn(exp.children[1]);
+              insertReturn(exp.children[2][3]);
+              return;
+          }
+          node.splice(1, 0, "return ");
+        }
+        module.addImplicitReturns = function(block) {
+          if (hasReturnStatement(block))
+            return block;
+          insertReturn(block);
+          return block;
+        };
         module.parsePosition = function() {
           let s = Error().stack.split(/\n    at /);
           s.shift();
@@ -4674,6 +4990,25 @@ var Civet = (() => {
           s = s.slice(1, s.indexOf("Program") + 1);
           return s;
         };
+        module.prune = function(node) {
+          if (node === null || node === void 0)
+            return;
+          if (node.length === 0)
+            return;
+          if (Array.isArray(node)) {
+            const a = node.map((n) => module.prune(n)).filter((n) => !!n);
+            if (a.length > 1)
+              return a;
+            if (a.length === 1)
+              return a[0];
+            return;
+          }
+          if (node.children != null) {
+            node.children = module.prune(node.children);
+            return node;
+          }
+          return node;
+        };
         module.insertTrimmingSpace = function(spacing, c) {
           let target = spacing;
           while (Array.isArray(target)) {
@@ -4730,7 +5065,7 @@ var Civet = (() => {
           if (trim) {
             str = str.replace(/^(\r?\n|\n)/, "").replace(/(\r?\n|\n)[ \t]*$/, "");
           }
-          str = str.replace(/(`|\$)/g, "\\$1");
+          str = str.replace(/(`|\$\{)/g, "\\$1");
           return {
             $loc: $loc2,
             token: str
@@ -4943,7 +5278,7 @@ var Civet = (() => {
           return;
         }
         if (node.children != null) {
-          node.children = prune(node.children);
+          node.children = prune(node.children) || [];
           return node;
         }
         return node;