@danielx/civet 0.11.2 → 0.11.3

package/dist/main.js

@@ -2932,20 +2932,7 @@ function wrapTypeInApplication(t, id, raw) {
 }
 function implicitFunctionBlock(f) {
   if (f.abstract || f.block || f.signature?.optional) return;
-  const { name, parent } = f;
-  let ancestor = parent;
-  let child = f;
-  if (ancestor?.type === "ExportDeclaration") {
-    child = ancestor;
-    ancestor = ancestor.parent;
-  }
-  const expressions = ancestor?.expressions ?? ancestor?.elements;
-  const currentIndex = expressions?.findIndex(([, def]) => def === child);
-  let following = currentIndex >= 0 && expressions[currentIndex + 1]?.[1];
-  if (following?.type === "ExportDeclaration") {
-    following = following.declaration;
-  }
-  if (f.type === following?.type && name != null && name === following.name) {
+  if (followingOverloads(f).length) {
     f.ts = true;
   } else {
     const block = makeEmptyBlock();
@@ -2955,6 +2942,66 @@ function implicitFunctionBlock(f) {
     f.ts = false;
   }
 }
+function overloadsInDirection(f, direction) {
+  if (!(f.name != null)) {
+    return [];
+  }
+  let ancestor = f.parent;
+  let child = f;
+  if (ancestor?.type === "ExportDeclaration") {
+    child = ancestor;
+    ancestor = ancestor.parent;
+  }
+  if (!(ancestor?.type === "BlockStatement")) {
+    return [];
+  }
+  const { expressions } = ancestor;
+  let index = findChildIndex(expressions, child);
+  if (!(index >= 0)) {
+    return [];
+  }
+  if (direction < 0) {
+    const results1 = [];
+    while (--index >= 0) {
+      let candidate = expressions[index][1];
+      if (!candidate) {
+        break;
+      }
+      if (candidate.type === "ExportDeclaration") {
+        candidate = candidate.declaration;
+      }
+      if (!(candidate && candidate.type === f.type && candidate.name === f.name)) {
+        break;
+      }
+      results1.push(candidate);
+    }
+    ;
+    return results1;
+  } else {
+    const results2 = [];
+    while (++index < expressions.length) {
+      let candidate = expressions[index][1];
+      if (!candidate) {
+        break;
+      }
+      if (candidate.type === "ExportDeclaration") {
+        candidate = candidate.declaration;
+      }
+      if (!(candidate && candidate.type === f.type && candidate.name === f.name)) {
+        break;
+      }
+      results2.push(candidate);
+    }
+    ;
+    return results2;
+  }
+}
+function precedingOverloads(f) {
+  return overloadsInDirection(f, -1);
+}
+function followingOverloads(f) {
+  return overloadsInDirection(f, 1);
+}
 function processReturn(f, implicitReturns) {
   let { returnType } = f.signature;
   if (returnType && returnType.optional) {
@@ -3988,10 +4035,7 @@ function processParams(f) {
       const classExpressions = ancestor.body.expressions;
       let index2 = findChildIndex(classExpressions, f);
       assert.notEqual(index2, -1, "Could not find constructor in class");
-      let m7;
-      while (m7 = classExpressions[index2 - 1]?.[1], typeof m7 === "object" && m7 != null && "type" in m7 && m7.type === "MethodDefinition" && "name" in m7 && m7.name === "constructor") {
-        index2--;
-      }
+      index2 -= precedingOverloads(f).length;
       const fStatement = classExpressions[index2];
       for (let ref20 = gatherRecursive(parameters, ($14) => $14.type === "Parameter"), i10 = 0, len9 = ref20.length; i10 < len9; i10++) {
         const parameter = ref20[i10];
@@ -4086,10 +4130,11 @@ function findSuperCall(block) {
 }
 function processSignature(f) {
   const { block, signature } = f;
+  let addAsync = false;
+  let addGenerator = false;
   if (!f.async?.length && hasAwait(block)) {
     if (f.async != null) {
-      f.async.push("async ");
-      signature.modifier.async = true;
+      addAsync = true;
     } else {
       for (let ref23 = gatherRecursiveWithinFunction(block, ($17) => $17.type === "Await"), i13 = 0, len12 = ref23.length; i13 < len12; i13++) {
         const a = ref23[i13];
@@ -4103,8 +4148,7 @@ function processSignature(f) {
   }
   if (!f.generator?.length && hasYield(block)) {
     if (f.generator != null) {
-      f.generator.push("*");
-      signature.modifier.generator = true;
+      addGenerator = true;
     } else {
       for (let ref24 = gatherRecursiveWithinFunction(block, ($18) => $18.type === "YieldExpression"), i14 = 0, len13 = ref24.length; i14 < len13; i14++) {
         const y = ref24[i14];
@@ -4116,17 +4160,28 @@ function processSignature(f) {
       }
     }
   }
-  if (signature.modifier.async && !signature.modifier.generator && signature.returnType && !isPromiseType(signature.returnType.t)) {
-    replaceNode(
-      signature.returnType.t,
-      wrapTypeInPromise(signature.returnType.t),
-      signature.returnType
-    );
+  for (let ref25 = [f, ...precedingOverloads(f)], i15 = 0, len14 = ref25.length; i15 < len14; i15++) {
+    const overload = ref25[i15];
+    if (addAsync && overload.async != null && !overload.async.length) {
+      overload.async.push("async ");
+      overload.signature.modifier.async = true;
+    }
+    if (addGenerator && overload.generator != null && !overload.generator.length) {
+      overload.generator.push("*");
+      overload.signature.modifier.generator = true;
+    }
+    if (overload.signature.modifier.async && !overload.signature.modifier.generator && overload.signature.returnType && !isPromiseType(overload.signature.returnType.t)) {
+      replaceNode(
+        overload.signature.returnType.t,
+        wrapTypeInPromise(overload.signature.returnType.t),
+        overload.signature.returnType
+      );
+    }
   }
 }
 function processFunctions(statements, config2) {
-  for (let ref25 = gatherRecursiveAll(statements, ($20) => $20.type === "FunctionExpression" || $20.type === "ArrowFunction" || $20.type === "MethodDefinition"), i15 = 0, len14 = ref25.length; i15 < len14; i15++) {
-    const f = ref25[i15];
+  for (let ref26 = gatherRecursiveAll(statements, ($20) => $20.type === "FunctionExpression" || $20.type === "ArrowFunction" || $20.type === "MethodDefinition"), i16 = 0, len15 = ref26.length; i16 < len15; i16++) {
+    const f = ref26[i16];
     if (f.type === "FunctionExpression" || f.type === "MethodDefinition") {
       implicitFunctionBlock(f);
     }
@@ -4185,9 +4240,9 @@ function expressionizeIteration(exp) {
   }
   let done;
   if (!async) {
-    let ref26;
-    if ((ref26 = blockContainingStatement(exp)) && typeof ref26 === "object" && "block" in ref26 && "index" in ref26) {
-      const { block: parentBlock, index } = ref26;
+    let ref27;
+    if ((ref27 = blockContainingStatement(exp)) && typeof ref27 === "object" && "block" in ref27 && "index" in ref27) {
+      const { block: parentBlock, index } = ref27;
       statements[0][0] = parentBlock.expressions[index][0];
       parentBlock.expressions.splice(index, index + 1 - index, ...statements);
       updateParentPointers(parentBlock);
@@ -4204,8 +4259,8 @@ function expressionizeIteration(exp) {
   }
 }
 function processIterationExpressions(statements) {
-  for (let ref27 = gatherRecursiveAll(statements, ($21) => $21.type === "IterationExpression"), i16 = 0, len15 = ref27.length; i16 < len15; i16++) {
-    const s = ref27[i16];
+  for (let ref28 = gatherRecursiveAll(statements, ($21) => $21.type === "IterationExpression"), i17 = 0, len16 = ref28.length; i17 < len16; i17++) {
+    const s = ref28[i17];
     expressionizeIteration(s);
   }
 }
@@ -4228,13 +4283,13 @@ function processCoffeeDo(ws, expression) {
   if (typeof expression === "object" && expression != null && "type" in expression && expression.type === "ArrowFunction" || typeof expression === "object" && expression != null && "type" in expression && expression.type === "FunctionExpression") {
     let { parameters } = expression;
     const parameterList = parameters.parameters;
-    const results1 = [];
-    for (let i17 = 0, len16 = parameterList.length; i17 < len16; i17++) {
-      let parameter = parameterList[i17];
+    const results3 = [];
+    for (let i18 = 0, len17 = parameterList.length; i18 < len17; i18++) {
+      let parameter = parameterList[i18];
       if (typeof parameter === "object" && parameter != null && "type" in parameter && parameter.type === "Parameter") {
-        let ref28;
-        if (ref28 = parameter.initializer) {
-          const initializer = ref28;
+        let ref29;
+        if (ref29 = parameter.initializer) {
+          const initializer = ref29;
           args.push(initializer.expression, parameter.delim);
           parameter = {
             ...parameter,
@@ -4247,10 +4302,10 @@ function processCoffeeDo(ws, expression) {
           ));
         }
       }
-      results1.push(parameter);
+      results3.push(parameter);
     }
     ;
-    const newParameterList = results1;
+    const newParameterList = results3;
     const newParameters = {
       ...parameters,
       parameters: newParameterList,
@@ -9186,12 +9241,16 @@ var grammar = {
   CommaDelimiter,
   OptionalCommaDelimiter,
   ArgumentList,
+  PostfixedArgumentList,
   NestedArguments,
   NestedArgumentList,
   NestedArgument,
   SingleLineArgumentExpressions,
   WArgumentPart,
+  SingleLinePostfixedArgumentExpressions,
+  WPostfixedArgumentPart,
   ArgumentPart,
+  PostfixedArgumentPart,
   BinaryOpExpression,
   BinaryOpNotDedented,
   BinaryOpRHS,
@@ -9574,6 +9633,7 @@ var grammar = {
   Debugger,
   MaybeNestedNonPipelineExpression,
   MaybeNestedPostfixedExpression,
+  MaybeNestedPostfixedCommaExpression,
   NestedPostfixedExpressionNoTrailing,
   MaybeNestedExpression,
   MaybeParenNestedExpression,
@@ -10589,7 +10649,7 @@ var ImplicitArguments$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ApplicationSt
 function ImplicitArguments(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "ImplicitArguments", ImplicitArguments$0);
 }
-var ExplicitArguments$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenParen, AllowAll, (0, import_lib2.$E)((0, import_lib2.$S)(ArgumentList, (0, import_lib2.$E)((0, import_lib2.$S)(__, Comma)))), __, RestoreAll, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+var ExplicitArguments$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenParen, AllowAll, (0, import_lib2.$E)((0, import_lib2.$S)(PostfixedArgumentList, (0, import_lib2.$E)((0, import_lib2.$S)(__, Comma)))), __, RestoreAll, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   var open = $1;
   var args = $3;
   var ws = $4;
@@ -10727,6 +10787,35 @@ var ArgumentList$$ = [ArgumentList$0, ArgumentList$1, ArgumentList$2];
 function ArgumentList(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "ArgumentList", ArgumentList$$);
 }
+var PostfixedArgumentList$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(EOS), PostfixedArgumentPart, (0, import_lib2.$Q)((0, import_lib2.$S)(CommaDelimiter, (0, import_lib2.$N)(EOS), (0, import_lib2.$E)(_), PostfixedArgumentPart)), (0, import_lib2.$S)(CommaDelimiter, NestedArguments), (0, import_lib2.$Q)((0, import_lib2.$S)(OptionalCommaDelimiter, NestedArguments))), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+  return [
+    $2,
+    ...$3.flatMap(([comma, eos, ws, arg]) => [comma, prepend(ws, arg)]),
+    ...Array.isArray($4[1]) ? [$4[0], ...$4[1]] : $4,
+    ...$5.flatMap(
+      ([comma, args]) => Array.isArray(args) ? [comma, ...args] : [comma, args]
+    )
+  ];
+});
+var PostfixedArgumentList$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(NestedArguments, (0, import_lib2.$Q)((0, import_lib2.$S)(OptionalCommaDelimiter, NestedArguments))), function($skip, $loc, $0, $1, $2) {
+  if (!Array.isArray($1)) $1 = [$1];
+  return [
+    ...trimFirstSpace($1),
+    ...$2.flatMap(
+      ([comma, args]) => Array.isArray(args) ? [comma, ...args] : [comma, args]
+    )
+  ];
+});
+var PostfixedArgumentList$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixedArgumentPart, (0, import_lib2.$Q)((0, import_lib2.$S)(CommaDelimiter, (0, import_lib2.$E)(_), PostfixedArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
+  return [
+    prepend($1, $2),
+    ...$3.flatMap(([comma, ws, arg]) => [comma, prepend(ws, arg)])
+  ];
+});
+var PostfixedArgumentList$$ = [PostfixedArgumentList$0, PostfixedArgumentList$1, PostfixedArgumentList$2];
+function PostfixedArgumentList(ctx, state2) {
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "PostfixedArgumentList", PostfixedArgumentList$$);
+}
 var NestedArguments$0 = NestedBulletedArray;
 var NestedArguments$1 = NestedImplicitObjectLiteral;
 var NestedArguments$2 = NestedArgumentList;
@@ -10742,7 +10831,7 @@ var NestedArgumentList$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent,
 function NestedArgumentList(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "NestedArgumentList", NestedArgumentList$0);
 }
-var NestedArgument$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(NestedImplicitPropertyDefinition), Nested, (0, import_lib2.$N)(Bullet), SingleLineArgumentExpressions, ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+var NestedArgument$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(NestedImplicitPropertyDefinition), Nested, (0, import_lib2.$N)(Bullet), SingleLinePostfixedArgumentExpressions, ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
   var indent = $2;
   var args = $4;
   var comma = $5;
@@ -10765,6 +10854,18 @@ var WArgumentPart$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$
 function WArgumentPart(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "WArgumentPart", WArgumentPart$0);
 }
+var SingleLinePostfixedArgumentExpressions$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(WPostfixedArgumentPart, (0, import_lib2.$Q)((0, import_lib2.$S)((0, import_lib2.$S)((0, import_lib2.$E)(_), Comma), WPostfixedArgumentPart))), function($skip, $loc, $0, $1, $2) {
+  return [$1, ...$2.flat()];
+});
+function SingleLinePostfixedArgumentExpressions(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "SingleLinePostfixedArgumentExpressions", SingleLinePostfixedArgumentExpressions$0);
+}
+var WPostfixedArgumentPart$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixedArgumentPart), function($skip, $loc, $0, $1, $2) {
+  return prepend($1, $2);
+});
+function WPostfixedArgumentPart(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "WPostfixedArgumentPart", WPostfixedArgumentPart$0);
+}
 var ArgumentPart$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(DotDotDot, Expression), function($skip, $loc, $0, $1, $2) {
   var spread = $1;
   var expression = $2;
@@ -10789,6 +10890,30 @@ var ArgumentPart$$ = [ArgumentPart$0, ArgumentPart$1];
 function ArgumentPart(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "ArgumentPart", ArgumentPart$$);
 }
+var PostfixedArgumentPart$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(DotDotDot, PostfixedExpression), function($skip, $loc, $0, $1, $2) {
+  var spread = $1;
+  var expression = $2;
+  return {
+    type: "Argument",
+    children: $0,
+    expression,
+    spread
+  };
+});
+var PostfixedArgumentPart$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(PostfixedExpression, (0, import_lib2.$E)(DotDotDot)), function($skip, $loc, $0, $1, $2) {
+  var expression = $1;
+  var spread = $2;
+  return {
+    type: "Argument",
+    children: spread ? [spread, expression] : [expression],
+    expression,
+    spread
+  };
+});
+var PostfixedArgumentPart$$ = [PostfixedArgumentPart$0, PostfixedArgumentPart$1];
+function PostfixedArgumentPart(ctx, state2) {
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "PostfixedArgumentPart", PostfixedArgumentPart$$);
+}
 var BinaryOpExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(UnaryExpression, (0, import_lib2.$Q)(BinaryOpRHS)), function($skip, $loc, $0, $1, $2) {
   if (!$2.length) return $1;
   return processBinaryOpExpression($0);
@@ -10821,10 +10946,13 @@ var BinaryOpRHS$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(BinaryOp, RHS), fun
 var BinaryOpRHS$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(NewlineBinaryOpAllowed, NotDedentedBinaryOp, WRHS), function($skip, $loc, $0, $1, $2, $3) {
   var op = $2;
   var rhs = $3;
+  if (op[1].token === ">" && op[0].length === 0) return $skip;
   return [...op, ...rhs];
 });
-var BinaryOpRHS$3 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$N)(NewlineBinaryOpAllowed), SingleLineBinaryOpRHS), function(value) {
-  return value[1];
+var BinaryOpRHS$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(NewlineBinaryOpAllowed), SingleLineBinaryOpRHS), function($skip, $loc, $0, $1, $2) {
+  const [ws1, op] = $2;
+  if (op.token === ">" && !ws1.length) return $skip;
+  return $2;
 });
 var BinaryOpRHS$$ = [BinaryOpRHS$0, BinaryOpRHS$1, BinaryOpRHS$2, BinaryOpRHS$3];
 function BinaryOpRHS(ctx, state2) {
@@ -11779,7 +11907,7 @@ var FieldDefinition$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(CoffeeClassesEn
       };
   }
 });
-var FieldDefinition$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertReadonly, ClassElementName, (0, import_lib2.$E)(TypeSuffix), __, ConstAssignment, MaybeNestedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+var FieldDefinition$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertReadonly, ClassElementName, (0, import_lib2.$E)(TypeSuffix), __, ConstAssignment, MaybeNestedPostfixedCommaExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   var readonly = $1;
   var id = $2;
   var typeSuffix = $3;
@@ -15547,26 +15675,37 @@ var PostfixedNoCommaStatement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(NoCom
 function PostfixedNoCommaStatement(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "PostfixedNoCommaStatement", PostfixedNoCommaStatement$0);
 }
-var PostfixedExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Expression, (0, import_lib2.$E)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
+var PostfixedExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(AssignmentExpressionSpread, (0, import_lib2.$E)(_), (0, import_lib2.$N)(IfClause), PostfixStatement), function($skip, $loc, $0, $1, $2, $3, $4) {
+  var expression = $1;
+  var ws = $2;
+  var post = $4;
+  return attachPostfixStatementAsExpression(expression, [ws, post]);
+});
+var PostfixedExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Expression, (0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement)), function($skip, $loc, $0, $1, $2) {
   var expression = $1;
   var post = $2;
-  if (post) return attachPostfixStatementAsExpression(expression, post);
-  return expression;
+  return attachPostfixStatementAsExpression(expression, post);
 });
