@danielx/civet 0.7.34 → 0.7.36

package/dist/main.mjs

@@ -544,11 +544,13 @@ __export(lib_exports, {
   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
@@ -685,6 +687,40 @@ function isWhitespaceOrEmpty(node) {
     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;
@@ -722,6 +758,14 @@ function isComma(node) {
   ;
   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;
@@ -894,8 +938,8 @@ function startsWithPredicate(node, predicate, skip = isWhitespaceOrEmpty) {
     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;
       }
@@ -982,6 +1026,9 @@ function makeLeftHandSideExpression(expression) {
       return expression;
     }
   }
+  return parenthesizeExpression(expression);
+}
+function parenthesizeExpression(expression) {
   return makeNode({
     type: "ParenthesizedExpression",
     children: ["(", expression, ")"],
@@ -997,8 +1044,8 @@ function updateParentPointers(node, parent, depth = 1) {
     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;
@@ -1008,8 +1055,8 @@ function updateParentPointers(node, parent, depth = 1) {
     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);
     }
   }
@@ -1139,8 +1186,8 @@ function wrapIIFE(expressions, asyncFlag, generator) {
       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({
@@ -1163,9 +1210,9 @@ function wrapWithReturn(expression) {
 }
 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);
     }
@@ -1564,12 +1611,6 @@ function isVoidType(t) {
 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;
@@ -1607,7 +1648,7 @@ function processReturn(f, implicitReturns) {
     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) {
@@ -1623,10 +1664,7 @@ function processReturn(f, implicitReturns) {
 }
 function processReturnValue(func) {
   const { block } = func;
-  const values = gatherRecursiveWithinFunction(
-    block,
-    ({ type }) => type === "ReturnValue"
-  );
+  const values = gatherRecursiveWithinFunction(block, ($) => $.type === "ReturnValue");
   if (!values.length) {
     return false;
   }
@@ -1636,7 +1674,7 @@ function processReturnValue(func) {
     value.children = [ref];
     const { ancestor, child } = findAncestor(
       value,
-      ({ type }) => type === "Declaration",
+      ($1) => $1.type === "Declaration",
       isFunction
     );
     if (ancestor) {
@@ -1656,8 +1694,8 @@ function processReturnValue(func) {
     }
   }
   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([
@@ -1997,7 +2035,7 @@ function processBreakContinueWith(statement) {
   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) {
@@ -2032,7 +2070,7 @@ function processBreakContinueWith(statement) {
         )
       );
       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);
       }
@@ -2156,8 +2194,8 @@ function processSignature(f) {
   }
   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"
@@ -2239,6 +2277,9 @@ function expressionizeIteration(exp) {
 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;
     }
@@ -2281,12 +2322,13 @@ function processCoffeeDo(ws, expression) {
     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",
@@ -2302,7 +2344,7 @@ function makeAmpersandFunction(rhs) {
     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({
@@ -3492,7 +3534,7 @@ function aliasBinding(p, ref) {
 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: {
@@ -3504,7 +3546,7 @@ function processAssignmentDeclaration(decl, pattern, suffix, ws, assign, e) {
   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",
@@ -3516,9 +3558,9 @@ function processAssignmentDeclaration(decl, pattern, suffix, ws, assign, e) {
     pattern,
     initializer,
     splices,
-    suffix,
+    typeSuffix,
     thisAssignments,
-    children: [pattern, suffix, initializer]
+    children: [pattern, typeSuffix, initializer]
   });
   const children = [decl, binding];
   return makeNode({
@@ -3535,9 +3577,9 @@ function processDeclarations(statements) {
   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) {
@@ -3618,8 +3660,8 @@ function processDeclarationCondition(condition, rootCondition, parent) {
   }
   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 = [
       {
@@ -3657,14 +3699,14 @@ function processDeclarationCondition(condition, rootCondition, parent) {
     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,
@@ -3672,7 +3714,7 @@ function processDeclarationCondition(condition, rootCondition, parent) {
     });
   }
   updateParentPointers(condition, parent);
-  rootCondition.blockPrefix = getPatternBlockPrefix(pattern, ref, decl, suffix);
+  rootCondition.blockPrefix = getPatternBlockPrefix(pattern, ref, decl, typeSuffix);
 }
 function processDeclarationConditions(node) {
   gatherRecursiveAll(
@@ -4050,6 +4092,10 @@ function processUnaryExpression(pre, exp, post) {
         };
         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]
@@ -4065,6 +4111,77 @@ function processUnaryExpression(pre, exp, post) {
     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) {
@@ -4102,36 +4219,31 @@ function constructInvocation(fn, arg) {
   };
 }
 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) => {
@@ -4388,7 +4500,29 @@ function processForInOf($0, getRef) {
       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,
@@ -4427,29 +4561,6 @@ function processForInOf($0, getRef) {
           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"], ";"]);
@@ -6131,44 +6242,82 @@ function attachPostfixStatementAsExpression(exp, post) {
 }
 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
         ]
       });
     }
@@ -6178,11 +6327,11 @@ function processStatementExpressions(statements) {
   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);
@@ -6245,6 +6394,7 @@ function processProgram(root) {
   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");
@@ -6328,10 +6478,10 @@ function processPlaceholders(statements) {
         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";
       }));
@@ -6410,14 +6560,18 @@ function processPlaceholders(statements) {
     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;
@@ -6428,16 +6582,16 @@ function processPlaceholders(statements) {
       }
       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":
@@ -6452,9 +6606,9 @@ function processPlaceholders(statements) {
       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);
     }
@@ -6499,8 +6653,8 @@ function reorderBindingRestProperty(props) {
       }
     ];
   }
-  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];
   }
@@ -6661,13 +6815,13 @@ var grammar = {
   AllowedTrailingCallExpressions,
   CommaDelimiter,
   ArgumentList,
-  NonPipelineArgumentList,
   NestedArgumentList,
   NestedArgument,
   SingleLineArgumentExpressions,
+  WArgumentPart,
   ArgumentPart,
-  NonPipelineArgumentPart,
   BinaryOpExpression,
+  BinaryOpNotDedented,
   BinaryOpRHS,
   IsLike,
   WRHS,
@@ -6676,6 +6830,8 @@ var grammar = {
   UnaryExpression,
   UnaryWithoutParenthesizedAssignment,
   UnaryBody,
+  MaybeNestedCoffeeDoBody,
+  CoffeeDoBody,
   UnaryWithoutParenthesizedAssignmentBody,
   ParenthesizedAssignment,
   UnaryPostfix,
@@ -6698,12 +6854,15 @@ var grammar = {
   FatArrowToken,
   TrailingDeclaration,
   TrailingPipe,
+  TrailingPostfix,
   FatArrowBody,
   ConditionalExpression,
   TernaryRest,
   NestedTernaryRest,
   ShortCircuitExpression,
   PipelineExpression,
+  PipelineExpressionBody,
+  PipelineExpressionBodySameLine,
   PipelineHeadItem,
   PipelineTailItem,
   PrimaryExpression,
@@ -6913,7 +7072,6 @@ var grammar = {
   PostfixedNoCommaStatement,
   PostfixedExpression,
   PostfixedCommaExpression,
-  NonPipelinePostfixedExpression,
   PostfixStatement,
   _PostfixStatement,
   Statement,
@@ -6991,10 +7149,18 @@ var grammar = {
   AllowTrailingMemberProperty,
   RestoreTrailingMemberProperty,
   TrailingMemberPropertyAllowed,
+  AllowNestedBinaryOp,
+  ForbidNestedBinaryOp,
+  RestoreNestedBinaryOp,
+  NestedBinaryOpAllowed,
   AllowNewlineBinaryOp,
   ForbidNewlineBinaryOp,
   RestoreNewlineBinaryOp,
   NewlineBinaryOpAllowed,
+  AllowPipeline,
+  ForbidPipeline,
+  RestorePipeline,
+  PipelineAllowed,
   AllowAll,
   RestoreAll,
   CommaExpressionStatement,
@@ -7008,6 +7174,7 @@ var grammar = {
   MaybeNestedNonPipelineExtendedExpression,
   MaybeNestedPostfixedExpression,
   MaybeNestedExtendedExpression,
+  NestedExtendedExpression,
   MaybeParenNestedExtendedExpression,
   ImportDeclaration,
   ImpliedImport,
@@ -7942,16 +8109,16 @@ var Arguments$$ = [Arguments$0, Arguments$1];
 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,
@@ -8061,33 +8228,7 @@ var CommaDelimiter$0 = (0, import_lib3.$S)(NotDedented, Comma);
 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)]),
@@ -8096,7 +8237,7 @@ var NonPipelineArgumentList$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, imp
     )
   ];
 });
-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(
@@ -8104,19 +8245,19 @@ var NonPipelineArgumentList$1 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, imp
     )
   ];
 });
-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();
@@ -8129,40 +8270,48 @@ var NestedArgument$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Nested, SingleLi
   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;
@@ -8171,7 +8320,13 @@ var BinaryOpExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(UnaryExpress
 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;
@@ -8234,17 +8389,18 @@ var RHS$$ = [RHS$0, RHS$1];
 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$$);
@@ -8258,14 +8414,35 @@ var UnaryWithoutParenthesizedAssignment$0 = (0, import_lib3.$TS)((0, import_lib3
 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;
@@ -8464,7 +8641,7 @@ var ArrowFunction$0 = ThinArrowFunction;
 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)
@@ -8475,13 +8652,13 @@ var ArrowFunction$1 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$
       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];
@@ -8512,7 +8689,11 @@ var TrailingPipe$0 = (0, import_lib3.$S)((0, import_lib3.$E)(_), Pipe);
 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);
@@ -8562,10 +8743,10 @@ var ShortCircuitExpression$0 = BinaryOpExpression;
 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",
@@ -8587,6 +8768,25 @@ var PipelineExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_l
 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];
@@ -10213,7 +10413,7 @@ var FunctionSignature$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_li
   var wid = $4;
   var w = $5;
   var parameters = $6;
-  var suffix = $7;
+  var returnType = $7;
   if (!async)
     async = [];
   if (!generator)
@@ -10224,7 +10424,7 @@ var FunctionSignature$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_li
     id,
     name: id?.name,
     parameters,
-    returnType: suffix,
+    returnType,
     async,
     generator,
     modifier: {
@@ -10232,7 +10432,7 @@ var FunctionSignature$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_li
       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
   };
 });
@@ -10431,7 +10631,7 @@ var OperatorSignature$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_li
   var behavior = $7;
   var w2 = $8;
   var parameters = $9;
-  var suffix = $10;
+  var returnType = $10;
   if (!async)
     async = [];
   if (!generator)
@@ -10446,7 +10646,7 @@ var OperatorSignature$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_li
     id,
     name: id.name,
     parameters,
-    returnType: suffix,
+    returnType,
     async,
     generator,
     modifier: {
@@ -10454,7 +10654,7 @@ var OperatorSignature$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_li
       generator: !!generator.length
     },
     block: null,
-    children: [async, func, generator, w1, id, w2, parameters, suffix],
+    children: [async, func, generator, w1, id, w2, parameters, returnType],
     behavior
   };
 });
@@ -10501,7 +10701,7 @@ function OperatorAssociativity(ctx, state2) {
 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)
@@ -10511,7 +10711,7 @@ var ThinArrowFunction$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_li
     type: "FunctionExpression",
     id: void 0,
     parameters,
-    returnType: suffix,
+    returnType,
     async,
     generator,
     block,
@@ -10523,14 +10723,14 @@ var ThinArrowFunction$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_li
         async: !!async.length,
         generator: !!generator.length
       },
