@danielx/civet 0.11.0 → 0.11.2

package/dist/main.js

@@ -1091,6 +1091,60 @@ function literalType(literal) {
     children: [t]
   };
 }
+function typeOfExpression(expression) {
+  let t;
+  if (!isASTNodeObject(expression)) {
+    return;
+  }
+  switch (expression.type) {
+    case "Literal": {
+      switch (expression.subtype) {
+        case "NullLiteral": {
+          return;
+        }
+        default: {
+          t = literalType(expression);
+        }
+      }
+      ;
+      break;
+    }
+    case "RegularExpressionLiteral":
+    case "TemplateLiteral": {
+      t = literalType(expression);
+      break;
+    }
+    case "Identifier": {
+      if (expression.name === "undefined") {
+        return;
+      }
+    }
+    case "MemberExpression": {
+      t = {
+        type: "TypeTypeof",
+        children: ["typeof ", expression],
+        expression
+      };
+      break;
+    }
+    default: {
+      return;
+    }
+  }
+  return t;
+}
+function typeSuffixForExpression(expression) {
+  const t = typeOfExpression(expression);
+  if (!(t != null)) {
+    return;
+  }
+  return {
+    type: "TypeSuffix",
+    ts: true,
+    t,
+    children: [": ", t]
+  };
+}
 function makeNumericLiteral(n) {
   const s = n.toString();
   return {
@@ -1968,11 +2022,14 @@ function gatherBindingPatternTypeSuffix(pattern) {
         const results1 = [];
         for (let ref7 = pattern.elements, i7 = 0, len6 = ref7.length; i7 < len6; i7++) {
           const elem = ref7[i7];
-          let { typeSuffix } = elem;
+          let { typeSuffix, initializer } = elem;
           typeSuffix ??= elem.binding?.typeSuffix;
           if (typeSuffix) {
             count++;
           }
+          if (initializer != null) {
+            typeSuffix ??= typeSuffixForExpression(trimFirstSpace(initializer.expression));
+          }
           let typeElement = [typeSuffix?.t, elem.delim];
           if (typeSuffix?.optional) {
             typeElement[0] = parenthesizeType(typeElement[0]);
@@ -2007,11 +2064,14 @@ function gatherBindingPatternTypeSuffix(pattern) {
         const results2 = [];
         for (let ref8 = pattern.properties, i8 = 0, len7 = ref8.length; i8 < len7; i8++) {
           const prop = ref8[i8];
-          let { typeSuffix } = prop;
+          let { typeSuffix, initializer } = prop;
           typeSuffix ??= prop.value?.typeSuffix;
           if (typeSuffix) {
             count++;
           }
+          if (initializer != null) {
+            typeSuffix ??= typeSuffixForExpression(trimFirstSpace(initializer.expression));
+          }
           typeSuffix ??= {
             type: "TypeSuffix",
             ts: true,
@@ -3112,19 +3172,23 @@ function patternBindings(pattern) {
 function assignResults(node, collect) {
   if (!node) return;
   switch (node.type) {
-    case "BlockStatement":
+    case "BlockStatement": {
       if (node.expressions.length) {
         let ref5;
         assignResults((ref5 = node.expressions)[ref5.length - 1], collect);
       } else {
         node.expressions.push(["", collect("void 0"), ";"]);
+        updateParentPointers(node);
       }
       return;
-    case "CaseBlock":
-      node.clauses.forEach((clause) => {
-        return assignResults(clause, collect);
-      });
+    }
+    case "CaseBlock": {
+      for (let ref6 = node.clauses, i4 = 0, len3 = ref6.length; i4 < len3; i4++) {
+        const clause = ref6[i4];
+        assignResults(clause, collect);
+      }
       return;
+    }
     case "WhenClause":
     case "DefaultClause":
     case "PatternClause": {
@@ -3150,7 +3214,8 @@ function assignResults(node, collect) {
   if (exp.type === "LabelledStatement") {
     exp = exp.statement;
   }
-  let ref6;
+  let ref7;
+  let ref8;
   let m1;
   switch (exp.type) {
     case "BreakStatement":
@@ -3162,18 +3227,19 @@ function assignResults(node, collect) {
       return;
     }
     case "Declaration": {
-      let ref7;
+      let ref9;
       if (exp.bindings?.length) {
-        ref7 = patternAsValue((ref6 = exp.bindings)[ref6.length - 1].pattern);
+        ref9 = patternAsValue((ref7 = exp.bindings)[ref7.length - 1].pattern);
       } else {
-        ref7 = "void 0";
+        ref9 = "void 0";
       }
       ;
-      const value = ref7;
+      const value = ref9;
       exp.children.push([
         "",
         [";", collect(value)]
       ]);
+      updateParentPointers(exp);
       return;
     }
     case "FunctionExpression": {
@@ -3182,6 +3248,7 @@ function assignResults(node, collect) {
           "",
           [";", collect(exp.id)]
         ]);
+        updateParentPointers(exp);
         return;
       }
       break;
@@ -3197,7 +3264,7 @@ function assignResults(node, collect) {
       if (exp.expressions.some(isExit)) {
         return;
       }
-      assignResults(exp.expressions[exp.expressions.length - 1], collect);
+      assignResults((ref8 = exp.expressions)[ref8.length - 1], collect);
       return;
     }
     case "IfStatement": {
@@ -3207,6 +3274,7 @@ function assignResults(node, collect) {
       } else {
         braceBlock(exp.then);
         exp.children.push([" else {", collect("void 0"), "}"]);
+        updateParentPointers(exp);
       }
       return;
     }
@@ -3215,15 +3283,15 @@ function assignResults(node, collect) {
       return;
     }
     case "SwitchStatement": {
-      for (let ref8 = exp.caseBlock.clauses, i4 = 0, len3 = ref8.length; i4 < len3; i4++) {
-        const clause = ref8[i4];
+      for (let ref10 = exp.caseBlock.clauses, i5 = 0, len4 = ref10.length; i5 < len4; i5++) {
+        const clause = ref10[i5];
         assignResults(clause, collect);
       }
       return;
     }
     case "TryStatement": {
-      for (let ref9 = exp.blocks, i5 = 0, len4 = ref9.length; i5 < len4; i5++) {
-        const block = ref9[i5];
+      for (let ref11 = exp.blocks, i6 = 0, len5 = ref11.length; i6 < len5; i6++) {
+        const block = ref11[i6];
         assignResults(block, collect);
       }
       return;
@@ -3235,6 +3303,7 @@ function assignResults(node, collect) {
       const semi2 = exp.children.lastIndexOf(";");
       if (0 <= semi2 && semi2 < exp.children.length - 1) {
         exp.children.splice(semi2 + 1, 1 / 0, ...[collect(exp.children.slice(semi2 + 1))]);
+        updateParentPointers(exp);
         return;
       }
       ;
@@ -3244,7 +3313,11 @@ function assignResults(node, collect) {
   if (node[node.length - 1]?.type === "SemicolonDelimiter") {
     return;
   }
+  const parent = node[1].parent;
   node[1] = collect(node[1]);
+  if (parent != null) {
+    updateParentPointers(parent);
+  }
 }
 function insertReturn(node) {
   if (!node) return;
@@ -3275,9 +3348,9 @@ function insertReturn(node) {
       insertReturn(node.block);
       if (!isExit(node.block)) {
         const comment = hasTrailingComment(node.block.expressions);
-        let ref10;
+        let ref12;
         node.block.expressions.push([
-          comment ? (ref10 = node.block.expressions)[ref10.length - 1][0] || "\n" : "",
+          comment ? (ref12 = node.block.expressions)[ref12.length - 1][0] || "\n" : "",
           wrapWithReturn(void 0, node, !comment)
         ]);
       }
@@ -3303,7 +3376,7 @@ function insertReturn(node) {
   if (exp.type === "LabelledStatement") {
     exp = exp.statement;
   }
-  let ref11;
+  let ref13;
   let m3;
   switch (exp.type) {
     case "BreakStatement":
@@ -3315,14 +3388,14 @@ function insertReturn(node) {
       return;
     }
     case "Declaration": {
-      let ref12;
+      let ref14;
       if (exp.bindings?.length) {
-        ref12 = [" ", patternAsValue((ref11 = exp.bindings)[ref11.length - 1].pattern)];
+        ref14 = [" ", patternAsValue((ref13 = exp.bindings)[ref13.length - 1].pattern)];
       } else {
-        ref12 = [];
+        ref14 = [];
       }
       ;
-      const value = ref12;
+      const value = ref14;
       const parent = outer.parent;
       const index = findChildIndex(parent?.expressions, outer);
       assert.notEqual(index, -1, "Could not find declaration in parent");
@@ -3382,15 +3455,15 @@ function insertReturn(node) {
       return;
     }
     case "SwitchStatement": {
-      for (let ref13 = exp.caseBlock.clauses, i6 = 0, len5 = ref13.length; i6 < len5; i6++) {
-        const clause = ref13[i6];
+      for (let ref15 = exp.caseBlock.clauses, i7 = 0, len6 = ref15.length; i7 < len6; i7++) {
+        const clause = ref15[i7];
         insertReturn(clause);
       }
       return;
     }
     case "TryStatement": {
-      for (let ref14 = exp.blocks, i7 = 0, len6 = ref14.length; i7 < len6; i7++) {
-        const block = ref14[i7];
+      for (let ref16 = exp.blocks, i8 = 0, len7 = ref16.length; i8 < len7; i8++) {
+        const block = ref16[i8];
         insertReturn(block);
       }
       return;
@@ -3642,9 +3715,9 @@ function iterationDefaultBody(statement) {
   }
   const reduction = statement.type === "ForStatement" && statement.reduction;
   function fillBlock(expression) {
-    let ref15;
+    let ref17;
     let m5;
-    if (m5 = (ref15 = block.expressions)[ref15.length - 1], Array.isArray(m5) && m5.length >= 2 && typeof m5[1] === "object" && m5[1] != null && "type" in m5[1] && m5[1].type === "EmptyStatement" && "implicit" in m5[1] && m5[1].implicit === true) {
+    if (m5 = (ref17 = block.expressions)[ref17.length - 1], Array.isArray(m5) && m5.length >= 2 && typeof m5[1] === "object" && m5[1] != null && "type" in m5[1] && m5[1].type === "EmptyStatement" && "implicit" in m5[1] && m5[1].implicit === true) {
       block.expressions.pop();
     }
     block.expressions.push(expression);
@@ -3714,8 +3787,8 @@ function processParams(f) {
   function append2(p) {
     (rest ? after : before).push(p);
   }
-  for (let ref16 = parameters.parameters, i8 = 0, len7 = ref16.length; i8 < len7; i8++) {
-    const param = ref16[i8];
+  for (let ref18 = parameters.parameters, i9 = 0, len8 = ref18.length; i9 < len8; i9++) {
+    const param = ref18[i9];
     switch (param.type) {
       case "ThisType": {
         if (tt) {
@@ -3727,8 +3800,8 @@ function processParams(f) {
         } else {
           tt = trimFirstSpace(param);
           if (before.length || rest) {
-            let ref17;
-            let delim = (ref17 = tt.children)[ref17.length - 1];
+            let ref19;
+            let delim = (ref19 = tt.children)[ref19.length - 1];
             if (Array.isArray(delim)) {
               delim = delim[delim.length - 1];
             }
@@ -3920,14 +3993,14 @@ function processParams(f) {
         index2--;
       }
       const fStatement = classExpressions[index2];
-      for (let ref18 = gatherRecursive(parameters, ($14) => $14.type === "Parameter"), i9 = 0, len8 = ref18.length; i9 < len8; i9++) {
-        const parameter = ref18[i9];
+      for (let ref20 = gatherRecursive(parameters, ($14) => $14.type === "Parameter"), i10 = 0, len9 = ref20.length; i10 < len9; i10++) {
+        const parameter = ref20[i10];
         const { accessModifier } = parameter;
         if (!(accessModifier || parameter.typeSuffix)) {
           continue;
         }
-        for (let ref19 = gatherRecursive(parameter, ($15) => $15.type === "AtBinding"), i10 = 0, len9 = ref19.length; i10 < len9; i10++) {
-          const binding = ref19[i10];
+        for (let ref21 = gatherRecursive(parameter, ($15) => $15.type === "AtBinding"), i11 = 0, len10 = ref21.length; i11 < len10; i11++) {
+          const binding = ref21[i11];
           const typeSuffix = binding.parent?.typeSuffix;
           if (!(accessModifier || typeSuffix)) {
             continue;
@@ -3965,8 +4038,8 @@ function processParams(f) {
       decl: "const"
     }));
   }
-  for (let ref20 = splices, i11 = 0, len10 = ref20.length; i11 < len10; i11++) {
-    const binding = ref20[i11];
+  for (let ref22 = splices, i12 = 0, len11 = ref22.length; i12 < len11; i12++) {
+    const binding = ref22[i12];
     assert.equal(binding.type, "PostRestBindingElements", "splice should be of type Binding");
     prefix.push(makeNode({
       type: "Declaration",
@@ -4018,8 +4091,8 @@ function processSignature(f) {
       f.async.push("async ");
       signature.modifier.async = true;
     } else {
-      for (let ref21 = gatherRecursiveWithinFunction(block, ($17) => $17.type === "Await"), i12 = 0, len11 = ref21.length; i12 < len11; i12++) {
-        const a = ref21[i12];
+      for (let ref23 = gatherRecursiveWithinFunction(block, ($17) => $17.type === "Await"), i13 = 0, len12 = ref23.length; i13 < len12; i13++) {
+        const a = ref23[i13];
         const i = findChildIndex(a.parent, a);
         a.parent.children.splice(i + 1, 0, {
           type: "Error",
@@ -4033,8 +4106,8 @@ function processSignature(f) {
       f.generator.push("*");
       signature.modifier.generator = true;
     } else {
-      for (let ref22 = gatherRecursiveWithinFunction(block, ($18) => $18.type === "YieldExpression"), i13 = 0, len12 = ref22.length; i13 < len12; i13++) {
-        const y = ref22[i13];
+      for (let ref24 = gatherRecursiveWithinFunction(block, ($18) => $18.type === "YieldExpression"), i14 = 0, len13 = ref24.length; i14 < len13; i14++) {
+        const y = ref24[i14];
         const i = y.children.findIndex(($19) => $19.type === "Yield");
         y.children.splice(i + 1, 0, {
           type: "Error",
@@ -4052,8 +4125,8 @@ function processSignature(f) {
   }
 }
 function processFunctions(statements, config2) {
-  for (let ref23 = gatherRecursiveAll(statements, ($20) => $20.type === "FunctionExpression" || $20.type === "ArrowFunction" || $20.type === "MethodDefinition"), i14 = 0, len13 = ref23.length; i14 < len13; i14++) {
-    const f = ref23[i14];
+  for (let ref25 = gatherRecursiveAll(statements, ($20) => $20.type === "FunctionExpression" || $20.type === "ArrowFunction" || $20.type === "MethodDefinition"), i15 = 0, len14 = ref25.length; i15 < len14; i15++) {
+    const f = ref25[i15];
     if (f.type === "FunctionExpression" || f.type === "MethodDefinition") {
       implicitFunctionBlock(f);
     }
@@ -4112,9 +4185,9 @@ function expressionizeIteration(exp) {
   }
   let done;
   if (!async) {
-    let ref24;
-    if ((ref24 = blockContainingStatement(exp)) && typeof ref24 === "object" && "block" in ref24 && "index" in ref24) {
-      const { block: parentBlock, index } = ref24;
+    let ref26;
+    if ((ref26 = blockContainingStatement(exp)) && typeof ref26 === "object" && "block" in ref26 && "index" in ref26) {
+      const { block: parentBlock, index } = ref26;
       statements[0][0] = parentBlock.expressions[index][0];
       parentBlock.expressions.splice(index, index + 1 - index, ...statements);
       updateParentPointers(parentBlock);
@@ -4131,8 +4204,8 @@ function expressionizeIteration(exp) {
   }
 }
 function processIterationExpressions(statements) {
-  for (let ref25 = gatherRecursiveAll(statements, ($21) => $21.type === "IterationExpression"), i15 = 0, len14 = ref25.length; i15 < len14; i15++) {
-    const s = ref25[i15];
+  for (let ref27 = gatherRecursiveAll(statements, ($21) => $21.type === "IterationExpression"), i16 = 0, len15 = ref27.length; i16 < len15; i16++) {
+    const s = ref27[i16];
     expressionizeIteration(s);
   }
 }
@@ -4156,12 +4229,12 @@ function processCoffeeDo(ws, expression) {
     let { parameters } = expression;
     const parameterList = parameters.parameters;
     const results1 = [];
-    for (let i16 = 0, len15 = parameterList.length; i16 < len15; i16++) {
-      let parameter = parameterList[i16];
+    for (let i17 = 0, len16 = parameterList.length; i17 < len16; i17++) {
+      let parameter = parameterList[i17];
       if (typeof parameter === "object" && parameter != null && "type" in parameter && parameter.type === "Parameter") {
-        let ref26;
-        if (ref26 = parameter.initializer) {
-          const initializer = ref26;
+        let ref28;
+        if (ref28 = parameter.initializer) {
+          const initializer = ref28;
           args.push(initializer.expression, parameter.delim);
           parameter = {
             ...parameter,
@@ -4291,8 +4364,9 @@ function unbraceBlock(block) {
   if (block.bare) {
     return;
   }
+  let m;
   let ref;
-  if (block.children[0] === " {" && (ref = block.children)[ref.length - 1] === "}") {
+  if ((m = block.children[0], m === " {" || m === "{") && (ref = block.children)[ref.length - 1] === "}") {
     block.children.shift();
     block.children.pop();
     block.bare = true;
@@ -4328,17 +4402,6 @@ function makeEmptyBlock() {
     empty: true
   };
 }
-function makeBlockFragment() {
-  const expressions = [];
-  return {
-    type: "BlockStatement",
-    children: expressions,
-    parent: void 0,
-    expressions,
-    bare: false,
-    root: false
-  };
-}
 function replaceBlockExpression(node, child, replacement) {
   let found = false;
   const { expressions } = node;
@@ -4384,22 +4447,44 @@ function hoistRefDecs(statements) {
   });
 }
 function insertHoistDec(block, node, dec) {
-  const { expressions } = block;
-  const index = findChildIndex(expressions, node);
+  const statement = ["", dec, ";"];
+  insertBeforeInBlock(block, node, statement);
+}
+function insertBeforeInBlock(block, node, ...statements) {
+  const index = findChildIndex(block.expressions, node);
   if (index < 0) {
-    throw new Error("Couldn't find expression in block for hoistable declaration.");
+    throw new Error("insertBeforeInBlock couldn't find existing statement in block");
   }
-  const statement = [expressions[index][0], dec, ";"];
-  expressions[index][0] = "";
-  expressions.splice(index, 0, statement);
-  updateParentPointers(dec, block);
+  insertBlockStatements(block, index, ...statements);
+}
+function insertBlockStatements(block, index, ...statements) {
+  if (!statements.length) {
+    return;
+  }
+  const { expressions } = block;
+  const before = expressions[index];
+  if (statements[0][0] && before?.[0]) {
+    if (!Array.isArray(statements[0][0])) {
+      statements[0][0] = [statements[0][0]];
+    }
+    if (!Array.isArray(before[0])) {
+      before[0] = [before[0]];
+    }
+    statements[0][0] = [...before[0], ...statements[0][0]];
+  } else {
+    statements[0][0] ||= before?.[0];
+  }
+  before[0] = "";
+  expressions.splice(index, 0, ...statements);
+  updateParentPointers(block);
+  braceBlock(block);
 }
 function processBlocks(statements) {
   insertSemicolon(statements);
   for (let ref1 = gatherRecursive(statements, ($) => $.type === "BlockStatement"), i2 = 0, len12 = ref1.length; i2 < len12; i2++) {
     const block = ref1[i2];
-    let m;
-    if (block.unwrapObject && block.expressions.length === 1 && (m = block.expressions[0][1], typeof m === "object" && m != null && "type" in m && m.type === "ParenthesizedExpression" && "implicit" in m && m.implicit === true && "expression" in m && typeof m.expression === "object" && m.expression != null && "type" in m.expression && m.expression.type === "ObjectExpression")) {
+    let m1;
+    if (block.unwrapObject && block.expressions.length === 1 && (m1 = block.expressions[0][1], typeof m1 === "object" && m1 != null && "type" in m1 && m1.type === "ParenthesizedExpression" && "implicit" in m1 && m1.implicit === true && "expression" in m1 && typeof m1.expression === "object" && m1.expression != null && "type" in m1.expression && m1.expression.type === "ObjectExpression")) {
       const object = block.expressions[0][1].expression;
       if (!(() => {
         let results = true;
@@ -4418,8 +4503,8 @@ function processBlocks(statements) {
       for (let ref2 = object.properties, i3 = 0, len22 = ref2.length; i3 < len22; i3++) {
         const i = i3;
         const prop = ref2[i3];
-        let m1;
-        if (m1 = prop.name, typeof m1 === "object" && m1 != null && "type" in m1 && m1.type === "ComputedPropertyName" && "implicit" in m1 && m1.implicit === true) {
+        let m2;
+        if (m2 = prop.name, typeof m2 === "object" && m2 != null && "type" in m2 && m2.type === "ComputedPropertyName" && "implicit" in m2 && m2.implicit === true) {
           replaceNode(prop.name, prop.name.expression, prop);
         }
         if (prop.delim?.implicit) {
@@ -4512,8 +4597,8 @@ function needsPrecedingSemicolon(exp) {
 function blockContainingStatement(exp) {
   let child = exp;
   let parent = exp.parent;
-  let m2;
-  while (parent != null && (m2 = parent.type, m2 === "StatementExpression" || m2 === "PipelineExpression" || m2 === "UnwrappedExpression")) {
+  let m3;
+  while (parent != null && (m3 = parent.type, m3 === "StatementExpression" || m3 === "PipelineExpression" || m3 === "UnwrappedExpression")) {
     child = parent;
     parent = parent.parent;
   }
@@ -4588,6 +4673,19 @@ function getPrecedence(op) {
     return precedenceMap.get(op.prec ?? op.token) ?? (op.relational ? precedenceRelational : precedenceCustomDefault);
   }
 }
+function isShortCircuitOp(op) {
+  if (op && typeof op === "object" && "token" in op) {
+    const { token } = op;
+    return isShortCircuitOp(token);
+  } else if (typeof op === "string") {
+    if (op.endsWith("=") && !op.endsWith("==")) {
+      op = op.slice(0, -1);
+    }
+    return op === "||" || op === "&&" || op === "??";
+  } else {
+    return false;
+  }
+}
 function processBinaryOpExpression($0) {
   return processExpandedBinaryOpExpression(expandChainedComparisons($0));
 }
@@ -5453,22 +5551,23 @@ function processDeclarations(statements) {
       if (typeSuffix && typeSuffix.optional) {
         if (initializer && !typeSuffix.t) {
           const expression = trimFirstSpace(initializer.expression);
-          let m;
-          if (m = expression.type, m === "Identifier" || m === "MemberExpression") {
-            typeSuffix.children.push(": ", typeSuffix.t = {
-              type: "TypeTypeof",
-              children: ["typeof ", expression],
-              expression
-            });
-          } else if (expression.type === "Literal" || expression.type === "RegularExpressionLiteral" || expression.type === "TemplateLiteral") {
-            typeSuffix.children.push(": ", typeSuffix.t = literalType(expression));
-          } else {
+          typeSuffix.t = typeOfExpression(expression);
+          if (!(typeSuffix.t != null)) {
             spliceChild(binding, typeSuffix, 1, {
               type: "Error",
-              message: `Optional type can only be inferred from literals or member expressions, not ${expression.type}`
+              message: (() => {
+                if (typeof expression === "object" && expression != null && "type" in expression && expression.type === "Literal" && "subtype" in expression && expression.subtype === "NullLiteral") {
+                  return "Optional type can't be inferred from null";
+                } else if (typeof expression === "object" && expression != null && "type" in expression && expression.type === "Identifier" && "name" in expression && expression.name === "undefined") {
+                  return "Optional type can't be inferred from undefined";
+                } else {
+                  return `Optional type can only be inferred from literals or member expressions, not ${expression.type}`;
+                }
+              })()
             });
             continue;
           }
+          typeSuffix.children.push(": ", typeSuffix.t);
         }
         if (typeSuffix.t) {
           convertOptionalType(typeSuffix);
@@ -5509,16 +5608,16 @@ function processDeclarations(statements) {
 function prependStatementExpressionBlock(initializer, statement) {
   let { expression: exp } = initializer;
   let ws;
-  if (Array.isArray(exp)) {
+  if (Array.isArray(exp) && exp.length === 2 && isWhitespaceOrEmpty(exp[0])) {
     ws = exp[0];
     exp = exp[1];
   }
   if (!(typeof exp === "object" && exp != null && "type" in exp && exp.type === "StatementExpression" || typeof exp === "object" && exp != null && "type" in exp && exp.type === "SpreadElement" && "expression" in exp && typeof exp.expression === "object" && exp.expression != null && "type" in exp.expression && exp.expression.type === "StatementExpression")) {
     return;
   }
-  const pre = [];
   const statementExp = exp.statement;
   const blockStatement = [ws || "", statementExp, ";"];
+  const pre = [blockStatement];
   let ref;
   if (statementExp.type === "IterationExpression") {
     if (statementExp.async || statementExp.generator) {
@@ -5534,8 +5633,7 @@ function prependStatementExpressionBlock(initializer, statement) {
       assignResults(blockStatement, (resultNode) => {
         return makeNode({
           type: "AssignmentExpression",
-          children: [ref, " = ", resultNode],
-          parent: statement2
+          children: [ref, " = ", resultNode]
         });
       });
       const refDec = {
@@ -5552,8 +5650,7 @@ function prependStatementExpressionBlock(initializer, statement) {
     assignResults(blockStatement, (resultNode) => {
       return makeNode({
         type: "AssignmentExpression",
-        children: [ref, " = ", resultNode],
-        parent: statement
+        children: [ref, " = ", resultNode]
       });
     });
     const refDec = {
@@ -5562,8 +5659,12 @@ function prependStatementExpressionBlock(initializer, statement) {
     };
     pre.unshift(["", refDec, ";"]);
   }
-  statement.children.unshift(...pre, blockStatement);
-  updateParentPointers(blockStatement, statement);
+  let ref3;
+  if (!((ref3 = blockContainingStatement(statement)) && typeof ref3 === "object" && "block" in ref3 && "index" in ref3)) {
+    throw new Error("Couldn't find block in prependStatementExpressionBlock");
+  }
+  const { block, index } = ref3;
+  insertBlockStatements(block, index, ...pre);
   return ref;
 }
 function processDeclarationCondition(condition, rootCondition, parent) {
@@ -5662,8 +5763,8 @@ function processDeclarationConditionStatement(s) {
     if (conditions.length) {
       let children = condition.children;
       if (s.negated) {
-        let m1;
-        if (!(m1 = condition.expression, typeof m1 === "object" && m1 != null && "type" in m1 && m1.type === "UnaryExpression" && "children" in m1 && Array.isArray(m1.children) && len2(m1.children, 2) && Array.isArray(m1.children[0]) && len2(m1.children[0], 1) && m1.children[0][0] === "!" && typeof m1.children[1] === "object" && m1.children[1] != null && "type" in m1.children[1] && m1.children[1].type === "ParenthesizedExpression")) {
+        let m;
+        if (!(m = condition.expression, typeof m === "object" && m != null && "type" in m && m.type === "UnaryExpression" && "children" in m && Array.isArray(m.children) && len2(m.children, 2) && Array.isArray(m.children[0]) && len2(m.children[0], 1) && m.children[0][0] === "!" && typeof m.children[1] === "object" && m.children[1] != null && "type" in m.children[1] && m.children[1].type === "ParenthesizedExpression")) {
           throw new Error("Unsupported negated condition");
         }
         ;
@@ -5693,11 +5794,11 @@ function processDeclarationConditionStatement(s) {
     ancestor.expressions.splice(index + 1, 0, ...blockPrefix);
     updateParentPointers(ancestor);
     braceBlock(ancestor);
-    let ref3;
+    let ref4;
     switch (s.type) {
       case "IfStatement": {
-        if (ref3 = s.else?.block) {
-          const elseBlock = ref3;
+        if (ref4 = s.else?.block) {
+          const elseBlock = ref4;
           if (elseBlock.bare && !elseBlock.semicolon) {
             elseBlock.children.push(elseBlock.semicolon = ";");
           }
@@ -5749,38 +5850,19 @@ function processDeclarationConditionStatement(s) {
       if (!blockPrefix) {
         return;
       }
-      const newCondition = {
-        type: "ParenthesizedExpression",
-        children: ["(", ref2, ")"],
-        expression: ref2,
-        parent: s
-      };
-      s.children = s.children.map(function(c) {
-        if (c === s.condition) {
-          return newCondition;
-        } else {
-          return c;
-        }
-      });
-      s.condition = newCondition;
-      updateParentPointers(s);
-      if (statementDeclaration) {
-        const block = makeEmptyBlock();
-        replaceBlockExpression(s.parent, s, block);
-        block.expressions.push(["", s]);
-        s.children.splice(s.children.findIndex(($5) => $5.token === "switch"), 0, blockPrefix);
-        s.parent = block;
-      } else {
-        const block = blockWithPrefix([["", [{
+      replaceNode(s.condition, parenthesizeExpression(ref2), s);
+      if (!statementDeclaration) {
+        const declStatement = ["", [{
           type: "Declaration",
           children: ["let ", ...condition.expression.children]
-        }], ";"], ...blockPrefix], makeEmptyBlock());
-        updateParentPointers(block, s.parent);
-        replaceBlockExpression(s.parent, s, block);
-        block.expressions.push(["", s]);
-        s.parent = block;
-      }
-      ;
+        }], ";"];
+        blockPrefix.unshift(declStatement);
+      }
+      const block = blockWithPrefix(blockPrefix, makeEmptyBlock());
+      updateParentPointers(block, s.parent);
+      replaceBlockExpression(s.parent, s, block);
+      block.expressions.push(["", s]);
+      s.parent = block;
       break;
     }
   }
@@ -5788,12 +5870,12 @@ function processDeclarationConditionStatement(s) {
 function dynamizeFromClause(from) {
   from = from.slice(1);
   from = trimFirstSpace(from);
-  let ref4;
-  if (ref4 = from[from.length - 1]?.assertion) {
-    const assert2 = ref4;
-    let ref5;
-    ref5 = from[from.length - 1];
-    ref5.children = ref5.children.filter((a2) => a2 !== assert2);
+  let ref5;
+  if (ref5 = from[from.length - 1]?.assertion) {
+    const assert2 = ref5;
+    let ref6;
+    ref6 = from[from.length - 1];
+    ref6.children = ref6.children.filter((a2) => a2 !== assert2);
     from.push(", {", assert2.keyword, ":", assert2.object, "}");
   }
   return ["(", ...from, ")"];
@@ -5802,20 +5884,20 @@ function dynamizeImportDeclaration(decl) {
   const { imports } = decl;
   let { star, binding, specifiers } = imports;
   const justDefault = binding && !specifiers && !star;
-  let ref6;
+  let ref7;
   {
     if (binding) {
       if (specifiers) {
-        ref6 = makeRef();
+        ref7 = makeRef();
       } else {
-        ref6 = binding;
+        ref7 = binding;
       }
     } else {
-      ref6 = convertNamedImportsToObject(imports, true);
+      ref7 = convertNamedImportsToObject(imports, true);
     }
   }
   ;
-  const pattern = ref6;
+  const pattern = ref7;
   const c = "const";
   const expression = [
     justDefault ? "(" : void 0,
@@ -6806,7 +6888,7 @@ function processForInOf($0) {
 var concatAssign2 = (lhs, rhs) => (rhs?.[Symbol.isConcatSpreadable] ?? Array.isArray(rhs) ? lhs.push.apply(lhs, rhs) : lhs.push(rhs), lhs);
 function findDecs(statements) {
   const declarations = gatherNodes(statements, ($) => $.type === "Declaration");
-  const declarationNames = declarations.flatMap((d) => d.names);
+  const declarationNames = declarations.flatMap(($1) => $1.names);
   const globals = getConfig().globals || [];
   return new Set(globals.concat(declarationNames));
 }
@@ -6814,16 +6896,16 @@ function createConstLetDecs(statements, scopes, letOrConst) {
   function findVarDecs(statements2, decs) {
     const declarationNames = gatherRecursive(statements2, (node) => {
       return node.type === "Declaration" && node.children && node.children.length > 0 && node.children[0].token && node.children[0].token.startsWith("var") || node.type === "FunctionExpression";
-    }).filter((node) => node.type === "Declaration").flatMap((node) => node.names);
+    }).filter(($2) => $2.type === "Declaration").flatMap(($3) => $3.names);
     return new Set(declarationNames);
   }
   let declaredIdentifiers = findVarDecs(statements);
   function hasDec(name) {
-    return declaredIdentifiers.has(name) || scopes.some(($1) => $1.has(name));
+    return declaredIdentifiers.has(name) || scopes.some(($4) => $4.has(name));
   }
   function gatherBlockOrOther(statement) {
-    return gatherNodes(statement, (s) => s.type === "BlockStatement" || s.type === "AssignmentExpression" || s.type === "Declaration").flatMap((node) => {
-      if (node.type == "BlockStatement") {
+    return gatherNodes(statement, ($5) => $5.type === "BlockStatement" || $5.type === "AssignmentExpression" || $5.type === "Declaration").flatMap((node) => {
+      if (node.type === "BlockStatement") {
         return node.bare ? gatherBlockOrOther(node.expressions) : node;
       } else if (node.children && node.children.length) {
         return [...gatherBlockOrOther(node.children), node];
@@ -6835,16 +6917,18 @@ function createConstLetDecs(statements, scopes, letOrConst) {
   let currentScope = /* @__PURE__ */ new Set();
   scopes.push(currentScope);
   const fnNodes = gatherNodes(statements, isFunction);
-  const forNodes = gatherNodes(statements, (s) => s.type === "ForStatement");
+  const forNodes = gatherNodes(statements, ($6) => $6.type === "ForStatement");
   let targetStatements = [];
-  for (const statement of statements) {
+  for (let i1 = 0, len3 = statements.length; i1 < len3; i1++) {
+    const statement = statements[i1];
     const nodes = gatherBlockOrOther(statement);
     let undeclaredIdentifiers = [];
-    for (const node of nodes) {
-      if (node.type == "BlockStatement") {
+    for (let i2 = 0, len12 = nodes.length; i2 < len12; i2++) {
+      const node = nodes[i2];
+      if (node.type === "BlockStatement") {
         let block = node;
-        let fnNode = fnNodes.find((fnNode2) => fnNode2.block === block);
-        let forNode = forNodes.find((forNode2) => forNode2.block === block);
+        let fnNode = fnNodes.find(($7) => $7.block === block);
+        let forNode = forNodes.find(($8) => $8.block === block);
         if (fnNode != null) {
           scopes.push(new Set(fnNode.parameters.names));
           createConstLetDecs(block.expressions, scopes, letOrConst);
@@ -6858,21 +6942,26 @@ function createConstLetDecs(statements, scopes, letOrConst) {
         }
         continue;
       }
-      if (node.names == null) continue;
-      let names = node.names.filter((name) => !hasDec(name));
-      if (node.type == "AssignmentExpression") {
+      if (!(node.names != null)) {
+        continue;
+      }
+      const names = node.names.filter((name) => !hasDec(name));
+      if (node.type === "AssignmentExpression") {
         undeclaredIdentifiers.push(...names);
       }
-      names.forEach((name) => currentScope.add(name));
+      for (let i3 = 0, len22 = names.length; i3 < len22; i3++) {
+        const name = names[i3];
+        currentScope.add(name);
+      }
     }
-    if (undeclaredIdentifiers.length > 0) {
+    if (undeclaredIdentifiers.length) {
       let indent = statement[0];
-      let firstIdentifier = gatherNodes(statement[1], (node) => node.type == "Identifier")[0];
-      if (undeclaredIdentifiers.length == 1 && statement[1].type == "AssignmentExpression" && statement[1].names.length == 1 && statement[1].names[0] == undeclaredIdentifiers[0] && firstIdentifier && firstIdentifier.names == undeclaredIdentifiers[0] && gatherNodes(statement[1], (node) => node.type === "ObjectBindingPattern").length == 0) {
+      let firstIdentifier = gatherNodes(statement[1], ($9) => $9.type === "Identifier")[0];
+      if (undeclaredIdentifiers.length === 1 && statement[1].type === "AssignmentExpression" && statement[1].names.length === 1 && statement[1].names[0] === undeclaredIdentifiers[0] && firstIdentifier && firstIdentifier.names == undeclaredIdentifiers[0] && gatherNodes(statement[1], ($10) => $10.type === "ObjectBindingPattern").length === 0) {
         statement[1].children.unshift([`${letOrConst} `]);
       } else {
         let tail = "\n";
-        if (gatherNodes(indent, (node) => node.token && node.token.endsWith("\n")).length > 0) {
+        if (gatherNodes(indent, ($11) => $11.token && $11.token.endsWith("\n")).length) {
           tail = void 0;
         }
         targetStatements.push([indent, {
@@ -6889,17 +6978,17 @@ function createConstLetDecs(statements, scopes, letOrConst) {
 }
 function createVarDecs(block, scopes, pushVar) {
   function hasDec(name) {
-    return scopes.some(($2) => $2.has(name));
+    return scopes.some(($12) => $12.has(name));
   }
   function findAssignments(statements2, decs2) {
-    let assignmentStatements2 = gatherNodes(statements2, ($3) => $3.type === "AssignmentExpression");
+    let assignmentStatements2 = gatherNodes(statements2, ($13) => $13.type === "AssignmentExpression");
     if (assignmentStatements2.length) {
       concatAssign2(
         assignmentStatements2,
         findAssignments(assignmentStatements2.map((s) => s.children), decs2)
       );
     }
-    return assignmentStatements2.filter(($4) => !($4.parent?.type === "CoffeeClassPublic"));
+    return assignmentStatements2.filter(($14) => !($14.parent?.type === "CoffeeClassPublic"));
   }
   pushVar ??= (name) => {
     varIds.push(name);
@@ -6910,7 +6999,7 @@ function createVarDecs(block, scopes, pushVar) {
   scopes.push(decs);
   const varIds = [];
   const assignmentStatements = findAssignments(statements, scopes);
-  const undeclaredIdentifiers = assignmentStatements.flatMap(($5) => $5?.names || []);
+  const undeclaredIdentifiers = assignmentStatements.flatMap(($15) => $15?.names || []);
   undeclaredIdentifiers.filter((x, i, a) => {
     if (!hasDec(x)) return a.indexOf(x) === i;
     return;
@@ -8076,23 +8165,20 @@ function processAssignments(statements) {
       continue;
     }
     let { lhs: $1, expression: $2 } = exp, tail = [], len3 = $1.length;
-    let block;
     let ref13;
-    if (blockContainingStatement(exp) && !(ref13 = $1[$1.length - 1])?.[ref13.length - 1]?.special) {
-      block = makeBlockFragment();
-      let ref14;
-      if (ref14 = prependStatementExpressionBlock(
+    let ref14;
+    if (blockContainingStatement(exp) && !(ref13 = $1[$1.length - 1])?.[ref13.length - 1]?.special && !isShortCircuitOp((ref14 = $1[$1.length - 1])?.[ref14.length - 1])) {
+      let ref15;
+      if (ref15 = prependStatementExpressionBlock(
         { type: "Initializer", expression: $2, children: [void 0, void 0, $2] },
-        block
+        exp
       )) {
-        const ref = ref14;
-        exp.children = exp.children.map(($7) => $7 === $2 ? ref : $7);
+        const ref = ref15;
+        replaceNode($2, ref, exp);
         $2 = ref;
-      } else {
-        block = void 0;
       }
     }
-    if ($1.some(($8) => $8[$8.length - 1].special)) {
+    if ($1.some(($7) => $7[$7.length - 1].special)) {
       if ($1.length !== 1) throw new Error("Only one assignment with id= is allowed");
       const [, lhs, , op] = $1[0];
       const { call, omitLhs } = op;
@@ -8164,7 +8250,7 @@ function processAssignments(statements) {
           break;
         } else if (m3 = lhs.type, m3 === "ObjectBindingPattern" || m3 === "ArrayBindingPattern" || m3 === "NamedBindingPattern") {
           processBindingPatternLHS(lhs, tail);
-          gatherRecursiveAll(lhs, ($9) => $9.type === "Ref").forEach(refsToDeclare.add.bind(refsToDeclare));
+          gatherRecursiveAll(lhs, ($8) => $8.type === "Ref").forEach(refsToDeclare.add.bind(refsToDeclare));
         }
       }
       i--;
@@ -8196,7 +8282,7 @@ function processAssignments(statements) {
     }
     if (refsToDeclare.size) {
       if (exp.hoistDec) {
-        exp.hoistDec.children.push([...refsToDeclare].map(($10) => [",", $10]));
+        exp.hoistDec.children.push([...refsToDeclare].map(($9) => [",", $9]));
       } else {
         exp.hoistDec = {
           type: "Declaration",
@@ -8211,11 +8297,6 @@ function processAssignments(statements) {
       if (index < 0) throw new Error("Assertion error: exp not in AssignmentExpression");
       exp.children.splice(index + 1, 0, ...tail);
     }
-    if (block) {
-      replaceNode(exp, block);
-      block.expressions.push(["", exp]);
-      exp.parent = block;
-    }
   }
 }
 function unchainOptionalMemberExpression(exp, ref, innerExp) {
@@ -8266,9 +8347,9 @@ function unchainOptionalMemberExpression(exp, ref, innerExp) {
     }
     j++;
   }
-  let ref15;
-  if (ref15 = conditions.length) {
-    const l = ref15;
+  let ref16;
+  if (ref16 = conditions.length) {
+    const l = ref16;
     const cs = flatJoin(conditions, " && ");
     return {
       ...exp,
@@ -8304,8 +8385,8 @@ function attachPostfixStatementAsExpression(exp, post) {
 }
 function processTypes(node) {
   const results1 = [];
-  for (let ref16 = gatherRecursiveAll(node, ($11) => $11.type === "TypeUnary"), i8 = 0, len7 = ref16.length; i8 < len7; i8++) {
-    const unary = ref16[i8];
+  for (let ref17 = gatherRecursiveAll(node, ($10) => $10.type === "TypeUnary"), i8 = 0, len7 = ref17.length; i8 < len7; i8++) {
+    const unary = ref17[i8];
     let suffixIndex = unary.suffix.length - 1;
     const results2 = [];
     while (suffixIndex >= 0) {
@@ -8384,10 +8465,10 @@ function processTypes(node) {
         const outer = unary.suffix.splice(suffixIndex + 1, Infinity);
         const space = getTrimmingSpace(unary);
         inplaceInsertTrimmingSpace(unary, "");
-        let ref17;
-        if (unary.suffix.length) ref17 = unary;
-        else ref17 = unary.t;
-        const t = ref17;
+        let ref18;
+        if (unary.suffix.length) ref18 = unary;
+        else ref18 = unary.t;
+        const t = ref18;
         const arg = makeNode({
           type: "TypeArgument",
           ts: true,
@@ -8432,18 +8513,18 @@ function processTypes(node) {
   return results1;
 }
 function processStatementExpressions(statements) {
-  for (let ref18 = gatherRecursiveAll(statements, ($12) => $12.type === "StatementExpression"), i9 = 0, len8 = ref18.length; i9 < len8; i9++) {
-    const exp = ref18[i9];
+  for (let ref19 = gatherRecursiveAll(statements, ($11) => $11.type === "StatementExpression"), i9 = 0, len8 = ref19.length; i9 < len8; i9++) {
+    const exp = ref19[i9];
     const { maybe, statement } = exp;
     if ((maybe || statement.type === "ThrowStatement") && blockContainingStatement(exp)) {
       replaceNode(exp, statement);
       continue;
     }
-    let ref19;
+    let ref20;
     switch (statement.type) {
       case "IfStatement": {
-        if (ref19 = expressionizeIfStatement(statement)) {
-          const expression = ref19;
+        if (ref20 = expressionizeIfStatement(statement)) {
+          const expression = ref20;
           replaceNode(statement, expression, exp);
         } else {
           replaceNode(statement, wrapIIFE([["", statement]]), exp);
@@ -8502,13 +8583,13 @@ function processNegativeIndexAccess(statements) {
   });
 }
 function processFinallyClauses(statements) {
-  for (let ref20 = gatherRecursiveAll(statements, ($) => $.type === "FinallyClause" && $.parent?.type !== "TryStatement"), i10 = 0, len9 = ref20.length; i10 < len9; i10++) {
-    let f = ref20[i10];
-    let ref21;
-    if (!((ref21 = blockContainingStatement(f)) && typeof ref21 === "object" && "block" in ref21 && "index" in ref21)) {
+  for (let ref21 = gatherRecursiveAll(statements, ($) => $.type === "FinallyClause" && $.parent?.type !== "TryStatement"), i10 = 0, len9 = ref21.length; i10 < len9; i10++) {
+    let f = ref21[i10];
+    let ref22;
+    if (!((ref22 = blockContainingStatement(f)) && typeof ref22 === "object" && "block" in ref22 && "index" in ref22)) {
       throw new Error("finally clause must be inside try statement or block");
     }
-    const { block, index } = ref21;
+    const { block, index } = ref22;
     const indent = block.expressions[index][0];
     const expressions = block.expressions.slice(index + 1);
     const t = makeNode({
@@ -8580,11 +8661,11 @@ function processBreaksContinues(statements) {
   }
 }
 function processCoffeeClasses(statements) {
-  for (let ref22 = gatherRecursiveAll(statements, ($13) => $13.type === "ClassExpression"), i11 = 0, len10 = ref22.length; i11 < len10; i11++) {
-    const ce = ref22[i11];
+  for (let ref23 = gatherRecursiveAll(statements, ($12) => $12.type === "ClassExpression"), i11 = 0, len10 = ref23.length; i11 < len10; i11++) {
+    const ce = ref23[i11];
     const { expressions } = ce.body;
     const indent = expressions[0]?.[0] ?? "\n";
-    const autoBinds = expressions.filter(($14) => $14[1]?.autoBind);
+    const autoBinds = expressions.filter(($13) => $13[1]?.autoBind);
     if (autoBinds.length) {
       let construct;
       for (const [, c] of expressions) {
@@ -8633,17 +8714,17 @@ function processCoffeeClasses(statements) {
         })()
       );
     }
-    const public_static_function_assignments = expressions.filter(($15) => $15[1]?.type === "CoffeeClassPublic" && $15[1].assignment?.expression?.type === "FunctionExpression").map(($16) => $16[1].assignment);
+    const public_static_function_assignments = expressions.filter(($14) => $14[1]?.type === "CoffeeClassPublic" && $14[1].assignment?.expression?.type === "FunctionExpression").map(($15) => $15[1].assignment);
     for (const public_static_function_assignment of public_static_function_assignments) {
       const id = public_static_function_assignment.lhs[0][1];
       replaceNode(public_static_function_assignment, convertFunctionToMethod(id, public_static_function_assignment.expression));
     }
-    const public_static_arrow_function_assignments = expressions.filter(($17) => $17[1]?.type === "CoffeeClassPublic" && $17[1].assignment?.expression?.type === "ArrowFunction").map(($18) => $18[1].assignment);
+    const public_static_arrow_function_assignments = expressions.filter(($16) => $16[1]?.type === "CoffeeClassPublic" && $16[1].assignment?.expression?.type === "ArrowFunction").map(($17) => $17[1].assignment);
     for (const public_static_arrow_function_assignment of public_static_arrow_function_assignments) {
       const id = public_static_arrow_function_assignment.lhs[0][1];
       replaceNode(public_static_arrow_function_assignment, convertArrowFunctionToMethod(id, public_static_arrow_function_assignment.expression));
     }
-    const privates = expressions.filter(($19) => $19[1]?.type === "CoffeeClassPrivate");
+    const privates = expressions.filter(($18) => $18[1]?.type === "CoffeeClassPrivate");
     if (!privates.length) {
       continue;
     }
@@ -8708,7 +8789,7 @@ function processProgram(root) {
       root.topLevelYield ? "*" : void 0
     );
     statements = [["", rootIIFE]];
-    root.children = root.children.map(($20) => $20 === root.expressions ? statements : $20);
+    root.children = root.children.map(($19) => $19 === root.expressions ? statements : $19);
     root.expressions = statements;
   }
   hoistRefDecs(statements);
@@ -8739,10 +8820,10 @@ async function processProgramAsync(root) {
   await processComptime(statements);
 }
 function processRepl(root, rootIIFE) {
-  const topBlock = gatherRecursive(rootIIFE, ($21) => $21.type === "BlockStatement")[0];
+  const topBlock = gatherRecursive(rootIIFE, ($20) => $20.type === "BlockStatement")[0];
   let i = 0;
-  for (let ref23 = gatherRecursiveWithinFunction(topBlock, ($22) => $22.type === "Declaration"), i14 = 0, len12 = ref23.length; i14 < len12; i14++) {
-    const decl = ref23[i14];
+  for (let ref24 = gatherRecursiveWithinFunction(topBlock, ($21) => $21.type === "Declaration"), i14 = 0, len12 = ref24.length; i14 < len12; i14++) {
+    const decl = ref24[i14];
     if (!decl.names?.length) {
       continue;
     }
@@ -8755,8 +8836,8 @@ function processRepl(root, rootIIFE) {
       root.expressions.splice(i++, 0, ["", `var ${decl.names.join(",")}`, ";"]);
     }
   }
-  for (let ref24 = gatherRecursive(topBlock, ($23) => $23.type === "FunctionExpression"), i15 = 0, len13 = ref24.length; i15 < len13; i15++) {
-    const func = ref24[i15];
+  for (let ref25 = gatherRecursive(topBlock, ($22) => $22.type === "FunctionExpression"), i15 = 0, len13 = ref25.length; i15 < len13; i15++) {
+    const func = ref25[i15];
     if (func.name && func.parent?.type === "BlockStatement") {
       if (func.parent === topBlock) {
         replaceNode(func, void 0);
@@ -8768,8 +8849,8 @@ function processRepl(root, rootIIFE) {
       }
     }
   }
-  for (let ref25 = gatherRecursiveWithinFunction(topBlock, ($24) => $24.type === "ClassExpression"), i16 = 0, len14 = ref25.length; i16 < len14; i16++) {
-    const classExp = ref25[i16];
+  for (let ref26 = gatherRecursiveWithinFunction(topBlock, ($23) => $23.type === "ClassExpression"), i16 = 0, len14 = ref26.length; i16 < len14; i16++) {
+    const classExp = ref26[i16];
     let m8;
     if (classExp.name && classExp.parent === topBlock || (m8 = classExp.parent, typeof m8 === "object" && m8 != null && "type" in m8 && m8.type === "ReturnStatement" && "parent" in m8 && m8.parent === topBlock)) {
       classExp.children.unshift(classExp.name, "=");
@@ -8780,8 +8861,8 @@ function processRepl(root, rootIIFE) {
 function processPlaceholders(statements) {
   const placeholderMap = /* @__PURE__ */ new Map();
   const liftedIfs = /* @__PURE__ */ new Set();
-  for (let ref26 = gatherRecursiveAll(statements, ($25) => $25.type === "Placeholder"), i17 = 0, len15 = ref26.length; i17 < len15; i17++) {
-    const exp = ref26[i17];
+  for (let ref27 = gatherRecursiveAll(statements, ($24) => $24.type === "Placeholder"), i17 = 0, len15 = ref27.length; i17 < len15; i17++) {
+    const exp = ref27[i17];
     let ancestor;
     if (exp.subtype === ".") {
       ({ ancestor } = findAncestor(
@@ -8893,8 +8974,8 @@ function processPlaceholders(statements) {
     for (let i18 = 0, len16 = placeholders.length; i18 < len16; i18++) {
       const placeholder = placeholders[i18];
       typeSuffix ??= placeholder.typeSuffix;
-      let ref27;
-      (ref27 = placeholder.children)[ref27.length - 1] = ref;
+      let ref28;
+      (ref28 = placeholder.children)[ref28.length - 1] = ref;
     }
     const { parent } = ancestor;
     const body = maybeUnwrap(ancestor);
@@ -8915,16 +8996,16 @@ function processPlaceholders(statements) {
       }
       case "PipelineExpression": {
         const i = findChildIndex(parent, ancestor);
-        let ref28;
+        let ref29;
         if (i === 1) {
-          ref28 = ancestor === parent.children[i];
+          ref29 = ancestor === parent.children[i];
         } else if (i === 2) {
-          ref28 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
+          ref29 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
         } else {
-          ref28 = void 0;
+          ref29 = void 0;
         }
         ;
-        outer = ref28;
+        outer = ref29;
         break;
       }
       case "AssignmentExpression":
@@ -8942,9 +9023,9 @@ function processPlaceholders(statements) {
     if (typeof parent === "object" && parent != null && "type" in parent && parent.type === "BlockStatement" && "parent" in parent && typeof parent.parent === "object" && parent.parent != null && "type" in parent.parent && parent.parent.type === "ArrowFunction" && "ampersandBlock" in parent.parent && parent.parent.ampersandBlock === true && "body" in parent.parent && parent.parent.body === body) {
       parent.parent.body = fnExp;
     }
-    let ref29;
-    if (ref29 = getTrimmingSpace(body)) {
-      const ws = ref29;
+    let ref30;
+    if (ref30 = getTrimmingSpace(body)) {
+      const ws = ref30;
       inplaceInsertTrimmingSpace(body, "");
       inplacePrepend(ws, fnExp);
     }
@@ -8988,8 +9069,8 @@ function reorderBindingRestProperty(props) {
       }
     ];
   }
-  let ref30;
-  if (Array.isArray(rest.delim) && (ref30 = rest.delim)[ref30.length - 1]?.token === ",") {
+  let ref31;
+  if (Array.isArray(rest.delim) && (ref31 = rest.delim)[ref31.length - 1]?.token === ",") {
     rest.delim = rest.delim.slice(0, -1);
     rest.children = [...rest.children.slice(0, -1), rest.delim];
   }
@@ -9065,7 +9146,7 @@ function typeOfJSXFragment(node, config2) {
     if (type.length === 1) {
       return type[0];
     } else {
-      type = type.flatMap(($26) => [$26, ", "]);
+      type = type.flatMap(($25) => [$25, ", "]);
       type.pop();
       return ["[", type, "]"];
     }
@@ -9130,6 +9211,7 @@ var grammar = {
   Tuple,
   NWTypePostfix,
   UpdateExpression,
+  UpdateExpressionPattern,
   UpdateExpressionSymbol,
   AssignmentExpression,
   NonPipelineAssignmentExpression,
@@ -9265,7 +9347,7 @@ var grammar = {
   OperatorPrecedence,
   OperatorAssociativity,
   ThinArrowFunction,
-  Arrow,
+  ThinArrow,
   ExplicitBlock,
   EmptyBracedContent,
   ImplicitNestedBlock,
@@ -10249,7 +10331,7 @@ var $R71 = (0, import_lib2.$R)(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
 var $R72 = (0, import_lib2.$R)(new RegExp("[^]*?###", "suy"));
 var $R73 = (0, import_lib2.$R)(new RegExp("###(?!#)", "suy"));
 var $R74 = (0, import_lib2.$R)(new RegExp("\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\/", "suy"));
-var $R75 = (0, import_lib2.$R)(new RegExp("(?=[ \\t\\/\\\\])", "suy"));
+var $R75 = (0, import_lib2.$R)(new RegExp("(?=[ \\t\\/\\\\#])", "suy"));
 var $R76 = (0, import_lib2.$R)(new RegExp("(?=\\s|\\/|#)", "suy"));
 var $R77 = (0, import_lib2.$R)(new RegExp("(?!\\p{ID_Continue})", "suy"));
 var $R78 = (0, import_lib2.$R)(new RegExp("[=:]", "suy"));
@@ -10936,6 +11018,12 @@ var UpdateExpression$$ = [UpdateExpression$0, UpdateExpression$1];
 function UpdateExpression(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "UpdateExpression", UpdateExpression$$);
 }
+var UpdateExpressionPattern$0 = NamedBindingPattern;
+var UpdateExpressionPattern$1 = UpdateExpression;
+var UpdateExpressionPattern$$ = [UpdateExpressionPattern$0, UpdateExpressionPattern$1];
+function UpdateExpressionPattern(ctx, state2) {
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "UpdateExpressionPattern", UpdateExpressionPattern$$);
+}
 var UpdateExpressionSymbol$0 = (0, import_lib2.$TV)((0, import_lib2.$C)((0, import_lib2.$EXPECT)($L9, 'UpdateExpressionSymbol "++"'), (0, import_lib2.$EXPECT)($L10, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
   return { $loc, token: $1 };
 });
@@ -10999,7 +11087,7 @@ var NonPipelineAssignmentExpressionTail$$ = [NonPipelineAssignmentExpressionTail
 function NonPipelineAssignmentExpressionTail(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "NonPipelineAssignmentExpressionTail", NonPipelineAssignmentExpressionTail$$);
 }
-var ActualAssignment$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$P)((0, import_lib2.$S)(NotDedented, UpdateExpression, WAssignmentOp)), MaybeNestedExpression), function($skip, $loc, $0, $1, $2) {
+var ActualAssignment$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$P)((0, import_lib2.$S)(NotDedented, UpdateExpressionPattern, WAssignmentOp)), MaybeNestedExpression), function($skip, $loc, $0, $1, $2) {
   $1 = $1.map((x) => [x[0], x[1], ...x[2]]);
   $0 = [$1, $2];
   return {
@@ -11016,7 +11104,7 @@ var ActualAssignment$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib
 function ActualAssignment(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "ActualAssignment", ActualAssignment$0);
 }
-var NonPipelineActualAssignment$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$P)((0, import_lib2.$S)(NotDedented, UpdateExpression, WAssignmentOp)), MaybeNestedNonPipelineExpression), function($skip, $loc, $0, $1, $2) {
+var NonPipelineActualAssignment$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$P)((0, import_lib2.$S)(NotDedented, UpdateExpressionPattern, WAssignmentOp)), MaybeNestedNonPipelineExpression), function($skip, $loc, $0, $1, $2) {
   $1 = $1.map((x) => [x[0], x[1], ...x[2]]);
   $0 = [$1, $2];
   return {
@@ -11195,8 +11283,14 @@ var PipelineExpressionBody$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Pipeline
     ...rest.map(([nested, line]) => [nested, ...line]).flat()
   ];
 });
-var PipelineExpressionBody$1 = (0, import_lib2.$P)((0, import_lib2.$S)(NotDedented, Pipe, __, PipelineTailItem));
-var PipelineExpressionBody$$ = [PipelineExpressionBody$0, PipelineExpressionBody$1];
+var PipelineExpressionBody$1 = (0, import_lib2.$T)((0, import_lib2.$S)(NewlineBinaryOpAllowed, (0, import_lib2.$P)((0, import_lib2.$S)(NotDedented, Pipe, __, PipelineTailItem))), function(value) {
+  return value[1];
+});
+var PipelineExpressionBody$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(NewlineBinaryOpAllowed), PipelineExpressionBodySameLine), function($skip, $loc, $0, $1, $2) {
+  if (!$2.length) return $skip;
+  return $2;
+});
+var PipelineExpressionBody$$ = [PipelineExpressionBody$0, PipelineExpressionBody$1, PipelineExpressionBody$2];
 function PipelineExpressionBody(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "PipelineExpressionBody", PipelineExpressionBody$$);
 }
@@ -11227,8 +11321,9 @@ var PipelineTailItem$3 = (0, import_lib2.$TS)((0, import_lib2.$S)(NWTypePostfix,
     body: [" ", $1, ...$2]
   });
 });
-var PipelineTailItem$4 = (0, import_lib2.$T)((0, import_lib2.$S)(PipelineHeadItem), function(value) {
-  return value[0];
+var PipelineTailItem$4 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidNewlineBinaryOp, (0, import_lib2.$E)(PipelineHeadItem), RestoreNewlineBinaryOp), function($skip, $loc, $0, $1, $2, $3) {
+  if (!$2) return $skip;
+  return $2;
 });
 var PipelineTailItem$$ = [PipelineTailItem$0, PipelineTailItem$1, PipelineTailItem$2, PipelineTailItem$3, PipelineTailItem$4];
 function PipelineTailItem(ctx, state2) {
@@ -11825,9 +11920,8 @@ var LeftHandSideExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, impo
     expression
   };
 });
-var LeftHandSideExpression$1 = NamedBindingPattern;
-var LeftHandSideExpression$2 = CallExpression;
-var LeftHandSideExpression$$ = [LeftHandSideExpression$0, LeftHandSideExpression$1, LeftHandSideExpression$2];
+var LeftHandSideExpression$1 = CallExpression;
+var LeftHandSideExpression$$ = [LeftHandSideExpression$0, LeftHandSideExpression$1];
 function LeftHandSideExpression(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "LeftHandSideExpression", LeftHandSideExpression$$);
 }
@@ -13282,14 +13376,21 @@ var OperatorAssociativity$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, impor
 function OperatorAssociativity(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "OperatorAssociativity", OperatorAssociativity$0);
 }
-var ThinArrowFunction$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(Async, _)), ArrowParameters, (0, import_lib2.$E)(ReturnTypeSuffix), (0, import_lib2.$E)(_), Arrow, (0, import_lib2.$C)(BracedObjectSingleLineStatements, NoCommaBracedOrEmptyBlock)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+var ThinArrowFunction$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(Async, _)), ArrowParameters, (0, import_lib2.$E)(ReturnTypeSuffix), (0, import_lib2.$E)(_), ThinArrow, (0, import_lib2.$C)(BracedObjectSingleLineStatements, NoCommaBracedOrEmptyBlock)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   var async = $1;
   var parameters = $2;
   var returnType = $3;
+  var ws = $4;
   var arrow = $5;
   var block = $6;
   if (!async) async = [];
   const generator = [];
+  if ((!parameters.implicit || returnType || ws) && !block.bare) {
+    const [first, ...rest] = block.children;
+    if (first === " {" || first?.[0]?.token === " ") {
+      block = { ...block, children: [first.slice(1), ...rest] };
+    }
+  }
   return {
     type: "FunctionExpression",
     id: void 0,
@@ -13314,6 +13415,7 @@ var ThinArrowFunction$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_li
       generator,
       parameters,
       returnType,
+      ws,
       block
     ]
   };
@@ -13321,11 +13423,11 @@ var ThinArrowFunction$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_li
 function ThinArrowFunction(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "ThinArrowFunction", ThinArrowFunction$0);
 }
-var Arrow$0 = (0, import_lib2.$TV)((0, import_lib2.$C)((0, import_lib2.$EXPECT)($L35, 'Arrow "->"'), (0, import_lib2.$EXPECT)($L36, 'Arrow "\u2192"')), function($skip, $loc, $0, $1) {
+var ThinArrow$0 = (0, import_lib2.$TV)((0, import_lib2.$C)((0, import_lib2.$EXPECT)($L35, 'ThinArrow "->"'), (0, import_lib2.$EXPECT)($L36, 'ThinArrow "\u2192"')), function($skip, $loc, $0, $1) {
   return { $loc, token: "->" };
 });
-function Arrow(ctx, state2) {
-  return (0, import_lib2.$EVENT)(ctx, state2, "Arrow", Arrow$0);
+function ThinArrow(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "ThinArrow", ThinArrow$0);
 }
 var ExplicitBlock$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), OpenBrace, AllowAll, (0, import_lib2.$E)((0, import_lib2.$C)(NestedBlockStatements, SingleLineStatements, EmptyBracedContent)), RestoreAll, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
   var ws1 = $1;
@@ -17983,8 +18085,10 @@ function CoffeeHereCommentStart(ctx, state2) {
 var InlineComment$0 = (0, import_lib2.$TR)((0, import_lib2.$EXPECT)($R74, "InlineComment /\\/\\*(?:(?!\\*\\/)[^\\r\\n])*\\*\\//"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
   return { $loc, token: $0 };
 });
+var InlineComment$1 = CoffeeMultiLineComment;
+var InlineComment$$ = [InlineComment$0, InlineComment$1];
 function InlineComment(ctx, state2) {
-  return (0, import_lib2.$EVENT)(ctx, state2, "InlineComment", InlineComment$0);
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "InlineComment", InlineComment$$);
 }
 var RestOfLine$0 = (0, import_lib2.$S)((0, import_lib2.$Q)((0, import_lib2.$C)(NonNewlineWhitespace, Comment)), EOL);
 function RestOfLine(ctx, state2) {
@@ -17994,7 +18098,7 @@ var TrailingComment$0 = (0, import_lib2.$S)((0, import_lib2.$E)(_), (0, import_l
 function TrailingComment(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "TrailingComment", TrailingComment$0);
 }
-var _$0 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($R75, "_ /(?=[ \\t\\/\\\\])/"), (0, import_lib2.$P)((0, import_lib2.$C)(NonNewlineWhitespace, InlineComment))), function(value) {
+var _$0 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($R75, "_ /(?=[ \\t\\/\\\\#])/"), (0, import_lib2.$P)((0, import_lib2.$C)(NonNewlineWhitespace, InlineComment))), function(value) {
   return value[1];
 });
 function _(ctx, state2) {
@@ -22163,8 +22267,9 @@ ${counts}`;
       const code = generate_civet_default(ast2, options);
       checkErrors();
       if (options.inlineMap) {
+        const outputFilename = options.outputFilename ?? (options.js ? filename2 + ".jsx" : filename2 + ".tsx");
         return `${code}
-${options.sourceMap.comment(filename2, filename2 + ".tsx")}`;
+${options.sourceMap.comment(filename2, outputFilename)}`;
       } else {
         return {
           code,