@danielx/civet 0.7.34 → 0.7.36

package/dist/browser.js

@@ -573,11 +573,13 @@ ${body}`;
     processProgramAsync: () => processProgramAsync,
     processTryBlock: () => processTryBlock,
     processUnaryExpression: () => processUnaryExpression,
+    processUnaryNestedExpression: () => processUnaryNestedExpression,
     quoteString: () => quoteString,
     reorderBindingRestProperty: () => reorderBindingRestProperty,
     replaceNode: () => replaceNode,
     replaceNodes: () => replaceNodes,
     skipImplicitArguments: () => skipImplicitArguments,
+    stripTrailingImplicitComma: () => stripTrailingImplicitComma,
     trimFirstSpace: () => trimFirstSpace,
     typeOfJSX: () => typeOfJSX,
     wrapIIFE: () => wrapIIFE
@@ -714,6 +716,40 @@ ${body}`;
       return node.every(isWhitespaceOrEmpty);
     return false;
   }
+  function firstNonSpace(node) {
+    if (!(node != null)) {
+      return;
+    }
+    if (Array.isArray(node)) {
+      for (let i2 = 0, len22 = node.length; i2 < len22; i2++) {
+        const child = node[i2];
+        let ref1;
+        if (ref1 = firstNonSpace(child)) {
+          const first = ref1;
+          return first;
+        }
+      }
+      return void 0;
+    } else if (isParent(node)) {
+      let ref2;
+      if (ref2 = firstNonSpace(node.children)) {
+        const first = ref2;
+        return first;
+      } else {
+        return node;
+      }
+    } else if (isToken(node)) {
+      let m;
+      if (m = node.token, typeof m === "string" && /^[ \t]*$/.test(m)) {
+        return;
+      }
+    } else if (typeof node === "string") {
+      if (typeof node === "string" && /^[ \t]*$/.test(node)) {
+        return;
+      }
+    }
+    return node;
+  }
   function isExit(node) {
     if (!(node != null)) {
       return false;
@@ -751,6 +787,14 @@ ${body}`;
     ;
     return;
   }
+  function stripTrailingImplicitComma(children) {
+    const last = children[children.length - 1];
+    if (isComma(last) && last.implicit) {
+      return children.slice(0, -1);
+    } else {
+      return children;
+    }
+  }
   function insertTrimmingSpace(target, c) {
     if (!(target != null)) {
       return target;
@@ -923,8 +967,8 @@ ${body}`;
       return void 0;
     }
     if (Array.isArray(node)) {
-      for (let i2 = 0, len22 = node.length; i2 < len22; i2++) {
-        const child = node[i2];
+      for (let i3 = 0, len3 = node.length; i3 < len3; i3++) {
+        const child = node[i3];
         if (skip(child)) {
           continue;
         }
@@ -1011,6 +1055,9 @@ ${body}`;
         return expression;
       }
     }
+    return parenthesizeExpression(expression);
+  }
+  function parenthesizeExpression(expression) {
     return makeNode({
       type: "ParenthesizedExpression",
       children: ["(", expression, ")"],
@@ -1026,8 +1073,8 @@ ${body}`;
       return;
     }
     if (Array.isArray(node)) {
-      for (let i3 = 0, len3 = node.length; i3 < len3; i3++) {
-        const child = node[i3];
+      for (let i4 = 0, len4 = node.length; i4 < len4; i4++) {
+        const child = node[i4];
         updateParentPointers(child, parent, depth);
       }
       return;
@@ -1037,8 +1084,8 @@ ${body}`;
       node.parent = parent;
     }
     if (depth && isParent(node)) {
-      for (let ref1 = node.children, i4 = 0, len4 = ref1.length; i4 < len4; i4++) {
-        const child = ref1[i4];
+      for (let ref3 = node.children, i5 = 0, len5 = ref3.length; i5 < len5; i5++) {
+        const child = ref3[i5];
         updateParentPointers(child, node, depth - 1);
       }
     }
@@ -1168,8 +1215,8 @@ ${body}`;
         children.splice(1, 0, ".bind(this)");
       }
       if (gatherRecursiveWithinFunction(block, (a2) => typeof a2 === "object" && a2 != null && "token" in a2 && a2.token === "arguments").length) {
-        let ref2;
-        children[children.length - 1] = (ref2 = parameters.children)[ref2.length - 1] = "(arguments)";
+        let ref4;
+        children[children.length - 1] = (ref4 = parameters.children)[ref4.length - 1] = "(arguments)";
       }
     }
     const exp = makeNode({
@@ -1192,9 +1239,9 @@ ${body}`;
   }
   function flatJoin(array, separator) {
     const result = [];
-    for (let i5 = 0, len5 = array.length; i5 < len5; i5++) {
-      const i = i5;
-      const items = array[i5];
+    for (let i6 = 0, len6 = array.length; i6 < len6; i6++) {
+      const i = i6;
+      const items = array[i6];
       if (i) {
         result.push(separator);
       }
@@ -1593,12 +1640,6 @@ ${body}`;
   function isPromiseVoidType(t) {
     return t?.type === "TypeIdentifier" && t.raw === "Promise" && t.args?.types?.length === 1 && isVoidType(t.args.types[0]);
   }
-  function isGeneratorVoidType(t) {
-    return t?.type === "TypeIdentifier" && (t.raw === "Iterator" || t.raw === "Generator") && t.args?.types?.length >= 2 && isVoidType(t.args.types[1]);
-  }
-  function isAsyncGeneratorVoidType(t) {
-    return t?.type === "TypeIdentifier" && (t.raw === "AsyncIterator" || t.raw === "AsyncGenerator") && t.args?.types?.length >= 2 && isVoidType(t.args.types[1]);
-  }
   function implicitFunctionBlock(f) {
     if (f.abstract || f.block || f.signature?.optional)
       return;
@@ -1636,7 +1677,7 @@ ${body}`;
       const { async, generator, set } = modifier;
       const isMethod = f.type === "MethodDefinition";
       const isConstructor = isMethod && name === "constructor";
-      const isVoid = isVoidType(returnType2?.t) || async && (isPromiseVoidType(returnType2?.t) || generator && isAsyncGeneratorVoidType(returnType2?.t)) || !async && generator && isGeneratorVoidType(returnType2?.t);
+      const isVoid = generator || isVoidType(returnType2?.t) || async && isPromiseVoidType(returnType2?.t);
       if (block?.type === "BlockStatement") {
         if (isVoid || set || isConstructor) {
           if (block.bare && block.implicitlyReturned) {
@@ -1652,10 +1693,7 @@ ${body}`;
   }
   function processReturnValue(func) {
     const { block } = func;
-    const values = gatherRecursiveWithinFunction(
-      block,
-      ({ type }) => type === "ReturnValue"
-    );
+    const values = gatherRecursiveWithinFunction(block, ($) => $.type === "ReturnValue");
     if (!values.length) {
       return false;
     }
@@ -1665,7 +1703,7 @@ ${body}`;
       value.children = [ref];
       const { ancestor, child } = findAncestor(
         value,
-        ({ type }) => type === "Declaration",
+        ($1) => $1.type === "Declaration",
         isFunction
       );
       if (ancestor) {
@@ -1685,8 +1723,8 @@ ${body}`;
       }
     }
     if (declaration) {
-      if (!(declaration.suffix != null)) {
-        declaration.children[1] = declaration.suffix = returnType;
+      if (!(declaration.typeSuffix != null)) {
+        declaration.children[1] = declaration.typeSuffix = returnType;
       }
     } else {
       block.expressions.unshift([
@@ -2026,7 +2064,7 @@ ${body}`;
     let changed = false;
     for (const control of gatherRecursiveWithinFunction(
       statement.block,
-      ($) => $.type === "BreakStatement" || $.type === "ContinueStatement"
+      ($2) => $2.type === "BreakStatement" || $2.type === "ContinueStatement"
     )) {
       let controlName2 = function() {
         switch (control.type) {
@@ -2061,7 +2099,7 @@ ${body}`;
           )
         );
         updateParentPointers(control.with, control);
-        const i = control.children.findIndex(($1) => $1?.type === "Error");
+        const i = control.children.findIndex(($3) => $3?.type === "Error");
         if (i >= 0) {
           control.children.splice(i, 1);
         }
@@ -2185,8 +2223,8 @@ ${body}`;
     }
     if (hasYield(block) && !f.generator?.length) {
       if (f.type === "ArrowFunction") {
-        gatherRecursiveWithinFunction(block, ($2) => $2.type === "YieldExpression").forEach((y) => {
-          const i = y.children.findIndex(($3) => $3.type === "Yield");
+        gatherRecursiveWithinFunction(block, ($4) => $4.type === "YieldExpression").forEach((y) => {
+          const i = y.children.findIndex(($5) => $5.type === "Yield");
           return y.children.splice(i + 1, 0, {
             type: "Error",
             message: "Can't use yield inside of => arrow function"
@@ -2268,6 +2306,9 @@ ${body}`;
   function skipImplicitArguments(args) {
     if (args.length === 1) {
       let arg0 = args[0];
+      if (arg0.type === "Argument") {
+        arg0 = arg0.expression;
+      }
       if (arg0.type === "StatementExpression") {
         arg0 = arg0.statement;
       }
@@ -2310,12 +2351,13 @@ ${body}`;
       expression = {
         ...expression,
         parameters: newParameters,
-        children: expression.children.map(($4) => $4 === parameters ? newParameters : $4)
+        children: expression.children.map(($6) => $6 === parameters ? newParameters : $6)
       };
     }
     return {
       type: "CallExpression",
       children: [
+        ws,
         makeLeftHandSideExpression(expression),
         {
           type: "Call",
@@ -2331,7 +2373,7 @@ ${body}`;
       ref = makeRef("$");
       inplacePrepend(ref, body);
     }
-    if (startsWithPredicate(body, ($5) => $5.type === "ObjectExpression")) {
+    if (startsWithPredicate(body, ($7) => $7.type === "ObjectExpression")) {
       body = makeLeftHandSideExpression(body);
     }
     const parameters = makeNode({
@@ -3521,7 +3563,7 @@ ${body}`;
   function len2(arr, length) {
     return arr.length === length;
   }
-  function processAssignmentDeclaration(decl, pattern, suffix, ws, assign, e) {
+  function processAssignmentDeclaration(decl, pattern, typeSuffix, ws, assign, e) {
     decl = {
       ...decl,
       $loc: {
@@ -3533,7 +3575,7 @@ ${body}`;
     splices = splices.map((s) => [", ", s]);
     const thisAssignments = assignments.map((a) => ["", a, ";"]);
     if ("typeSuffix" in pattern) {
-      suffix ??= pattern.typeSuffix;
+      typeSuffix ??= pattern.typeSuffix;
     }
     const initializer = makeNode({
       type: "Initializer",
@@ -3545,9 +3587,9 @@ ${body}`;
       pattern,
       initializer,
       splices,
-      suffix,
+      typeSuffix,
       thisAssignments,
-      children: [pattern, suffix, initializer]
+      children: [pattern, typeSuffix, initializer]
     });
     const children = [decl, binding];
     return makeNode({
@@ -3564,9 +3606,9 @@ ${body}`;
     gatherRecursiveAll(statements, ($) => $.type === "Declaration").forEach((statement) => {
       const { bindings } = statement;
       return bindings?.forEach((binding) => {
-        const suffix = binding.suffix;
-        if (suffix && suffix.optional && suffix.t) {
-          convertOptionalType(suffix);
+        const { typeSuffix } = binding;
+        if (typeSuffix && typeSuffix.optional && typeSuffix.t) {
+          convertOptionalType(typeSuffix);
         }
         const { initializer } = binding;
         if (initializer) {
@@ -3647,8 +3689,8 @@ ${body}`;
     }
     const { decl, bindings } = condition.declaration;
     const binding = bindings[0];
-    let { pattern, suffix, initializer } = binding;
-    const nullCheck = suffix?.optional && !suffix.t && !suffix.nonnull;
+    let { pattern, typeSuffix, initializer } = binding;
+    const nullCheck = typeSuffix?.optional && !typeSuffix.t && !typeSuffix.nonnull;
     if (!(initializer != null)) {
       condition.children = [
         {
@@ -3686,14 +3728,14 @@ ${body}`;
       if (nullCheck) {
         children.unshift("(");
         children.push(") != null");
-        suffix = void 0;
+        typeSuffix = void 0;
       }
       Object.assign(condition, {
         type: "AssignmentExpression",
         children,
         hoistDec: !simple ? {
           type: "Declaration",
-          children: ["let ", ref, suffix],
+          children: ["let ", ref, typeSuffix],
           names: []
         } : void 0,
         pattern,
@@ -3701,7 +3743,7 @@ ${body}`;
       });
     }
     updateParentPointers(condition, parent);
-    rootCondition.blockPrefix = getPatternBlockPrefix(pattern, ref, decl, suffix);
+    rootCondition.blockPrefix = getPatternBlockPrefix(pattern, ref, decl, typeSuffix);
   }
   function processDeclarationConditions(node) {
     gatherRecursiveAll(
@@ -4079,6 +4121,10 @@ ${body}`;
           };
           pre = pre.slice(0, -1);
         } else {
+          let m;
+          if (m = firstNonSpace(exp), typeof m === "string" && /^[ \t]*\n/.test(m) || typeof m === "object" && m != null && "token" in m && typeof m.token === "string" && /^[ \t]*\n/.test(m.token)) {
+            exp = parenthesizeExpression(exp);
+          }
           exp = {
             type: "AwaitExpression",
             children: [...last.children, exp]
@@ -4094,6 +4140,77 @@ ${body}`;
       children: [...pre, exp, post]
     };
   }
+  function processUnaryNestedExpression(pre, args, post) {
+    const isArray = args.type === "ArrayExpression";
+    if (!isArray) {
+      args = stripTrailingImplicitComma(args);
+    }
+    if (isArray || args.length > 2) {
+      const last = pre[pre.length - 1];
+      if (!(typeof last === "object" && last != null && "type" in last && last.type === "Await")) {
+        return;
+      }
+      if (last.op) {
+        if (!isArray) {
+          args = {
+            type: "ArrayExpression",
+            children: ["[", args, "]"]
+          };
+        }
+      } else {
+        pre.pop();
+        if (!isArray) {
+          args = args;
+          args = {
+            type: "ArrayExpression",
+            children: [
+              "[",
+              ...(() => {
+                const results = [];
+                for (let i = 0, len3 = args.length; i < len3; i++) {
+                  const arg = args[i];
+                  if (typeof arg === "object" && arg != null && "type" in arg && arg.type === "Argument") {
+                    const expression = processUnaryExpression([last], arg.expression);
+                    results.push({
+                      ...arg,
+                      expression,
+                      children: arg.children.map(($) => $ === arg.expression ? expression : $)
+                    });
+                  } else {
+                    results.push(arg);
+                  }
+                }
+                return results;
+              })(),
+              "]"
+            ]
+          };
+        } else {
+          args = trimFirstSpace(args);
+          args = {
+            ...args,
+            children: args.children.map(
+              (arg) => {
+                if (typeof arg === "object" && arg != null && "type" in arg && arg.type === "ArrayElement" && "expression" in arg && "children" in arg) {
+                  const { type, expression: exp, children } = arg;
+                  let expression = processUnaryExpression([last], trimFirstSpace(exp));
+                  expression = prepend(getTrimmingSpace(exp), expression);
+                  return {
+                    ...arg,
+                    expression,
+                    children: children.map(($1) => $1 === exp ? expression : $1)
+                  };
+                } else {
+                  return arg;
+                }
+              }
+            )
+          };
+        }
+      }
+    }
+    return processUnaryExpression(pre, args, post);
+  }
 
   // source/parser/pipe.civet
   function constructInvocation(fn, arg) {
@@ -4131,36 +4248,31 @@ ${body}`;
     };
   }
   function constructPipeStep(fn, arg, returning) {
+    if (!returning) {
+      returning = null;
+    }
     let children = [[fn.leadingComment, fn.expr, fn.trailingComment].map(skipIfOnlyWS), " ", arg];
     switch (fn.expr.token) {
-      case "yield":
-      case "await":
-        if (fn.expr.op) {
-          children = processUnaryExpression([fn.expr], arg, void 0);
-        }
-        if (returning) {
-          return [
-            children,
-            returning
-          ];
-        }
+      case "await": {
+        children = processUnaryExpression([fn.expr], arg, void 0);
+      }
+      case "yield": {
         return [
           children,
-          null
+          returning
         ];
-      case "return":
+      }
+      case "return": {
         return [{
           type: "ReturnStatement",
           children
         }, null];
+      }
     }
-    if (returning) {
-      return [
-        constructInvocation(fn, arg),
-        returning
-      ];
-    }
-    return [constructInvocation(fn, arg), null];
+    return [
+      constructInvocation(fn, arg),
+      returning
+    ];
   }
   function processPipelineExpressions(statements) {
     gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
@@ -4417,7 +4529,29 @@ ${body}`;
         message: "'own' is only meaningful in for..in loops"
       };
     }
-    if (!declaration2 && !own) {
+    const { binding } = declaration;
+    let pattern = binding?.pattern;
+    if (binding?.typeSuffix || inOf.token === "in" && declaration2 && pattern.type !== "Identifier") {
+      const itemRef = makeRef(inOf.token === "in" ? "key" : "item");
+      blockPrefix.push(["", {
+        type: "Declaration",
+        children: [declaration, " = ", itemRef],
+        names: declaration.names
+      }, ";"]);
+      pattern = itemRef;
+      declaration = {
+        type: "ForDeclaration",
+        binding: {
+          type: "Binding",
+          pattern,
+          children: [pattern],
+          names: []
+        },
+        children: ["const ", itemRef],
+        names: []
+      };
+    }
+    if (!(declaration2 || own)) {
       return {
         declaration,
         blockPrefix,
@@ -4456,29 +4590,6 @@ ${body}`;
             children: [" ", expRef2, " =", exp]
           };
         }
-        const { binding } = declaration;
-        let { pattern } = binding;
-        if (!(pattern.type === "Identifier")) {
-          const keyRef = makeRef("key");
-          blockPrefix.push(["", [
-            declaration,
-            " = ",
-            keyRef
-          ], ";"]);
-          pattern = keyRef;
-          declaration = {
-            type: "ForDeclaration",
-            binding: {
-              type: "Binding",
-              pattern,
-              children: [pattern],
-              names: [],
-              suffix: binding.suffix
-            },
-            children: ["const ", keyRef],
-            names: []
-          };
-        }
         if (own) {
           const hasPropRef = getRef("hasProp");
           blockPrefix.push(["", ["if (!", hasPropRef, "(", insertTrimmingSpace(expRef2, ""), ", ", insertTrimmingSpace(pattern, ""), ")) continue"], ";"]);
@@ -6175,44 +6286,82 @@ ${js}`
   }
   function processTypes(node) {
     return gatherRecursiveAll(node, (n) => n.type === "TypeUnary").forEach((unary) => {
-      let last;
-      let count = 0;
-      let ref10;
-      while (unary.suffix.length && (ref10 = unary.suffix)[ref10.length - 1]?.token === "?") {
-        last = unary.suffix.pop();
-        count++;
-      }
-      if (!count) {
+      if (!unary.suffix.length) {
         return;
       }
-      let ref11;
-      if (unary.suffix.length || unary.prefix.length)
-        ref11 = unary;
-      else
-        ref11 = unary.t;
-      const t = ref11;
-      if (unary.parent?.type === "TypeTuple") {
-        if (count === 1) {
-          unary.suffix.push(last);
-          return;
+      let ref10;
+      let m3;
+      if (m3 = (ref10 = unary.suffix)[ref10.length - 1], typeof m3 === "object" && m3 != null && "token" in m3 && m3.token === "?") {
+        const { token } = m3;
+        let last;
+        let count = 0;
+        let ref11;
+        while (unary.suffix.length && (ref11 = unary.suffix)[ref11.length - 1]?.token === "?") {
+          last = unary.suffix.pop();
+          count++;
         }
-        replaceNode(unary, [
-          getTrimmingSpace(unary),
-          "(",
-          parenthesizeType(trimFirstSpace(t)),
-          " | null)",
-          last
-        ]);
-      } else {
-        replaceNode(unary, {
-          type: "TypeParenthesized",
-          ts: true,
-          children: [
+        let ref12;
+        while (unary.suffix.length && (ref12 = unary.suffix)[ref12.length - 1]?.type === "NonNullAssertion") {
+          unary.suffix.pop();
+        }
+        let ref13;
+        if (unary.suffix.length || unary.prefix.length)
+          ref13 = unary;
+        else
+          ref13 = unary.t;
+        const t = ref13;
+        if (unary.parent?.type === "TypeTuple") {
+          if (count === 1) {
+            unary.suffix.push(last);
+            return;
+          }
+          replaceNode(unary, [
             getTrimmingSpace(unary),
             "(",
             parenthesizeType(trimFirstSpace(t)),
-            count === 1 ? " | undefined" : " | undefined | null",
-            ")"
+            " | null)",
+            last
+          ]);
+        } else {
+          replaceNode(unary, {
+            type: "TypeParenthesized",
+            ts: true,
+            children: [
+              getTrimmingSpace(unary),
+              "(",
+              parenthesizeType(trimFirstSpace(t)),
+              count === 1 ? " | undefined" : " | undefined | null",
+              ")"
+            ]
+          });
+        }
+      } else if (typeof m3 === "object" && m3 != null && "type" in m3 && m3.type === "NonNullAssertion") {
+        const { type } = m3;
+        let ref14;
+        while (unary.suffix.length && (ref14 = unary.suffix)[ref14.length - 1]?.type === "NonNullAssertion") {
+          unary.suffix.pop();
+        }
+        let ref15;
+        while (unary.suffix.length && (ref15 = unary.suffix)[ref15.length - 1]?.token === "?") {
+          unary.suffix.pop();
+        }
+        const t = trimFirstSpace(
+          unary.suffix.length || unary.prefix.length ? unary : unary.t
+        );
+        const args = {
+          type: "TypeArguments",
+          ts: true,
+          types: [t],
+          children: ["<", t, ">"]
+        };
+        replaceNode(unary, {
+          type: "TypeIdentifier",
+          raw: "NonNullable",
+          args,
+          children: [
+            getTrimmingSpace(unary),
+            "NonNullable",
+            args
           ]
         });
       }
@@ -6222,11 +6371,11 @@ ${js}`
     gatherRecursiveAll(statements, ($7) => $7.type === "StatementExpression").forEach((_exp) => {
       const exp = _exp;
       const { statement } = exp;
-      let ref12;
+      let ref16;
       switch (statement.type) {
         case "IfStatement": {
-          if (ref12 = expressionizeIfStatement(statement)) {
-            const expression = ref12;
+          if (ref16 = expressionizeIfStatement(statement)) {
+            const expression = ref16;
             return replaceNode(statement, expression, exp);
           } else {
             return replaceNode(statement, wrapIIFE([["", statement]]), exp);
@@ -6289,6 +6438,7 @@ ${js}`
     assert.equal(state2.forbidBracedApplication.length, 1, "forbidBracedApplication");
     assert.equal(state2.forbidClassImplicitCall.length, 1, "forbidClassImplicitCall");
     assert.equal(state2.forbidIndentedApplication.length, 1, "forbidIndentedApplication");
+    assert.equal(state2.forbidNestedBinaryOp.length, 1, "forbidNestedBinaryOp");
     assert.equal(state2.forbidNewlineBinaryOp.length, 1, "forbidNewlineBinaryOp");
     assert.equal(state2.forbidTrailingMemberProperty.length, 1, "forbidTrailingMemberProperty");
     assert.equal(state2.JSXTagStack.length, 1, "JSXTagStack");
@@ -6372,10 +6522,10 @@ ${js}`
           if (type === "IfStatement") {
             liftedIfs.add(ancestor2);
           }
-          let m3;
           let m4;
+          let m5;
           return type === "Call" || // Block, except for if/else blocks when condition already lifted
-          type === "BlockStatement" && !((m3 = ancestor2.parent, typeof m3 === "object" && m3 != null && "type" in m3 && m3.type === "IfStatement") && liftedIfs.has(ancestor2.parent)) && !((m4 = ancestor2.parent, typeof m4 === "object" && m4 != null && "type" in m4 && m4.type === "ElseClause" && "parent" in m4 && typeof m4.parent === "object" && m4.parent != null && "type" in m4.parent && m4.parent.type === "IfStatement") && liftedIfs.has(ancestor2.parent.parent)) || type === "PipelineExpression" || // Declaration
+          type === "BlockStatement" && !((m4 = ancestor2.parent, typeof m4 === "object" && m4 != null && "type" in m4 && m4.type === "IfStatement") && liftedIfs.has(ancestor2.parent)) && !((m5 = ancestor2.parent, typeof m5 === "object" && m5 != null && "type" in m5 && m5.type === "ElseClause" && "parent" in m5 && typeof m5.parent === "object" && m5.parent != null && "type" in m5.parent && m5.parent.type === "IfStatement") && liftedIfs.has(ancestor2.parent.parent)) || type === "PipelineExpression" || // Declaration
           type === "Initializer" || // Right-hand side of assignment
           type === "AssignmentExpression" && findChildIndex(ancestor2, child2) === ancestor2.children.indexOf(ancestor2.expression) || type === "ReturnStatement" || type === "YieldExpression";
         }));
@@ -6454,14 +6604,18 @@ ${js}`
       for (let i4 = 0, len3 = placeholders.length; i4 < len3; i4++) {
         const placeholder = placeholders[i4];
         typeSuffix ??= placeholder.typeSuffix;
-        let ref13;
-        replaceNode((ref13 = placeholder.children)[ref13.length - 1], ref);
+        let ref17;
+        replaceNode((ref17 = placeholder.children)[ref17.length - 1], ref);
       }
       const { parent } = ancestor;
       const body = maybeUnwrap(ancestor);
       let fnExp = makeAmpersandFunction({ ref, typeSuffix, body });
       let outer;
       switch (parent?.type) {
+        case "Argument": {
+          outer = ancestor === parent.expression;
+          break;
+        }
         case "Call": {
           outer = ancestor === parent.args[findChildIndex(parent.args, ancestor)];
           break;
@@ -6472,16 +6626,16 @@ ${js}`
         }
         case "PipelineExpression": {
           const i = findChildIndex(parent, ancestor);
-          let ref14;
+          let ref18;
           if (i === 1) {
-            ref14 = ancestor === parent.children[i];
+            ref18 = ancestor === parent.children[i];
           } else if (i === 2) {
-            ref14 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
+            ref18 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
           } else {
-            ref14 = void 0;
+            ref18 = void 0;
           }
           ;
-          outer = ref14;
+          outer = ref18;
           break;
         }
         case "AssignmentExpression":
@@ -6496,9 +6650,9 @@ ${js}`
         fnExp = makeLeftHandSideExpression(fnExp);
       }
       replaceNode(ancestor, fnExp, parent);
-      let ref15;
-      if (ref15 = getTrimmingSpace(body)) {
-        const ws = ref15;
+      let ref19;
+      if (ref19 = getTrimmingSpace(body)) {
+        const ws = ref19;
         inplaceInsertTrimmingSpace(body, "");
         inplacePrepend(ws, fnExp);
       }
@@ -6543,8 +6697,8 @@ ${js}`
         }
       ];
     }
-    let ref16;
-    if (Array.isArray(rest.delim) && (ref16 = rest.delim)[ref16.length - 1]?.token === ",") {
+    let ref20;
+    if (Array.isArray(rest.delim) && (ref20 = rest.delim)[ref20.length - 1]?.token === ",") {
       rest.delim = rest.delim.slice(0, -1);
       rest.children = [...rest.children.slice(0, -1), rest.delim];
     }
@@ -6705,13 +6859,13 @@ ${js}`
     AllowedTrailingCallExpressions,
     CommaDelimiter,
     ArgumentList,
-    NonPipelineArgumentList,
     NestedArgumentList,
     NestedArgument,
     SingleLineArgumentExpressions,
+    WArgumentPart,
     ArgumentPart,
-    NonPipelineArgumentPart,
     BinaryOpExpression,
+    BinaryOpNotDedented,
     BinaryOpRHS,
     IsLike,
     WRHS,
@@ -6720,6 +6874,8 @@ ${js}`
     UnaryExpression,
     UnaryWithoutParenthesizedAssignment,
     UnaryBody,
+    MaybeNestedCoffeeDoBody,
+    CoffeeDoBody,
     UnaryWithoutParenthesizedAssignmentBody,
     ParenthesizedAssignment,
     UnaryPostfix,
@@ -6742,12 +6898,15 @@ ${js}`
     FatArrowToken,
     TrailingDeclaration,
     TrailingPipe,
+    TrailingPostfix,
     FatArrowBody,
     ConditionalExpression,
     TernaryRest,
     NestedTernaryRest,
     ShortCircuitExpression,
     PipelineExpression,
+    PipelineExpressionBody,
+    PipelineExpressionBodySameLine,
     PipelineHeadItem,
     PipelineTailItem,
     PrimaryExpression,
@@ -6957,7 +7116,6 @@ ${js}`
     PostfixedNoCommaStatement,
     PostfixedExpression,
     PostfixedCommaExpression,
-    NonPipelinePostfixedExpression,
     PostfixStatement,
     _PostfixStatement,
     Statement,
@@ -7035,10 +7193,18 @@ ${js}`
     AllowTrailingMemberProperty,
     RestoreTrailingMemberProperty,
     TrailingMemberPropertyAllowed,
+    AllowNestedBinaryOp,
+    ForbidNestedBinaryOp,
+    RestoreNestedBinaryOp,
+    NestedBinaryOpAllowed,
     AllowNewlineBinaryOp,
     ForbidNewlineBinaryOp,
     RestoreNewlineBinaryOp,
     NewlineBinaryOpAllowed,
+    AllowPipeline,
+    ForbidPipeline,
+    RestorePipeline,
+    PipelineAllowed,
     AllowAll,
     RestoreAll,
     CommaExpressionStatement,
@@ -7052,6 +7218,7 @@ ${js}`
     MaybeNestedNonPipelineExtendedExpression,
     MaybeNestedPostfixedExpression,
     MaybeNestedExtendedExpression,
+    NestedExtendedExpression,
     MaybeParenNestedExtendedExpression,
     ImportDeclaration,
     ImpliedImport,
@@ -7986,16 +8153,16 @@ ${js}`
   function Arguments(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "Arguments", Arguments$$);
   }
-  var ImplicitArguments$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(ApplicationStart, InsertOpenParen, (0, import_lib3.$E)(Trimmed_), NonPipelineArgumentList, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+  var ImplicitArguments$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(ApplicationStart, InsertOpenParen, (0, import_lib3.$E)(Trimmed_), ForbidNestedBinaryOp, ForbidPipeline, (0, import_lib3.$E)(ArgumentList), RestorePipeline, RestoreNestedBinaryOp, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
     var open = $2;
     var ws = $3;
-    var args = $4;
-    var close = $5;
+    var args = $6;
+    var close = $9;
+    if (!args)
+      return $skip;
     if (skipImplicitArguments(args))
       return $skip;
-    let last = args[args.length - 1];
-    if (last?.token === "," && last.implicit)
-      args = args.slice(0, -1);
+    args = stripTrailingImplicitComma(args);
     return {
       type: "Call",
       args,
@@ -8105,33 +8272,7 @@ ${js}`
   function CommaDelimiter(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "CommaDelimiter", CommaDelimiter$0);
   }
-  var ArgumentList$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(ArgumentPart, (0, import_lib3.$Q)((0, import_lib3.$S)(CommaDelimiter, (0, import_lib3.$N)(EOS), (0, import_lib3.$E)(_), ArgumentPart)), (0, import_lib3.$P)((0, import_lib3.$S)(CommaDelimiter, (0, import_lib3.$C)(NestedBulletedArray, NestedImplicitObjectLiteral, NestedArgumentList)))), function($skip, $loc, $0, $1, $2, $3) {
-    return [
-      $1,
-      ...$2.flatMap(([comma, eos, ws, arg]) => [comma, prepend(ws, arg)]),
-      ...$3.flatMap(
-        ([comma, args]) => Array.isArray(args) ? [comma, ...args] : [comma, args]
-      )
-    ];
-  });
-  var ArgumentList$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(NestedBulletedArray), function($skip, $loc, $0, $1) {
-    return [trimFirstSpace($1)];
-  });
-  var ArgumentList$2 = (0, import_lib3.$TS)((0, import_lib3.$S)(NestedImplicitObjectLiteral), function($skip, $loc, $0, $1) {
-    return [trimFirstSpace($1)];
-  });
-  var ArgumentList$3 = NestedArgumentList;
-  var ArgumentList$4 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$E)(_), ArgumentPart, (0, import_lib3.$Q)((0, import_lib3.$S)(CommaDelimiter, (0, import_lib3.$E)(_), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
-    return [
-      prepend($1, $2),
-      ...$3.flatMap(([comma, ws, arg]) => [comma, prepend(ws, arg)])
-    ];
-  });
-  var ArgumentList$$ = [ArgumentList$0, ArgumentList$1, ArgumentList$2, ArgumentList$3, ArgumentList$4];
-  function ArgumentList(ctx, state2) {
-    return (0, import_lib3.$EVENT_C)(ctx, state2, "ArgumentList", ArgumentList$$);
-  }
-  var NonPipelineArgumentList$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$N)(EOS), NonPipelineArgumentPart, (0, import_lib3.$Q)((0, import_lib3.$S)(CommaDelimiter, (0, import_lib3.$N)(EOS), (0, import_lib3.$E)(_), NonPipelineArgumentPart)), (0, import_lib3.$P)((0, import_lib3.$S)(CommaDelimiter, (0, import_lib3.$C)(NestedBulletedArray, NestedImplicitObjectLiteral, NestedArgumentList)))), function($skip, $loc, $0, $1, $2, $3, $4) {
+  var ArgumentList$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$N)(EOS), ArgumentPart, (0, import_lib3.$Q)((0, import_lib3.$S)(CommaDelimiter, (0, import_lib3.$N)(EOS), (0, import_lib3.$E)(_), ArgumentPart)), (0, import_lib3.$P)((0, import_lib3.$S)(CommaDelimiter, (0, import_lib3.$C)(NestedBulletedArray, NestedImplicitObjectLiteral, NestedArgumentList)))), function($skip, $loc, $0, $1, $2, $3, $4) {
     return [
       $2,
       ...$3.flatMap(([comma, eos, ws, arg]) => [comma, prepend(ws, arg)]),
@@ -8140,7 +8281,7 @@ ${js}`
       )
     ];
   });
-  var NonPipelineArgumentList$1 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$C)(NestedBulletedArray, NestedImplicitObjectLiteral), (0, import_lib3.$Q)((0, import_lib3.$S)(CommaDelimiter, (0, import_lib3.$C)(NestedBulletedArray, NestedImplicitObjectLiteral, NestedArgumentList)))), function($skip, $loc, $0, $1, $2) {
+  var ArgumentList$1 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$C)(NestedBulletedArray, NestedImplicitObjectLiteral), (0, import_lib3.$Q)((0, import_lib3.$S)(CommaDelimiter, (0, import_lib3.$C)(NestedBulletedArray, NestedImplicitObjectLiteral, NestedArgumentList)))), function($skip, $loc, $0, $1, $2) {
     return [
       trimFirstSpace($1),
       ...$2.flatMap(
@@ -8148,19 +8289,19 @@ ${js}`
       )
     ];
   });
-  var NonPipelineArgumentList$2 = NestedArgumentList;
-  var NonPipelineArgumentList$3 = (0, import_lib3.$TS)((0, import_lib3.$S)(NonPipelineArgumentPart, (0, import_lib3.$Q)((0, import_lib3.$S)(CommaDelimiter, (0, import_lib3.$E)(_), NonPipelineArgumentPart))), function($skip, $loc, $0, $1, $2) {
+  var ArgumentList$2 = NestedArgumentList;
+  var ArgumentList$3 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$E)(_), ArgumentPart, (0, import_lib3.$Q)((0, import_lib3.$S)(CommaDelimiter, (0, import_lib3.$E)(_), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
     return [
-      $1,
-      ...$2.flatMap(([comma, ws, arg]) => [comma, prepend(ws, arg)])
+      prepend($1, $2),
+      ...$3.flatMap(([comma, ws, arg]) => [comma, prepend(ws, arg)])
     ];
   });
-  var NonPipelineArgumentList$$ = [NonPipelineArgumentList$0, NonPipelineArgumentList$1, NonPipelineArgumentList$2, NonPipelineArgumentList$3];
-  function NonPipelineArgumentList(ctx, state2) {
-    return (0, import_lib3.$EVENT_C)(ctx, state2, "NonPipelineArgumentList", NonPipelineArgumentList$$);
+  var ArgumentList$$ = [ArgumentList$0, ArgumentList$1, ArgumentList$2, ArgumentList$3];
+  function ArgumentList(ctx, state2) {
+    return (0, import_lib3.$EVENT_C)(ctx, state2, "ArgumentList", ArgumentList$$);
   }
-  var NestedArgumentList$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(PushIndent, (0, import_lib3.$Q)(NestedArgument), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
-    var args = $2;
+  var NestedArgumentList$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(PushIndent, AllowPipeline, (0, import_lib3.$Q)(NestedArgument), RestorePipeline, PopIndent), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+    var args = $3;
     if (!args.length)
       return $skip;
     return args.flat();
@@ -8173,40 +8314,48 @@ ${js}`
     var args = $2;
     var comma = $3;
     let [arg0, ...rest] = args;
-    arg0 = [indent, ...arg0];
+    arg0 = prepend(indent, arg0);
     return [arg0, ...rest, comma];
   });
   function NestedArgument(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "NestedArgument", NestedArgument$0);
   }
-  var SingleLineArgumentExpressions$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$S)((0, import_lib3.$E)(_), ArgumentPart), (0, import_lib3.$Q)((0, import_lib3.$S)((0, import_lib3.$S)((0, import_lib3.$E)(_), Comma), (0, import_lib3.$S)((0, import_lib3.$E)(_), ArgumentPart)))), function($skip, $loc, $0, $1, $2) {
+  var SingleLineArgumentExpressions$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(WArgumentPart, (0, import_lib3.$Q)((0, import_lib3.$S)((0, import_lib3.$S)((0, import_lib3.$E)(_), Comma), WArgumentPart))), function($skip, $loc, $0, $1, $2) {
     return [$1, ...$2.flat()];
   });
   function SingleLineArgumentExpressions(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "SingleLineArgumentExpressions", SingleLineArgumentExpressions$0);
   }
-  var ArgumentPart$0 = (0, import_lib3.$S)(DotDotDot, ExtendedExpression);
+  var WArgumentPart$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$E)(_), ArgumentPart), function($skip, $loc, $0, $1, $2) {
+    return prepend($1, $2);
+  });
+  function WArgumentPart(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "WArgumentPart", WArgumentPart$0);
+  }
+  var ArgumentPart$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(DotDotDot, ExtendedExpression), function($skip, $loc, $0, $1, $2) {
+    var spread = $1;
+    var expression = $2;
+    return {
+      type: "Argument",
+      children: $0,
+      expression,
+      spread
+    };
+  });
   var ArgumentPart$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(ExtendedExpression, (0, import_lib3.$E)(DotDotDot)), function($skip, $loc, $0, $1, $2) {
-    if ($2) {
-      return [$2, $1];
-    }
-    return $1;
+    var expression = $1;
+    var spread = $2;
+    return {
+      type: "Argument",
+      children: spread ? [spread, expression] : [expression],
+      expression,
+      spread
+    };
   });
   var ArgumentPart$$ = [ArgumentPart$0, ArgumentPart$1];
   function ArgumentPart(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "ArgumentPart", ArgumentPart$$);
   }
-  var NonPipelineArgumentPart$0 = (0, import_lib3.$S)(DotDotDot, NonPipelineExtendedExpression);
-  var NonPipelineArgumentPart$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(NonPipelineExtendedExpression, (0, import_lib3.$E)(DotDotDot)), function($skip, $loc, $0, $1, $2) {
-    if ($2) {
-      return [$2, $1];
-    }
-    return $1;
-  });
-  var NonPipelineArgumentPart$$ = [NonPipelineArgumentPart$0, NonPipelineArgumentPart$1];
-  function NonPipelineArgumentPart(ctx, state2) {
-    return (0, import_lib3.$EVENT_C)(ctx, state2, "NonPipelineArgumentPart", NonPipelineArgumentPart$$);
-  }
   var BinaryOpExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(UnaryExpression, (0, import_lib3.$Q)(BinaryOpRHS)), function($skip, $loc, $0, $1, $2) {
     if (!$2.length)
       return $1;
@@ -8215,7 +8364,13 @@ ${js}`
   function BinaryOpExpression(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "BinaryOpExpression", BinaryOpExpression$0);
   }
-  var BinaryOpRHS$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(NotDedented, IsLike, (0, import_lib3.$E)(_), PatternExpressionList), function($skip, $loc, $0, $1, $2, $3, $4) {
+  var BinaryOpNotDedented$0 = (0, import_lib3.$T)((0, import_lib3.$S)((0, import_lib3.$C)(NestedBinaryOpAllowed, (0, import_lib3.$N)(Nested)), NotDedented), function(value) {
+    return value[1];
+  });
+  function BinaryOpNotDedented(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "BinaryOpNotDedented", BinaryOpNotDedented$0);
+  }
+  var BinaryOpRHS$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(BinaryOpNotDedented, IsLike, (0, import_lib3.$E)(_), PatternExpressionList), function($skip, $loc, $0, $1, $2, $3, $4) {
     var ws1 = $1;
     var op = $2;
     var ws2 = $3;
@@ -8278,17 +8433,18 @@ ${js}`
   function RHS(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "RHS", RHS$$);
   }
-  var UnaryExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$Q)(UnaryOp), UnaryBody, (0, import_lib3.$E)(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3) {
+  var UnaryExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(IndentedApplicationAllowed, (0, import_lib3.$P)(UnaryOp), (0, import_lib3.$C)(ArrayLiteral, NestedArgumentList), (0, import_lib3.$E)(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var pre = $2;
+    var args = $3;
+    var post = $4;
+    return processUnaryNestedExpression(pre, args, post) ?? $skip;
+  });
+  var UnaryExpression$1 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$Q)(UnaryOp), UnaryBody, (0, import_lib3.$E)(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3) {
     var pre = $1;
     var exp = $2;
     var post = $3;
     return processUnaryExpression(pre, exp, post);
   });
-  var UnaryExpression$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(CoffeeDoEnabled, Do, __, (0, import_lib3.$C)(ArrowFunction, (0, import_lib3.$S)(LeftHandSideExpression, (0, import_lib3.$N)((0, import_lib3.$S)(__, AssignmentOpSymbol))), ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
-    var ws = $3;
-    var exp = $4;
-    return processCoffeeDo(ws, exp);
-  });
   var UnaryExpression$$ = [UnaryExpression$0, UnaryExpression$1];
   function UnaryExpression(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "UnaryExpression", UnaryExpression$$);
@@ -8302,14 +8458,35 @@ ${js}`
   function UnaryWithoutParenthesizedAssignment(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "UnaryWithoutParenthesizedAssignment", UnaryWithoutParenthesizedAssignment$0);
   }
-  var UnaryBody$0 = ParenthesizedAssignment;
-  var UnaryBody$1 = ExpressionizedStatementWithTrailingCallExpressions;
-  var UnaryBody$2 = UpdateExpression;
-  var UnaryBody$3 = NestedNonAssignmentExtendedExpression;
-  var UnaryBody$$ = [UnaryBody$0, UnaryBody$1, UnaryBody$2, UnaryBody$3];
+  var UnaryBody$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(CoffeeDoEnabled, Do, MaybeNestedCoffeeDoBody), function($skip, $loc, $0, $1, $2, $3) {
+    var body = $3;
+    return processCoffeeDo(...body);
+  });
+  var UnaryBody$1 = ParenthesizedAssignment;
+  var UnaryBody$2 = ExpressionizedStatementWithTrailingCallExpressions;
+  var UnaryBody$3 = UpdateExpression;
+  var UnaryBody$4 = NestedNonAssignmentExtendedExpression;
+  var UnaryBody$$ = [UnaryBody$0, UnaryBody$1, UnaryBody$2, UnaryBody$3, UnaryBody$4];
   function UnaryBody(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "UnaryBody", UnaryBody$$);
   }
+  var MaybeNestedCoffeeDoBody$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(PushIndent, (0, import_lib3.$E)((0, import_lib3.$S)(Nested, CoffeeDoBody)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+    if (!$2)
+      return $skip;
+    return $2;
+  });
+  var MaybeNestedCoffeeDoBody$1 = (0, import_lib3.$S)((0, import_lib3.$E)(_), CoffeeDoBody);
+  var MaybeNestedCoffeeDoBody$$ = [MaybeNestedCoffeeDoBody$0, MaybeNestedCoffeeDoBody$1];
+  function MaybeNestedCoffeeDoBody(ctx, state2) {
+    return (0, import_lib3.$EVENT_C)(ctx, state2, "MaybeNestedCoffeeDoBody", MaybeNestedCoffeeDoBody$$);
+  }
+  var CoffeeDoBody$0 = ArrowFunction;
+  var CoffeeDoBody$1 = (0, import_lib3.$S)(LeftHandSideExpression, (0, import_lib3.$N)((0, import_lib3.$S)(__, AssignmentOpSymbol)));
+  var CoffeeDoBody$2 = ExtendedExpression;
+  var CoffeeDoBody$$ = [CoffeeDoBody$0, CoffeeDoBody$1, CoffeeDoBody$2];
+  function CoffeeDoBody(ctx, state2) {
+    return (0, import_lib3.$EVENT_C)(ctx, state2, "CoffeeDoBody", CoffeeDoBody$$);
+  }
   var UnaryWithoutParenthesizedAssignmentBody$0 = UpdateExpression;
   var UnaryWithoutParenthesizedAssignmentBody$1 = ExpressionizedStatementWithTrailingCallExpressions;
   var UnaryWithoutParenthesizedAssignmentBody$2 = NestedNonAssignmentExtendedExpression;
@@ -8508,7 +8685,7 @@ ${js}`
   var ArrowFunction$1 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$E)((0, import_lib3.$S)(Async, _)), ArrowParameters, (0, import_lib3.$E)(ReturnTypeSuffix), FatArrow, FatArrowBody), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
     var async = $1;
     var parameters = $2;
-    var suffix = $3;
+    var returnType = $3;
     var arrow = $4;
     var expOrBlock = $5;
     if (!async)
@@ -8519,13 +8696,13 @@ ${js}`
         modifier: {
           async: !!async.length
         },
-        returnType: suffix
+        returnType
       },
       parameters,
-      returnType: suffix,
+      returnType,
       async,
       block: expOrBlock,
-      children: [async, parameters, suffix, arrow, expOrBlock]
+      children: [async, parameters, returnType, arrow, expOrBlock]
     };
   });
   var ArrowFunction$$ = [ArrowFunction$0, ArrowFunction$1];
@@ -8556,7 +8733,11 @@ ${js}`
   function TrailingPipe(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "TrailingPipe", TrailingPipe$0);
   }
-  var FatArrowBody$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$N)(EOS), (0, import_lib3.$N)((0, import_lib3.$S)((0, import_lib3.$E)(_), ExpressionizedStatement)), NonPipelinePostfixedExpression, (0, import_lib3.$N)(TrailingDeclaration), (0, import_lib3.$N)(TrailingPipe), (0, import_lib3.$N)(SemicolonDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+  var TrailingPostfix$0 = (0, import_lib3.$S)((0, import_lib3.$E)(_), PostfixStatement);
+  function TrailingPostfix(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "TrailingPostfix", TrailingPostfix$0);
+  }
+  var FatArrowBody$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$N)(EOS), (0, import_lib3.$N)((0, import_lib3.$S)((0, import_lib3.$E)(_), ExpressionizedStatement)), NonPipelineExtendedExpression, (0, import_lib3.$N)(TrailingDeclaration), (0, import_lib3.$N)(TrailingPipe), (0, import_lib3.$N)(TrailingPostfix), (0, import_lib3.$N)(SemicolonDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
     var exp = $3;
     if (exp.type === "ObjectExpression") {
       exp = makeLeftHandSideExpression(exp);
@@ -8606,10 +8787,10 @@ ${js}`
   function ShortCircuitExpression(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "ShortCircuitExpression", ShortCircuitExpression$0);
   }
-  var PipelineExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$E)(_), PipelineHeadItem, (0, import_lib3.$P)((0, import_lib3.$S)(NotDedented, Pipe, __, PipelineTailItem))), function($skip, $loc, $0, $1, $2, $3) {
-    var ws = $1;
-    var head = $2;
-    var body = $3;
+  var PipelineExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(PipelineAllowed, (0, import_lib3.$E)(_), PipelineHeadItem, PipelineExpressionBody), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var ws = $2;
+    var head = $3;
+    var body = $4;
     if (head.type === "ArrowFunction" && head.ampersandBlock) {
       const expressions = [{
         type: "PipelineExpression",
@@ -8631,6 +8812,25 @@ ${js}`
   function PipelineExpression(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "PipelineExpression", PipelineExpression$0);
   }
+  var PipelineExpressionBody$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(PipelineExpressionBodySameLine, PushIndent, (0, import_lib3.$Q)((0, import_lib3.$S)((0, import_lib3.$S)(Nested, Pipe, __, PipelineTailItem), PipelineExpressionBodySameLine)), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var first = $1;
+    var rest = $3;
+    if (!rest.length)
+      return $skip;
+    return [
+      ...first,
+      ...rest.map(([nested, line]) => [nested, ...line]).flat()
+    ];
+  });
+  var PipelineExpressionBody$1 = (0, import_lib3.$P)((0, import_lib3.$S)(NotDedented, Pipe, __, PipelineTailItem));
+  var PipelineExpressionBody$$ = [PipelineExpressionBody$0, PipelineExpressionBody$1];
+  function PipelineExpressionBody(ctx, state2) {
+    return (0, import_lib3.$EVENT_C)(ctx, state2, "PipelineExpressionBody", PipelineExpressionBody$$);
+  }
+  var PipelineExpressionBodySameLine$0 = (0, import_lib3.$Q)((0, import_lib3.$S)((0, import_lib3.$E)(_), Pipe, __, PipelineTailItem));
+  function PipelineExpressionBodySameLine(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "PipelineExpressionBodySameLine", PipelineExpressionBodySameLine$0);
+  }
   var PipelineHeadItem$0 = NonPipelineExtendedExpression;
   var PipelineHeadItem$1 = ParenthesizedExpression;
   var PipelineHeadItem$$ = [PipelineHeadItem$0, PipelineHeadItem$1];
@@ -10257,7 +10457,7 @@ ${js}`
     var wid = $4;
     var w = $5;
     var parameters = $6;
-    var suffix = $7;
+    var returnType = $7;
     if (!async)
       async = [];
     if (!generator)
@@ -10268,7 +10468,7 @@ ${js}`
       id,
       name: id?.name,
       parameters,
-      returnType: suffix,
+      returnType,
       async,
       generator,
       modifier: {
@@ -10276,7 +10476,7 @@ ${js}`
         generator: !!generator.length
       },
       block: null,
-      children: !parameters.implicit ? [async, func, generator, wid, w, parameters, suffix] : [async, func, generator, wid, parameters, w, suffix]
+      children: !parameters.implicit ? [async, func, generator, wid, w, parameters, returnType] : [async, func, generator, wid, parameters, w, returnType]
       // move whitespace w to after implicit () in parameters
     };
   });
@@ -10475,7 +10675,7 @@ ${js}`
     var behavior = $7;
     var w2 = $8;
     var parameters = $9;
-    var suffix = $10;
+    var returnType = $10;
     if (!async)
       async = [];
     if (!generator)
@@ -10490,7 +10690,7 @@ ${js}`
       id,
       name: id.name,
       parameters,
-      returnType: suffix,
+      returnType,
       async,
       generator,
       modifier: {
@@ -10498,7 +10698,7 @@ ${js}`
         generator: !!generator.length
       },
       block: null,
-      children: [async, func, generator, w1, id, w2, parameters, suffix],
+      children: [async, func, generator, w1, id, w2, parameters, returnType],
       behavior
     };
   });
@@ -10545,7 +10745,7 @@ ${js}`
   var ThinArrowFunction$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$E)((0, import_lib3.$S)(Async, _)), ArrowParameters, (0, import_lib3.$E)(ReturnTypeSuffix), (0, import_lib3.$E)(_), Arrow, NoCommaBracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
     var async = $1;
     var parameters = $2;
-    var suffix = $3;
+    var returnType = $3;
     var arrow = $5;
     var block = $6;
     if (!async)
@@ -10555,7 +10755,7 @@ ${js}`
       type: "FunctionExpression",
       id: void 0,
       parameters,
-      returnType: suffix,
+      returnType,
       async,
       generator,
       block,
@@ -10567,14 +10767,14 @@ ${js}`
           async: !!async.length,
           generator: !!generator.length
         },
-        returnType: suffix
+        returnType
       },
       children: [
         async,
         { $loc: arrow.$loc, token: "function" },
         generator,
         parameters,
-        suffix,
+        returnType,
         block
       ]
     };
