@danielx/civet 0.4.6 → 0.4.7

package/dist/browser.js

@@ -535,6 +535,7 @@ var Civet = (() => {
         NestedCaseClause,
         CaseClause,
         CaseExpressionList,
+        NoExpressions,
         ImpliedColon,
         TryStatement,
         CatchClause,
@@ -655,6 +656,7 @@ var Civet = (() => {
         SubstitutionStart,
         Switch,
         Target,
+        Throw,
         TripleDoubleQuote,
         TripleSingleQuote,
         TripleTick,
@@ -821,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("```");
@@ -942,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");
@@ -1023,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));
@@ -1055,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");
@@ -1095,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));
@@ -1115,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) {
@@ -1127,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) {
@@ -1192,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");
@@ -1381,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));
@@ -1431,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) {
@@ -1667,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));
@@ -1675,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)
@@ -1708,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) {
@@ -1720,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));
@@ -1728,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));
@@ -1825,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");
@@ -2213,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)
@@ -2269,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");
@@ -2289,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;
@@ -2303,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) {
@@ -2315,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));
@@ -2324,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");
@@ -2334,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");
@@ -2344,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");
@@ -2413,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");
@@ -2423,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));
@@ -2447,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");
@@ -2457,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) {
@@ -2486,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: ":" };
@@ -2498,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)
@@ -2525,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));
@@ -2599,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));
@@ -2620,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);
@@ -2758,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) {
@@ -2818,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;
@@ -2826,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) {
@@ -2835,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) {
@@ -2866,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");
@@ -3247,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($R21, 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) {
@@ -3271,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($R21, 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) {
@@ -3283,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($R23, 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) {
@@ -3392,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) {
@@ -3404,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) {
@@ -3416,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) {
@@ -3428,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) {
@@ -3440,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) {
@@ -3452,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) {
@@ -3500,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) {
@@ -3512,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) {
@@ -3536,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) {
@@ -3548,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) {
@@ -3560,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) {
@@ -3572,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) {
@@ -3596,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) {
@@ -3608,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) {
@@ -3620,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) {
@@ -3632,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) {
@@ -3644,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) {
@@ -3656,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) {
@@ -3692,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) {
@@ -3704,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) {
@@ -3716,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) {
@@ -3728,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) {
@@ -3740,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) {
@@ -3752,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) {
@@ -3764,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) {
@@ -3776,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) {
@@ -3788,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) {
@@ -3812,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) {
@@ -3836,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) {
@@ -3849,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) {
@@ -3861,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) {
@@ -3873,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) {
@@ -3885,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: "`" };
       });
@@ -4722,6 +4891,7 @@ var Civet = (() => {
         module.indentLevels = [0];
         module.verbose = false;
         module.coffeeCompat = false;
+        module.implicitReturns = true;
       });
       function Reset(state) {
         if (state.verbose)
@@ -4738,6 +4908,81 @@ var Civet = (() => {
           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();
@@ -4745,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)) {
@@ -5014,7 +5278,7 @@ var Civet = (() => {
           return;
         }
         if (node.children != null) {
-          node.children = prune(node.children);
+          node.children = prune(node.children) || [];
           return node;
         }
         return node;