-      returnType: suffix
+      returnType
     },
     children: [
       async,
       { $loc: arrow.$loc, token: "function" },
       generator,
       parameters,
-      suffix,
+      returnType,
       block
     ]
   };
@@ -11227,6 +11427,7 @@ var ArrayElementExpression$2 = (0, import_lib3.$TS)((0, import_lib3.$S)(Extended
   return {
     type: "SpreadElement",
     children: [ws, dots, exp],
+    expression: exp,
     names: exp.names
   };
 });
@@ -11238,12 +11439,14 @@ var ArrayElementExpression$3 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, impo
       return {
         type: "ArrayElement",
         children: [exp],
+        expression: exp,
         names: exp.names
       };
     } else {
       return {
         type: "SpreadElement",
         children: [...spread, exp],
+        expression: exp,
         names: exp.names
       };
     }
@@ -11257,10 +11460,10 @@ var ArrayElementExpression$$ = [ArrayElementExpression$0, ArrayElementExpression
 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();
@@ -11287,9 +11490,9 @@ var BulletedArray$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(InsertOpenBracket
     // 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",
@@ -11427,8 +11630,8 @@ var BracedObjectLiteralContent$$ = [BracedObjectLiteralContent$0, BracedObjectLi
 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 {
@@ -12121,18 +12324,23 @@ function CoffeeWordAssignmentOp(ctx, state2) {
   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];
@@ -12560,16 +12768,6 @@ var PostfixedCommaExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Postfi
 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];
 });
@@ -13179,14 +13377,14 @@ function ForDeclaration(ctx, state2) {
 }
 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: []
   };