@@ -11271,6 +11471,7 @@ ${js}`
     return {
       type: "SpreadElement",
       children: [ws, dots, exp],
+      expression: exp,
       names: exp.names
     };
   });
@@ -11282,12 +11483,14 @@ ${js}`
         return {
           type: "ArrayElement",
           children: [exp],
+          expression: exp,
           names: exp.names
         };
       } else {
         return {
           type: "SpreadElement",
           children: [...spread, exp],
+          expression: exp,
           names: exp.names
         };
       }
@@ -11301,10 +11504,10 @@ ${js}`
   function ArrayElementExpression(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "ArrayElementExpression", ArrayElementExpression$$);
   }
-  var NestedBulletedArray$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$S)(InsertSpace, InsertOpenBracket), PushIndent, (0, import_lib3.$Q)(NestedArrayBullet), InsertCloseBracket, PopIndent), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+  var NestedBulletedArray$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$S)(InsertSpace, InsertOpenBracket), PushIndent, AllowPipeline, (0, import_lib3.$Q)(NestedArrayBullet), RestorePipeline, InsertCloseBracket, PopIndent), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
     var open = $1;
-    var content = $3;
-    var close = $4;
+    var content = $4;
+    var close = $6;
     if (!content.length)
       return $skip;
     content = content.flat();
@@ -11331,9 +11534,9 @@ ${js}`
       // replace first space with bracket
       ...content[1].flat()
     ];
