@danielx/civet 0.4.7 → 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,
@@ -1179,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));
@@ -1202,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));
@@ -1522,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: "()" };
       });
@@ -1533,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)
@@ -1701,8 +1731,17 @@ var Civet = (() => {
         }
       }
       var FunctionExpression$0 = ThinArrowFunction;
-      var FunctionExpression$1 = $T($S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock), function(value) {
-        return { "type": "FunctionExpression", "children": value };
+      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) {
@@ -1716,7 +1755,8 @@ var Civet = (() => {
         var suffix = $2;
         var arrow = $4;
         var block = $5;
-        if (module.implicitReturns && suffix?.children[3] !== "void") {
+        const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
+        if (module.implicitReturns && !isVoid) {
           block = module.addImplicitReturns(block);
         }
         return {
@@ -1768,9 +1808,7 @@ var Civet = (() => {
         }
       }
       var BracedOrEmptyBlock$0 = BracedBlock;
-      var BracedOrEmptyBlock$1 = $T($S(InsertOpenBrace, InsertCloseBrace), function(value) {
-        return { "type": "BlockStatement", "expressions": [], "children": value };
-      });
+      var BracedOrEmptyBlock$1 = EmptyBlock;
       function BracedOrEmptyBlock(state) {
         if (state.tokenize) {
           return $TOKEN("BracedOrEmptyBlock", state, BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state));
@@ -1778,6 +1816,18 @@ var Civet = (() => {
           return BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state);
         }
       }
+      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 };
@@ -2101,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");
@@ -2122,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));
@@ -2140,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");
@@ -4413,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));
@@ -4491,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)
@@ -4502,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)
@@ -4514,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");
@@ -4534,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");
@@ -4544,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");
@@ -4587,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));
@@ -4596,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");
@@ -4607,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));
@@ -4616,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));
@@ -4949,7 +5066,6 @@ var Civet = (() => {
           if (!Array.isArray(node))
             return;
           const [, exp] = node;
-          debugger;
           if (!exp)
             return;
           switch (exp.type) {
@@ -4962,7 +5078,6 @@ var Civet = (() => {
             case "VariableDeclaration":
               return;
             case "IfStatement":
-              debugger;
               insertReturn(exp.children[2]);
               if (exp.children[3])
                 insertReturn(exp.children[3][2]);

package/dist/esbuild-plugin.js

@@ -7,7 +7,7 @@ const { compile } = require("../dist/main.js");
 module.exports = {
   name: 'civet',
   setup(build) {
-    build.onLoad({
+    return build.onLoad({
       filter: /\.civet$/
     }, async function(args) {
       try {

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,
@@ -1178,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));
@@ -1201,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));
@@ -1521,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: "()" };
     });
@@ -1532,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)
@@ -1700,8 +1730,17 @@ var require_parser = __commonJS({
       }
     }
     var FunctionExpression$0 = ThinArrowFunction;
-    var FunctionExpression$1 = $T($S($E($S(Async, __)), Function, $E($S(Star, __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock), function(value) {
-      return { "type": "FunctionExpression", "children": value };
+    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) {
@@ -1715,7 +1754,8 @@ var require_parser = __commonJS({
       var suffix = $2;
       var arrow = $4;
       var block = $5;
-      if (module2.implicitReturns && suffix?.children[3] !== "void") {
+      const isVoid = suffix?.children?.[1]?.[0]?.[1]?.token === "void";
+      if (module2.implicitReturns && !isVoid) {
         block = module2.addImplicitReturns(block);
       }
       return {
@@ -1767,9 +1807,7 @@ var require_parser = __commonJS({
       }
     }
     var BracedOrEmptyBlock$0 = BracedBlock;
-    var BracedOrEmptyBlock$1 = $T($S(InsertOpenBrace, InsertCloseBrace), function(value) {
-      return { "type": "BlockStatement", "expressions": [], "children": value };
-    });
+    var BracedOrEmptyBlock$1 = EmptyBlock;
     function BracedOrEmptyBlock(state) {
       if (state.tokenize) {
         return $TOKEN("BracedOrEmptyBlock", state, BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state));
@@ -1777,6 +1815,18 @@ var require_parser = __commonJS({
         return BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state);
       }
     }
+    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 };
@@ -2100,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");
@@ -2121,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));
@@ -2139,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");
@@ -4412,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));
@@ -4490,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)
@@ -4501,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)
@@ -4513,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");
@@ -4533,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");
@@ -4543,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");
@@ -4586,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));
@@ -4595,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");
@@ -4606,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));
@@ -4615,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));
@@ -4948,7 +5065,6 @@ var require_parser = __commonJS({
         if (!Array.isArray(node))
           return;
         const [, exp] = node;
-        debugger;
         if (!exp)
           return;
         switch (exp.type) {
@@ -4961,7 +5077,6 @@ var require_parser = __commonJS({
           case "VariableDeclaration":
             return;
           case "IfStatement":
-            debugger;
             insertReturn(exp.children[2]);
             if (exp.children[3])
               insertReturn(exp.children[3][2]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielx/civet",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "exports": {