+var PostfixedExpression$2 = Expression;
+var PostfixedExpression$$ = [PostfixedExpression$0, PostfixedExpression$1, PostfixedExpression$2];
 function PostfixedExpression(ctx, state2) {
-  return (0, import_lib2.$EVENT)(ctx, state2, "PostfixedExpression", PostfixedExpression$0);
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "PostfixedExpression", PostfixedExpression$$);
 }
-var PostfixedCommaExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PostfixedExpression, (0, import_lib2.$C)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement), (0, import_lib2.$Q)((0, import_lib2.$S)(CommaDelimiter, AssignmentExpression)))), function($skip, $loc, $0, $1, $2) {
+var PostfixedCommaExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(CommaExpressionSpread, (0, import_lib2.$E)(_), (0, import_lib2.$N)(IfClause), PostfixStatement), function($skip, $loc, $0, $1, $2, $3, $4) {
+  var expression = $1;
+  var ws = $2;
+  var post = $4;
+  return attachPostfixStatementAsExpression(expression, [ws, post]);
+});
+var PostfixedCommaExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Expression, (0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement)), function($skip, $loc, $0, $1, $2) {
   var expression = $1;
   var post = $2;
-  if (!post.length) return $1;
-  if (post.length === 2 && !Array.isArray(post[1])) {
-    return attachPostfixStatementAsExpression(expression, post);
-  }
-  return $0;
+  return attachPostfixStatementAsExpression(expression, post);
 });