-    const last = content[content.length - 1];
+    let last = content[content.length - 1];
     if (last.children?.at(-1)?.implicit) {
-      last.children = last.children.slice(0, -1);
+      content[content.length - 1] = last = { ...last, children: last.children.slice(0, -1) };
     }
     return {
       type: "ArrayExpression",
@@ -11471,8 +11674,8 @@ ${js}`
   function BracedObjectLiteralContent(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "BracedObjectLiteralContent", BracedObjectLiteralContent$$);
   }
-  var NestedImplicitObjectLiteral$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(InsertOpenBrace, PushIndent, (0, import_lib3.$E)(NestedImplicitPropertyDefinitions), PopIndent, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
-    var properties = $3;
+  var NestedImplicitObjectLiteral$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(InsertOpenBrace, PushIndent, AllowPipeline, (0, import_lib3.$E)(NestedImplicitPropertyDefinitions), RestorePipeline, PopIndent, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+    var properties = $4;
     if (!properties)
       return $skip;
     return {
@@ -12165,18 +12368,23 @@ ${js}`
     return (0, import_lib3.$EVENT_C)(ctx, state2, "CoffeeWordAssignmentOp", CoffeeWordAssignmentOp$$);
   }
   var NotDedentedBinaryOp$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$E)(IndentedFurther), (0, import_lib3.$E)(_), BinaryOp), function($skip, $loc, $0, $1, $2, $3) {
+    var ws1 = $1;
+    var ws2 = $2;
+    var op = $3;
     const ws = [];
-    if ($1)
-      ws.push(...$1);
-    if ($2)
-      ws.push(...$2);
-    return [ws, $3];
+    if (ws1)
+      ws.push(...ws1);
+    if (ws2)
+      ws.push(...ws2);
+    return [ws, op];
   });
