@danielx/civet 0.8.16 → 0.8.17

package/dist/browser.js

@@ -1204,7 +1204,6 @@ ${body}`;
     "JSXElement",
     "JSXFragment",
     "Literal",
-    "NewExpression",
     "ParenthesizedExpression",
     "Ref",
     "Placeholder",
@@ -1226,7 +1225,10 @@ ${body}`;
       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;
       }
     }
@@ -1762,13 +1764,14 @@ ${body}`;
           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;
@@ -1780,8 +1783,8 @@ ${body}`;
     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) {
@@ -1793,8 +1796,8 @@ ${body}`;
       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) {
@@ -1832,8 +1835,8 @@ ${body}`;
         {
           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) {
@@ -2000,8 +2003,14 @@ ${body}`;
         // [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) {
@@ -2566,7 +2575,7 @@ ${js}`
     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";
@@ -3432,7 +3441,7 @@ ${js}`
     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");
@@ -3443,15 +3452,20 @@ ${js}`
         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;
@@ -3460,7 +3474,7 @@ ${js}`
               type: "FieldDefinition",
               id,
               typeSuffix,
-              children: [id, typeSuffix]
+              children: [accessModifier, id, typeSuffix]
             }, ";"]);
             fStatement[0] = "";
           }
@@ -3484,10 +3498,10 @@ ${js}`
     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");
@@ -3502,21 +3516,33 @@ ${js}`
   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)) {
@@ -3524,21 +3550,15 @@ ${js}`
     }
   }
   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;
@@ -3587,9 +3607,9 @@ ${js}`
     }
     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);
@@ -3606,8 +3626,8 @@ ${js}`
     }
   }
   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);
     }
   }
@@ -3633,21 +3653,21 @@ ${js}`
         ...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
                 ));
               }
             }
@@ -3720,7 +3740,7 @@ ${js}`
     }
     if (gatherRecursiveWithinFunction(
       block,
-      (a6) => a6 === ref
+      (a7) => a7 === ref
     ).length > 1) {
       fn.ampersandBlock = false;
     }
@@ -5397,7 +5417,6 @@ ${js}`
 
   // 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;
@@ -5414,22 +5433,46 @@ ${js}`
       });
     }
     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) {
@@ -5476,21 +5519,24 @@ ${js}`
       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 = {
@@ -5502,6 +5548,7 @@ ${js}`
                     children: [usingRef, access]
                   };
                   break;
+                }
               }
             const lhs = [[
               [initRef],
@@ -5530,7 +5577,7 @@ ${js}`
             });
           }
         } else {
-          if (i === 0)
+          if (i2 === 0)
             s.children = children;
         }
         if (returns && (ref = needsRef(arg))) {
@@ -5555,7 +5602,7 @@ ${js}`
           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"
@@ -5583,7 +5630,7 @@ ${js}`
         };
       }
       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, {
@@ -5869,7 +5916,8 @@ ${js}`
         blockPrefix.push(["", {
           type: "Declaration",
           children: [declaration, " = ", trimFirstSpace(expRef2), "[", counterRef, "]"],
-          names: assignmentNames
+          names: assignmentNames,
+          implicitLift: true
         }, ";"]);
         declaration = {
           type: "Declaration",
@@ -6957,19 +7005,19 @@ ${js}`
   }
   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,
@@ -6977,7 +7025,7 @@ ${js}`
       signature,
       type: "FunctionExpression",
       children: [
-        [modifier, ...signature.children.slice(1)],
+        [...func, ...signature.children.slice(1)],
         block
       ],
       block
@@ -7091,7 +7139,8 @@ ${js}`
       block = {
         type: "BlockStatement",
         expressions,
-        children: ["{ ", expressions, " }"]
+        children: ["{ ", expressions, " }"],
+        bare: false
       };
     }
     if (autoReturn) {
@@ -7804,7 +7853,13 @@ ${js}`
         }
       } 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);
@@ -7890,7 +7945,7 @@ ${js}`
         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);
@@ -8180,6 +8235,7 @@ ${js}`
     LeftHandSideExpression,
     CallExpression,
     CallExpressionRest,
+    ExplicitCallExpressionRest,
     OptionalShorthand,
     OptionalDot,
     NonNullAssertion,
@@ -8463,8 +8519,8 @@ ${js}`
     Debugger,
     MaybeNestedNonPipelineExpression,
     MaybeNestedPostfixedExpression,
+    NestedPostfixedExpressionNoTrailing,
     MaybeNestedExpression,
-    NestedExpression,
     MaybeParenNestedExpression,
     ImportDeclaration,
     ImpliedImport,
@@ -9477,7 +9533,7 @@ ${js}`
   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;
@@ -9573,10 +9629,10 @@ ${js}`
   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];
@@ -10766,6 +10822,32 @@ ${js}`
   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;
@@ -11403,7 +11485,8 @@ ${js}`
     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) {
@@ -11412,7 +11495,8 @@ ${js}`
     return {
       type: "AtBinding",
       children: [ref],
-      ref
+      ref,
+      names: []
     };
   });
   var NWBindingIdentifier$2 = Identifier;
@@ -13528,52 +13612,23 @@ ${js}`
       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) {
@@ -13656,36 +13711,38 @@ ${js}`
   }
   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$$);
   }
@@ -13700,10 +13757,12 @@ ${js}`
       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) {
@@ -13712,14 +13771,15 @@ ${js}`
       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
@@ -15720,48 +15780,65 @@ ${js}`
     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 "";
   });
@@ -15771,7 +15848,7 @@ ${js}`
   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;
@@ -17863,17 +17940,13 @@ ${js}`
   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];