@danielx/civet 0.11.12 → 0.11.13

package/dist/main.js

@@ -3428,10 +3428,10 @@ function insertReturn(node) {
       }
       insertReturn(node.block);
       if (!isExit(node.block)) {
-        const comment = hasTrailingComment(node.block.expressions);
+        const comment = node.block.trailing?.length || hasTrailingComment(node.block.expressions);
         let ref12;
         node.block.expressions.push([
-          comment ? (ref12 = node.block.expressions)[ref12.length - 1][0] || "\n" : "",
+          comment ? (ref12 = node.block.expressions)[ref12.length - 1]?.[0] || "\n" : "",
           wrapWithReturn(void 0, node, !comment)
         ]);
       }
@@ -4071,6 +4071,53 @@ function processParams(f) {
   } else {
     indent = expressions[0][0];
   }
+  const { ancestor: enclosingClass } = findAncestor(f, ($10) => $10.type === "ClassExpression");
+  if (enclosingClass != null) {
+    const fieldTypes = /* @__PURE__ */ new Map();
+    for (let ref20 = gatherRecursiveWithinFunction(enclosingClass.body, ($11) => $11.type === "FieldDefinition"), i9 = 0, len8 = ref20.length; i9 < len8; i9++) {
+      const { id, typeSuffix } = ref20[i9];
+      if (typeSuffix != null && id?.type === "Identifier") {
+        fieldTypes.set(id.name, typeSuffix);
+      }
+    }
+    if (fieldTypes.size) {
+      for (let ref21 = gatherRecursive(parameters, ($12) => $12.type === "Parameter"), i10 = 0, len9 = ref21.length; i10 < len9; i10++) {
+        const parameter = ref21[i10];
+        if (parameter.typeSuffix != null) {
+          continue;
+        }
+        let inferredInPattern = false;
+        for (let ref22 = gatherRecursive(parameter, ($13) => $13.type === "AtBinding"), i11 = 0, len10 = ref22.length; i11 < len10; i11++) {
+          const binding = ref22[i11];
+          const owner = binding.parent;
+          assert(owner, "@-binding has no parent");
+          const fieldType = fieldTypes.get(binding.ref.id);
+          if (!(fieldType != null)) {
+            continue;
+          }
+          owner.typeSuffix = deepCopy(fieldType);
+          updateParentPointers(owner);
+          if (owner === parameter) {
+            const i = owner.children.indexOf(binding);
+            assert.notEqual(i, -1, "@-binding missing from parameter children");
+            owner.children[i + 1] = owner.typeSuffix;
+          } else {
+            inferredInPattern = true;
+          }
+        }
+        if (inferredInPattern) {
+          const pattern = parameter.binding;
+          pattern.typeSuffix = void 0;
+          gatherBindingPatternTypeSuffix(pattern);
+          assert(pattern.typeSuffix, "expected aggregated binding pattern type");
+          parameter.typeSuffix = pattern.typeSuffix;
+          const i = parameter.children.indexOf(pattern);
+          assert.notEqual(i, -1, "binding pattern missing from parameter children");
+          parameter.children[i + 1] = parameter.typeSuffix;
+        }
+      }
+    }
+  }
   const [splices, thisAssignments] = gatherBindingCode(parameters, {
     injectParamProps: isConstructor,
     assignPins: true
@@ -4079,22 +4126,21 @@ function processParams(f) {
   simplifyBindingProperties(parameters.parameters);
   simplifyBindingProperties(subbindings);
   if (isConstructor) {
-    const { ancestor } = findAncestor(f, ($10) => $10.type === "ClassExpression");
-    if (ancestor != null) {
-      const fields = new Set(gatherRecursiveWithinFunction(ancestor, ($11) => $11.type === "FieldDefinition").map(($12) => $12.id).filter(((a3) => typeof a3 === "object" && a3 != null && "type" in a3 && a3.type === "Identifier")).map(($13) => $13.name));
-      const classExpressions = ancestor.body.expressions;
+    if (enclosingClass != null) {
+      const fields = new Set(gatherRecursiveWithinFunction(enclosingClass, ($14) => $14.type === "FieldDefinition").map(($15) => $15.id).filter(((a3) => typeof a3 === "object" && a3 != null && "type" in a3 && a3.type === "Identifier")).map(($16) => $16.name));
+      const classExpressions = enclosingClass.body.expressions;
       let index2 = findChildIndex(classExpressions, f);
       assert.notEqual(index2, -1, "Could not find constructor in class");
       index2 -= precedingOverloads(f).length;
       const fStatement = classExpressions[index2];
-      for (let ref20 = gatherRecursive(parameters, ($14) => $14.type === "Parameter"), i9 = 0, len8 = ref20.length; i9 < len8; i9++) {
-        const parameter = ref20[i9];
+      for (let ref23 = gatherRecursive(parameters, ($17) => $17.type === "Parameter"), i12 = 0, len11 = ref23.length; i12 < len11; i12++) {
+        const parameter = ref23[i12];
         const { accessModifier } = parameter;
         if (!(accessModifier || parameter.typeSuffix)) {
           continue;
         }
-        for (let ref21 = gatherRecursive(parameter, ($15) => $15.type === "AtBinding"), i10 = 0, len9 = ref21.length; i10 < len9; i10++) {
-          const binding = ref21[i10];
+        for (let ref24 = gatherRecursive(parameter, ($18) => $18.type === "AtBinding"), i13 = 0, len12 = ref24.length; i13 < len12; i13++) {
+          const binding = ref24[i13];
           const typeSuffix = binding.parent?.typeSuffix;
           if (!(accessModifier || typeSuffix)) {
             continue;
@@ -4132,8 +4178,8 @@ function processParams(f) {
       decl: "const"
     }));
   }
-  for (let ref22 = splices, i11 = 0, len10 = ref22.length; i11 < len10; i11++) {
-    const binding = ref22[i11];
+  for (let ref25 = splices, i14 = 0, len13 = ref25.length; i14 < len13; i14++) {
+    const binding = ref25[i14];
     assert.equal(binding.type, "PostRestBindingElements", "splice should be of type Binding");
     prefix.push(makeNode({
       type: "Declaration",
@@ -4176,6 +4222,43 @@ function findSuperCall(block) {
     return -1;
   }
 }
+function transformArrowFunctionWithYield(f) {
+  const { block, parameters, returnType, async, signature } = f;
+  if (block?.type === "BlockStatement" && block.implicitlyReturned) {
+    insertReturn(block);
+    block.implicitlyReturned = false;
+  }
+  if (block?.type === "BlockStatement" && block.bare && !block.root) {
+    block.children.unshift(" {");
+    block.children.push("}");
+    block.bare = false;
+  }
+  const generator = ["*"];
+  signature.modifier ??= {};
+  signature.modifier.generator = true;
+  signature.generator = generator;
+  signature.children = [async, "function", generator, parameters, returnType];
+  f.type = "FunctionExpression";
+  f.generator = generator;
+  f.children = [async, "function", generator, parameters, returnType, block];
+  const originalParent = f.parent;
+  const lhs = makeLeftHandSideExpression(f);
+  let ref26;
+  if (gatherRecursiveWithinFunction(block, ((a6) => typeof a6 === "object" && a6 != null && "token" in a6 && a6.token === "this")).length) {
+    ref26 = makeNode({
+      type: "CallExpression",
+      children: [lhs, ".bind(this)"]
+    });
+  } else {
+    ref26 = lhs;
+  }
+  ;
+  const newNode = ref26;
+  if (newNode !== f && originalParent != null) {
+    replaceNode(f, newNode, originalParent);
+    updateParentPointers(newNode, originalParent);
+  }
+}
 function processSignature(f) {
   const { block, signature } = f;
   let addAsync = false;
@@ -4184,8 +4267,8 @@ function processSignature(f) {
     if (f.async != null) {
       addAsync = true;
     } else {
-      for (let ref23 = gatherRecursiveWithinFunction(block, ($16) => $16.type === "Await"), i12 = 0, len11 = ref23.length; i12 < len11; i12++) {
-        const a = ref23[i12];
+      for (let ref27 = gatherRecursiveWithinFunction(block, ($19) => $19.type === "Await"), i15 = 0, len14 = ref27.length; i15 < len14; i15++) {
+        const a = ref27[i15];
         const i = findChildIndex(a.parent, a);
         a.parent.children.splice(i + 1, 0, {
           type: "Error",
@@ -4197,19 +4280,21 @@ function processSignature(f) {
   if (!f.generator?.length && hasYield(block)) {
     if (f.generator != null) {
       addGenerator = true;
+    } else if (f.type === "ArrowFunction") {
+      transformArrowFunctionWithYield(f);
     } else {
-      for (let ref24 = gatherRecursiveWithinFunction(block, ($17) => $17.type === "YieldExpression"), i13 = 0, len12 = ref24.length; i13 < len12; i13++) {
-        const y = ref24[i13];
-        const i = y.children.findIndex(($18) => $18.type === "Yield");
+      for (let ref28 = gatherRecursiveWithinFunction(block, ($20) => $20.type === "YieldExpression"), i16 = 0, len15 = ref28.length; i16 < len15; i16++) {
+        const y = ref28[i16];
+        const i = y.children.findIndex(($21) => $21.type === "Yield");
         y.children.splice(i + 1, 0, {
           type: "Error",
-          message: `yield invalid in ${f.type === "ArrowFunction" ? "=> arrow function" : signature.modifier.get ? "getter" : signature.modifier.set ? "setter" : signature.name}`
+          message: `yield invalid in ${signature.modifier.get ? "getter" : signature.modifier.set ? "setter" : signature.name}`
         });
       }
     }
   }
-  for (let ref25 = [f, ...precedingOverloads(f)], i14 = 0, len13 = ref25.length; i14 < len13; i14++) {
-    const overload = ref25[i14];
+  for (let ref29 = [f, ...precedingOverloads(f)], i17 = 0, len16 = ref29.length; i17 < len16; i17++) {
+    const overload = ref29[i17];
     if (addAsync && overload.async != null && !overload.async.length) {
       overload.async.push("async ");
       overload.signature.modifier.async = true;
@@ -4228,8 +4313,8 @@ function processSignature(f) {
   }
 }
 function processFunctions(statements, config2) {
-  for (let ref26 = gatherRecursiveAll(statements, ($19) => $19.type === "FunctionExpression" || $19.type === "ArrowFunction" || $19.type === "MethodDefinition"), i15 = 0, len14 = ref26.length; i15 < len14; i15++) {
-    const f = ref26[i15];
+  for (let ref30 = gatherRecursiveAll(statements, ($22) => $22.type === "FunctionExpression" || $22.type === "ArrowFunction" || $22.type === "MethodDefinition"), i18 = 0, len17 = ref30.length; i18 < len17; i18++) {
+    const f = ref30[i18];
     if (f.type === "FunctionExpression" || f.type === "MethodDefinition") {
       implicitFunctionBlock(f);
     }
@@ -4302,14 +4387,14 @@ function expressionizeIteration(exp, consumeRoot) {
     ];
   } else {
     const reduction = statement.type === "ForStatement" && statement.reduction;
-    let ref27;
+    let ref31;
     if (!async && !reduction && !statement.block.empty) {
-      ref27 = blockContainingStatement(exp);
+      ref31 = blockContainingStatement(exp);
     } else {
-      ref27 = void 0;
+      ref31 = void 0;
     }
     ;
-    const parentInfo = ref27;
+    const parentInfo = ref31;
     if (parentInfo && iterationValueDiscarded(parentInfo.block, parentInfo.index, consumeRoot)) {
       const origSemi = parentInfo.block.expressions[parentInfo.index][2];
       statements = [["", statement, origSemi]];
@@ -4325,9 +4410,9 @@ function expressionizeIteration(exp, consumeRoot) {
   }
   let done;
   if (!async) {
-    let ref28;
-    if ((ref28 = blockContainingStatement(exp)) && typeof ref28 === "object" && "block" in ref28 && "index" in ref28) {
-      const { block: parentBlock, index } = ref28;
+    let ref32;
+    if ((ref32 = blockContainingStatement(exp)) && typeof ref32 === "object" && "block" in ref32 && "index" in ref32) {
+      const { block: parentBlock, index } = ref32;
       statements[0][0] = parentBlock.expressions[index][0];
       parentBlock.expressions.splice(index, index + 1 - index, ...statements);
       updateParentPointers(parentBlock);
@@ -4344,8 +4429,8 @@ function expressionizeIteration(exp, consumeRoot) {
   }
 }
 function processIterationExpressions(statements, consumeRoot = false) {
-  for (let ref29 = gatherRecursiveAll(statements, ($20) => $20.type === "IterationExpression"), i16 = 0, len15 = ref29.length; i16 < len15; i16++) {
-    const s = ref29[i16];
+  for (let ref33 = gatherRecursiveAll(statements, ($23) => $23.type === "IterationExpression"), i19 = 0, len18 = ref33.length; i19 < len18; i19++) {
+    const s = ref33[i19];
     expressionizeIteration(s, consumeRoot);
   }
 }
@@ -4358,7 +4443,12 @@ function skipImplicitArguments(args) {
     if (arg0.type === "StatementExpression") {
       arg0 = arg0.statement;
     }
-    return arg0.type === "IterationExpression" && arg0.subtype !== "DoStatement" && !arg0.async && isEmptyBareBlock(arg0.block);
+    if (arg0.type === "IterationExpression") {
+      return arg0.subtype !== "DoStatement" && !arg0.async && isEmptyBareBlock(arg0.block);
+    }
+    if (arg0.type === "IfStatement") {
+      return !arg0.else && isEmptyBareBlock(arg0.then);
+    }
   }
   return false;
 }
@@ -4369,21 +4459,21 @@ function processCoffeeDo(ws, expression) {
     let { parameters } = expression;
     const parameterList = parameters.parameters;
     const results3 = [];
-    for (let i17 = 0, len16 = parameterList.length; i17 < len16; i17++) {
-      let parameter = parameterList[i17];
+    for (let i20 = 0, len19 = parameterList.length; i20 < len19; i20++) {
+      let parameter = parameterList[i20];
       if (typeof parameter === "object" && parameter != null && "type" in parameter && parameter.type === "Parameter") {
-        let ref30;
-        if (ref30 = parameter.initializer) {
-          const initializer = ref30;
+        let ref34;
+        if (ref34 = parameter.initializer) {
+          const initializer = ref34;
           args.push(initializer.expression, parameter.delim);
           parameter = {
             ...parameter,
             initializer: void 0,
-            children: parameter.children.filter(((a6) => a6 !== initializer))
+            children: parameter.children.filter(((a7) => a7 !== initializer))
           };
         } else {
           args.push(parameter.children.filter(
-            ((a7) => a7 !== parameter.typeSuffix)
+            ((a8) => a8 !== parameter.typeSuffix)
           ));
         }
       }
@@ -4394,12 +4484,12 @@ function processCoffeeDo(ws, expression) {
     const newParameters = {
       ...parameters,
       parameters: newParameterList,
-      children: parameters.children.map(($21) => $21 === parameterList ? newParameterList : $21)
+      children: parameters.children.map(($24) => $24 === parameterList ? newParameterList : $24)
     };
     expression = {
       ...expression,
       parameters: newParameters,
-      children: expression.children.map(($22) => $22 === parameters ? newParameters : $22)
+      children: expression.children.map(($25) => $25 === parameters ? newParameters : $25)
     };
   }
   return {
@@ -4421,7 +4511,7 @@ function makeAmpersandFunction(rhs) {
     ref = makeRef("$");
     inplacePrepend(ref, body);
   }
-  if (startsWithPredicate(body, ($23) => $23.type === "ObjectExpression")) {
+  if (startsWithPredicate(body, ($26) => $26.type === "ObjectExpression")) {
     body = makeLeftHandSideExpression(body);
   }
   const parameterList = [
@@ -4464,7 +4554,7 @@ function makeAmpersandFunction(rhs) {
   }
   if (gatherRecursiveWithinFunction(
     block,
-    ((a8) => a8 === ref)
+    ((a9) => a9 === ref)
   ).length > 1) {
     fn.ampersandBlock = false;
   }
@@ -4489,6 +4579,9 @@ function blockWithPrefix(prefixStatements, block) {
 function braceBlock(block) {
   if (block.bare && !block.root) {
     block.children.unshift(" {");
+    if (hasTrailingComment(block.children)) {
+      block.children.push("\n");
+    }
     block.children.push("}");
     const { implicitlyReturned } = block;
     block.bare = block.implicitlyReturned = false;
@@ -6051,15 +6144,42 @@ function dynamizeFromClause(from) {
   }
   return ["(", ...from, ")"];
 }
+function markAllTypeImports(decl) {
+  if (decl.ts) {
+    return decl;
+  }
+  const { imports } = decl;
+  if (!imports) {
+    return decl;
+  }
+  const i = imports;
+  if (!i.binding && !i.star) {
+    const specs = i.specifiers;
+    if (specs?.length && specs.every(($5) => $5.ts)) {
+      return { ...decl, ts: true };
+    }
+    return decl;
+  }
+  const children = imports.children;
+  const namedSpecs = children.at(-1).specifiers;
+  if (!(namedSpecs?.length && namedSpecs.every(($6) => $6.ts))) {
+    return decl;
+  }
+  const [binding, ...rest] = children;
+  const newImportsChildren = [binding, { ts: true, children: rest }];
+  const newImports = { ...imports, children: newImportsChildren };
+  const newDeclChildren = decl.children.map((c) => c === imports ? newImports : c);
+  return { ...decl, imports: newImports, children: newDeclChildren };
+}
 function processStaticImport(decl) {
   const { imports, from, children } = decl;
   if (!(imports && "rest" in imports)) {
-    return decl;
+    return markAllTypeImports(decl);
   }
   const namedImports = imports.binding ? imports.children.at(-1) : imports;
   const allSpecs = namedImports.specifiers;
   if (!(namedImports.rest || allSpecs.some((s) => s.pattern))) {
-    return decl;
+    return markAllTypeImports(decl);
   }
   const ref = makeRef("imports");
   const star = { type: "Star", token: "*" };
@@ -7748,6 +7868,12 @@ function expressionizeIfStatement(statement) {
     children.push(":void 0");
   }
   children.push(closeParen);
+  if (b.trailing?.length) {
+    children.push(b.trailing);
+  }
+  if (e?.block.trailing?.length) {
+    children.push(e.block.trailing);
+  }
   return makeNode({
     type: "IfExpression",
     children
@@ -10029,6 +10155,9 @@ var grammar = {
   PostfixedSingleLineNoCommaStatements,
   NestedBlockStatements,
   NestedBlockStatement,
+  TrailingNestedComments,
+  TrailingInlineComment,
+  TrailingNestedCommentLine,
   BlockStatementPart,
   Literal,
   LiteralContent,
@@ -10646,6 +10775,7 @@ var grammar = {
   CoffeeOfEnabled,
   CoffeePrototypeEnabled,
   ESArrowFunctionEnabled,
+  ESBraceBlockEnabled,
   JSXCodeNestedEnabled,
   JSXCodeSameLineEnabled,
   ObjectIsEnabled,
@@ -13085,7 +13215,7 @@ function TrailingPostfix($$ctx, $$state) {
   $$ctx.exit?.("TrailingPostfix", $$state, $$final, $$eventData);
   return $$final;
 }
-var FatArrowBody$0$parser = (0, import_lib2.$S)((0, import_lib2.$N)(EOS), (0, import_lib2.$N)((0, import_lib2.$S)((0, import_lib2.$E)(_), ExpressionizedStatement)), (0, import_lib2.$N)((0, import_lib2.$S)((0, import_lib2.$E)(_), Declaration)), NonPipelineExpression, (0, import_lib2.$N)(TrailingDeclaration), (0, import_lib2.$N)(TrailingPipe), (0, import_lib2.$N)(TrailingPostfix), (0, import_lib2.$N)(SemicolonDelimiter));
+var FatArrowBody$0$parser = (0, import_lib2.$S)((0, import_lib2.$N)(EOS), (0, import_lib2.$N)((0, import_lib2.$S)((0, import_lib2.$E)(_), ExpressionizedStatement)), (0, import_lib2.$N)((0, import_lib2.$S)((0, import_lib2.$E)(_), Declaration)), NonPipelineExpression, (0, import_lib2.$N)(TrailingDeclaration), (0, import_lib2.$N)(TrailingPipe), (0, import_lib2.$N)(TrailingPostfix), (0, import_lib2.$C)(ESArrowFunctionEnabled, (0, import_lib2.$N)(SemicolonDelimiter)));
 function FatArrowBody$0($$ctx, $$state) {
   const $$r = FatArrowBody$0$parser($$ctx, $$state);
   if (!$$r) {
@@ -14201,7 +14331,7 @@ function ClassBracedContent($$ctx, $$state) {
   $$ctx.exit?.("ClassBracedContent", $$state, $$final, $$eventData);
   return $$final;
 }
-var NestedClassElements$parser = (0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedClassElement), PopIndent);
+var NestedClassElements$parser = (0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedClassElement), (0, import_lib2.$Q)(TrailingNestedCommentLine), PopIndent);
 function NestedClassElements($$ctx, $$state) {
   const $$entered = $$ctx.enter?.("NestedClassElements", $$state);
   if ($$entered && "cache" in $$entered) return $$entered.cache;
@@ -14211,12 +14341,13 @@ function NestedClassElements($$ctx, $$state) {
     $$ctx.exit?.("NestedClassElements", $$state, void 0, $$eventData);
     return void 0;
   }
-  const $$m = (function(elements) {
-    if (!elements.length) {
+  const $$value = $$r.value;
+  const $$m = (function(elements, trailing) {
+    if (!(elements.length || trailing.length)) {
       return $skip;
     }
-    return elements;
-  })($$r.value[1]);
+    return trailing.length ? [...elements, ...trailing] : elements;
+  })($$value[1], $$value[2]);
   const $$final = $$m !== import_lib2.SKIP ? ($$r.value = $$m, $$r) : void 0;
   $$ctx.exit?.("NestedClassElements", $$state, $$final, $$eventData);
   return $$final;
@@ -17788,8 +17919,9 @@ function ThenClause($$ctx, $$state) {
 }
 var ThenBlock$0$parser = (0, import_lib2.$S)(NoBlock, EmptyBlock);
 var ThenBlock$1$parser = ImplicitNestedBlock;
-var ThenBlock$2$parser = ObjectSingleLineStatements;
-var ThenBlock$3$parser = SingleLineStatements;
+var ThenBlock$2$parser = (0, import_lib2.$S)(ESBraceBlockEnabled, ExplicitBlock);
+var ThenBlock$3$parser = (0, import_lib2.$S)((0, import_lib2.$N)(ESBraceBlockEnabled), ObjectSingleLineStatements);
+var ThenBlock$4$parser = SingleLineStatements;
 function ThenBlock$0($$ctx, $$state) {
   const $$r = ThenBlock$0$parser($$ctx, $$state);
   if (!$$r) {
@@ -17805,16 +17937,35 @@ function ThenBlock$1($$ctx, $$state) {
   return ThenBlock$1$parser($$ctx, $$state);
 }
 function ThenBlock$2($$ctx, $$state) {
-  return ThenBlock$2$parser($$ctx, $$state);
+  const $$r = ThenBlock$2$parser($$ctx, $$state);
+  if (!$$r) {
+    return void 0;
+  }
+  const $$m = /* @__PURE__ */ (function($2) {
+    return $2;
+  })($$r.value[1]);
+  $$r.value = $$m;
+  return $$r;
 }
 function ThenBlock$3($$ctx, $$state) {
-  return ThenBlock$3$parser($$ctx, $$state);
+  const $$r = ThenBlock$3$parser($$ctx, $$state);
+  if (!$$r) {
+    return void 0;
+  }
+  const $$m = /* @__PURE__ */ (function($2) {
+    return $2;
+  })($$r.value[1]);
+  $$r.value = $$m;
+  return $$r;
+}
+function ThenBlock$4($$ctx, $$state) {
+  return ThenBlock$4$parser($$ctx, $$state);
 }
 function ThenBlock($$ctx, $$state) {
   const $$entered = $$ctx.enter?.("ThenBlock", $$state);
   if ($$entered && "cache" in $$entered) return $$entered.cache;
   const $$eventData = $$entered?.data;
-  const $$final = ThenBlock$0($$ctx, $$state) || ThenBlock$1($$ctx, $$state) || ThenBlock$2($$ctx, $$state) || ThenBlock$3($$ctx, $$state);
+  const $$final = ThenBlock$0($$ctx, $$state) || ThenBlock$1($$ctx, $$state) || ThenBlock$2($$ctx, $$state) || ThenBlock$3($$ctx, $$state) || ThenBlock$4($$ctx, $$state);
   $$ctx.exit?.("ThenBlock", $$state, $$final, $$eventData);
   return $$final;
 }
@@ -17939,11 +18090,19 @@ function BlockOrEmptyStatement($$ctx, $$state) {
   $$ctx.exit?.("BlockOrEmptyStatement", $$state, $$final, $$eventData);
   return $$final;
 }
-var BlockOrEmpty$0$parser = ObjectSingleLineStatements;
+var BlockOrEmpty$0$parser = (0, import_lib2.$S)((0, import_lib2.$N)(ESBraceBlockEnabled), ObjectSingleLineStatements);
 var BlockOrEmpty$1$parser = Block;
 var BlockOrEmpty$2$parser = (0, import_lib2.$S)(NoBlock, EmptyBlock);
 function BlockOrEmpty$0($$ctx, $$state) {
-  return BlockOrEmpty$0$parser($$ctx, $$state);
+  const $$r = BlockOrEmpty$0$parser($$ctx, $$state);
+  if (!$$r) {
+    return void 0;
+  }
+  const $$m = /* @__PURE__ */ (function($2) {
+    return $2;
+  })($$r.value[1]);
+  $$r.value = $$m;
+  return $$r;
 }
 function BlockOrEmpty$1($$ctx, $$state) {
   return BlockOrEmpty$1$parser($$ctx, $$state);
@@ -18313,7 +18472,7 @@ function PostfixedSingleLineNoCommaStatements($$ctx, $$state) {
   $$ctx.exit?.("PostfixedSingleLineNoCommaStatements", $$state, $$r, $$eventData);
   return $$r;
 }
-var NestedBlockStatements$parser = (0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedBlockStatement), PopIndent);
+var NestedBlockStatements$parser = (0, import_lib2.$S)(PushIndent, (0, import_lib2.$Q)(NestedBlockStatement), TrailingNestedComments, PopIndent);
 function NestedBlockStatements($$ctx, $$state) {
   const $$entered = $$ctx.enter?.("NestedBlockStatements", $$state);
   if ($$entered && "cache" in $$entered) return $$entered.cache;
@@ -18323,18 +18482,24 @@ function NestedBlockStatements($$ctx, $$state) {
     $$ctx.exit?.("NestedBlockStatements", $$state, void 0, $$eventData);
     return void 0;
   }
-  const $$m = (function(statements) {
-    if (!statements.length) {
+  const $$value = $$r.value;
+  const $$m = (function(statements, trailing) {
+    if (!(statements.length || trailing.length)) {
       return $skip;
     }
-    statements = statements.flat();
+    const expressions = statements.flat();
+    const children = [expressions];
+    if (trailing.length) {
+      children.push(trailing);
+    }
     return {
       type: "BlockStatement",
-      expressions: statements,
-      children: [statements],
-      bare: true
+      expressions,
+      children,
+      bare: true,
+      trailing: trailing.length ? trailing : void 0
     };
-  })($$r.value[1]);
+  })($$value[1], $$value[2]);
   const $$final = $$m !== import_lib2.SKIP ? ($$r.value = $$m, $$r) : void 0;
   $$ctx.exit?.("NestedBlockStatements", $$state, $$final, $$eventData);
   return $$final;
@@ -18360,6 +18525,70 @@ function NestedBlockStatement($$ctx, $$state) {
   $$ctx.exit?.("NestedBlockStatement", $$state, $$r, $$eventData);
   return $$r;
 }
+var TrailingNestedComments$parser = (0, import_lib2.$S)((0, import_lib2.$E)(TrailingInlineComment), (0, import_lib2.$Q)(TrailingNestedCommentLine));
+function TrailingNestedComments($$ctx, $$state) {
+  const $$entered = $$ctx.enter?.("TrailingNestedComments", $$state);
+  if ($$entered && "cache" in $$entered) return $$entered.cache;
+  const $$eventData = $$entered?.data;
+  const $$r = TrailingNestedComments$parser($$ctx, $$state);
+  if (!$$r) {
+    $$ctx.exit?.("TrailingNestedComments", $$state, void 0, $$eventData);
+    return void 0;
+  }
+  const $$value = $$r.value;
+  const $$m = (function(inline, lines) {
+    const out = [];
+    if (inline) {
+      out.push(inline);
+    }
+    if (lines.length) {
+      out.push(...lines);
+    }
+    return out;
+  })($$value[0], $$value[1]);
+  $$r.value = $$m;
+  $$ctx.exit?.("TrailingNestedComments", $$state, $$r, $$eventData);
+  return $$r;
+}
+var TrailingInlineComment$parser = (0, import_lib2.$S)((0, import_lib2.$E)(_), SingleLineComment);
+function TrailingInlineComment($$ctx, $$state) {
+  const $$entered = $$ctx.enter?.("TrailingInlineComment", $$state);
+  if ($$entered && "cache" in $$entered) return $$entered.cache;
+  const $$eventData = $$entered?.data;
+  const $$r = TrailingInlineComment$parser($$ctx, $$state);
+  if (!$$r) {
+    $$ctx.exit?.("TrailingInlineComment", $$state, void 0, $$eventData);
+    return void 0;
+  }
+  const $$value = $$r.value;
+  const $$m = /* @__PURE__ */ (function(ws, c) {
+    return [ws, c];
+  })($$value[0], $$value[1]);
+  $$r.value = $$m;
+  $$ctx.exit?.("TrailingInlineComment", $$state, $$r, $$eventData);
+  return $$r;
+}
+var TrailingNestedCommentLine$parser = (0, import_lib2.$S)(EOL, Indent, SingleLineComment);
+function TrailingNestedCommentLine($$ctx, $$state) {
+  const $$entered = $$ctx.enter?.("TrailingNestedCommentLine", $$state);
+  if ($$entered && "cache" in $$entered) return $$entered.cache;
+  const $$eventData = $$entered?.data;
+  const $$r = TrailingNestedCommentLine$parser($$ctx, $$state);
+  if (!$$r) {
+    $$ctx.exit?.("TrailingNestedCommentLine", $$state, void 0, $$eventData);
+    return void 0;
+  }
+  const $$value = $$r.value;
+  const $$m = (function(eol, indent, c) {
+    if (!(indent.level >= state.currentIndent.level)) {
+      return $skip;
+    }
+    return [eol, indent, c];
+  })($$value[0], $$value[1], $$value[2]);
+  const $$final = $$m !== import_lib2.SKIP ? ($$r.value = $$m, $$r) : void 0;
+  $$ctx.exit?.("TrailingNestedCommentLine", $$state, $$final, $$eventData);
+  return $$final;
+}
 var BlockStatementPart$parser = (0, import_lib2.$S)((0, import_lib2.$N)(EOS), (0, import_lib2.$E)(_), StatementListItem, StatementDelimiter);
 function BlockStatementPart($$ctx, $$state) {
   const $$entered = $$ctx.enter?.("BlockStatementPart", $$state);
@@ -23638,10 +23867,16 @@ function CaseClause$2($$ctx, $$state) {
     return void 0;
   }
   const $$value = $$r.value;
-  const $$m = /* @__PURE__ */ (function($0, cases, block, b) {
+  const $$m = (function($0, cases, block, b) {
+    let children = $0;
+    if (hasTrailingComment(block)) {
+      const bIdx = children.indexOf(b);
+      b = { ...b, token: "\n" + b.token };
+      children = [...children.slice(0, bIdx), b, ...children.slice(bIdx + 1)];
+    }
     return {
       type: "WhenClause",
-      children: $0,
+      children,
       cases,
       block,
       break: b
@@ -25333,7 +25568,7 @@ function MaybeNestedExpression($$ctx, $$state) {
   $$ctx.exit?.("MaybeNestedExpression", $$state, $$final, $$eventData);
   return $$final;
 }
-var MaybeParenNestedExpression$0$parser = (0, import_lib2.$Y)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement, NoBlock));
+var MaybeParenNestedExpression$0$parser = (0, import_lib2.$Y)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement, (0, import_lib2.$C)(NoBlock, (0, import_lib2.$S)((0, import_lib2.$E)(_), Semicolon))));
 var MaybeParenNestedExpression$1$parser = (0, import_lib2.$S)((0, import_lib2.$N)(EOS), Expression);
 var MaybeParenNestedExpression$2$parser = (0, import_lib2.$S)((0, import_lib2.$Y)(EOS), (0, import_lib2.$C)(ArrayLiteral, ObjectLiteral));
 var MaybeParenNestedExpression$3$parser = (0, import_lib2.$S)((0, import_lib2.$Y)(EOS), InsertSpace, InsertOpenParen, PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, Expression)), PopIndent, (0, import_lib2.$E)(AllowedTrailingCallExpressions), InsertNewline, InsertIndent, InsertCloseParen);
@@ -35149,6 +35384,24 @@ function ESArrowFunctionEnabled($$ctx, $$state) {
   $$ctx.exit?.("ESArrowFunctionEnabled", $$state, $$final, $$eventData);
   return $$final;
 }
+var ESBraceBlockEnabled$parser = (0, import_lib2.$EXPECT)($L0, 'ESBraceBlockEnabled ""');
+function ESBraceBlockEnabled($$ctx, $$state) {
+  const $$entered = $$ctx.enter?.("ESBraceBlockEnabled", $$state);
+  if ($$entered && "cache" in $$entered) return $$entered.cache;
+  const $$eventData = $$entered?.data;
+  const $$r = ESBraceBlockEnabled$parser($$ctx, $$state);
+  if (!$$r) {
+    $$ctx.exit?.("ESBraceBlockEnabled", $$state, void 0, $$eventData);
+    return void 0;
+  }
+  const $$m = (function() {
+    if (config.esBraceBlock) return;
+    return $skip;
+  })();
+  const $$final = $$m !== import_lib2.SKIP ? ($$r.value = $$m, $$r) : void 0;
+  $$ctx.exit?.("ESBraceBlockEnabled", $$state, $$final, $$eventData);
+  return $$final;
+}
 var JSXCodeNestedEnabled$parser = (0, import_lib2.$EXPECT)($L0, 'JSXCodeNestedEnabled ""');
 function JSXCodeNestedEnabled($$ctx, $$state) {
   const $$entered = $$ctx.enter?.("JSXCodeNestedEnabled", $$state);
@@ -35486,12 +35739,19 @@ function TrackIndented($$ctx, $$state) {
   $$ctx.exit?.("TrackIndented", $$state, $$final, $$eventData);
   return $$final;
 }
-var PushIndent$parser = (0, import_lib2.$Y)((0, import_lib2.$S)(EOS, TrackIndented));
+var PushIndent$0$parser = (0, import_lib2.$Y)((0, import_lib2.$S)(EOS, TrackIndented));
+var PushIndent$1$parser = (0, import_lib2.$Y)((0, import_lib2.$S)(EOL, TrackIndented));
+function PushIndent$0($$ctx, $$state) {
+  return PushIndent$0$parser($$ctx, $$state);
+}
+function PushIndent$1($$ctx, $$state) {
+  return PushIndent$1$parser($$ctx, $$state);
+}
 function PushIndent($$ctx, $$state) {
   const $$entered = $$ctx.enter?.("PushIndent", $$state);
   if ($$entered && "cache" in $$entered) return $$entered.cache;
   const $$eventData = $$entered?.data;
-  const $$final = PushIndent$parser($$ctx, $$state);
+  const $$final = PushIndent$0($$ctx, $$state) || PushIndent$1($$ctx, $$state);
   $$ctx.exit?.("PushIndent", $$state, $$final, $$eventData);
   return $$final;
 }