-  var NotDedentedBinaryOp$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(Nested, (0, import_lib3.$E)(_), (0, import_lib3.$N)(Identifier), (0, import_lib3.$C)((0, import_lib3.$N)((0, import_lib3.$EXPECT)($L75, 'NotDedentedBinaryOp "*"')), (0, import_lib3.$N)(ImportDeclaration)), BinaryOp), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
-    var op = $5;
-    const ws = [...$1];
-    if ($2)
-      ws.push(...$2);
+  var NotDedentedBinaryOp$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(NestedBinaryOpAllowed, Nested, (0, import_lib3.$E)(_), (0, import_lib3.$N)(Identifier), (0, import_lib3.$C)((0, import_lib3.$N)((0, import_lib3.$EXPECT)($L75, 'NotDedentedBinaryOp "*"')), (0, import_lib3.$N)(ImportDeclaration)), BinaryOp), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+    var ws1 = $2;
+    var ws2 = $3;
+    var op = $6;
+    const ws = [...ws1];
+    if (ws2)
+      ws.push(...ws2);
     return [ws, op];
   });
   var NotDedentedBinaryOp$$ = [NotDedentedBinaryOp$0, NotDedentedBinaryOp$1];
@@ -12604,16 +12812,6 @@ ${js}`
   function PostfixedCommaExpression(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "PostfixedCommaExpression", PostfixedCommaExpression$0);
   }
-  var NonPipelinePostfixedExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(NonPipelineExtendedExpression, (0, import_lib3.$E)((0, import_lib3.$S)((0, import_lib3.$E)(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
-    var expression = $1;
-    var post = $2;
-    if (post)
-      return attachPostfixStatementAsExpression(expression, post);
-    return expression;
-  });
-  function NonPipelinePostfixedExpression(ctx, state2) {
-    return (0, import_lib3.$EVENT)(ctx, state2, "NonPipelinePostfixedExpression", NonPipelinePostfixedExpression$0);
-  }
   var PostfixStatement$0 = (0, import_lib3.$T)((0, import_lib3.$S)((0, import_lib3.$EXPECT)($R29, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
     return value[1];
   });
@@ -13223,14 +13421,14 @@ ${js}`
   }
   var ForBinding$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$C)(BindingPattern, BindingIdentifier), (0, import_lib3.$E)(TypeSuffix)), function($skip, $loc, $0, $1, $2) {
     var pattern = $1;
-    var suffix = $2;
-    suffix ??= pattern.typeSuffix;
+    var typeSuffix = $2;
+    typeSuffix ??= pattern.typeSuffix;
     return {
       type: "Binding",
-      children: [pattern, suffix],
+      children: [pattern, typeSuffix],
       names: pattern.names,
       pattern,
-      suffix,
+      typeSuffix,
       splices: [],
       thisAssignments: []
     };
@@ -13703,6 +13901,34 @@ ${js}`
   function TrailingMemberPropertyAllowed(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "TrailingMemberPropertyAllowed", TrailingMemberPropertyAllowed$0);
   }
+  var AllowNestedBinaryOp$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L0, 'AllowNestedBinaryOp ""'), function($skip, $loc, $0, $1) {
+    state.forbidNestedBinaryOp.push(false);
+  });
+  function AllowNestedBinaryOp(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "AllowNestedBinaryOp", AllowNestedBinaryOp$0);
+  }
+  var ForbidNestedBinaryOp$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L0, 'ForbidNestedBinaryOp ""'), function($skip, $loc, $0, $1) {
+    state.forbidNestedBinaryOp.push(true);
+  });
+  function ForbidNestedBinaryOp(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "ForbidNestedBinaryOp", ForbidNestedBinaryOp$0);
+  }
+  var RestoreNestedBinaryOp$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L0, 'RestoreNestedBinaryOp ""'), function($skip, $loc, $0, $1) {
+    state.forbidNestedBinaryOp.pop();
+  });
+  function RestoreNestedBinaryOp(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "RestoreNestedBinaryOp", RestoreNestedBinaryOp$0);
+  }
+  var NestedBinaryOpAllowed$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L0, 'NestedBinaryOpAllowed ""'), function($skip, $loc, $0, $1) {
+    if (config.verbose) {
+      console.log("forbidNestedBinaryOp:", state.forbidNestedBinaryOp);
+    }
+    if (state.nestedBinaryOpForbidden)
+      return $skip;
+  });
+  function NestedBinaryOpAllowed(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "NestedBinaryOpAllowed", NestedBinaryOpAllowed$0);
+  }
   var AllowNewlineBinaryOp$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L0, 'AllowNewlineBinaryOp ""'), function($skip, $loc, $0, $1) {
     state.forbidNewlineBinaryOp.push(false);
   });
@@ -13731,11 +13957,39 @@ ${js}`
   function NewlineBinaryOpAllowed(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "NewlineBinaryOpAllowed", NewlineBinaryOpAllowed$0);
   }
