@danielx/civet 0.6.13 → 0.6.15

package/dist/browser.js

@@ -209,7 +209,7 @@ var Civet = (() => {
           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;
@@ -631,12 +631,20 @@ var Civet = (() => {
           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) {
@@ -652,12 +660,15 @@ var Civet = (() => {
         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];
@@ -674,6 +685,14 @@ var Civet = (() => {
           }
           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;
@@ -1126,8 +1145,10 @@ var Civet = (() => {
       function makeLeftHandSideExpression(expression) {
         switch (expression.type) {
           case "Ref":
+          case "AmpersandRef":
           case "Identifier":
           case "Literal":
+          case "IterationExpression":
           case "CallExpression":
           case "MemberExpression":
           case "ParenthesizedExpression":
@@ -1140,7 +1161,8 @@ var Civet = (() => {
             return {
               type: "ParenthesizedExpression",
               children: ["(", expression, ")"],
-              expression
+              expression,
+              implicit: true
             };
         }
       }
@@ -1403,6 +1425,46 @@ var Civet = (() => {
         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)) {
@@ -1412,7 +1474,14 @@ var Civet = (() => {
             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) {
@@ -1463,49 +1532,11 @@ var Civet = (() => {
             }
             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) {
@@ -1952,7 +1983,8 @@ var Civet = (() => {
                 });
               }
             } else {
-              s.children = children;
+              if (i === 0)
+                s.children = children;
             }
             if (returns && (ref = needsRef(arg))) {
               usingRef = usingRef || ref;
@@ -2248,27 +2280,20 @@ var Civet = (() => {
         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 === "-") {
@@ -2949,6 +2974,7 @@ ${input.slice(result.pos)}
         NonPipelineExtendedExpression,
         NonAssignmentExtendedExpression,
         NestedNonAssignmentExtendedExpression,
+        ExpressionizedStatementWithTrailingCallExpressions,
         ExpressionizedStatement,
         Expression,
         Arguments,
@@ -2959,6 +2985,8 @@ ${input.slice(result.pos)}
         ArgumentsWithTrailingMemberExpressions,
         TrailingMemberExpressions,
         AllowedTrailingMemberExpressions,
+        TrailingCallExpressions,
+        AllowedTrailingCallExpressions,
         CommaDelimiter,
         ArgumentList,
         NonPipelineArgumentList,
@@ -3141,6 +3169,7 @@ ${input.slice(result.pos)}
         OperatorAssignmentOp,
         AssignmentOpSymbol,
         CoffeeWordAssignmentOp,
+        NotDedentedBinaryOp,
         BinaryOp,
         BinaryOpSymbol,
         Xor,
@@ -3499,6 +3528,7 @@ ${input.slice(result.pos)}
         TypeIndex,
         TypeSuffix,
         ReturnTypeSuffix,
+        ReturnType,
         TypePredicate,
         Type,
         TypeBinary,
@@ -3803,7 +3833,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"));
@@ -4096,7 +4126,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]
@@ -4124,11 +4157,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;
@@ -4152,6 +4191,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;
@@ -4437,6 +4509,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;
@@ -4684,9 +4804,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];
@@ -4744,7 +4864,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) {
@@ -4825,10 +4945,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) {
@@ -4842,12 +4959,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;
@@ -5458,6 +5575,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",
@@ -7898,17 +8024,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 ");
         }
@@ -8068,7 +8206,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",
@@ -10572,6 +10710,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 };
@@ -10901,7 +11075,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;
@@ -11390,6 +11564,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, ")"]],
@@ -21159,27 +21335,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;
@@ -21187,14 +21390,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;
         }
       }
@@ -21851,7 +22054,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;