@danielx/civet 0.6.13 → 0.6.15

package/dist/main.mjs

@@ -206,7 +206,7 @@ var require_lib = __commonJS({
         ref.children = [makeLeftHandSideExpression(arg)];
         return {
           type: "UnwrappedExpression",
-          children: [skipIfOnlyWS(fn.leadingComment), ...body, skipIfOnlyWS(fn.trailingComment)]
+          children: [skipIfOnlyWS(fn.leadingComment), body, skipIfOnlyWS(fn.trailingComment)]
         };
       }
       expr = fn.expr;
@@ -628,12 +628,20 @@ var require_lib = __commonJS({
         children
       };
     }
+    function isExistence(exp) {
+      if (exp.type === "ParenthesizedExpression" && exp.implicit) {
+        exp = exp.expression;
+      }
+      if (exp.type === "Existence") {
+        return exp;
+      }
+    }
     function expandChainedComparisons([first, binops]) {
       const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in"];
       const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
       let results = [];
       let i = 0;
-      let l = binops.length;
+      const l = binops.length;
       let start = 0;
       let chains = [];
       while (i < l) {
@@ -649,12 +657,15 @@ var require_lib = __commonJS({
       processChains();
       return results;
       function processChains() {
+        first = expandExistence(first);
         if (chains.length > 1) {
           chains.forEach((index, k) => {
             if (k > 0) {
               results.push(" ", "&&", " ");
             }
-            const [pre, op, post, exp] = binops[index];
+            const binop = binops[index];
+            let [pre, op, post, exp] = binop;
+            exp = binop[3] = expandExistence(exp);
             let endIndex;
             if (k < chains.length - 1) {
               endIndex = chains[k + 1];
@@ -671,6 +682,14 @@ var require_lib = __commonJS({
         }
         chains.length = 0;
       }
+      function expandExistence(exp) {
+        const existence = isExistence(exp);
+        if (existence) {
+          results.push(existence, " ", "&&", " ");
+          return existence.expression;
+        }
+        return exp;
+      }
     }
     function processParams(f) {
       const { type, parameters, block } = f;
@@ -1123,8 +1142,10 @@ var require_lib = __commonJS({
     function makeLeftHandSideExpression(expression) {
       switch (expression.type) {
         case "Ref":
+        case "AmpersandRef":
         case "Identifier":
         case "Literal":
+        case "IterationExpression":
         case "CallExpression":
         case "MemberExpression":
         case "ParenthesizedExpression":
@@ -1137,7 +1158,8 @@ var require_lib = __commonJS({
           return {
             type: "ParenthesizedExpression",
             children: ["(", expression, ")"],
-            expression
+            expression,
+            implicit: true
           };
       }
     }
@@ -1400,6 +1422,46 @@ var require_lib = __commonJS({
       tail.push(...splices.map((s) => [", ", s]), ...thisAssignments.map((a) => [", ", a]));
     }
     function processAssignments(statements) {
+      gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" || n.type === "UpdateExpression").forEach((exp) => {
+        function extractAssignment(lhs) {
+          let expr = lhs;
+          while (expr.type === "ParenthesizedExpression") {
+            expr = expr.expression;
+          }
+          if (expr.type === "AssignmentExpression" || expr.type === "UpdateExpression") {
+            if (expr.type === "UpdateExpression" && expr.children[0] === expr.assigned) {
+              post.push([", ", lhs]);
+            } else {
+              pre.push([lhs, ", "]);
+            }
+            return expr.assigned;
+          }
+        }
+        const pre = [], post = [];
+        switch (exp.type) {
+          case "AssignmentExpression":
+            if (!exp.lhs)
+              return;
+            exp.lhs.forEach((lhsPart, i) => {
+              let newLhs2 = extractAssignment(lhsPart[1]);
+              if (newLhs2) {
+                lhsPart[1] = newLhs2;
+              }
+            });
+            break;
+          case "UpdateExpression":
+            let newLhs = extractAssignment(exp.assigned);
+            if (newLhs) {
+              const i = exp.children.indexOf(exp.assigned);
+              exp.assigned = exp.children[i] = newLhs;
+            }
+            break;
+        }
+        if (pre.length)
+          exp.children.unshift(...pre);
+        if (post.length)
+          exp.children.push(...post);
+      });
       gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" && n.names === null).forEach((exp) => {
         let { lhs: $1, exp: $2 } = exp, tail = [], i = 0, len = $1.length;
         if ($1.some((left) => left[left.length - 1].special)) {
@@ -1409,7 +1471,14 @@ var require_lib = __commonJS({
           const [, lhs, , op] = $1[0];
           const { call } = op;
           op[op.length - 1] = "=";
-          $2 = [call, "(", lhs, ", ", $2, ")"];
+          const index2 = exp.children.indexOf($2);
+          if (index2 < 0)
+            throw new Error("Assertion error: exp not in AssignmentExpression");
+          exp.children.splice(
+            index2,
+            1,
+            exp.exp = $2 = [call, "(", lhs, ", ", $2, ")"]
+          );
         }
         let wrapped = false;
         while (i < len) {
@@ -1460,49 +1529,11 @@ var require_lib = __commonJS({
           }
           i--;
         }
-        const names = $1.flatMap(([, l]) => l.names || []);
-        exp.children = [$1, $2, ...tail];
-        exp.names = names;
-      });
-      gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" || n.type === "UpdateExpression").forEach((exp) => {
-        function extractAssignment(lhs) {
-          let expr = lhs;
-          while (expr.type === "ParenthesizedExpression") {
-            expr = expr.expression;
-          }
-          if (expr.type === "AssignmentExpression" || expr.type === "UpdateExpression") {
-            if (expr.type === "UpdateExpression" && expr.children[0] === expr.assigned) {
-              post.push([", ", lhs]);
-            } else {
-              pre.push([lhs, ", "]);
-            }
-            return expr.assigned;
-          }
-        }
-        const pre = [], post = [];
-        switch (exp.type) {
-          case "AssignmentExpression":
-            if (!exp.lhs)
-              return;
-            exp.lhs.forEach((lhsPart, i) => {
-              let newLhs2 = extractAssignment(lhsPart[1]);
-              if (newLhs2) {
-                lhsPart[1] = newLhs2;
-              }
-            });
-            break;
-          case "UpdateExpression":
-            let newLhs = extractAssignment(exp.assigned);
-            if (newLhs) {
-              const i = exp.children.indexOf(exp.assigned);
-              exp.assigned = exp.children[i] = newLhs;
-            }
-            break;
-        }
-        if (pre.length)
-          exp.children.unshift(...pre);
-        if (post.length)
-          exp.children.push(...post);
+        exp.names = $1.flatMap(([, l]) => l.names || []);
+        const index = exp.children.indexOf($2);
+        if (index < 0)
+          throw new Error("Assertion error: exp not in AssignmentExpression");
+        exp.children.splice(index + 1, 0, ...tail);
       });
     }
     function attachPostfixStatementAsExpression(exp, post) {
@@ -1949,7 +1980,8 @@ var require_lib = __commonJS({
               });
             }
           } else {
-            s.children = children;
+            if (i === 0)
+              s.children = children;
           }
           if (returns && (ref = needsRef(arg))) {
             usingRef = usingRef || ref;
@@ -2245,27 +2277,20 @@ var require_lib = __commonJS({
       if (post?.token === "?") {
         post = {
           $loc: post.$loc,
-          token: " != null"
+          token: "!="
         };
-        switch (exp.type) {
-          case "Identifier":
-          case "Literal":
-          case "AmpersandRef":
-            return {
-              ...exp,
-              children: [...pre, ...exp.children, post]
-            };
-          default:
-            const expression = {
-              ...exp,
-              children: [...pre, "(", exp.children, ")", post]
-            };
-            return {
-              type: "ParenthesizedExpression",
-              children: ["(", expression, ")"],
-              expression
-            };
+        if (pre.length) {
+          exp = {
+            type: "UnaryExpression",
+            children: [...pre, exp, void 0]
+          };
         }
+        const existence = {
+          type: "Existence",
+          expression: exp,
+          children: [exp, " ", post, " ", "null"]
+        };
+        return makeLeftHandSideExpression(existence);
       }
       if (exp.type === "Literal") {
         if (pre.length === 1 && pre[0].token === "-") {
@@ -2946,6 +2971,7 @@ ${input.slice(result.pos)}
       NonPipelineExtendedExpression,
       NonAssignmentExtendedExpression,
       NestedNonAssignmentExtendedExpression,
+      ExpressionizedStatementWithTrailingCallExpressions,
       ExpressionizedStatement,
       Expression,
       Arguments,
@@ -2956,6 +2982,8 @@ ${input.slice(result.pos)}
       ArgumentsWithTrailingMemberExpressions,
       TrailingMemberExpressions,
       AllowedTrailingMemberExpressions,
+      TrailingCallExpressions,
+      AllowedTrailingCallExpressions,
       CommaDelimiter,
       ArgumentList,
       NonPipelineArgumentList,
@@ -3138,6 +3166,7 @@ ${input.slice(result.pos)}
       OperatorAssignmentOp,
       AssignmentOpSymbol,
       CoffeeWordAssignmentOp,
+      NotDedentedBinaryOp,
       BinaryOp,
       BinaryOpSymbol,
       Xor,
@@ -3496,6 +3525,7 @@ ${input.slice(result.pos)}
       TypeIndex,
       TypeSuffix,
       ReturnTypeSuffix,
+      ReturnType,
       TypePredicate,
       Type,
       TypeBinary,
@@ -3800,7 +3830,7 @@ ${input.slice(result.pos)}
     var $R6 = $R(new RegExp("[!+-]", "suy"));
     var $R7 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
     var $R8 = $R(new RegExp("!\\^\\^?", "suy"));
-    var $R9 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*&)", "suy"));
+    var $R9 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])", "suy"));
     var $R10 = $R(new RegExp("(?=[\\s\\)])", "suy"));
     var $R11 = $R(new RegExp('[^;"\\s]+', "suy"));
     var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
@@ -4093,7 +4123,10 @@ ${input.slice(result.pos)}
       }
     }
     var NonAssignmentExtendedExpression$0 = NestedNonAssignmentExtendedExpression;
-    var NonAssignmentExtendedExpression$1 = $TS($S(__, ExpressionizedStatement), function($skip, $loc, $0, $1, $2) {
+    var NonAssignmentExtendedExpression$1 = $TS($S(__, ExpressionizedStatementWithTrailingCallExpressions), function($skip, $loc, $0, $1, $2) {
+      if ($2.length) {
+        return [...$1, ...$2];
+      }
       return {
         ...$2,
         children: [...$1, ...$2.children]
@@ -4121,11 +4154,17 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var NestedNonAssignmentExtendedExpression$0 = $TS($S($Y(EOS), PushIndent, $E($S(Nested, ExpressionizedStatement)), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var NestedNonAssignmentExtendedExpression$0 = $TS($S($Y(EOS), PushIndent, $E($S(Nested, ExpressionizedStatementWithTrailingCallExpressions)), PopIndent, $E(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var expression = $3;
-      if (expression)
+      var trailing = $5;
+      if (!expression)
+        return $skip;
+      if (!trailing)
         return expression;
-      return $skip;
+      return {
+        type: "CallExpression",
+        children: [expression, ...trailing.flat()]
+      };
     });
     function NestedNonAssignmentExtendedExpression(state) {
       let eventData;
@@ -4149,6 +4188,39 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var ExpressionizedStatementWithTrailingCallExpressions$0 = $TS($S(ExpressionizedStatement, $E(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2) {
+      if (!$2)
+        return $1;
+      return {
+        type: "CallExpression",
+        children: [
+          makeLeftHandSideExpression($1),
+          $2
+        ]
+      };
+    });
+    function ExpressionizedStatementWithTrailingCallExpressions(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ExpressionizedStatementWithTrailingCallExpressions", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ExpressionizedStatementWithTrailingCallExpressions", state, ExpressionizedStatementWithTrailingCallExpressions$0(state));
+        if (state.events)
+          state.events.exit?.("ExpressionizedStatementWithTrailingCallExpressions", state, result, eventData);
+        return result;
+      } else {
+        const result = ExpressionizedStatementWithTrailingCallExpressions$0(state);
+        if (state.events)
+          state.events.exit?.("ExpressionizedStatementWithTrailingCallExpressions", state, result, eventData);
+        return result;
+      }
+    }
     var ExpressionizedStatement$0 = DebuggerExpression;
     var ExpressionizedStatement$1 = IfExpression;
     var ExpressionizedStatement$2 = UnlessExpression;
@@ -4434,6 +4506,54 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var TrailingCallExpressions$0 = $P($S($C(Samedent, IndentedFurther), $Y($S($E($EXPECT($L5, fail, 'TrailingCallExpressions "?"')), $EXPECT($L6, fail, 'TrailingCallExpressions "."'), $N($R$0($EXPECT($R1, fail, "TrailingCallExpressions /[0-9]/"))))), $P(CallExpressionRest)));
+    function TrailingCallExpressions(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("TrailingCallExpressions", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("TrailingCallExpressions", state, TrailingCallExpressions$0(state));
+        if (state.events)
+          state.events.exit?.("TrailingCallExpressions", state, result, eventData);
+        return result;
+      } else {
+        const result = TrailingCallExpressions$0(state);
+        if (state.events)
+          state.events.exit?.("TrailingCallExpressions", state, result, eventData);
+        return result;
+      }
+    }
+    var AllowedTrailingCallExpressions$0 = $T($S(TrailingMemberPropertyAllowed, TrailingCallExpressions), function(value) {
+      return value[1];
+    });
+    function AllowedTrailingCallExpressions(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("AllowedTrailingCallExpressions", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("AllowedTrailingCallExpressions", state, AllowedTrailingCallExpressions$0(state));
+        if (state.events)
+          state.events.exit?.("AllowedTrailingCallExpressions", state, result, eventData);
+        return result;
+      } else {
+        const result = AllowedTrailingCallExpressions$0(state);
+        if (state.events)
+          state.events.exit?.("AllowedTrailingCallExpressions", state, result, eventData);
+        return result;
+      }
+    }
     var CommaDelimiter$0 = $S($E($C(Samedent, IndentedFurther)), $Q(_), Comma);
     function CommaDelimiter(state) {
       let eventData;
@@ -4681,9 +4801,9 @@ ${input.slice(result.pos)}
       var rhs = $2;
       return [[], op, [], rhs];
     });
-    var BinaryOpRHS$1 = $T($S(NewlineBinaryOpAllowed, $S(NotDedented, BinaryOp, $C(_, $S(EOS, __)), RHS)), function(value) {
-      var rhs = value[1];
-      return rhs;
+    var BinaryOpRHS$1 = $TS($S(NewlineBinaryOpAllowed, $S(NotDedentedBinaryOp, $C(_, $S(EOS, __)), RHS)), function($skip, $loc, $0, $1, $2) {
+      var rhs = $2;
+      return [...rhs[0], ...rhs.slice(1)];
     });
     var BinaryOpRHS$2 = $T($S($N(NewlineBinaryOpAllowed), SingleLineBinaryOpRHS), function(value) {
       return value[1];
@@ -4741,7 +4861,7 @@ ${input.slice(result.pos)}
     }
     var RHS$0 = ParenthesizedAssignment;
     var RHS$1 = UnaryExpression;
-    var RHS$2 = ExpressionizedStatement;
+    var RHS$2 = ExpressionizedStatementWithTrailingCallExpressions;
     function RHS(state) {
       let eventData;
       if (state.events) {
@@ -4822,10 +4942,7 @@ ${input.slice(result.pos)}
       }
     }
     var UnaryPostfix$0 = QuestionMark;
-    var UnaryPostfix$1 = $T($P($S(__, As, Type)), function(value) {
-      return { "ts": true, "children": value };
-    });
-    var UnaryPostfix$2 = $T($P($S(__, Satisfies, Type)), function(value) {
+    var UnaryPostfix$1 = $T($P($S(__, $C(As, Satisfies), Type)), function(value) {
       return { "ts": true, "children": value };
     });
     function UnaryPostfix(state) {
@@ -4839,12 +4956,12 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state) || UnaryPostfix$2(state));
+        const result = $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state));
         if (state.events)
           state.events.exit?.("UnaryPostfix", state, result, eventData);
         return result;
       } else {
-        const result = UnaryPostfix$0(state) || UnaryPostfix$1(state) || UnaryPostfix$2(state);
+        const result = UnaryPostfix$0(state) || UnaryPostfix$1(state);
         if (state.events)
           state.events.exit?.("UnaryPostfix", state, result, eventData);
         return result;
@@ -5455,6 +5572,15 @@ ${input.slice(result.pos)}
       switch (exp.type) {
         case "IterationExpression":
           return exp;
+        case "ParenthesizedExpression":
+          if (exp.implicit) {
+            return {
+              ...exp,
+              children: [open, exp.expression, ws, close],
+              implicit: false
+            };
+          }
+          break;
       }
       return {
         type: "ParenthesizedExpression",
@@ -7895,17 +8021,29 @@ ${input.slice(result.pos)}
         return $skip;
       let body, ref;
       if (!rhs) {
-        ref = {
+        body = ref = {
           type: "Ref",
           base: "$",
           id: "$"
         };
-        body = [prefix, ref];
       } else {
-        ({ ref } = rhs);
-        body = [prefix, rhs];
+        let exp = rhs;
+        while (!exp.ref && exp.expression) {
+          exp = exp.expression;
+        }
+        ({ ref } = exp);
+        if (!ref) {
+          throw new Error("Could not find ref in ampersand shorthand block");
+        }
+        body = rhs;
+      }
+      if (prefix) {
+        body = {
+          type: "UnaryExpression",
+          children: [prefix, body, void 0]
+        };
       }
-      const children = [ref, " => ", ...body];
+      const children = [ref, " => ", body];
       if (hasAwait(body)) {
         children.unshift("async ");
       }
@@ -8065,7 +8203,7 @@ ${input.slice(result.pos)}
       var callExpRest = $1;
       var unaryPostfix = $2;
       var binopRHS = $3;
-      if (!callExpRest && !binopRHS)
+      if (!callExpRest && !binopRHS && !unaryPostfix)
         return $skip;
       const ref = {
         type: "Ref",
@@ -10569,6 +10707,42 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var NotDedentedBinaryOp$0 = $TS($S($E(IndentedFurther), $E(_), BinaryOp), function($skip, $loc, $0, $1, $2, $3) {
+      const ws = [];
+      if ($1)
+        ws.push(...$1);
+      if ($2)
+        ws.push(...$2);
+      return [ws, $3];
+    });
+    var NotDedentedBinaryOp$1 = $TS($S(Samedent, $E(_), $N(Identifier), BinaryOp), function($skip, $loc, $0, $1, $2, $3, $4) {
+      const ws = [...$1];
+      if ($2)
+        ws.push(...$2);
+      return [ws, $4];
+    });
+    function NotDedentedBinaryOp(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NotDedentedBinaryOp", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NotDedentedBinaryOp", state, NotDedentedBinaryOp$0(state) || NotDedentedBinaryOp$1(state));
+        if (state.events)
+          state.events.exit?.("NotDedentedBinaryOp", state, result, eventData);
+        return result;
+      } else {
+        const result = NotDedentedBinaryOp$0(state) || NotDedentedBinaryOp$1(state);
+        if (state.events)
+          state.events.exit?.("NotDedentedBinaryOp", state, result, eventData);
+        return result;
+      }
+    }
     var BinaryOp$0 = $TS($S(BinaryOpSymbol), function($skip, $loc, $0, $1) {
       if (typeof $1 === "string")
         return { $loc, token: $1 };
@@ -10898,7 +11072,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var UnaryOp$0 = $TR($EXPECT($R9, fail, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+    var UnaryOp$0 = $TR($EXPECT($R9, fail, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
       return { $loc, token: $0 };
     });
     var UnaryOp$1 = AwaitOp;
@@ -11387,6 +11561,8 @@ ${input.slice(result.pos)}
       var kind = $1;
       var condition = $2;
       kind = { ...kind, token: "if" };
+      kind.token += getTrimmingSpace(condition);
+      condition = insertTrimmingSpace(condition, "");
       return {
         type: "IfStatement",
         children: [kind, ["(!", condition, ")"]],
@@ -21156,27 +21332,54 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, $E($S(__, $EXPECT($L202, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
-      var asserts = $3;
-      var t = $4;
+    var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, ReturnType), function($skip, $loc, $0, $1, $2, $3) {
+      var t = $3;
+      return { ...t, children: [$1, $2, ...t.children] };
+    });
+    function ReturnTypeSuffix(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ReturnTypeSuffix", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ReturnTypeSuffix", state, ReturnTypeSuffix$0(state));
+        if (state.events)
+          state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+        return result;
+      } else {
+        const result = ReturnTypeSuffix$0(state);
+        if (state.events)
+          state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+        return result;
+      }
+    }
+    var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L202, fail, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
+      var asserts = $1;
+      var t = $2;
       if (asserts) {
         t = {
           type: "AssertsType",
           t,
-          children: [asserts[0], asserts[1], t]
+          children: [asserts[0], asserts[1], t],
+          ts: true
         };
       }
       return {
         type: "ReturnTypeAnnotation",
-        children: [$1, $2, t],
+        children: [t],
         t,
         ts: true
       };
     });
-    function ReturnTypeSuffix(state) {
+    function ReturnType(state) {
       let eventData;
       if (state.events) {
-        const result = state.events.enter?.("ReturnTypeSuffix", state);
+        const result = state.events.enter?.("ReturnType", state);
         if (result) {
           if (result.cache)
             return result.cache;
@@ -21184,14 +21387,14 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("ReturnTypeSuffix", state, ReturnTypeSuffix$0(state));
+        const result = $TOKEN("ReturnType", state, ReturnType$0(state));
         if (state.events)
-          state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+          state.events.exit?.("ReturnType", state, result, eventData);
         return result;
       } else {
-        const result = ReturnTypeSuffix$0(state);
+        const result = ReturnType$0(state);
         if (state.events)
-          state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+          state.events.exit?.("ReturnType", state, result, eventData);
         return result;
       }
     }
@@ -21848,7 +22051,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var FunctionType$0 = $TS($S($E($S(New, $E(_))), Parameters, __, TypeArrowFunction, $E(Type)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+    var FunctionType$0 = $TS($S($E($S($E($S(Abstract, $E(_))), New, $E(_))), Parameters, __, TypeArrowFunction, $E(ReturnType)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var type = $5;
       if (type) {
         return $0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielx/civet",
-  "version": "0.6.13",
+  "version": "0.6.15",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "module": "dist/main.mjs",