-  var AllowAll$0 = (0, import_lib3.$S)(AllowTrailingMemberProperty, AllowBracedApplication, AllowIndentedApplication, AllowClassImplicitCall, AllowNewlineBinaryOp);
+  var AllowPipeline$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L0, 'AllowPipeline ""'), function($skip, $loc, $0, $1) {
+    state.forbidPipeline.push(false);
+  });
+  function AllowPipeline(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "AllowPipeline", AllowPipeline$0);
+  }
+  var ForbidPipeline$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L0, 'ForbidPipeline ""'), function($skip, $loc, $0, $1) {
+    state.forbidPipeline.push(true);
+  });
+  function ForbidPipeline(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "ForbidPipeline", ForbidPipeline$0);
+  }
+  var RestorePipeline$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L0, 'RestorePipeline ""'), function($skip, $loc, $0, $1) {
+    state.forbidPipeline.pop();
+  });
+  function RestorePipeline(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "RestorePipeline", RestorePipeline$0);
+  }
+  var PipelineAllowed$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L0, 'PipelineAllowed ""'), function($skip, $loc, $0, $1) {
+    if (config.verbose) {
+      console.log("forbidPipeline:", state.forbidPipeline);
+    }
+    if (state.pipelineForbidden)
+      return $skip;
+  });
+  function PipelineAllowed(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "PipelineAllowed", PipelineAllowed$0);
+  }
+  var AllowAll$0 = (0, import_lib3.$S)(AllowTrailingMemberProperty, AllowBracedApplication, AllowIndentedApplication, AllowClassImplicitCall, AllowNestedBinaryOp, AllowNewlineBinaryOp, AllowPipeline);
   function AllowAll(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "AllowAll", AllowAll$0);
   }