@@ -13659,6 +13857,34 @@ var TrailingMemberPropertyAllowed$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPE
 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);
 });
@@ -13687,11 +13913,39 @@ var NewlineBinaryOpAllowed$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L0
 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);
 }
@@ -13823,6 +14077,16 @@ var MaybeNestedExtendedExpression$$ = [MaybeNestedExtendedExpression$0, MaybeNes
 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];
 });
@@ -14317,16 +14581,16 @@ function TypeAssignment(ctx, state2) {
 }
 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, ";"])
@@ -14334,14 +14598,14 @@ var LexicalBinding$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(BindingPattern,
 });
 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: []
@@ -16286,14 +16550,14 @@ function UsingDeclaration(ctx, state2) {
 }
 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: []
@@ -16855,7 +17119,8 @@ function TypeUnary(ctx, state2) {
 }
 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$$);
 }
@@ -17850,7 +18115,9 @@ var Reset$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L0, 'Reset ""'), fu
   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 = {};
@@ -18121,12 +18388,24 @@ Object.defineProperties(state, {
       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;
@@ -18135,12 +18414,12 @@ Object.defineProperties(state, {
   }
 });
 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) {
@@ -18540,21 +18819,27 @@ var uncacheable = /* @__PURE__ */ new Set([
   "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) {
@@ -18699,13 +18984,16 @@ var makeCache = function({ hits, trace } = {}) {
         };
       }
       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();
@@ -18719,7 +19007,7 @@ var makeCache = function({ hits, trace } = {}) {
       }
       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;
     }