@danielx/civet 0.8.16 → 0.8.17

package/dist/main.js

@@ -1195,7 +1195,6 @@ var skipParens = /* @__PURE__ */ new Set([
   "JSXElement",
   "JSXFragment",
   "Literal",
-  "NewExpression",
   "ParenthesizedExpression",
   "Ref",
   "Placeholder",
@@ -1217,7 +1216,10 @@ function makeLeftHandSideExpression(expression) {
     if (skipParens.has(expression.type)) {
       return expression;
     }
-    if (expression.type === "MemberExpression" && !startsWithPredicate(expression, ($6) => $6.type === "ObjectExpression")) {
+    if (expression.type === "NewExpression" && expression.expression.children.some(($6) => $6?.type === "Call")) {
+      return expression;
+    }
+    if (expression.type === "MemberExpression" && !startsWithPredicate(expression, ($7) => $7.type === "ObjectExpression")) {
       return expression;
     }
   }
@@ -1753,13 +1755,14 @@ function gatherBindingCode(statements, opts) {
         return;
       }
       if (opts?.injectParamProps && n.type === "Parameter" && n.accessModifier) {
-        n.names.forEach((id) => ({
-          push: thisAssignments2.push({
+        for (let ref1 = n.names, i2 = 0, len1 = ref1.length; i2 < len1; i2++) {
+          const id = ref1[i2];
+          thisAssignments2.push({
             type: "AssignmentExpression",
             children: [`this.${id} = `, id],
             js: true
-          })
-        }));
+          });
+        }
         return;
       }
       const { blockPrefix } = n;
@@ -1771,8 +1774,8 @@ function gatherBindingCode(statements, opts) {
   return [splices, thisAssignments];
 }
 function arrayElementHasTrailingComma(elementNode) {
-  let ref1;
-  const lastChild = (ref1 = elementNode.children)[ref1.length - 1];
+  let ref2;
+  const lastChild = (ref2 = elementNode.children)[ref2.length - 1];
   return lastChild && lastChild[lastChild.length - 1]?.token === ",";
 }
 function gatherBindingPatternTypeSuffix(pattern) {
@@ -1784,8 +1787,8 @@ function gatherBindingPatternTypeSuffix(pattern) {
     case "ArrayBindingPattern": {
       {
         const results = [];
-        for (let ref2 = pattern.elements, i2 = 0, len1 = ref2.length; i2 < len1; i2++) {
-          const elem = ref2[i2];
+        for (let ref3 = pattern.elements, i3 = 0, len22 = ref3.length; i3 < len22; i3++) {
+          const elem = ref3[i3];
           let { typeSuffix } = elem;
           typeSuffix ??= elem.binding?.typeSuffix;
           if (typeSuffix) {
@@ -1823,8 +1826,8 @@ function gatherBindingPatternTypeSuffix(pattern) {
       {
         let restType;
         const results1 = [];
-        for (let ref3 = pattern.properties, i3 = 0, len22 = ref3.length; i3 < len22; i3++) {
-          const prop = ref3[i3];
+        for (let ref4 = pattern.properties, i4 = 0, len3 = ref4.length; i4 < len3; i4++) {
+          const prop = ref4[i4];
           let { typeSuffix } = prop;
           typeSuffix ??= prop.value?.typeSuffix;
           if (typeSuffix) {
@@ -1976,8 +1979,14 @@ var declareHelper = {
       // [indent, statement]
       preludeVar,
       moduloRef,
-      ts(": (a: number, b: number) => number"),
-      " = (a, b) => (a % b + b) % b"
+      " = ",
+      ts("("),
+      "(a",
+      ts(": number"),
+      ", b",
+      ts(": number"),
+      ") => (a % b + b) % b",
+      ts(") as ((a: number, b: number) => number) & ((a: bigint, b: bigint) => bigint)")
     ], ";\n"]);
   },
   Falsy(FalsyRef) {
@@ -2542,7 +2551,7 @@ function getTypeArguments(args) {
   if (!Array.isArray(args)) {
     throw new Error("getTypeArguments could not find relevant array");
   }
-  return args.filter((a) => typeof a === "object" && a != null && "type" in a && a.type === "TypeArgument");
+  return args.filter((a1) => typeof a1 === "object" && a1 != null && "type" in a1 && a1.type === "TypeArgument");
 }
 function isVoidType(t) {
   return typeof t === "object" && t != null && "type" in t && t.type === "TypeLiteral" && "t" in t && typeof t.t === "object" && t.t != null && "type" in t.t && t.t.type === "VoidType";
@@ -3408,7 +3417,7 @@ function processParams(f) {
   if (isConstructor) {
     const { ancestor } = findAncestor(f, ($6) => $6.type === "ClassExpression");
     if (ancestor != null) {
-      const fields = new Set(gatherRecursiveWithinFunction(ancestor, ($7) => $7.type === "FieldDefinition").map(($8) => $8.id).filter((a1) => typeof a1 === "object" && a1 != null && "type" in a1 && a1.type === "Identifier").map(($9) => $9.name));
+      const fields = new Set(gatherRecursiveWithinFunction(ancestor, ($7) => $7.type === "FieldDefinition").map(($8) => $8.id).filter((a2) => typeof a2 === "object" && a2 != null && "type" in a2 && a2.type === "Identifier").map(($9) => $9.name));
       const classExpressions = ancestor.body.expressions;
       let index = findChildIndex(classExpressions, f);
       assert.notEqual(index, -1, "Could not find constructor in class");
@@ -3419,15 +3428,20 @@ function processParams(f) {
       const fStatement = classExpressions[index];
       for (let ref16 = gatherRecursive(parameters, ($10) => $10.type === "Parameter"), i8 = 0, len7 = ref16.length; i8 < len7; i8++) {
         const parameter = ref16[i8];
-        if (!parameter.typeSuffix) {
+        const { accessModifier } = parameter;
+        if (!(accessModifier || parameter.typeSuffix)) {
           continue;
         }
         for (let ref17 = gatherRecursive(parameter, ($11) => $11.type === "AtBinding"), i9 = 0, len8 = ref17.length; i9 < len8; i9++) {
           const binding = ref17[i9];
           const typeSuffix = binding.parent?.typeSuffix;
-          if (!typeSuffix) {
+          if (!(accessModifier || typeSuffix)) {
             continue;
           }
+          if (parameter.accessModifier) {
+            replaceNode(parameter.accessModifier, void 0);
+            parameter.accessModifier = void 0;
+          }
           const id = binding.ref.id;
           if (fields.has(id)) {
             continue;
@@ -3436,7 +3450,7 @@ function processParams(f) {
             type: "FieldDefinition",
             id,
             typeSuffix,
-            children: [id, typeSuffix]
+            children: [accessModifier, id, typeSuffix]
           }, ";"]);
           fStatement[0] = "";
         }
@@ -3460,10 +3474,10 @@ function processParams(f) {
   if (isConstructor) {
     const superCalls = gatherNodes(
       expressions,
-      (a2) => typeof a2 === "object" && a2 != null && "type" in a2 && a2.type === "CallExpression" && "children" in a2 && Array.isArray(a2.children) && a2.children.length >= 1 && typeof a2.children[0] === "object" && a2.children[0] != null && "token" in a2.children[0] && a2.children[0].token === "super"
+      (a3) => typeof a3 === "object" && a3 != null && "type" in a3 && a3.type === "CallExpression" && "children" in a3 && Array.isArray(a3.children) && a3.children.length >= 1 && typeof a3.children[0] === "object" && a3.children[0] != null && "token" in a3.children[0] && a3.children[0].token === "super"
     );
     if (superCalls.length) {
-      const { child } = findAncestor(superCalls[0], (a3) => a3 === block);
+      const { child } = findAncestor(superCalls[0], (a4) => a4 === block);
       const index = findChildIndex(expressions, child);
       if (index < 0) {
         throw new Error("Could not find super call within top-level expressions");
@@ -3478,21 +3492,33 @@ function processParams(f) {
 function processSignature(f) {
   const { block, signature } = f;
   if (!f.async?.length && hasAwait(block)) {
-    f.async.push("async ");
-    signature.modifier.async = true;
-  }
-  if (!f.generator?.length && hasYield(block)) {
-    if (f.type === "ArrowFunction") {
-      gatherRecursiveWithinFunction(block, ($12) => $12.type === "YieldExpression").forEach((y) => {
-        const i = y.children.findIndex(($13) => $13.type === "Yield");
-        return y.children.splice(i + 1, 0, {
+    if (f.async != null) {
+      f.async.push("async ");
+      signature.modifier.async = true;
+    } else {
+      for (let ref18 = gatherRecursiveWithinFunction(block, ($12) => $12.type === "Await"), i10 = 0, len9 = ref18.length; i10 < len9; i10++) {
+        const a = ref18[i10];
+        const i = findChildIndex(a.parent, a);
+        a.parent.children.splice(i + 1, 0, {
           type: "Error",
-          message: "Can't use yield inside of => arrow function"
+          message: `await invalid in ${signature.modifier.get ? "getter" : signature.modifier.set ? "setter" : signature.name}`
         });
-      });
-    } else {
+      }
+    }
+  }
+  if (!f.generator?.length && hasYield(block)) {
+    if (f.generator != null) {
       f.generator.push("*");
       signature.modifier.generator = true;
+    } else {
+      for (let ref19 = gatherRecursiveWithinFunction(block, ($13) => $13.type === "YieldExpression"), i11 = 0, len10 = ref19.length; i11 < len10; i11++) {
+        const y = ref19[i11];
+        const i = y.children.findIndex(($14) => $14.type === "Yield");
+        y.children.splice(i + 1, 0, {
+          type: "Error",
+          message: `yield invalid in ${f.type === "ArrowFunction" ? "=> arrow function" : signature.modifier.get ? "getter" : signature.modifier.set ? "setter" : signature.name}`
+        });
+      }
     }
   }
   if (signature.modifier.async && !signature.modifier.generator && signature.returnType && !isPromiseType(signature.returnType.t)) {
@@ -3500,21 +3526,15 @@ function processSignature(f) {
   }
 }
 function processFunctions(statements, config2) {
-  for (let ref18 = gatherRecursiveAll(statements, ($14) => $14.type === "FunctionExpression" || $14.type === "ArrowFunction"), i10 = 0, len9 = ref18.length; i10 < len9; i10++) {
-    const f = ref18[i10];
-    if (f.type === "FunctionExpression") {
+  for (let ref20 = gatherRecursiveAll(statements, ($15) => $15.type === "FunctionExpression" || $15.type === "ArrowFunction" || $15.type === "MethodDefinition"), i12 = 0, len11 = ref20.length; i12 < len11; i12++) {
+    const f = ref20[i12];
+    if (f.type === "FunctionExpression" || f.type === "MethodDefinition") {
       implicitFunctionBlock(f);
     }
     processSignature(f);
     processParams(f);
     processReturn(f, config2.implicitReturns);
   }
-  for (let ref19 = gatherRecursiveAll(statements, ($15) => $15.type === "MethodDefinition"), i11 = 0, len10 = ref19.length; i11 < len10; i11++) {
-    const f = ref19[i11];
-    implicitFunctionBlock(f);
-    processParams(f);
-    processReturn(f, config2.implicitReturns);
-  }
 }
 function expressionizeIteration(exp) {
   let { async, generator, block, children, statement } = exp;
@@ -3563,9 +3583,9 @@ function expressionizeIteration(exp) {
   }
   let done;
   if (!async) {
-    let ref20;
-    if ((ref20 = blockContainingStatement(exp)) && typeof ref20 === "object" && "block" in ref20 && "index" in ref20) {
-      const { block: parentBlock, index } = ref20;
+    let ref21;
+    if ((ref21 = blockContainingStatement(exp)) && typeof ref21 === "object" && "block" in ref21 && "index" in ref21) {
+      const { block: parentBlock, index } = ref21;
       statements[0][0] = parentBlock.expressions[index][0];
       parentBlock.expressions.splice(index, index + 1 - index, ...statements);
       updateParentPointers(parentBlock);
@@ -3582,8 +3602,8 @@ function expressionizeIteration(exp) {
   }
 }
 function processIterationExpressions(statements) {
-  for (let ref21 = gatherRecursiveAll(statements, ($16) => $16.type === "IterationExpression"), i12 = 0, len11 = ref21.length; i12 < len11; i12++) {
-    const s = ref21[i12];
+  for (let ref22 = gatherRecursiveAll(statements, ($16) => $16.type === "IterationExpression"), i13 = 0, len12 = ref22.length; i13 < len12; i13++) {
+    const s = ref22[i13];
     expressionizeIteration(s);
   }
 }
@@ -3609,21 +3629,21 @@ function processCoffeeDo(ws, expression) {
       ...parameters,
       children: (() => {
         const results1 = [];
-        for (let ref22 = parameters.children, i13 = 0, len12 = ref22.length; i13 < len12; i13++) {
-          let parameter = ref22[i13];
+        for (let ref23 = parameters.children, i14 = 0, len13 = ref23.length; i14 < len13; i14++) {
+          let parameter = ref23[i14];
           if (typeof parameter === "object" && parameter != null && "type" in parameter && parameter.type === "Parameter") {
-            let ref23;
-            if (ref23 = parameter.initializer) {
-              const initializer = ref23;
+            let ref24;
+            if (ref24 = parameter.initializer) {
+              const initializer = ref24;
               args.push(initializer.expression, parameter.delim);
               parameter = {
                 ...parameter,
                 initializer: void 0,
-                children: parameter.children.filter((a4) => a4 !== initializer)
+                children: parameter.children.filter((a5) => a5 !== initializer)
               };
             } else {
               args.push(parameter.children.filter(
-                (a5) => a5 !== parameter.typeSuffix
+                (a6) => a6 !== parameter.typeSuffix
               ));
             }
           }
@@ -3696,7 +3716,7 @@ function makeAmpersandFunction(rhs) {
   }
   if (gatherRecursiveWithinFunction(
     block,
-    (a6) => a6 === ref
+    (a7) => a7 === ref
   ).length > 1) {
     fn.ampersandBlock = false;
   }
@@ -5373,7 +5393,6 @@ function processUnaryNestedExpression(pre, args, post) {
 
 // source/parser/pipe.civet
 function constructInvocation(fn, arg) {
-  const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
   let expr = fn.expr;
   while (expr.type === "ParenthesizedExpression") {
     expr = expr.expression;
@@ -5390,22 +5409,46 @@ function constructInvocation(fn, arg) {
     });
   }
   expr = fn.expr;
-  const lhs = makeLeftHandSideExpression(expr);
+  let lhs = expr;
+  if (!(lhs.type === "NewExpression")) {
+    lhs = makeLeftHandSideExpression(lhs);
+  }
   let comment = skipIfOnlyWS(fn.trailingComment);
   if (comment)
-    lhs.children.splice(2, 0, comment);
+    lhs.children.push(comment);
   comment = skipIfOnlyWS(fn.leadingComment);
   if (comment)
     lhs.children.splice(1, 0, comment);
   switch (arg.type) {
-    case "CommaExpression":
+    case "CommaExpression": {
       arg = makeLeftHandSideExpression(arg);
       break;
+    }
   }
-  return {
-    type: "CallExpression",
-    children: [lhs, "(", arg, ")"]
+  const args = [arg];
+  const call = {
+    type: "Call",
+    args,
+    children: ["(", args, ")"]
   };
+  if (lhs.type === "NewExpression") {
+    let { expression } = lhs;
+    expression = {
+      ...expression,
+      type: "CallExpression",
+      children: [...expression.children, call]
+    };
+    return {
+      ...lhs,
+      expression,
+      children: lhs.children.map(($) => $ === lhs.expression ? expression : $)
+    };
+  } else {
+    return {
+      type: "CallExpression",
+      children: [lhs, call]
+    };
+  }
 }
 function constructPipeStep(fn, arg, returning) {
   if (!returning) {
@@ -5452,21 +5495,24 @@ function processPipelineExpressions(statements) {
     let i = 0, l = body.length;
     const children = [ws];
     let usingRef = null;
-    for (i = 0; i < l; i++) {
-      const step = body[i];
+    for (let i1 = 0, len3 = body.length; i1 < len3; i1++) {
+      const i2 = i1;
+      const step = body[i1];
       const [leadingComment, pipe, trailingComment, expr] = step;
       const returns = pipe.token === "||>";
       let ref, result, returning = returns ? arg : null;
       if (pipe.token === "|>=") {
         let initRef;
-        if (i === 0) {
+        if (i2 === 0) {
           checkValidLHS(arg);
           outer:
             switch (arg.type) {
-              case "MemberExpression":
-                if (arg.children.length <= 2)
+              case "MemberExpression": {
+                if (arg.children.length <= 2) {
                   break;
-              case "CallExpression":
+                }
+              }
+              case "CallExpression": {
                 const access = arg.children.pop();
                 usingRef = makeRef();
                 initRef = {
@@ -5478,6 +5524,7 @@ function processPipelineExpressions(statements) {
                   children: [usingRef, access]
                 };
                 break;
+              }
             }
           const lhs = [[
             [initRef],
@@ -5506,7 +5553,7 @@ function processPipelineExpressions(statements) {
           });
         }
       } else {
-        if (i === 0)
+        if (i2 === 0)
           s.children = children;
       }
       if (returns && (ref = needsRef(arg))) {
@@ -5531,7 +5578,7 @@ function processPipelineExpressions(statements) {
         returning
       );
       if (result.type === "ReturnStatement") {
-        if (i < l - 1) {
+        if (i2 < l - 1) {
           result.children.push({
             type: "Error",
             message: "Can't continue a pipeline after returning"
@@ -5559,7 +5606,7 @@ function processPipelineExpressions(statements) {
       };
     }
     children.push(arg);
-    if (!children.some(($) => $?.type === "ReturnStatement") && children.some(($1) => $1 === ",")) {
+    if (!children.some(($1) => $1?.type === "ReturnStatement") && children.some(($2) => $2 === ",")) {
       const { parent } = s;
       const parenthesizedExpression = makeLeftHandSideExpression({ ...s });
       Object.assign(s, parenthesizedExpression, {
@@ -5845,7 +5892,8 @@ function processForInOf($0) {
       blockPrefix.push(["", {
         type: "Declaration",
         children: [declaration, " = ", trimFirstSpace(expRef2), "[", counterRef, "]"],
-        names: assignmentNames
+        names: assignmentNames,
+        implicitLift: true
       }, ";"]);
       declaration = {
         type: "Declaration",
@@ -6933,19 +6981,19 @@ function lastAccessInCallExpression(exp) {
 }
 function convertMethodToFunction(method) {
   const { signature, block } = method;
-  let { modifier, optional } = signature;
-  if (optional)
+  const { async, modifier, optional } = signature;
+  if (optional) {
     return;
-  if (modifier) {
-    if (modifier.get || modifier.set) {
-      return;
-    } else if (modifier.async) {
-      modifier = [modifier.children[0][0], " function ", ...modifier.children.slice(1)];
-    } else {
-      modifier = ["function ", ...modifier.children || []];
+  }
+  if (modifier?.get || modifier?.set) {
+    return;
+  }
+  const func = ["function "];
+  if (async != null) {
+    func.unshift(async);
+    if (async.length && !async[async.length - 1]?.length) {
+      async.push(" ");
     }
-  } else {
-    modifier = "function ";
   }
   return {
     ...signature,
@@ -6953,7 +7001,7 @@ function convertMethodToFunction(method) {
     signature,
     type: "FunctionExpression",
     children: [
-      [modifier, ...signature.children.slice(1)],
+      [...func, ...signature.children.slice(1)],
       block
     ],
     block
@@ -7067,7 +7115,8 @@ function makeGetterMethod(name, ws, value, returnType, block, kind = { token: "g
     block = {
       type: "BlockStatement",
       expressions,
-      children: ["{ ", expressions, " }"]
+      children: ["{ ", expressions, " }"],
+      bare: false
     };
   }
   if (autoReturn) {
@@ -7780,7 +7829,13 @@ function processPlaceholders(statements) {
       }
     } else {
       let child;
+      let implicitLift;
       ({ ancestor, child } = findAncestor(exp, (ancestor2, child2) => {
+        const prevImplicitLift = implicitLift;
+        ({ implicitLift } = ancestor2);
+        if (prevImplicitLift) {
+          return;
+        }
         const { type } = ancestor2;
         if (type === "IfStatement") {
           liftedIfs.add(ancestor2);
@@ -7866,7 +7921,7 @@ function processPlaceholders(statements) {
       const placeholder = placeholders[i15];
       typeSuffix ??= placeholder.typeSuffix;
       let ref26;
-      replaceNode((ref26 = placeholder.children)[ref26.length - 1], ref);
+      (ref26 = placeholder.children)[ref26.length - 1] = ref;
     }
     const { parent } = ancestor;
     const body = maybeUnwrap(ancestor);
@@ -8156,6 +8211,7 @@ var grammar = {
   LeftHandSideExpression,
   CallExpression,
   CallExpressionRest,
+  ExplicitCallExpressionRest,
   OptionalShorthand,
   OptionalDot,
   NonNullAssertion,
@@ -8439,8 +8495,8 @@ var grammar = {
   Debugger,
   MaybeNestedNonPipelineExpression,
   MaybeNestedPostfixedExpression,
+  NestedPostfixedExpressionNoTrailing,
   MaybeNestedExpression,
-  NestedExpression,
   MaybeParenNestedExpression,
   ImportDeclaration,
   ImpliedImport,
@@ -9453,7 +9509,7 @@ var ArgumentsWithTrailingCallExpressions$0 = (0, import_lib2.$TS)((0, import_lib
 function ArgumentsWithTrailingCallExpressions(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "ArgumentsWithTrailingCallExpressions", ArgumentsWithTrailingCallExpressions$0);
 }
-var TrailingCallExpressions$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$Q)(CallExpressionRest), (0, import_lib2.$E)(IndentedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2) {
+var TrailingCallExpressions$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$Q)(ExplicitCallExpressionRest), (0, import_lib2.$E)(IndentedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2) {
   $1 = $1.flat();
   if (!$1.length && !$2)
     return $skip;
@@ -9549,10 +9605,10 @@ 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)(Nested, (0, import_lib2.$N)(Bullet), SingleLineArgumentExpressions, ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
-  var indent = $1;
-  var args = $3;
-  var comma = $4;
+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 indent = $2;
+  var args = $4;
+  var comma = $5;
   let [arg0, ...rest] = args;
   arg0 = prepend(indent, arg0);
   return [arg0, ...rest, comma];
@@ -10742,6 +10798,32 @@ var CallExpressionRest$$ = [CallExpressionRest$0, CallExpressionRest$1, CallExpr
 function CallExpressionRest(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "CallExpressionRest", CallExpressionRest$$);
 }
+var ExplicitCallExpressionRest$0 = MemberExpressionRest;
+var ExplicitCallExpressionRest$1 = (0, import_lib2.$T)((0, import_lib2.$S)(TypeArguments, (0, import_lib2.$N)((0, import_lib2.$C)(IdentifierName, NumericLiteral))), function(value) {
+  return value[0];
+});
+var ExplicitCallExpressionRest$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($R8, "ExplicitCallExpressionRest /(?=['\"`])/"), (0, import_lib2.$C)(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2) {
+  var literal = $2;
+  if (literal.type === "StringLiteral") {
+    literal = "`" + literal.token.slice(1, -1).replace(/(`|\$\{)/g, "\\$1") + "`";
+  }
+  return literal;
+});
+var ExplicitCallExpressionRest$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(OptionalShorthand), ExplicitArguments), function($skip, $loc, $0, $1, $2) {
+  var optional = $1;
+  var call = $2;
+  if (!optional)
+    return call;
+  return {
+    ...call,
+    children: [optional, ...call.children],
+    optional
+  };
+});
+var ExplicitCallExpressionRest$$ = [ExplicitCallExpressionRest$0, ExplicitCallExpressionRest$1, ExplicitCallExpressionRest$2, ExplicitCallExpressionRest$3];
+function ExplicitCallExpressionRest(ctx, state2) {
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "ExplicitCallExpressionRest", ExplicitCallExpressionRest$$);
+}
 var OptionalShorthand$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($R9, "OptionalShorthand /(?=[\\/?])/"), (0, import_lib2.$Q)(InlineComment), QuestionMark, OptionalDot), function($skip, $loc, $0, $1, $2, $3, $4) {
   var comments = $2;
   var q = $3;
@@ -11379,7 +11461,8 @@ var NWBindingIdentifier$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(At, AtIdent
   return {
     type: "AtBinding",
     children: [ref],
-    ref
+    ref,
+    names: []
   };
 });
 var NWBindingIdentifier$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Hash, AtIdentifierRef), function($skip, $loc, $0, $1, $2) {
@@ -11388,7 +11471,8 @@ var NWBindingIdentifier$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Hash, AtIde
   return {
     type: "AtBinding",
     children: [ref],
-    ref
+    ref,
+    names: []
   };
 });
 var NWBindingIdentifier$2 = Identifier;
@@ -13504,52 +13588,23 @@ var MethodDefinition$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Abstract, __,
     abstract: true,
     signature,
     parameters: signature.parameters,
+    async: signature.async,
+    generator: signature.generator,
     ts: true
   };
 });
 var MethodDefinition$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(MethodSignature, (0, import_lib2.$N)((0, import_lib2.$C)(PropertyAccess, ExplicitPropertyGlob, UnaryPostfix, NonNullAssertion)), (0, import_lib2.$E)(BracedBlock)), function($skip, $loc, $0, $1, $2, $3) {
   var signature = $1;
   var block = $3;
-  let children = $0;
-  let generatorPos = 0;
-  let { modifier } = signature;
-  if (hasAwait(block)) {
-    generatorPos++;
-    children = children.slice();
-    if (modifier?.get || modifier?.set) {
-      children.push({
-        type: "Error",
-        message: "Getters and setters cannot be async"
-      });
-    } else if (modifier?.async) {
-    } else {
-      children.unshift("async ");
-      modifier = { ...modifier, async: true };
-      signature = { ...signature, modifier };
-    }
-  }
-  if (hasYield(block)) {
-    if (children === $0)
-      children = children.slice();
-    if (modifier?.get || modifier?.set) {
-      children.push({
-        type: "Error",
-        message: "Getters and setters cannot be generators"
-      });
-    } else if (modifier?.generator) {
-    } else {
-      children.splice(generatorPos, 0, "*");
-      modifier = { ...modifier, generator: true };
-      signature = { ...signature, modifier };
-    }
-  }
   return {
     type: "MethodDefinition",
-    children,
+    children: $0,
     name: signature.name,
     signature,
     block,
-    parameters: signature.parameters
+    parameters: signature.parameters,
+    async: signature.async,
+    generator: signature.generator
   };
 });
 var MethodDefinition$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(GetOrSet, (0, import_lib2.$E)(_), ForbidIndentedApplication, (0, import_lib2.$E)((0, import_lib2.$S)(MemberBase, (0, import_lib2.$Q)(CallExpressionRest), (0, import_lib2.$E)(ReturnTypeSuffix))), RestoreIndentedApplication, (0, import_lib2.$E)(BracedBlock)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
@@ -13632,36 +13687,38 @@ function MethodDefinition(ctx, state2) {
 }
 var MethodModifier$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(GetOrSet, (0, import_lib2.$E)(_), (0, import_lib2.$Y)(ClassElementName)), function($skip, $loc, $0, $1, $2, $3) {
   var kind = $1;
+  var ws = $2;
   return {
-    type: "MethodModifier",
-    async: false,
-    generator: false,
-    get: kind.token === "get",
-    set: kind.token === "set",
-    children: $0
-  };
-});
-var MethodModifier$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$S)(Async, __), (0, import_lib2.$E)((0, import_lib2.$S)(Star, __))), function($skip, $loc, $0, $1, $2) {
-  return {
-    type: "MethodModifier",
-    async: true,
-    get: false,
-    set: false,
-    generator: !!$2,
-    children: $0
+    // no async or generator, because getters and setters can't be
+    modifier: {
+      async: false,
+      generator: false,
+      get: kind.token === "get",
+      set: kind.token === "set"
+    },
+    children: [kind, ws]
   };
 });
-var MethodModifier$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(Star, __), function($skip, $loc, $0, $1, $2) {
+var MethodModifier$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(Async, __)), (0, import_lib2.$E)((0, import_lib2.$S)(Star, __))), function($skip, $loc, $0, $1, $2) {
+  var async = $1;
+  var generator = $2;
+  if (!async)
+    async = [];
+  if (!generator)
+    generator = [];
   return {
-    type: "MethodModifier",
-    async: false,
-    get: false,
-    set: false,
-    generator: true,
-    children: $0
+    async,
+    generator,
+    modifier: {
+      async: !!async.length,
+      get: false,
+      set: false,
+      generator: !!generator.length
+    },
+    children: [async, generator]
   };
 });
-var MethodModifier$$ = [MethodModifier$0, MethodModifier$1, MethodModifier$2];
+var MethodModifier$$ = [MethodModifier$0, MethodModifier$1];
 function MethodModifier(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "MethodModifier", MethodModifier$$);
 }
@@ -13676,10 +13733,12 @@ var MethodSignature$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ConstructorShor
     parameters
   };
 });
-var MethodSignature$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(MethodModifier), ClassElementName, (0, import_lib2.$E)(_), (0, import_lib2.$E)(QuestionMark), (0, import_lib2.$E)(_), NonEmptyParameters, (0, import_lib2.$E)(ReturnTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+var MethodSignature$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(MethodModifier, ClassElementName, (0, import_lib2.$E)(_), (0, import_lib2.$E)(QuestionMark), (0, import_lib2.$E)(_), NonEmptyParameters, (0, import_lib2.$E)(ReturnTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
   var modifier = $1;
   var name = $2;
+  var ws1 = $3;
   var optional = $4;
+  var ws2 = $5;
   var parameters = $6;
   var returnType = $7;
   if (name.name) {
@@ -13688,14 +13747,15 @@ var MethodSignature$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2
     name = name.token.match(/^(?:"|')/) ? name.token.slice(1, -1) : name.token;
   }
   if (optional)
-    $0[3] = optional = { ...optional, ts: true };
-  modifier = modifier || {};
+    optional = { ...optional, ts: true };
   return {
     type: "MethodSignature",
-    children: $0,
+    children: [...modifier.children, name, ws1, optional, ws2, parameters, returnType],
+    async: modifier.async,
+    generator: modifier.generator,
     name,
     optional,
-    modifier,
+    modifier: modifier.modifier,
     // get/set/async/generator
     returnType,
     parameters
@@ -15696,48 +15756,65 @@ function Debugger(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "Debugger", Debugger$0);
 }
 var MaybeNestedNonPipelineExpression$0 = NestedBulletedArray;
-var MaybeNestedNonPipelineExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, NonPipelineExpression)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
-  if ($3)
-    return $3;
-  return $skip;
+var MaybeNestedNonPipelineExpression$1 = NestedImplicitObjectLiteral;
+var MaybeNestedNonPipelineExpression$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, NonPipelineExpression)), PopIndent, (0, import_lib2.$E)(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2, $3, $4) {
+  var expression = $2;
+  var trailing = $4;
+  if (!expression)
+    return $skip;
+  if (!trailing)
+    return expression;
+  return [expression, trailing];
 });
-var MaybeNestedNonPipelineExpression$2 = NonPipelineExpression;
-var MaybeNestedNonPipelineExpression$$ = [MaybeNestedNonPipelineExpression$0, MaybeNestedNonPipelineExpression$1, MaybeNestedNonPipelineExpression$2];
+var MaybeNestedNonPipelineExpression$3 = NonPipelineExpression;
+var MaybeNestedNonPipelineExpression$$ = [MaybeNestedNonPipelineExpression$0, MaybeNestedNonPipelineExpression$1, MaybeNestedNonPipelineExpression$2, MaybeNestedNonPipelineExpression$3];
 function MaybeNestedNonPipelineExpression(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "MaybeNestedNonPipelineExpression", MaybeNestedNonPipelineExpression$$);
 }
 var MaybeNestedPostfixedExpression$0 = NestedBulletedArray;
-var MaybeNestedPostfixedExpression$1 = (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) {
-  if ($3)
-    return $3;
-  return $skip;
+var MaybeNestedPostfixedExpression$1 = NestedImplicitObjectLiteral;
+var MaybeNestedPostfixedExpression$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, PostfixedExpression)), PopIndent, (0, import_lib2.$E)(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2, $3, $4) {
+  var expression = $2;
+  var trailing = $4;
+  if (!expression)
+    return $skip;
+  if (!trailing)
+    return expression;
+  return [expression, trailing];
 });
-var MaybeNestedPostfixedExpression$2 = PostfixedExpression;
-var MaybeNestedPostfixedExpression$$ = [MaybeNestedPostfixedExpression$0, MaybeNestedPostfixedExpression$1, MaybeNestedPostfixedExpression$2];
+var MaybeNestedPostfixedExpression$3 = PostfixedExpression;
+var MaybeNestedPostfixedExpression$$ = [MaybeNestedPostfixedExpression$0, MaybeNestedPostfixedExpression$1, MaybeNestedPostfixedExpression$2, MaybeNestedPostfixedExpression$3];
 function MaybeNestedPostfixedExpression(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "MaybeNestedPostfixedExpression", MaybeNestedPostfixedExpression$$);
 }
+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) {
+  var expression = $2;
+  if (!expression)
+    return $skip;
+  return expression;
+});
+var NestedPostfixedExpressionNoTrailing$$ = [NestedPostfixedExpressionNoTrailing$0, NestedPostfixedExpressionNoTrailing$1, NestedPostfixedExpressionNoTrailing$2];
+function NestedPostfixedExpressionNoTrailing(ctx, state2) {
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "NestedPostfixedExpressionNoTrailing", NestedPostfixedExpressionNoTrailing$$);
+}
 var MaybeNestedExpression$0 = NestedBulletedArray;
-var MaybeNestedExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, Expression)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
-  if ($3)
-    return $3;
-  return $skip;
+var MaybeNestedExpression$1 = NestedImplicitObjectLiteral;
+var MaybeNestedExpression$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, Expression)), PopIndent, (0, import_lib2.$E)(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2, $3, $4) {
+  var expression = $2;
+  var trailing = $4;
+  if (!expression)
+    return $skip;
+  if (!trailing)
+    return expression;
+  return [expression, trailing];
 });
-var MaybeNestedExpression$2 = Expression;
-var MaybeNestedExpression$$ = [MaybeNestedExpression$0, MaybeNestedExpression$1, MaybeNestedExpression$2];
+var MaybeNestedExpression$3 = Expression;
+var MaybeNestedExpression$$ = [MaybeNestedExpression$0, MaybeNestedExpression$1, MaybeNestedExpression$2, MaybeNestedExpression$3];
 function MaybeNestedExpression(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "MaybeNestedExpression", MaybeNestedExpression$$);
 }
-var NestedExpression$0 = NestedBulletedArray;
-var NestedExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, Expression)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
-  if ($3)
-    return $3;
-  return $skip;
-});
-var NestedExpression$$ = [NestedExpression$0, NestedExpression$1];
-function NestedExpression(ctx, state2) {
-  return (0, import_lib2.$EVENT_C)(ctx, state2, "NestedExpression", NestedExpression$$);
-}
 var MaybeParenNestedExpression$0 = (0, import_lib2.$T)((0, import_lib2.$Y)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement, NoBlock)), function(value) {
   return "";
 });
@@ -15747,7 +15824,7 @@ var MaybeParenNestedExpression$1 = (0, import_lib2.$T)((0, import_lib2.$S)((0, i
 var MaybeParenNestedExpression$2 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$Y)(EOS), (0, import_lib2.$C)(ArrayLiteral, ObjectLiteral)), function(value) {
   return value[1];
 });
-var MaybeParenNestedExpression$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$Y)(EOS), InsertSpace, InsertOpenParen, PushIndent, (0, import_lib2.$S)(Nested, Expression), PopIndent, InsertNewline, InsertIndent, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+var MaybeParenNestedExpression$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$Y)(EOS), InsertSpace, InsertOpenParen, PushIndent, (0, import_lib2.$S)(Nested, Expression), PopIndent, (0, import_lib2.$E)(AllowedTrailingCallExpressions), InsertNewline, InsertIndent, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9, $10) {
   var exp = $5;
   if (!exp)
     return $skip;
@@ -17839,17 +17916,13 @@ var JSXAttributeName$$ = [JSXAttributeName$0, JSXAttributeName$1];
 function JSXAttributeName(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "JSXAttributeName", JSXAttributeName$$);
 }
-var JSXAttributeInitializer$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(CoffeeJSXEnabled), (0, import_lib2.$E)(Whitespace), Equals, (0, import_lib2.$Y)((0, import_lib2.$S)((0, import_lib2.$Q)(NonNewlineWhitespace), EOL)), InsertInlineOpenBrace, PushIndent, (0, import_lib2.$E)(PostfixedExpression), PopIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+var JSXAttributeInitializer$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(CoffeeJSXEnabled), (0, import_lib2.$E)(Whitespace), Equals, (0, import_lib2.$Y)((0, import_lib2.$S)((0, import_lib2.$Q)(NonNewlineWhitespace), EOL)), InsertInlineOpenBrace, NestedPostfixedExpressionNoTrailing, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
   var ws1 = $2;
   var equals = $3;
-  var ws2 = $4;
   var open = $5;
-  var indent = $6;
-  var expression = $7;
-  var close = $9;
-  if (!expression)
-    return $skip;
-  return [ws1, equals, ws2, open, indent, expression, close];
+  var expression = $6;
+  var close = $7;
+  return [ws1, equals, open, trimFirstSpace(expression), close];
 });
 var JSXAttributeInitializer$1 = (0, import_lib2.$S)((0, import_lib2.$E)(Whitespace), Equals, (0, import_lib2.$E)(Whitespace), JSXAttributeValue);
 var JSXAttributeInitializer$$ = [JSXAttributeInitializer$0, JSXAttributeInitializer$1];