+var PostfixedCommaExpression$2 = CommaExpression;
+var PostfixedCommaExpression$$ = [PostfixedCommaExpression$0, PostfixedCommaExpression$1, PostfixedCommaExpression$2];
 function PostfixedCommaExpression(ctx, state2) {
-  return (0, import_lib2.$EVENT)(ctx, state2, "PostfixedCommaExpression", PostfixedCommaExpression$0);
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "PostfixedCommaExpression", PostfixedCommaExpression$$);
 }
 var PostfixStatement$0 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($R31, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
   return value[1];
@@ -17018,6 +17157,22 @@ var MaybeNestedPostfixedExpression$$ = [MaybeNestedPostfixedExpression$0, MaybeN
 function MaybeNestedPostfixedExpression(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "MaybeNestedPostfixedExpression", MaybeNestedPostfixedExpression$$);
 }
+var MaybeNestedPostfixedCommaExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(NestedBulletedArray), (0, import_lib2.$N)(NestedImplicitObjectLiteral), PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, PostfixedCommaExpression)), PopIndent, (0, import_lib2.$E)(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+  var expression = $4;
+  var trailing = $6;
+  if (!expression) return $skip;
+  if (!trailing) return expression;
+  return [expression, trailing];
+});
+var MaybeNestedPostfixedCommaExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidImplicitFragment, (0, import_lib2.$E)(PostfixedCommaExpression), RestoreImplicitFragment), function($skip, $loc, $0, $1, $2, $3) {
+  var expression = $2;
+  if (!expression) return $skip;
+  return expression;
+});
+var MaybeNestedPostfixedCommaExpression$$ = [MaybeNestedPostfixedCommaExpression$0, MaybeNestedPostfixedCommaExpression$1];
+function MaybeNestedPostfixedCommaExpression(ctx, state2) {
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "MaybeNestedPostfixedCommaExpression", MaybeNestedPostfixedCommaExpression$$);
+}
 var NestedPostfixedExpressionNoTrailing$0 = NestedBulletedArray;
 var NestedPostfixedExpressionNoTrailing$1 = NestedImplicitObjectLiteral;
 var NestedPostfixedExpressionNoTrailing$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, PostfixedExpression)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