-  var RestoreAll$0 = (0, import_lib3.$S)(RestoreTrailingMemberProperty, RestoreBracedApplication, RestoreIndentedApplication, RestoreClassImplicitCall, RestoreNewlineBinaryOp);
+  var RestoreAll$0 = (0, import_lib3.$S)(RestoreTrailingMemberProperty, RestoreBracedApplication, RestoreIndentedApplication, RestoreClassImplicitCall, RestoreNestedBinaryOp, RestoreNewlineBinaryOp, RestorePipeline);
   function RestoreAll(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "RestoreAll", RestoreAll$0);
   }
@@ -13867,6 +14121,16 @@ ${js}`
   function MaybeNestedExtendedExpression(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "MaybeNestedExtendedExpression", MaybeNestedExtendedExpression$$);
   }
+  var NestedExtendedExpression$0 = NestedBulletedArray;
+  var NestedExtendedExpression$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(PushIndent, (0, import_lib3.$E)((0, import_lib3.$S)(Nested, ExtendedExpression)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+    if ($3)
+      return $3;
+    return $skip;
+  });
+  var NestedExtendedExpression$$ = [NestedExtendedExpression$0, NestedExtendedExpression$1];
+  function NestedExtendedExpression(ctx, state2) {
+    return (0, import_lib3.$EVENT_C)(ctx, state2, "NestedExtendedExpression", NestedExtendedExpression$$);
+  }
   var MaybeParenNestedExtendedExpression$0 = (0, import_lib3.$T)((0, import_lib3.$S)((0, import_lib3.$N)(EOS), ExtendedExpression), function(value) {
     return value[1];
   });
@@ -14361,16 +14625,16 @@ ${js}`
   }
   var LexicalBinding$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(BindingPattern, (0, import_lib3.$E)(TypeSuffix), Initializer), function($skip, $loc, $0, $1, $2, $3) {
     var pattern = $1;
-    var suffix = $2;
+    var typeSuffix = $2;
     var initializer = $3;
     const [splices, thisAssignments] = gatherBindingCode(pattern);
-    suffix ??= pattern.typeSuffix;
+    typeSuffix ??= pattern.typeSuffix;
     return {
       type: "Binding",
-      children: [pattern, suffix, initializer],
+      children: [pattern, typeSuffix, initializer],
       names: pattern.names,
       pattern,
-      suffix,
+      typeSuffix,
       initializer,
       splices: splices.map((s) => [",", s]),
       thisAssignments: thisAssignments.map((s) => ["", s, ";"])
@@ -14378,14 +14642,14 @@ ${js}`
   });
   var LexicalBinding$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(BindingIdentifier, (0, import_lib3.$E)(TypeSuffix), (0, import_lib3.$E)(Initializer)), function($skip, $loc, $0, $1, $2, $3) {
     var pattern = $1;
-    var suffix = $2;
+    var typeSuffix = $2;
     var initializer = $3;
     return {
       type: "Binding",
       children: $0,
       names: pattern.names,
       pattern,
-      suffix,
+      typeSuffix,
       initializer,
       splices: [],
       thisAssignments: []
@@ -16330,14 +16594,14 @@ ${js}`
   }
   var UsingBinding$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(BindingIdentifier, (0, import_lib3.$E)(TypeSuffix), Initializer), function($skip, $loc, $0, $1, $2, $3) {
     var pattern = $1;
-    var suffix = $2;
+    var typeSuffix = $2;
     var initializer = $3;
     return {
       type: "Binding",
       children: $0,
       names: pattern.names,
       pattern,
-      suffix,
+      typeSuffix,
       initializer,
       splices: [],
       thisAssignments: []
@@ -16899,7 +17163,8 @@ ${js}`
   }
   var TypeUnarySuffix$0 = TypeIndexedAccess;
   var TypeUnarySuffix$1 = QuestionMark;
-  var TypeUnarySuffix$$ = [TypeUnarySuffix$0, TypeUnarySuffix$1];
+  var TypeUnarySuffix$2 = NonNullAssertion;
+  var TypeUnarySuffix$$ = [TypeUnarySuffix$0, TypeUnarySuffix$1, TypeUnarySuffix$2];
   function TypeUnarySuffix(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "TypeUnarySuffix", TypeUnarySuffix$$);
   }
@@ -17894,7 +18159,9 @@ ${js}`
     state.forbidIndentedApplication = [false];
     state.forbidBracedApplication = [false];
     state.forbidTrailingMemberProperty = [false];
+    state.forbidNestedBinaryOp = [false];
     state.forbidNewlineBinaryOp = [false];
+    state.forbidPipeline = [false];
     state.JSXTagStack = [void 0];
     state.operators = /* @__PURE__ */ new Map();
     state.helperRefs = {};
@@ -18165,12 +18432,24 @@ ${js}`
         return s[s.length - 1];
       }
     },
+    nestedBinaryOpForbidden: {
+      get() {
+        const { forbidNestedBinaryOp: s } = state;
+        return s[s.length - 1];
+      }
+    },
     newlineBinaryOpForbidden: {
       get() {
         const { forbidNewlineBinaryOp: s } = state;
         return s[s.length - 1];
       }
     },
+    pipelineForbidden: {
+      get() {
+        const { forbidPipeline: s } = state;
+        return s[s.length - 1];
+      }
+    },
     currentJSXTag: {
       get() {
         const { JSXTagStack: s } = state;
@@ -18179,12 +18458,12 @@ ${js}`
     }
   });
   function getStateKey() {
-    const stateInt = state.currentIndent.level % 256 << 8 | state.classImplicitCallForbidden << 7 | state.indentedApplicationForbidden << 6 | state.bracedApplicationForbidden << 5 | state.trailingMemberPropertyForbidden << 4 | state.newlineBinaryOpForbidden << 3 | // This is slightly different than the rest of the state,
+    const stateInt = state.currentIndent.level % 256 << 8 | state.classImplicitCallForbidden << 7 | state.indentedApplicationForbidden << 6 | state.bracedApplicationForbidden << 5 | state.trailingMemberPropertyForbidden << 4 | state.nestedBinaryOpForbidden << 3 | state.newlineBinaryOpForbidden << 2 | state.pipelineForbidden << 1 | // This is slightly different than the rest of the state,
     // since it is affected by the directive prologue and may be hit
     // by the EOL rule early in the parse. Later if we wanted to
     // allow block scoping of the compat directives we would need to
     // add them all here.
-    config.coffeeComment << 2;
+    config.coffeeComment << 0;
     return [stateInt, state.currentJSXTag];
   }
   function parseProgram(input, options) {
@@ -18584,21 +18863,27 @@ ${js}`
     "AllowBracedApplication",
     "AllowIndentedApplication",
     "AllowMultiLineImplicitObjectLiteral",
+    "AllowNestedBinaryOp",
     "AllowNewlineBinaryOp",
     "AllowTrailingMemberProperty",
+    "AllowPipeline",
     "ForbidClassImplicitCall",
     "ForbidBracedApplication",
     "ForbidIndentedApplication",
     "ForbidMultiLineImplicitObjectLiteral",
+    "ForbidNestedBinaryOp",
     "ForbidNewlineBinaryOp",
     "ForbidTrailingMemberProperty",
+    "ForbidPipeline",
     "RestoreAll",
     "RestoreClassImplicitCall",
     "RestoreMultiLineImplicitObjectLiteral",
     "RestoreBracedApplication",
     "RestoreIndentedApplication",
     "RestoreTrailingMemberProperty",
-    "RestoreNewlineBinaryOp"
+    "RestoreNestedBinaryOp",
+    "RestoreNewlineBinaryOp",
+    "RestorePipeline"
   ]);
   function compile(src, options) {
     if (!options) {
@@ -18743,13 +19028,16 @@ ${counts}`;
           };
         }
         if (trace) {
-          logs.push("".padStart(stack.length * 2, " ") + ruleName + ":" + state2.pos + "\u2192");
+          logs.push("".padStart(stack.length * 2, " ") + ruleName + ":" + state2.pos + "{");
           stack.push(ruleName);
         }
         return;
       },
       exit: function(ruleName, state2, result) {
         if (uncacheable.has(ruleName)) {
+          if (trace) {
+            logs.push("".padStart(stack.length * 2, " ") + ruleName + ":" + state2.pos + "\u26A0\uFE0F " + (result ? "\u2705" : "\u274C"));
+          }
           return;
         }
         const [stateKey, tagKey] = getStateKey();
@@ -18763,7 +19051,7 @@ ${counts}`;
         }
         if (trace) {
           stack.pop();
-          logs.push("".padStart(stack.length * 2, " ") + ruleName + ":" + state2.pos + " " + (result ? "\u2705" : "\u274C"));
+          logs.push("".padStart(stack.length * 2, " ") + ruleName + ":" + state2.pos + "} " + (result ? "\u2705" : "\u274C"));
         }
         return;
       }