@danielx/civet 0.11.12 → 0.11.13

package/CHANGELOG.md

@@ -4,6 +4,21 @@ This changelog is generated automatically by [`build/changelog.civet`](build/cha
 For each version of Civet, it lists and links to all incorporated PRs,
 as well as a full diff and commit list.
 
+## 0.11.13 (2026-06-04, [diff](https://github.com/DanielXMoore/Civet/compare/v0.11.12...v0.11.13), [commits](https://github.com/DanielXMoore/Civet/commits/v0.11.13))
+* LSP: Don't indent after keyword property inside Object [[#2129](https://github.com/DanielXMoore/Civet/pull/2129)]
+* Move ts-service unit tests to root; gate coverage from single compile path [[#2130](https://github.com/DanielXMoore/Civet/pull/2130)]
+* Drop type-only named imports entirely in JS mode [[#2126](https://github.com/DanielXMoore/Civet/pull/2126)]
+* Fix postfix if/unless followed by ; emitting invalid JS [[#2132](https://github.com/DanielXMoore/Civet/pull/2132)]
+* docs: coverage mechanics guide for agents [[#2135](https://github.com/DanielXMoore/Civet/pull/2135)]
+* coverage: exclude sibling git worktrees from the gate [[#2136](https://github.com/DanielXMoore/Civet/pull/2136)]
+* LSP: pull-model diagnostics (`textDocument/diagnostic`) [[#2133](https://github.com/DanielXMoore/Civet/pull/2133)]
+* LSP: Hera-aware grammar-level features for `.hera` [[#2127](https://github.com/DanielXMoore/Civet/pull/2127)]
+* LSP: grammar-level folding and selection ranges for `.hera` [[#2138](https://github.com/DanielXMoore/Civet/pull/2138)]
+* feat: infer @-param types from class field declarations [[#2139](https://github.com/DanielXMoore/Civet/pull/2139)]
+* feat: allow yield in fat-arrow functions (#2140) [[#2143](https://github.com/DanielXMoore/Civet/pull/2143)]
+* esCompat: full ES-superset for statement-position braces and `=> expr;` [[#2142](https://github.com/DanielXMoore/Civet/pull/2142)]
+* Keep trailing comments inside indented blocks [[#2120](https://github.com/DanielXMoore/Civet/pull/2120)]
+
 ## 0.11.12 (2026-05-26, [diff](https://github.com/DanielXMoore/Civet/compare/v0.11.11...v0.11.12), [commits](https://github.com/DanielXMoore/Civet/commits/v0.11.12))
 * Fix Sublime support via JSON to XML conversion [[#2111](https://github.com/DanielXMoore/Civet/pull/2111)]
 * Fix crash on optional-chain LHS with custom `oper=` (#2109) [[#2113](https://github.com/DanielXMoore/Civet/pull/2113)]

package/dist/browser.js

@@ -2725,9 +2725,9 @@ ${js}`
           assert.notEqual(breakIndex, -1, "Could not find break in when clause"), node.children.splice(breakIndex, 1), node.break = void 0;
         }
         if (insertReturn(node.block), !isExit(node.block)) {
-          let comment = hasTrailingComment(node.block.expressions), ref12;
+          let comment = node.block.trailing?.length || hasTrailingComment(node.block.expressions), ref12;
           node.block.expressions.push([
-            comment ? (ref12 = node.block.expressions)[ref12.length - 1][0] || `
+            comment ? (ref12 = node.block.expressions)[ref12.length - 1]?.[0] || `
 ` : "",
             wrapWithReturn(void 0, node, !comment)
           ]);
@@ -3188,33 +3188,62 @@ ${js}`
     assert(expressions, "block is missing expressions");
     let indent;
     expressions.length ? indent = expressions[0][0] : indent = "";
+    let { ancestor: enclosingClass } = findAncestor(f, ($10) => $10.type === "ClassExpression");
+    if (enclosingClass != null) {
+      let fieldTypes = /* @__PURE__ */ new Map();
+      for (let ref20 = gatherRecursiveWithinFunction(enclosingClass.body, ($11) => $11.type === "FieldDefinition"), i9 = 0, len8 = ref20.length; i9 < len8; i9++) {
+        let { id, typeSuffix } = ref20[i9];
+        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++) {
+          let parameter = ref21[i10];
+          if (parameter.typeSuffix != null)
+            continue;
+          let inferredInPattern = !1;
+          for (let ref22 = gatherRecursive(parameter, ($13) => $13.type === "AtBinding"), i11 = 0, len10 = ref22.length; i11 < len10; i11++) {
+            let binding = ref22[i11], owner = binding.parent;
+            assert(owner, "@-binding has no parent");
+            let fieldType = fieldTypes.get(binding.ref.id);
+            if (fieldType != null)
+              if (owner.typeSuffix = deepCopy(fieldType), updateParentPointers(owner), owner === parameter) {
+                let i = owner.children.indexOf(binding);
+                assert.notEqual(i, -1, "@-binding missing from parameter children"), owner.children[i + 1] = owner.typeSuffix;
+              } else
+                inferredInPattern = !0;
+          }
+          if (inferredInPattern) {
+            let pattern = parameter.binding;
+            pattern.typeSuffix = void 0, gatherBindingPatternTypeSuffix(pattern), assert(pattern.typeSuffix, "expected aggregated binding pattern type"), parameter.typeSuffix = pattern.typeSuffix;
+            let i = parameter.children.indexOf(pattern);
+            assert.notEqual(i, -1, "binding pattern missing from parameter children"), parameter.children[i + 1] = parameter.typeSuffix;
+          }
+        }
+    }
     let [splices, thisAssignments] = gatherBindingCode(parameters, {
       injectParamProps: isConstructor,
       assignPins: !0
     }), subbindings = gatherSubbindings(parameters.parameters);
-    if (simplifyBindingProperties(parameters.parameters), simplifyBindingProperties(subbindings), isConstructor) {
-      let { ancestor } = findAncestor(f, ($10) => $10.type === "ClassExpression");
-      if (ancestor != null) {
-        let 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)), classExpressions = ancestor.body.expressions, index2 = findChildIndex(classExpressions, f);
-        assert.notEqual(index2, -1, "Could not find constructor in class"), index2 -= precedingOverloads(f).length;
-        let fStatement = classExpressions[index2];
-        for (let ref20 = gatherRecursive(parameters, ($14) => $14.type === "Parameter"), i9 = 0, len8 = ref20.length; i9 < len8; i9++) {
-          let parameter = ref20[i9], { accessModifier } = parameter;
-          if (accessModifier || parameter.typeSuffix)
-            for (let ref21 = gatherRecursive(parameter, ($15) => $15.type === "AtBinding"), i10 = 0, len9 = ref21.length; i10 < len9; i10++) {
-              let binding = ref21[i10], typeSuffix = binding.parent?.typeSuffix;
-              if (!(accessModifier || typeSuffix))
-                continue;
-              parameter.accessModifier && (replaceNode(parameter.accessModifier, void 0), parameter.accessModifier = void 0);
-              let id = binding.ref.id;
-              fields.has(id) || (classExpressions.splice(index2++, 0, [fStatement[0], {
-                type: "FieldDefinition",
-                id,
-                typeSuffix,
-                children: [accessModifier, id, typeSuffix]
-              }, ";"]), fStatement[0] = "");
-            }
-        }
+    if (simplifyBindingProperties(parameters.parameters), simplifyBindingProperties(subbindings), isConstructor && enclosingClass != null) {
+      let 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)), classExpressions = enclosingClass.body.expressions, index2 = findChildIndex(classExpressions, f);
+      assert.notEqual(index2, -1, "Could not find constructor in class"), index2 -= precedingOverloads(f).length;
+      let fStatement = classExpressions[index2];
+      for (let ref23 = gatherRecursive(parameters, ($17) => $17.type === "Parameter"), i12 = 0, len11 = ref23.length; i12 < len11; i12++) {
+        let parameter = ref23[i12], { accessModifier } = parameter;
+        if (accessModifier || parameter.typeSuffix)
+          for (let ref24 = gatherRecursive(parameter, ($18) => $18.type === "AtBinding"), i13 = 0, len12 = ref24.length; i13 < len12; i13++) {
+            let binding = ref24[i13], typeSuffix = binding.parent?.typeSuffix;
+            if (!(accessModifier || typeSuffix))
+              continue;
+            parameter.accessModifier && (replaceNode(parameter.accessModifier, void 0), parameter.accessModifier = void 0);
+            let id = binding.ref.id;
+            fields.has(id) || (classExpressions.splice(index2++, 0, [fStatement[0], {
+              type: "FieldDefinition",
+              id,
+              typeSuffix,
+              children: [accessModifier, id, typeSuffix]
+            }, ";"]), fStatement[0] = "");
+          }
       }
     }
     let delimiter = {
@@ -3228,8 +3257,8 @@ ${js}`
       bindings: [],
       decl: "const"
     }));
-    for (let ref22 = splices, i11 = 0, len10 = ref22.length; i11 < len10; i11++) {
-      let binding = ref22[i11];
+    for (let ref25 = splices, i14 = 0, len13 = ref25.length; i14 < len13; i14++) {
+      let binding = ref25[i14];
       assert.equal(binding.type, "PostRestBindingElements", "splice should be of type Binding"), prefix.push(makeNode({
         type: "Declaration",
         children: ["let ", binding],
@@ -3259,14 +3288,27 @@ ${js}`
     } else
       return -1;
   }
+  function transformArrowFunctionWithYield(f) {
+    let { block, parameters, returnType, async, signature } = f;
+    block?.type === "BlockStatement" && block.implicitlyReturned && (insertReturn(block), block.implicitlyReturned = !1), block?.type === "BlockStatement" && block.bare && !block.root && (block.children.unshift(" {"), block.children.push("}"), block.bare = !1);
+    let generator = ["*"];
+    signature.modifier ??= {}, signature.modifier.generator = !0, signature.generator = generator, signature.children = [async, "function", generator, parameters, returnType], f.type = "FunctionExpression", f.generator = generator, f.children = [async, "function", generator, parameters, returnType, block];
+    let originalParent = f.parent, lhs = makeLeftHandSideExpression(f), ref26;
+    gatherRecursiveWithinFunction(block, ((a6) => typeof a6 == "object" && a6 != null && "token" in a6 && a6.token === "this")).length ? ref26 = makeNode({
+      type: "CallExpression",
+      children: [lhs, ".bind(this)"]
+    }) : ref26 = lhs;
+    let newNode = ref26;
+    newNode !== f && originalParent != null && (replaceNode(f, newNode, originalParent), updateParentPointers(newNode, originalParent));
+  }
   function processSignature(f) {
     let { block, signature } = f, addAsync = !1, addGenerator = !1;
     if (!f.async?.length && hasAwait(block))
       if (f.async != null)
         addAsync = !0;
       else
-        for (let ref23 = gatherRecursiveWithinFunction(block, ($16) => $16.type === "Await"), i12 = 0, len11 = ref23.length; i12 < len11; i12++) {
-          let a = ref23[i12], i = findChildIndex(a.parent, a);
+        for (let ref27 = gatherRecursiveWithinFunction(block, ($19) => $19.type === "Await"), i15 = 0, len14 = ref27.length; i15 < len14; i15++) {
+          let a = ref27[i15], i = findChildIndex(a.parent, a);
           a.parent.children.splice(i + 1, 0, {
             type: "Error",
             message: `await invalid in ${signature.modifier.get ? "getter" : signature.modifier.set ? "setter" : signature.name}`
@@ -3275,16 +3317,18 @@ ${js}`
     if (!f.generator?.length && hasYield(block))
       if (f.generator != null)
         addGenerator = !0;
+      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++) {
-          let y = ref24[i13], 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++) {
+          let y = ref28[i16], 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++) {
-      let overload = ref25[i14];
+    for (let ref29 = [f, ...precedingOverloads(f)], i17 = 0, len16 = ref29.length; i17 < len16; i17++) {
+      let overload = ref29[i17];
       addAsync && overload.async != null && !overload.async.length && (overload.async.push("async "), overload.signature.modifier.async = !0), addGenerator && overload.generator != null && !overload.generator.length && (overload.generator.push("*"), overload.signature.modifier.generator = !0), overload.signature.modifier.async && !overload.signature.modifier.generator && overload.signature.returnType && !isPromiseType(overload.signature.returnType.t) && replaceNode(
         overload.signature.returnType.t,
         wrapTypeInPromise(overload.signature.returnType.t),
@@ -3293,8 +3337,8 @@ ${js}`
     }
   }
   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++) {
-      let 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++) {
+      let f = ref30[i18];
       (f.type === "FunctionExpression" || f.type === "MethodDefinition") && implicitFunctionBlock(f), processSignature(f), processParams(f), processReturn(f, config2.implicitReturns);
     }
   }
@@ -3349,9 +3393,9 @@ ${js}`
         ["", statement]
       ];
     else {
-      let reduction = statement.type === "ForStatement" && statement.reduction, ref27;
-      !async && !reduction && !statement.block.empty ? ref27 = blockContainingStatement(exp) : ref27 = void 0;
-      let parentInfo = ref27;
+      let reduction = statement.type === "ForStatement" && statement.reduction, ref31;
+      !async && !reduction && !statement.block.empty ? ref31 = blockContainingStatement(exp) : ref31 = void 0;
+      let parentInfo = ref31;
       if (parentInfo && iterationValueDiscarded(parentInfo.block, parentInfo.index, consumeRoot)) {
         let origSemi = parentInfo.block.expressions[parentInfo.index][2];
         statements = [["", statement, origSemi]];
@@ -3366,24 +3410,27 @@ ${js}`
     }
     let done;
     if (!async) {
-      let ref28;
-      if ((ref28 = blockContainingStatement(exp)) && typeof ref28 == "object" && "block" in ref28 && "index" in ref28) {
-        let { block: parentBlock, index } = ref28;
+      let ref32;
+      if ((ref32 = blockContainingStatement(exp)) && typeof ref32 == "object" && "block" in ref32 && "index" in ref32) {
+        let { block: parentBlock, index } = ref32;
         statements[0][0] = parentBlock.expressions[index][0], parentBlock.expressions.splice(index, index + 1 - index, ...statements), updateParentPointers(parentBlock), braceBlock(parentBlock), done = !0;
       }
     }
     done || (generator || (statements[statements.length - 1][1] = wrapWithReturn(statements[statements.length - 1][1])), children.splice(i, 1, wrapIIFE(statements, async, generator)), updateParentPointers(exp));
   }
   function processIterationExpressions(statements, consumeRoot = !1) {
-    for (let ref29 = gatherRecursiveAll(statements, ($20) => $20.type === "IterationExpression"), i16 = 0, len15 = ref29.length; i16 < len15; i16++) {
-      let s = ref29[i16];
+    for (let ref33 = gatherRecursiveAll(statements, ($23) => $23.type === "IterationExpression"), i19 = 0, len18 = ref33.length; i19 < len18; i19++) {
+      let s = ref33[i19];
       expressionizeIteration(s, consumeRoot);
     }
   }
   function skipImplicitArguments(args) {
     if (args.length === 1) {
       let arg0 = args[0];
-      return arg0.type === "Argument" && (arg0 = arg0.expression), arg0.type === "StatementExpression" && (arg0 = arg0.statement), arg0.type === "IterationExpression" && arg0.subtype !== "DoStatement" && !arg0.async && isEmptyBareBlock(arg0.block);
+      if (arg0.type === "Argument" && (arg0 = arg0.expression), arg0.type === "StatementExpression" && (arg0 = arg0.statement), arg0.type === "IterationExpression")
+        return arg0.subtype !== "DoStatement" && !arg0.async && isEmptyBareBlock(arg0.block);
+      if (arg0.type === "IfStatement")
+        return !arg0.else && isEmptyBareBlock(arg0.then);
     }
     return !1;
   }
@@ -3392,20 +3439,20 @@ ${js}`
     let args = [];
     if (typeof expression == "object" && expression != null && "type" in expression && expression.type === "ArrowFunction" || typeof expression == "object" && expression != null && "type" in expression && expression.type === "FunctionExpression") {
       let { parameters } = expression, parameterList = parameters.parameters, 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) {
-            let initializer = ref30;
+          let ref34;
+          if (ref34 = parameter.initializer) {
+            let 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)
             ));
         }
         results3.push(parameter);
@@ -3413,12 +3460,12 @@ ${js}`
       let newParameterList = results3, 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 {
@@ -3436,7 +3483,7 @@ ${js}`
   }
   function makeAmpersandFunction(rhs) {
     let { ref, typeSuffix, body } = rhs;
-    ref == null && (ref = makeRef("$"), inplacePrepend(ref, body)), startsWithPredicate(body, ($23) => $23.type === "ObjectExpression") && (body = makeLeftHandSideExpression(body));
+    ref == null && (ref = makeRef("$"), inplacePrepend(ref, body)), startsWithPredicate(body, ($26) => $26.type === "ObjectExpression") && (body = makeLeftHandSideExpression(body));
     let parameterList = [
       typeSuffix ? [ref, typeSuffix] : ref
     ], parameters = makeNode({
@@ -3467,7 +3514,7 @@ ${js}`
     });
     return isStatement(body) && (braceBlock(block), fn.ampersandBlock = !1), gatherRecursiveWithinFunction(
       block,
-      ((a8) => a8 === ref)
+      ((a9) => a9 === ref)
     ).length > 1 && (fn.ampersandBlock = !1), fn;
   }
 
@@ -3485,7 +3532,8 @@ ${js}`
   }
   function braceBlock(block) {
     if (block.bare && !block.root) {
-      block.children.unshift(" {"), block.children.push("}");
+      block.children.unshift(" {"), hasTrailingComment(block.children) && block.children.push(`
+`), block.children.push("}");
       let { implicitlyReturned } = block;
       block.bare = block.implicitlyReturned = !1, implicitlyReturned && processReturn(block.parent, !0);
     }
@@ -4560,13 +4608,30 @@ ${js}`
     }
     return ["(", ...from, ")"];
   }
+  function markAllTypeImports(decl) {
+    if (decl.ts)
+      return decl;
+    let { imports } = decl;
+    if (!imports)
+      return decl;
+    let i = imports;
+    if (!i.binding && !i.star) {
+      let specs = i.specifiers;
+      return specs?.length && specs.every(($5) => $5.ts) ? { ...decl, ts: !0 } : decl;
+    }
+    let children = imports.children, namedSpecs = children.at(-1).specifiers;
+    if (!(namedSpecs?.length && namedSpecs.every(($6) => $6.ts)))
+      return decl;
+    let [binding, ...rest] = children, newImports = { ...imports, children: [binding, { ts: !0, children: rest }] }, newDeclChildren = decl.children.map((c) => c === imports ? newImports : c);
+    return { ...decl, imports: newImports, children: newDeclChildren };
+  }
   function processStaticImport(decl) {
     let { imports, from, children } = decl;
     if (!(imports && "rest" in imports))
-      return decl;
+      return markAllTypeImports(decl);
     let namedImports = imports.binding ? imports.children.at(-1) : imports, allSpecs = namedImports.specifiers;
     if (!(namedImports.rest || allSpecs.some((s) => s.pattern)))
-      return decl;
+      return markAllTypeImports(decl);
     let ref = makeRef("imports"), star = { type: "Star", token: "*" }, tsSpecs = allSpecs.filter((s) => s.ts), runtimeSpecs = allSpecs.filter((s) => !s.ts), runtimeNames = runtimeSpecs.flatMap((s) => s.binding.names);
     namedImports.rest && runtimeNames.push(...namedImports.rest.binding.names);
     let runtimeNamed = {
@@ -5745,7 +5810,7 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
       children.push(e.children[0], ":", e2, ...e.children.slice(3));
     } else
       children.push(":void 0");
-    return children.push(closeParen), makeNode({
+    return children.push(closeParen), b.trailing?.length && children.push(b.trailing), e?.block.trailing?.length && children.push(e.block.trailing), makeNode({
       type: "IfExpression",
       children
     });
@@ -7416,6 +7481,9 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
     PostfixedSingleLineNoCommaStatements,
     NestedBlockStatements,
     NestedBlockStatement,
+    TrailingNestedComments,
+    TrailingInlineComment,
+    TrailingNestedCommentLine,
     BlockStatementPart,
     Literal,
     LiteralContent,
@@ -8033,6 +8101,7 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
     CoffeeOfEnabled,
     CoffeePrototypeEnabled,
     ESArrowFunctionEnabled,
+    ESBraceBlockEnabled,
     JSXCodeNestedEnabled,
     JSXCodeSameLineEnabled,
     ObjectIsEnabled,
@@ -9608,7 +9677,7 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
     let $$eventData = $$entered?.data, $$final = TrailingPostfix$parser($$ctx, $$state);
     return $$ctx.exit?.("TrailingPostfix", $$state, $$final, $$eventData), $$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) {
     let $$r = FatArrowBody$0$parser($$ctx, $$state);
     if (!$$r)
@@ -10454,7 +10523,7 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
     let $$eventData = $$entered?.data, $$final = ClassBracedContent$0($$ctx, $$state) || ClassBracedContent$1($$ctx, $$state);
     return $$ctx.exit?.("ClassBracedContent", $$state, $$final, $$eventData), $$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) {
     let $$entered = $$ctx.enter?.("NestedClassElements", $$state);
     if ($$entered && "cache" in $$entered) return $$entered.cache;
@@ -10463,9 +10532,9 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
       $$ctx.exit?.("NestedClassElements", $$state, void 0, $$eventData);
       return;
     }
-    let $$m = (function(elements) {
-      return elements.length ? elements : $skip;
-    })($$r.value[1]), $$final = $$m !== import_lib2.SKIP ? ($$r.value = $$m, $$r) : void 0;
+    let $$value = $$r.value, $$m = (function(elements, trailing) {
+      return elements.length || trailing.length ? trailing.length ? [...elements, ...trailing] : elements : $skip;
+    })($$value[1], $$value[2]), $$final = $$m !== import_lib2.SKIP ? ($$r.value = $$m, $$r) : void 0;
     return $$ctx.exit?.("NestedClassElements", $$state, $$final, $$eventData), $$final;
   }
   var NestedClassElement$parser = (0, import_lib2.$S)(Nested, ClassElement, StatementDelimiter);
@@ -13232,7 +13301,7 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
     })($$r.value[1]);
     return $$r.value = $$m, $$ctx.exit?.("ThenClause", $$state, $$r, $$eventData), $$r;
   }
-  var ThenBlock$0$parser = (0, import_lib2.$S)(NoBlock, EmptyBlock), ThenBlock$1$parser = ImplicitNestedBlock, ThenBlock$2$parser = ObjectSingleLineStatements, ThenBlock$3$parser = SingleLineStatements;
+  var ThenBlock$0$parser = (0, import_lib2.$S)(NoBlock, EmptyBlock), ThenBlock$1$parser = ImplicitNestedBlock, ThenBlock$2$parser = (0, import_lib2.$S)(ESBraceBlockEnabled, ExplicitBlock), ThenBlock$3$parser = (0, import_lib2.$S)((0, import_lib2.$N)(ESBraceBlockEnabled), ObjectSingleLineStatements), ThenBlock$4$parser = SingleLineStatements;
   function ThenBlock$0($$ctx, $$state) {
     let $$r = ThenBlock$0$parser($$ctx, $$state);
     if (!$$r)
@@ -13246,15 +13315,30 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
     return ThenBlock$1$parser($$ctx, $$state);
   }
   function ThenBlock$2($$ctx, $$state) {
-    return ThenBlock$2$parser($$ctx, $$state);
+    let $$r = ThenBlock$2$parser($$ctx, $$state);
+    if (!$$r)
+      return;
+    let $$m = /* @__PURE__ */ (function($2) {
+      return $2;
+    })($$r.value[1]);
+    return $$r.value = $$m, $$r;
   }
   function ThenBlock$3($$ctx, $$state) {
-    return ThenBlock$3$parser($$ctx, $$state);
+    let $$r = ThenBlock$3$parser($$ctx, $$state);
+    if (!$$r)
+      return;
+    let $$m = /* @__PURE__ */ (function($2) {
+      return $2;
+    })($$r.value[1]);
+    return $$r.value = $$m, $$r;
+  }
+  function ThenBlock$4($$ctx, $$state) {
+    return ThenBlock$4$parser($$ctx, $$state);
   }
   function ThenBlock($$ctx, $$state) {
     let $$entered = $$ctx.enter?.("ThenBlock", $$state);
     if ($$entered && "cache" in $$entered) return $$entered.cache;
-    let $$eventData = $$entered?.data, $$final = ThenBlock$0($$ctx, $$state) || ThenBlock$1($$ctx, $$state) || ThenBlock$2($$ctx, $$state) || ThenBlock$3($$ctx, $$state);
+    let $$eventData = $$entered?.data, $$final = ThenBlock$0($$ctx, $$state) || ThenBlock$1($$ctx, $$state) || ThenBlock$2($$ctx, $$state) || ThenBlock$3($$ctx, $$state) || ThenBlock$4($$ctx, $$state);
     return $$ctx.exit?.("ThenBlock", $$state, $$final, $$eventData), $$final;
   }
   var BracedThenClause$parser = (0, import_lib2.$S)((0, import_lib2.$Y)(Then), InsertOpenBrace, ThenClause, InsertCloseBrace);
@@ -13356,9 +13440,15 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
     let $$eventData = $$entered?.data, $$final = BlockOrEmptyStatement$0($$ctx, $$state) || BlockOrEmptyStatement$1($$ctx, $$state);
     return $$ctx.exit?.("BlockOrEmptyStatement", $$state, $$final, $$eventData), $$final;
   }
-  var BlockOrEmpty$0$parser = ObjectSingleLineStatements, BlockOrEmpty$1$parser = Block, BlockOrEmpty$2$parser = (0, import_lib2.$S)(NoBlock, EmptyBlock);
+  var BlockOrEmpty$0$parser = (0, import_lib2.$S)((0, import_lib2.$N)(ESBraceBlockEnabled), ObjectSingleLineStatements), BlockOrEmpty$1$parser = Block, BlockOrEmpty$2$parser = (0, import_lib2.$S)(NoBlock, EmptyBlock);
   function BlockOrEmpty$0($$ctx, $$state) {
-    return BlockOrEmpty$0$parser($$ctx, $$state);
+    let $$r = BlockOrEmpty$0$parser($$ctx, $$state);
+    if (!$$r)
+      return;
+    let $$m = /* @__PURE__ */ (function($2) {
+      return $2;
+    })($$r.value[1]);
+    return $$r.value = $$m, $$r;
   }
   function BlockOrEmpty$1($$ctx, $$state) {
     return BlockOrEmpty$1$parser($$ctx, $$state);
@@ -13648,7 +13738,7 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
     })($$value[0], $$value[1]);
     return $$r.value = $$m, $$ctx.exit?.("PostfixedSingleLineNoCommaStatements", $$state, $$r, $$eventData), $$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) {
     let $$entered = $$ctx.enter?.("NestedBlockStatements", $$state);
     if ($$entered && "cache" in $$entered) return $$entered.cache;
@@ -13657,14 +13747,18 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
       $$ctx.exit?.("NestedBlockStatements", $$state, void 0, $$eventData);
       return;
     }
-    let $$m = (function(statements) {
-      return statements.length ? (statements = statements.flat(), {
+    let $$value = $$r.value, $$m = (function(statements, trailing) {
+      if (!(statements.length || trailing.length))
+        return $skip;
+      let expressions = statements.flat(), children = [expressions];
+      return trailing.length && children.push(trailing), {
         type: "BlockStatement",
-        expressions: statements,
-        children: [statements],
-        bare: !0
-      }) : $skip;
-    })($$r.value[1]), $$final = $$m !== import_lib2.SKIP ? ($$r.value = $$m, $$r) : void 0;
+        expressions,
+        children,
+        bare: !0,
+        trailing: trailing.length ? trailing : void 0
+      };
+    })($$value[1], $$value[2]), $$final = $$m !== import_lib2.SKIP ? ($$r.value = $$m, $$r) : void 0;
     return $$ctx.exit?.("NestedBlockStatements", $$state, $$final, $$eventData), $$final;
   }
   var NestedBlockStatement$parser = (0, import_lib2.$S)(Nested, (0, import_lib2.$P)(BlockStatementPart));
@@ -13684,6 +13778,49 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
     })($$value[0], $$value[1]);
     return $$r.value = $$m, $$ctx.exit?.("NestedBlockStatement", $$state, $$r, $$eventData), $$r;
   }
+  var TrailingNestedComments$parser = (0, import_lib2.$S)((0, import_lib2.$E)(TrailingInlineComment), (0, import_lib2.$Q)(TrailingNestedCommentLine));
+  function TrailingNestedComments($$ctx, $$state) {
+    let $$entered = $$ctx.enter?.("TrailingNestedComments", $$state);
+    if ($$entered && "cache" in $$entered) return $$entered.cache;
+    let $$eventData = $$entered?.data, $$r = TrailingNestedComments$parser($$ctx, $$state);
+    if (!$$r) {
+      $$ctx.exit?.("TrailingNestedComments", $$state, void 0, $$eventData);
+      return;
+    }
+    let $$value = $$r.value, $$m = (function(inline, lines) {
+      let out = [];
+      return inline && out.push(inline), lines.length && out.push(...lines), out;
+    })($$value[0], $$value[1]);
+    return $$r.value = $$m, $$ctx.exit?.("TrailingNestedComments", $$state, $$r, $$eventData), $$r;
+  }
+  var TrailingInlineComment$parser = (0, import_lib2.$S)((0, import_lib2.$E)(_), SingleLineComment);
+  function TrailingInlineComment($$ctx, $$state) {
+    let $$entered = $$ctx.enter?.("TrailingInlineComment", $$state);
+    if ($$entered && "cache" in $$entered) return $$entered.cache;
+    let $$eventData = $$entered?.data, $$r = TrailingInlineComment$parser($$ctx, $$state);
+    if (!$$r) {
+      $$ctx.exit?.("TrailingInlineComment", $$state, void 0, $$eventData);
+      return;
+    }
+    let $$value = $$r.value, $$m = /* @__PURE__ */ (function(ws, c) {
+      return [ws, c];
+    })($$value[0], $$value[1]);
+    return $$r.value = $$m, $$ctx.exit?.("TrailingInlineComment", $$state, $$r, $$eventData), $$r;
+  }
+  var TrailingNestedCommentLine$parser = (0, import_lib2.$S)(EOL, Indent, SingleLineComment);
+  function TrailingNestedCommentLine($$ctx, $$state) {
+    let $$entered = $$ctx.enter?.("TrailingNestedCommentLine", $$state);
+    if ($$entered && "cache" in $$entered) return $$entered.cache;
+    let $$eventData = $$entered?.data, $$r = TrailingNestedCommentLine$parser($$ctx, $$state);
+    if (!$$r) {
+      $$ctx.exit?.("TrailingNestedCommentLine", $$state, void 0, $$eventData);
+      return;
+    }
+    let $$value = $$r.value, $$m = (function(eol, indent, c) {
+      return indent.level >= state.currentIndent.level ? [eol, indent, c] : $skip;
+    })($$value[0], $$value[1], $$value[2]), $$final = $$m !== import_lib2.SKIP ? ($$r.value = $$m, $$r) : void 0;
+    return $$ctx.exit?.("TrailingNestedCommentLine", $$state, $$final, $$eventData), $$final;
+  }
   var BlockStatementPart$parser = (0, import_lib2.$S)((0, import_lib2.$N)(EOS), (0, import_lib2.$E)(_), StatementListItem, StatementDelimiter);
   function BlockStatementPart($$ctx, $$state) {
     let $$entered = $$ctx.enter?.("BlockStatementPart", $$state);
@@ -17743,10 +17880,16 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
     let $$r = CaseClause$2$parser($$ctx, $$state);
     if (!$$r)
       return;
-    let $$value = $$r.value, $$m = /* @__PURE__ */ (function($0, cases, block, b) {
+    let $$value = $$r.value, $$m = (function($0, cases, block, b) {
+      let children = $0;
+      if (hasTrailingComment(block)) {
+        let bIdx = children.indexOf(b);
+        b = { ...b, token: `
+` + b.token }, children = [...children.slice(0, bIdx), b, ...children.slice(bIdx + 1)];
+      }
       return {
         type: "WhenClause",
-        children: $0,
+        children,
         cases,
         block,
         break: b
@@ -18998,7 +19141,7 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
     let $$eventData = $$entered?.data, $$final = MaybeNestedExpression$0($$ctx, $$state) || MaybeNestedExpression$1($$ctx, $$state);
     return $$ctx.exit?.("MaybeNestedExpression", $$state, $$final, $$eventData), $$final;
   }
-  var MaybeParenNestedExpression$0$parser = (0, import_lib2.$Y)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement, NoBlock)), MaybeParenNestedExpression$1$parser = (0, import_lib2.$S)((0, import_lib2.$N)(EOS), Expression), MaybeParenNestedExpression$2$parser = (0, import_lib2.$S)((0, import_lib2.$Y)(EOS), (0, import_lib2.$C)(ArrayLiteral, ObjectLiteral)), 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);
+  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)))), MaybeParenNestedExpression$1$parser = (0, import_lib2.$S)((0, import_lib2.$N)(EOS), Expression), MaybeParenNestedExpression$2$parser = (0, import_lib2.$S)((0, import_lib2.$Y)(EOS), (0, import_lib2.$C)(ArrayLiteral, ObjectLiteral)), 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);
   function MaybeParenNestedExpression$0($$ctx, $$state) {
     let $$r = MaybeParenNestedExpression$0$parser($$ctx, $$state);
     if (!$$r)
@@ -26683,6 +26826,21 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
     })(), $$final = $$m !== import_lib2.SKIP ? ($$r.value = $$m, $$r) : void 0;
     return $$ctx.exit?.("ESArrowFunctionEnabled", $$state, $$final, $$eventData), $$final;
   }
+  var ESBraceBlockEnabled$parser = (0, import_lib2.$EXPECT)($L0, 'ESBraceBlockEnabled ""');
+  function ESBraceBlockEnabled($$ctx, $$state) {
+    let $$entered = $$ctx.enter?.("ESBraceBlockEnabled", $$state);
+    if ($$entered && "cache" in $$entered) return $$entered.cache;
+    let $$eventData = $$entered?.data, $$r = ESBraceBlockEnabled$parser($$ctx, $$state);
+    if (!$$r) {
+      $$ctx.exit?.("ESBraceBlockEnabled", $$state, void 0, $$eventData);
+      return;
+    }
+    let $$m = (function() {
+      if (!config.esBraceBlock)
+        return $skip;
+    })(), $$final = $$m !== import_lib2.SKIP ? ($$r.value = $$m, $$r) : void 0;
+    return $$ctx.exit?.("ESBraceBlockEnabled", $$state, $$final, $$eventData), $$final;
+  }
   var JSXCodeNestedEnabled$parser = (0, import_lib2.$EXPECT)($L0, 'JSXCodeNestedEnabled ""');
   function JSXCodeNestedEnabled($$ctx, $$state) {
     let $$entered = $$ctx.enter?.("JSXCodeNestedEnabled", $$state);
@@ -26930,11 +27088,17 @@ const `, convertNamedImportsToObject(runtimeNamed, !0, "destructuring"), " = ",
     })($$value, $$value), $$final = $$m !== import_lib2.SKIP ? ($$r.value = $$m, $$r) : void 0;
     return $$ctx.exit?.("TrackIndented", $$state, $$final, $$eventData), $$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)), 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) {
     let $$entered = $$ctx.enter?.("PushIndent", $$state);
     if ($$entered && "cache" in $$entered) return $$entered.cache;
-    let $$eventData = $$entered?.data, $$final = PushIndent$parser($$ctx, $$state);
+    let $$eventData = $$entered?.data, $$final = PushIndent$0($$ctx, $$state) || PushIndent$1($$ctx, $$state);
     return $$ctx.exit?.("PushIndent", $$state, $$final, $$eventData), $$final;
   }
   var PopIndent$parser = (0, import_lib2.$EXPECT)($L0, 'PopIndent ""');