@@ -17468,7 +17623,7 @@ var ExportDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_li
     }
   ];
 });
-var ExportDeclaration$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(Decorators), Export, __, Default, __, (0, import_lib2.$C)(HoistableDeclaration, ClassDeclaration, InterfaceDeclaration, MaybeNestedExpression)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+var ExportDeclaration$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(Decorators), Export, __, Default, __, (0, import_lib2.$C)(HoistableDeclaration, ClassDeclaration, InterfaceDeclaration, MaybeNestedPostfixedExpression)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   var declaration = $6;
   return { type: "ExportDeclaration", declaration, ts: declaration.ts, children: $0 };
 });
@@ -17591,7 +17746,7 @@ var LexicalDeclaration$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(LetOrConst,
     thisAssignments: bindings.flatMap((b) => b.thisAssignments)
   };
 });
-var LexicalDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Loc, (0, import_lib2.$C)(BindingPattern, BindingIdentifier), (0, import_lib2.$E)(TypeSuffix), __, (0, import_lib2.$C)(ConstAssignment, LetAssignment), MaybeNestedPostfixedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+var LexicalDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Loc, (0, import_lib2.$C)(BindingPattern, BindingIdentifier), (0, import_lib2.$E)(TypeSuffix), __, (0, import_lib2.$C)(ConstAssignment, LetAssignment), MaybeNestedPostfixedCommaExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   var loc = $1;
   var assign = $5;
   return processAssignmentDeclaration(
@@ -17657,7 +17812,7 @@ var LexicalBinding$$ = [LexicalBinding$0, LexicalBinding$1];
 function LexicalBinding(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "LexicalBinding", LexicalBinding$$);
 }
-var Initializer$0 = (0, import_lib2.$T)((0, import_lib2.$S)(__, Equals, MaybeNestedExpression), function(value) {
+var Initializer$0 = (0, import_lib2.$T)((0, import_lib2.$S)(__, Equals, MaybeNestedPostfixedExpression), function(value) {
   var expression = value[2];
   return { "type": "Initializer", "expression": expression, "children": value };
 });