@danielx/civet 0.4.6 → 0.4.8

package/dist/browser.js

@@ -456,6 +456,7 @@ var Civet = (() => {
         SuperProperty,
         MetaProperty,
         Parameters,
+        NonEmptyParameters,
         ParameterElement,
         ParameterElementDelimiter,
         BindingIdentifier,
@@ -476,6 +477,7 @@ var Civet = (() => {
         Arrow,
         Block,
         BracedOrEmptyBlock,
+        EmptyBlock,
         BracedBlock,
         SingleNestedExpression,
         NestedBlockExpressions,
@@ -535,6 +537,7 @@ var Civet = (() => {
         NestedCaseClause,
         CaseClause,
         CaseExpressionList,
+        NoExpressions,
         ImpliedColon,
         TryStatement,
         CatchClause,
@@ -655,6 +658,7 @@ var Civet = (() => {
         SubstitutionStart,
         Switch,
         Target,
+        Throw,
         TripleDoubleQuote,
         TripleSingleQuote,
         TripleTick,
@@ -821,46 +825,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 +946,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 +1031,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 +1065,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 +1109,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 +1133,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 +1149,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) {
@@ -1157,7 +1181,19 @@ var Civet = (() => {
         }
       }
       var ArrowFunction$0 = ThinArrowFunction;
-      var ArrowFunction$1 = $S(Parameters, $E(ReturnTypeSuffix), FatArrow, FatArrowBody);
+      var ArrowFunction$1 = $TS($S(Parameters, $E(ReturnTypeSuffix), FatArrow, FatArrowBody), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var suffix = $2;
+        var expOrBlock = $4;
+        const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
+        const isBlock = expOrBlock.type === "BlockStatement";
+        if (module.implicitReturns && !isVoid && isBlock) {
+          module.addImplicitReturns(expOrBlock);
+        }
+        return {
+          type: "FunctionExpression",
+          children: $0
+        };
+      });
       function ArrowFunction(state) {
         if (state.tokenize) {
           return $TOKEN("ArrowFunction", state, ArrowFunction$0(state) || ArrowFunction$1(state));
@@ -1180,11 +1216,17 @@ var Civet = (() => {
           return FatArrow$0(state);
         }
       }
-      var FatArrowBody$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
-      var FatArrowBody$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
+      var FatArrowBody$0 = $T($S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace), function(value) {
+        var exps = value[3];
+        return { "type": "BlockStatement", "expressions": exps, "children": value };
+      });
+      var FatArrowBody$1 = $T($S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace), function(value) {
+        var exps = value[2];
+        return { "type": "BlockStatement", "expressions": exps, "children": value };
+      });
       var FatArrowBody$2 = AssignmentExpression;
       var FatArrowBody$3 = $S(__, AssignmentExpression);
-      var FatArrowBody$4 = $S(InsertOpenBrace, InsertCloseBrace);
+      var FatArrowBody$4 = EmptyBlock;
       function FatArrowBody(state) {
         if (state.tokenize) {
           return $TOKEN("FatArrowBody", state, FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state) || FatArrowBody$4(state));
@@ -1192,7 +1234,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 +1427,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 +1481,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) {
@@ -1488,7 +1542,7 @@ var Civet = (() => {
           return MetaProperty$0(state) || MetaProperty$1(state);
         }
       }
-      var Parameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), __, CloseParen);
+      var Parameters$0 = NonEmptyParameters;
       var Parameters$1 = $TV($EXPECT($L1, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
         return { $loc, token: "()" };
       });
@@ -1499,6 +1553,16 @@ var Civet = (() => {
           return Parameters$0(state) || Parameters$1(state);
         }
       }
+      var NonEmptyParameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), __, CloseParen);
+      function NonEmptyParameters(state) {
+        if (state.verbose)
+          console.log("ENTER:", "NonEmptyParameters");
+        if (state.tokenize) {
+          return $TOKEN("NonEmptyParameters", state, NonEmptyParameters$0(state));
+        } else {
+          return NonEmptyParameters$0(state);
+        }
+      }
       var ParameterElement$0 = $S(__, $C(BindingIdentifier, BindingPattern), $E(TypeSuffix), $E(Initializer), ParameterElementDelimiter);
       function ParameterElement(state) {
         if (state.verbose)
@@ -1667,7 +1731,18 @@ 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 = $TS($S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
+        var suffix = $7;
+        var block = $8;
+        const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
+        if (module.implicitReturns && !isVoid) {
+          module.addImplicitReturns(block);
+        }
+        return {
+          type: "FunctionExpression",
+          children: $0
+        };
+      });
       function FunctionExpression(state) {
         if (state.tokenize) {
           return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1675,17 +1750,24 @@ 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
-        ];
+        const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
+        if (module.implicitReturns && !isVoid) {
+          block = module.addImplicitReturns(block);
+        }
+        return {
+          type: "FunctionExpression",
+          children: [
+            { $loc: arrow.$loc, token: "function" },
+            params,
+            suffix,
+            block
+          ]
+        };
       });
       function ThinArrowFunction(state) {
         if (state.verbose)
@@ -1708,8 +1790,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 +1808,7 @@ var Civet = (() => {
         }
       }
       var BracedOrEmptyBlock$0 = BracedBlock;
-      var BracedOrEmptyBlock$1 = $S(InsertOpenBrace, InsertCloseBrace);
+      var BracedOrEmptyBlock$1 = EmptyBlock;
       function BracedOrEmptyBlock(state) {
         if (state.tokenize) {
           return $TOKEN("BracedOrEmptyBlock", state, BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state));
@@ -1728,9 +1816,34 @@ 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 EmptyBlock$0 = $T($S(InsertOpenBrace, InsertCloseBrace), function(value) {
+        return { "type": "BlockStatement", "expressions": [], "children": value };
+      });
+      function EmptyBlock(state) {
+        if (state.verbose)
+          console.log("ENTER:", "EmptyBlock");
+        if (state.tokenize) {
+          return $TOKEN("EmptyBlock", state, EmptyBlock$0(state));
+        } else {
+          return EmptyBlock$0(state);
+        }
+      }
+      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 +1938,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");
@@ -2036,7 +2151,17 @@ var Civet = (() => {
           return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
         }
       }
-      var MethodDefinition$0 = $S(MethodSignature, BracedBlock);
+      var MethodDefinition$0 = $TS($S(MethodSignature, BracedBlock), function($skip, $loc, $0, $1, $2) {
+        var sig = $1;
+        var block = $2;
+        const isConstructor = sig.name === "constructor";
+        const isVoid = sig.returnType === "void";
+        const isSet = sig.modifier === "set";
+        if (module.implicitReturns && !isConstructor && !isSet && !isVoid) {
+          block = module.addImplicitReturns(block);
+        }
+        return $0;
+      });
       function MethodDefinition(state) {
         if (state.verbose)
           console.log("ENTER:", "MethodDefinition");
@@ -2057,8 +2182,26 @@ var Civet = (() => {
           return MethodModifier$0(state) || MethodModifier$1(state) || MethodModifier$2(state) || MethodModifier$3(state);
         }
       }
-      var MethodSignature$0 = $S(ConstructorShorthand, Parameters);
-      var MethodSignature$1 = $S($E(MethodModifier), ClassElementName, $Q(_), Parameters);
+      var MethodSignature$0 = $TS($S(ConstructorShorthand, Parameters), function($skip, $loc, $0, $1, $2) {
+        return {
+          type: "MethodSignature",
+          children: $0,
+          name: $1.token,
+          returnType: void 0
+        };
+      });
+      var MethodSignature$1 = $TS($S($E(MethodModifier), ClassElementName, $Q(_), NonEmptyParameters, $E(ReturnTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+        var name = $2;
+        var suffix = $5;
+        name = name.token.match(/^(?:"|')/) ? name.token.slice(1, -1) : name.token;
+        return {
+          type: "MethodSignature",
+          children: $0,
+          name,
+          modifier: $1?.[0]?.token,
+          returnType: void 0
+        };
+      });
       function MethodSignature(state) {
         if (state.tokenize) {
           return $TOKEN("MethodSignature", state, MethodSignature$0(state) || MethodSignature$1(state));
@@ -2075,7 +2218,12 @@ var Civet = (() => {
           return ClassElementName$0(state) || ClassElementName$1(state);
         }
       }
-      var PrivateIdentifier$0 = $S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName);
+      var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
+        return {
+          $loc,
+          token: $1
+        };
+      });
       function PrivateIdentifier(state) {
         if (state.verbose)
           console.log("ENTER:", "PrivateIdentifier");
@@ -2213,8 +2361,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 +2416,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 +2438,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 +2454,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 +2469,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 +2482,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 +2494,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 +2506,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 +2577,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 +2589,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 +2629,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 +2642,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 +2689,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 +2713,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 +2748,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 +2822,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 +2853,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 +2991,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 +3051,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 +3061,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 +3073,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 +3104,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 +3487,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 +3511,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 +3523,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 +3632,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 +3644,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 +3656,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 +3668,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 +3680,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 +3692,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 +3740,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 +3752,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 +3776,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 +3788,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 +3800,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 +3812,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 +3836,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 +3848,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 +3860,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 +3872,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 +3884,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 +3896,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 +3932,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 +3944,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 +3956,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 +3968,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 +3980,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 +3992,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 +4004,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 +4016,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 +4028,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 +4052,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 +4076,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 +4089,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 +4101,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 +4113,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 +4125,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: "`" };
       });
@@ -4244,7 +4496,7 @@ var Civet = (() => {
         }
       }
       var InterfaceProperty$0 = $S($C(TypeIndexSignature, PropertyName), TypeSuffix, InterfacePropertyDelimiter);
-      var InterfaceProperty$1 = $S(MethodSignature, $E(TypeSuffix));
+      var InterfaceProperty$1 = MethodSignature;
       function InterfaceProperty(state) {
         if (state.tokenize) {
           return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state));
@@ -4322,7 +4574,7 @@ var Civet = (() => {
         }
       }
       var TypeSuffix$0 = $T($S($E(QuestionMark), __, Colon, Type), function(value) {
-        return { "ts": true, "children": value };
+        return { "type": "TypeSuffix", "ts": true, "children": value };
       });
       function TypeSuffix(state) {
         if (state.verbose)
@@ -4333,8 +4585,16 @@ var Civet = (() => {
           return TypeSuffix$0(state);
         }
       }
-      var ReturnTypeSuffix$0 = $T($S(__, Colon, $E($S(__, $EXPECT($L137, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
-        return { "ts": true, "children": value };
+      var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L137, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
+        if (!$3)
+          $0.splice(2, 1);
+        if ($1.length === 0)
+          $0.shift();
+        return {
+          type: "ReturnTypeAnnotation",
+          children: $0,
+          ts: true
+        };
       });
       function ReturnTypeSuffix(state) {
         if (state.verbose)
@@ -4345,7 +4605,11 @@ var Civet = (() => {
           return ReturnTypeSuffix$0(state);
         }
       }
-      var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L56, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
+      var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L56, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
+        if (!$2)
+          return $1;
+        return $0;
+      });
       function TypePredicate(state) {
         if (state.verbose)
           console.log("ENTER:", "TypePredicate");
@@ -4365,7 +4629,11 @@ var Civet = (() => {
           return Type$0(state);
         }
       }
-      var TypeBinary$0 = $S(TypeUnary, $Q($S(__, TypeBinaryOp, __, TypeUnary)));
+      var TypeBinary$0 = $TS($S(TypeUnary, $Q($S(__, TypeBinaryOp, __, TypeUnary))), function($skip, $loc, $0, $1, $2) {
+        if ($2.length)
+          return $0;
+        return $1;
+      });
       function TypeBinary(state) {
         if (state.verbose)
           console.log("ENTER:", "TypeBinary");
@@ -4375,7 +4643,13 @@ var Civet = (() => {
           return TypeBinary$0(state);
         }
       }
-      var TypeUnary$0 = $S($Q($S(__, TypeUnaryOp, NonIdContinue)), TypePrimary, $Q(TypeUnarySuffix));
+      var TypeUnary$0 = $TS($S($Q($S(__, TypeUnaryOp, NonIdContinue)), TypePrimary, $Q(TypeUnarySuffix)), function($skip, $loc, $0, $1, $2, $3) {
+        if (!$3.length)
+          $0.pop();
+        if (!$1.length)
+          $0.shift();
+        return $0;
+      });
       function TypeUnary(state) {
         if (state.verbose)
           console.log("ENTER:", "TypeUnary");
@@ -4418,8 +4692,8 @@ var Civet = (() => {
       var TypePrimary$0 = InterfaceBlock;
       var TypePrimary$1 = $S(__, OpenParen, Type, __, CloseParen);
       var TypePrimary$2 = $S($Q(_), FunctionType);
-      var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
-      var TypePrimary$4 = $S($Q(_), TypeLiteral);
+      var TypePrimary$3 = $S($Q(_), TypeLiteral);
+      var TypePrimary$4 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
       function TypePrimary(state) {
         if (state.tokenize) {
           return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state));
@@ -4427,7 +4701,11 @@ var Civet = (() => {
           return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
         }
       }
-      var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type)))));
+      var TypeConditional$0 = $TS($S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type))))), function($skip, $loc, $0, $1, $2) {
+        if ($2)
+          return $0;
+        return $1;
+      });
       function TypeConditional(state) {
         if (state.verbose)
           console.log("ENTER:", "TypeConditional");
@@ -4438,8 +4716,12 @@ var Civet = (() => {
         }
       }
       var TypeLiteral$0 = Literal;
-      var TypeLiteral$1 = $EXPECT($L70, fail, 'TypeLiteral "void"');
-      var TypeLiteral$2 = $EXPECT($L140, fail, 'TypeLiteral "[]"');
+      var TypeLiteral$1 = $TV($EXPECT($L70, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "void" };
+      });
+      var TypeLiteral$2 = $TV($EXPECT($L140, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "[]" };
+      });
       function TypeLiteral(state) {
         if (state.tokenize) {
           return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
@@ -4447,8 +4729,12 @@ var Civet = (() => {
           return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
         }
       }
-      var TypeBinaryOp$0 = $EXPECT($L68, fail, 'TypeBinaryOp "|"');
-      var TypeBinaryOp$1 = $EXPECT($L66, fail, 'TypeBinaryOp "&"');
+      var TypeBinaryOp$0 = $TV($EXPECT($L68, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "|" };
+      });
+      var TypeBinaryOp$1 = $TV($EXPECT($L66, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "&" };
+      });
       function TypeBinaryOp(state) {
         if (state.tokenize) {
           return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -4722,6 +5008,7 @@ var Civet = (() => {
         module.indentLevels = [0];
         module.verbose = false;
         module.coffeeCompat = false;
+        module.implicitReturns = true;
       });
       function Reset(state) {
         if (state.verbose)
@@ -4738,6 +5025,79 @@ 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;
+          if (!exp)
+            return;
+          switch (exp.type) {
+            case "BreakStatement":
+            case "ContinueStatement":
+            case "DebuggerStatement":
+            case "EmptyStatement":
+            case "IterationStatement":
+            case "ThrowStatement":
+            case "VariableDeclaration":
+              return;
+            case "IfStatement":
+              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 +5105,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 +5393,7 @@ var Civet = (() => {
           return;
         }
         if (node.children != null) {
-          node.children = prune(node.children);
+          node.children = prune(node.children) || [];
           return node;
         }
         return node;