@danielx/civet 0.4.6 → 0.4.8

package/dist/main.js

@@ -455,6 +455,7 @@ var require_parser = __commonJS({
       SuperProperty,
       MetaProperty,
       Parameters,
+      NonEmptyParameters,
       ParameterElement,
       ParameterElementDelimiter,
       BindingIdentifier,
@@ -475,6 +476,7 @@ var require_parser = __commonJS({
       Arrow,
       Block,
       BracedOrEmptyBlock,
+      EmptyBlock,
       BracedBlock,
       SingleNestedExpression,
       NestedBlockExpressions,
@@ -534,6 +536,7 @@ var require_parser = __commonJS({
       NestedCaseClause,
       CaseClause,
       CaseExpressionList,
+      NoExpressions,
       ImpliedColon,
       TryStatement,
       CatchClause,
@@ -654,6 +657,7 @@ var require_parser = __commonJS({
       SubstitutionStart,
       Switch,
       Target,
+      Throw,
       TripleDoubleQuote,
       TripleSingleQuote,
       TripleTick,
@@ -820,46 +824,46 @@ var require_parser = __commonJS({
     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("```");
@@ -941,7 +945,11 @@ var require_parser = __commonJS({
         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");
@@ -1022,7 +1030,9 @@ var require_parser = __commonJS({
       var spacing = $2;
       return module2.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));
@@ -1054,7 +1064,11 @@ var require_parser = __commonJS({
         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");
@@ -1094,7 +1108,11 @@ var require_parser = __commonJS({
       }
     }
     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));
@@ -1114,7 +1132,11 @@ var require_parser = __commonJS({
         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) {
@@ -1126,7 +1148,9 @@ var require_parser = __commonJS({
     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) {
@@ -1156,7 +1180,19 @@ var require_parser = __commonJS({
       }
     }
     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 (module2.implicitReturns && !isVoid && isBlock) {
+        module2.addImplicitReturns(expOrBlock);
+      }
+      return {
+        type: "FunctionExpression",
+        children: $0
+      };
+    });
     function ArrowFunction(state) {
       if (state.tokenize) {
         return $TOKEN("ArrowFunction", state, ArrowFunction$0(state) || ArrowFunction$1(state));
@@ -1179,11 +1215,17 @@ var require_parser = __commonJS({
         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));
@@ -1191,7 +1233,11 @@ var require_parser = __commonJS({
         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");
@@ -1380,7 +1426,11 @@ var require_parser = __commonJS({
     }
     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));
@@ -1430,7 +1480,11 @@ var require_parser = __commonJS({
         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) {
@@ -1487,7 +1541,7 @@ var require_parser = __commonJS({
         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: "()" };
     });
@@ -1498,6 +1552,16 @@ var require_parser = __commonJS({
         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)
@@ -1666,7 +1730,18 @@ var require_parser = __commonJS({
       }
     }
     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 (module2.implicitReturns && !isVoid) {
+        module2.addImplicitReturns(block);
+      }
+      return {
+        type: "FunctionExpression",
+        children: $0
+      };
+    });
     function FunctionExpression(state) {
       if (state.tokenize) {
         return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1674,17 +1749,24 @@ var require_parser = __commonJS({
         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 (module2.implicitReturns && !isVoid) {
+        block = module2.addImplicitReturns(block);
+      }
+      return {
+        type: "FunctionExpression",
+        children: [
+          { $loc: arrow.$loc, token: "function" },
+          params,
+          suffix,
+          block
+        ]
+      };
     });
     function ThinArrowFunction(state) {
       if (state.verbose)
@@ -1707,8 +1789,14 @@ var require_parser = __commonJS({
         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) {
@@ -1719,7 +1807,7 @@ var require_parser = __commonJS({
       }
     }
     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));
@@ -1727,9 +1815,34 @@ var require_parser = __commonJS({
         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));
@@ -1824,7 +1937,9 @@ var require_parser = __commonJS({
         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");
@@ -2035,7 +2150,17 @@ var require_parser = __commonJS({
         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 (module2.implicitReturns && !isConstructor && !isSet && !isVoid) {
+        block = module2.addImplicitReturns(block);
+      }
+      return $0;
+    });
     function MethodDefinition(state) {
       if (state.verbose)
         console.log("ENTER:", "MethodDefinition");
@@ -2056,8 +2181,26 @@ var require_parser = __commonJS({
         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));
@@ -2074,7 +2217,12 @@ var require_parser = __commonJS({
         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");
@@ -2212,8 +2360,7 @@ var require_parser = __commonJS({
       var l = $3;
       if (cond)
         return [cond, statement, { $loc: l.$loc, token: "}" }];
-      $0.pop();
-      return $0;
+      return statement;
     });
     function StatementListItem(state) {
       if (state.verbose)
@@ -2268,7 +2415,9 @@ var require_parser = __commonJS({
         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");
@@ -2288,7 +2437,9 @@ var require_parser = __commonJS({
         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;
@@ -2302,7 +2453,10 @@ var require_parser = __commonJS({
           c.token = "))";
       });
       kind.token = "if";
-      return [kind, condition, block];
+      return {
+        type: "IfStatement",
+        children: [kind, condition, block]
+      };
     });
     function IfStatement(state) {
       if (state.tokenize) {
@@ -2314,8 +2468,12 @@ var require_parser = __commonJS({
     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));
@@ -2323,7 +2481,9 @@ var require_parser = __commonJS({
         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");
@@ -2333,7 +2493,9 @@ var require_parser = __commonJS({
         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");
@@ -2343,7 +2505,9 @@ var require_parser = __commonJS({
         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");
@@ -2412,7 +2576,9 @@ var require_parser = __commonJS({
         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");
@@ -2422,8 +2588,24 @@ var require_parser = __commonJS({
         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));
@@ -2446,7 +2628,10 @@ var require_parser = __commonJS({
         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");
@@ -2456,14 +2641,32 @@ var require_parser = __commonJS({
         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) {
@@ -2485,6 +2688,18 @@ var require_parser = __commonJS({
         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: ":" };
@@ -2497,12 +2712,20 @@ var require_parser = __commonJS({
       }
     }
     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)
@@ -2524,7 +2747,7 @@ var require_parser = __commonJS({
       }
     }
     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));
@@ -2598,11 +2821,21 @@ var require_parser = __commonJS({
         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));
@@ -2619,7 +2852,7 @@ var require_parser = __commonJS({
         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);
@@ -2757,7 +2990,7 @@ var require_parser = __commonJS({
         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) {
@@ -2817,7 +3050,9 @@ var require_parser = __commonJS({
         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;
@@ -2825,7 +3060,10 @@ var require_parser = __commonJS({
         pos: ca.$loc.pos - 1,
         length: ca.$loc.length + 1
       };
-      return $0;
+      return {
+        type: "VariableDeclaration",
+        children: $0
+      };
     });
     function LexicalDeclaration(state) {
       if (state.tokenize) {
@@ -2834,7 +3072,7 @@ var require_parser = __commonJS({
         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) {
@@ -2865,7 +3103,9 @@ var require_parser = __commonJS({
         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");
@@ -3246,7 +3486,7 @@ var require_parser = __commonJS({
         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) {
@@ -3270,7 +3510,7 @@ var require_parser = __commonJS({
         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) {
@@ -3282,7 +3522,7 @@ var require_parser = __commonJS({
         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) {
@@ -3391,7 +3631,7 @@ var require_parser = __commonJS({
         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) {
@@ -3403,7 +3643,7 @@ var require_parser = __commonJS({
         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) {
@@ -3415,7 +3655,7 @@ var require_parser = __commonJS({
         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) {
@@ -3427,7 +3667,7 @@ var require_parser = __commonJS({
         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) {
@@ -3439,7 +3679,7 @@ var require_parser = __commonJS({
         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) {
@@ -3451,7 +3691,7 @@ var require_parser = __commonJS({
         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) {
@@ -3499,7 +3739,7 @@ var require_parser = __commonJS({
         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) {
@@ -3511,7 +3751,7 @@ var require_parser = __commonJS({
         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) {
@@ -3535,7 +3775,7 @@ var require_parser = __commonJS({
         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) {
@@ -3547,7 +3787,7 @@ var require_parser = __commonJS({
         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) {
@@ -3559,7 +3799,7 @@ var require_parser = __commonJS({
         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) {
@@ -3571,7 +3811,7 @@ var require_parser = __commonJS({
         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) {
@@ -3595,7 +3835,7 @@ var require_parser = __commonJS({
         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) {
@@ -3607,7 +3847,7 @@ var require_parser = __commonJS({
         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) {
@@ -3619,7 +3859,7 @@ var require_parser = __commonJS({
         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) {
@@ -3631,7 +3871,7 @@ var require_parser = __commonJS({
         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) {
@@ -3643,7 +3883,7 @@ var require_parser = __commonJS({
         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) {
@@ -3655,7 +3895,7 @@ var require_parser = __commonJS({
         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) {
@@ -3691,7 +3931,7 @@ var require_parser = __commonJS({
         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) {
@@ -3703,7 +3943,7 @@ var require_parser = __commonJS({
         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) {
@@ -3715,7 +3955,7 @@ var require_parser = __commonJS({
         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) {
@@ -3727,7 +3967,7 @@ var require_parser = __commonJS({
         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) {
@@ -3739,7 +3979,7 @@ var require_parser = __commonJS({
         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) {
@@ -3751,7 +3991,7 @@ var require_parser = __commonJS({
         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) {
@@ -3763,7 +4003,7 @@ var require_parser = __commonJS({
         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) {
@@ -3775,7 +4015,7 @@ var require_parser = __commonJS({
         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) {
@@ -3787,7 +4027,7 @@ var require_parser = __commonJS({
         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) {
@@ -3811,7 +4051,7 @@ var require_parser = __commonJS({
         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) {
@@ -3835,10 +4075,10 @@ var require_parser = __commonJS({
         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) {
@@ -3848,7 +4088,7 @@ var require_parser = __commonJS({
         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) {
@@ -3860,7 +4100,7 @@ var require_parser = __commonJS({
         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) {
@@ -3872,7 +4112,7 @@ var require_parser = __commonJS({
         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) {
@@ -3884,6 +4124,18 @@ var require_parser = __commonJS({
         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: "`" };
     });
@@ -4243,7 +4495,7 @@ var require_parser = __commonJS({
       }
     }
     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));
@@ -4321,7 +4573,7 @@ var require_parser = __commonJS({
       }
     }
     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)
@@ -4332,8 +4584,16 @@ var require_parser = __commonJS({
         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)
@@ -4344,7 +4604,11 @@ var require_parser = __commonJS({
         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");
@@ -4364,7 +4628,11 @@ var require_parser = __commonJS({
         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");
@@ -4374,7 +4642,13 @@ var require_parser = __commonJS({
         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");
@@ -4417,8 +4691,8 @@ var require_parser = __commonJS({
     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));
@@ -4426,7 +4700,11 @@ var require_parser = __commonJS({
         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");
@@ -4437,8 +4715,12 @@ var require_parser = __commonJS({
       }
     }
     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));
@@ -4446,8 +4728,12 @@ var require_parser = __commonJS({
         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));
@@ -4721,6 +5007,7 @@ var require_parser = __commonJS({
       module2.indentLevels = [0];
       module2.verbose = false;
       module2.coffeeCompat = false;
+      module2.implicitReturns = true;
     });
     function Reset(state) {
       if (state.verbose)
@@ -4737,6 +5024,79 @@ var require_parser = __commonJS({
         const compatRe = /use coffee-compat/;
         module2.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 ");
+      }
+      module2.addImplicitReturns = function(block) {
+        if (hasReturnStatement(block))
+          return block;
+        insertReturn(block);
+        return block;
+      };
       module2.parsePosition = function() {
         let s = Error().stack.split(/\n    at /);
         s.shift();
@@ -4744,6 +5104,25 @@ var require_parser = __commonJS({
         s = s.slice(1, s.indexOf("Program") + 1);
         return s;
       };
+      module2.prune = function(node) {
+        if (node === null || node === void 0)
+          return;
+        if (node.length === 0)
+          return;
+        if (Array.isArray(node)) {
+          const a = node.map((n) => module2.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 = module2.prune(node.children);
+          return node;
+        }
+        return node;
+      };
       module2.insertTrimmingSpace = function(spacing, c) {
         let target = spacing;
         while (Array.isArray(target)) {
@@ -5013,7 +5392,7 @@ var require_generate = __commonJS({
         return;
       }
       if (node.children != null) {
-        node.children = prune2(node.children);
+        node.children = prune2(node.children) || [];
         return node;
       }
       return node;