@openrewrite/rewrite 8.72.2 → 8.72.3

package/dist/javascript/format/format.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prettierFormat = exports.BlankLinesVisitor = exports.WrappingAndBracesVisitor = exports.SpacesVisitor = exports.AutoformatVisitor = exports.autoFormat = exports.maybeAutoFormat = exports.MinimumViableSpacingVisitor = exports.NormalizeWhitespaceVisitor = exports.TabsAndIndentsVisitor = void 0;
 /*
@@ -42,14 +33,14 @@ var normalize_whitespace_visitor_2 = require("./normalize-whitespace-visitor");
 Object.defineProperty(exports, "NormalizeWhitespaceVisitor", { enumerable: true, get: function () { return normalize_whitespace_visitor_2.NormalizeWhitespaceVisitor; } });
 var minimum_viable_spacing_visitor_2 = require("./minimum-viable-spacing-visitor");
 Object.defineProperty(exports, "MinimumViableSpacingVisitor", { enumerable: true, get: function () { return minimum_viable_spacing_visitor_2.MinimumViableSpacingVisitor; } });
-const maybeAutoFormat = (before, after, p, stopAfter, parent) => __awaiter(void 0, void 0, void 0, function* () {
+const maybeAutoFormat = async (before, after, p, stopAfter, parent) => {
     if (before !== after) {
         return (0, exports.autoFormat)(after, p, stopAfter, parent);
     }
     return after;
-});
+};
 exports.maybeAutoFormat = maybeAutoFormat;
-const autoFormat = (j, p, stopAfter, parent, styles) => __awaiter(void 0, void 0, void 0, function* () { return yield new AutoformatVisitor(stopAfter, styles).visit(j, p, parent); });
+const autoFormat = async (j, p, stopAfter, parent, styles) => await new AutoformatVisitor(stopAfter, styles).visit(j, p, parent);
 exports.autoFormat = autoFormat;
 /**
  * Formats JavaScript/TypeScript code using a comprehensive set of formatting rules.
@@ -68,31 +59,29 @@ class AutoformatVisitor extends visitor_1.JavaScriptVisitor {
         this.stopAfter = stopAfter;
         this.styles = styles;
     }
-    visit(tree, p, cursor) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Check for PrettierStyle in styles array or as marker on source file
-            // If found, delegate entirely to Prettier (skip other formatting visitors)
-            const prettierStyle = (0, prettier_format_1.getPrettierStyle)(tree, cursor, this.styles);
-            if (prettierStyle) {
-                return (0, prettier_format_1.applyPrettierFormatting)(tree, prettierStyle, p, cursor, this.stopAfter);
-            }
-            const visitors = [
-                new normalize_whitespace_visitor_1.NormalizeWhitespaceVisitor(this.stopAfter),
-                new minimum_viable_spacing_visitor_1.MinimumViableSpacingVisitor(this.stopAfter),
-                new BlankLinesVisitor((0, style_1.getStyle)(style_1.StyleKind.BlankLinesStyle, tree, this.styles), this.stopAfter),
-                new WrappingAndBracesVisitor((0, style_1.getStyle)(style_1.StyleKind.WrappingAndBracesStyle, tree, this.styles), this.stopAfter),
-                new SpacesVisitor((0, style_1.getStyle)(style_1.StyleKind.SpacesStyle, tree, this.styles), this.stopAfter),
-                new tabs_and_indents_visitor_1.TabsAndIndentsVisitor((0, style_1.getStyle)(style_1.StyleKind.TabsAndIndentsStyle, tree, this.styles), this.stopAfter),
-            ];
-            let t = tree;
-            for (const visitor of visitors) {
-                t = yield visitor.visit(t, p, cursor);
-                if (t === undefined) {
-                    return undefined;
-                }
+    async visit(tree, p, cursor) {
+        // Check for PrettierStyle in styles array or as marker on source file
+        // If found, delegate entirely to Prettier (skip other formatting visitors)
+        const prettierStyle = (0, prettier_format_1.getPrettierStyle)(tree, cursor, this.styles);
+        if (prettierStyle) {
+            return (0, prettier_format_1.applyPrettierFormatting)(tree, prettierStyle, p, cursor, this.stopAfter);
+        }
+        const visitors = [
+            new normalize_whitespace_visitor_1.NormalizeWhitespaceVisitor(this.stopAfter),
+            new minimum_viable_spacing_visitor_1.MinimumViableSpacingVisitor(this.stopAfter),
+            new BlankLinesVisitor((0, style_1.getStyle)(style_1.StyleKind.BlankLinesStyle, tree, this.styles), this.stopAfter),
+            new WrappingAndBracesVisitor((0, style_1.getStyle)(style_1.StyleKind.WrappingAndBracesStyle, tree, this.styles), this.stopAfter),
+            new SpacesVisitor((0, style_1.getStyle)(style_1.StyleKind.SpacesStyle, tree, this.styles), this.stopAfter),
+            new tabs_and_indents_visitor_1.TabsAndIndentsVisitor((0, style_1.getStyle)(style_1.StyleKind.TabsAndIndentsStyle, tree, this.styles), this.stopAfter),
+        ];
+        let t = tree;
+        for (const visitor of visitors) {
+            t = await visitor.visit(t, p, cursor);
+            if (t === undefined) {
+                return undefined;
             }
-            return t;
-        });
+        }
+        return t;
     }
 }
 exports.AutoformatVisitor = AutoformatVisitor;
@@ -102,479 +91,440 @@ class SpacesVisitor extends visitor_1.JavaScriptVisitor {
         this.style = style;
         this.stopAfter = stopAfter;
     }
-    visit(tree, p, parent) {
-        const _super = Object.create(null, {
-            visit: { get: () => super.visit }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (((_a = this.cursor) === null || _a === void 0 ? void 0 : _a.getNearestMessage("stop")) != null) {
-                return tree;
-            }
-            return _super.visit.call(this, tree, p, parent);
-        });
+    async visit(tree, p, parent) {
+        var _a;
+        if (((_a = this.cursor) === null || _a === void 0 ? void 0 : _a.getNearestMessage("stop")) != null) {
+            return tree;
+        }
+        return super.visit(tree, p, parent);
     }
-    postVisit(tree, p) {
-        const _super = Object.create(null, {
-            postVisit: { get: () => super.postVisit }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (this.stopAfter != null && (0, tree_2.isScope)(this.stopAfter, tree)) {
-                (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.root.messages.set("stop", true);
-            }
-            return _super.postVisit.call(this, tree, p);
-        });
+    async postVisit(tree, p) {
+        var _a;
+        if (this.stopAfter != null && (0, tree_2.isScope)(this.stopAfter, tree)) {
+            (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.root.messages.set("stop", true);
+        }
+        return super.postVisit(tree, p);
     }
-    visitAlias(alias, p) {
-        const _super = Object.create(null, {
-            visitAlias: { get: () => super.visitAlias }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitAlias.call(this, alias, p);
-            return (0, mutative_1.create)(ret, draft => {
-                draft.propertyName.after.whitespace = " ";
-            });
+    async visitAlias(alias, p) {
+        const ret = await super.visitAlias(alias, p);
+        return (0, mutative_1.create)(ret, draft => {
+            draft.propertyName.after.whitespace = " ";
         });
     }
-    visitArrayAccess(arrayAccess, p) {
-        const _super = Object.create(null, {
-            visitArrayAccess: { get: () => super.visitArrayAccess }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitArrayAccess.call(this, arrayAccess, p);
-            return (0, mutative_1.create)(ret, draft => {
-                // Preserve newlines - only modify if no newlines present
-                if (!draft.dimension.index.element.prefix.whitespace.includes("\n")) {
-                    draft.dimension.index.element.prefix.whitespace = this.style.within.arrayBrackets ? " " : "";
-                }
-                if (!draft.dimension.index.after.whitespace.includes("\n")) {
-                    draft.dimension.index.after.whitespace = this.style.within.arrayBrackets ? " " : "";
-                }
-            });
+    async visitArrayAccess(arrayAccess, p) {
+        const ret = await super.visitArrayAccess(arrayAccess, p);
+        return (0, mutative_1.create)(ret, draft => {
+            // Preserve newlines - only modify if no newlines present
+            if (!draft.dimension.index.element.prefix.whitespace.includes("\n")) {
+                draft.dimension.index.element.prefix.whitespace = this.style.within.arrayBrackets ? " " : "";
+            }
+            if (!draft.dimension.index.after.whitespace.includes("\n")) {
+                draft.dimension.index.after.whitespace = this.style.within.arrayBrackets ? " " : "";
+            }
         });
     }
-    visitAssignment(assignment, p) {
-        const _super = Object.create(null, {
-            visitAssignment: { get: () => super.visitAssignment }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitAssignment.call(this, assignment, p);
-            return (0, mutative_1.create)(ret, draft => {
-                // Preserve newlines - only modify if no newlines present
-                if (!draft.assignment.before.whitespace.includes("\n")) {
-                    draft.assignment.before.whitespace = this.style.aroundOperators.assignment ? " " : "";
-                }
-                if (!draft.assignment.element.prefix.whitespace.includes("\n")) {
-                    draft.assignment.element.prefix.whitespace = this.style.aroundOperators.assignment ? " " : "";
-                }
-            });
+    async visitAssignment(assignment, p) {
+        const ret = await super.visitAssignment(assignment, p);
+        return (0, mutative_1.create)(ret, draft => {
+            // Preserve newlines - only modify if no newlines present
+            if (!draft.assignment.before.whitespace.includes("\n")) {
+                draft.assignment.before.whitespace = this.style.aroundOperators.assignment ? " " : "";
+            }
+            if (!draft.assignment.element.prefix.whitespace.includes("\n")) {
+                draft.assignment.element.prefix.whitespace = this.style.aroundOperators.assignment ? " " : "";
+            }
         });
     }
-    visitBinary(binary, p) {
-        const _super = Object.create(null, {
-            visitBinary: { get: () => super.visitBinary }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitBinary.call(this, binary, p);
-            let property = false;
-            switch (ret.operator.element.valueOf()) {
-                case java_1.J.Binary.Type.And:
-                case java_1.J.Binary.Type.Or:
-                    property = this.style.aroundOperators.logical;
-                    break;
-                case java_1.J.Binary.Type.Equal:
-                case java_1.J.Binary.Type.NotEqual:
-                    property = this.style.aroundOperators.equality;
-                    break;
-                case java_1.J.Binary.Type.LessThan:
-                case java_1.J.Binary.Type.LessThanOrEqual:
-                case java_1.J.Binary.Type.GreaterThan:
-                case java_1.J.Binary.Type.GreaterThanOrEqual:
-                    property = this.style.aroundOperators.relational;
-                    break;
-                case java_1.J.Binary.Type.BitAnd:
-                case java_1.J.Binary.Type.BitOr:
-                case java_1.J.Binary.Type.BitXor:
-                    property = this.style.aroundOperators.bitwise;
-                    break;
-                case java_1.J.Binary.Type.Addition:
-                case java_1.J.Binary.Type.Subtraction:
-                    property = this.style.aroundOperators.additive;
-                    break;
-                case java_1.J.Binary.Type.Multiplication:
-                case java_1.J.Binary.Type.Division:
-                case java_1.J.Binary.Type.Modulo:
-                    property = this.style.aroundOperators.multiplicative;
-                    break;
-                case java_1.J.Binary.Type.LeftShift:
-                case java_1.J.Binary.Type.RightShift:
-                case java_1.J.Binary.Type.UnsignedRightShift:
-                    property = this.style.aroundOperators.shift;
-                    break;
-                default:
-                    throw new Error("Unsupported operator type " + ret.operator.element.valueOf());
+    async visitBinary(binary, p) {
+        const ret = await super.visitBinary(binary, p);
+        let property = false;
+        switch (ret.operator.element.valueOf()) {
+            case java_1.J.Binary.Type.And:
+            case java_1.J.Binary.Type.Or:
+                property = this.style.aroundOperators.logical;
+                break;
+            case java_1.J.Binary.Type.Equal:
+            case java_1.J.Binary.Type.NotEqual:
+                property = this.style.aroundOperators.equality;
+                break;
+            case java_1.J.Binary.Type.LessThan:
+            case java_1.J.Binary.Type.LessThanOrEqual:
+            case java_1.J.Binary.Type.GreaterThan:
+            case java_1.J.Binary.Type.GreaterThanOrEqual:
+                property = this.style.aroundOperators.relational;
+                break;
+            case java_1.J.Binary.Type.BitAnd:
+            case java_1.J.Binary.Type.BitOr:
+            case java_1.J.Binary.Type.BitXor:
+                property = this.style.aroundOperators.bitwise;
+                break;
+            case java_1.J.Binary.Type.Addition:
+            case java_1.J.Binary.Type.Subtraction:
+                property = this.style.aroundOperators.additive;
+                break;
+            case java_1.J.Binary.Type.Multiplication:
+            case java_1.J.Binary.Type.Division:
+            case java_1.J.Binary.Type.Modulo:
+                property = this.style.aroundOperators.multiplicative;
+                break;
+            case java_1.J.Binary.Type.LeftShift:
+            case java_1.J.Binary.Type.RightShift:
+            case java_1.J.Binary.Type.UnsignedRightShift:
+                property = this.style.aroundOperators.shift;
+                break;
+            default:
+                throw new Error("Unsupported operator type " + ret.operator.element.valueOf());
+        }
+        return (0, mutative_1.create)(ret, draft => {
+            // Preserve newlines - only modify if no newlines present
+            if (!draft.operator.before.whitespace.includes("\n")) {
+                draft.operator.before.whitespace = property ? " " : "";
+            }
+            if (!draft.right.prefix.whitespace.includes("\n")) {
+                draft.right.prefix.whitespace = property ? " " : "";
             }
-            return (0, mutative_1.create)(ret, draft => {
-                // Preserve newlines - only modify if no newlines present
-                if (!draft.operator.before.whitespace.includes("\n")) {
-                    draft.operator.before.whitespace = property ? " " : "";
-                }
-                if (!draft.right.prefix.whitespace.includes("\n")) {
-                    draft.right.prefix.whitespace = property ? " " : "";
-                }
-            });
         });
     }
-    visitCase(aCase, p) {
-        const _super = Object.create(null, {
-            visitCase: { get: () => super.visitCase }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitCase.call(this, aCase, p);
-            return ret && (0, mutative_1.create)(ret, draft => {
-                if (draft.caseLabels.elements[0].element.kind != java_1.J.Kind.Identifier || draft.caseLabels.elements[0].element.simpleName != "default") {
-                    // Preserve newlines - only set to space if no newline exists
-                    if (!draft.caseLabels.before.whitespace.includes("\n")) {
-                        draft.caseLabels.before.whitespace = " ";
-                    }
+    async visitCase(aCase, p) {
+        const ret = await super.visitCase(aCase, p);
+        return ret && (0, mutative_1.create)(ret, draft => {
+            if (draft.caseLabels.elements[0].element.kind != java_1.J.Kind.Identifier || draft.caseLabels.elements[0].element.simpleName != "default") {
+                // Preserve newlines - only set to space if no newline exists
+                if (!draft.caseLabels.before.whitespace.includes("\n")) {
+                    draft.caseLabels.before.whitespace = " ";
                 }
-            });
-        });
-    }
-    visitClassDeclaration(classDecl, p) {
-        const _super = Object.create(null, {
-            visitClassDeclaration: { get: () => super.visitClassDeclaration }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitClassDeclaration.call(this, classDecl, p);
-            // TODO typeParameters - IntelliJ doesn't seem to provide a setting for angleBrackets spacing for Typescript (while it does for Java),
-            // thus we either introduce our own setting or just enforce the natural spacing with no setting
-            return (0, mutative_1.create)(ret, draft => {
-                draft.body.prefix.whitespace = this.style.beforeLeftBrace.classInterfaceModuleLeftBrace ? " " : "";
-            });
+            }
         });
     }
-    visitContainer(container, p) {
-        const _super = Object.create(null, {
-            visitContainer: { get: () => super.visitContainer }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitContainer.call(this, container, p);
-            return (0, mutative_1.create)(ret, draft => {
-                if (draft.elements.length > 0) {
-                    // Apply beforeComma rule to all elements except the last
-                    // (last element's after is before closing bracket, not a comma)
-                    for (let i = 0; i < draft.elements.length - 1; i++) {
-                        const afterWs = draft.elements[i].after.whitespace;
-                        // Preserve newlines - only adjust when on same line
-                        if (!afterWs.includes("\n")) {
-                            draft.elements[i].after.whitespace = this.style.other.beforeComma ? " " : "";
-                        }
+    async visitClassDeclaration(classDecl, p) {
+        const ret = await super.visitClassDeclaration(classDecl, p);
+        // TODO typeParameters - IntelliJ doesn't seem to provide a setting for angleBrackets spacing for Typescript (while it does for Java),
+        // thus we either introduce our own setting or just enforce the natural spacing with no setting
+        return (0, mutative_1.create)(ret, draft => {
+            draft.body.prefix.whitespace = this.style.beforeLeftBrace.classInterfaceModuleLeftBrace ? " " : "";
+        });
+    }
+    async visitContainer(container, p) {
+        const ret = await super.visitContainer(container, p);
+        return (0, mutative_1.create)(ret, draft => {
+            if (draft.elements.length > 0) {
+                // Apply beforeComma rule to all elements except the last
+                // (last element's after is before closing bracket, not a comma)
+                for (let i = 0; i < draft.elements.length - 1; i++) {
+                    const afterWs = draft.elements[i].after.whitespace;
+                    // Preserve newlines - only adjust when on same line
+                    if (!afterWs.includes("\n")) {
+                        draft.elements[i].after.whitespace = this.style.other.beforeComma ? " " : "";
                     }
                 }
-                if (draft.elements.length > 1) {
-                    // Apply afterComma rule to elements after the first
-                    for (let i = 1; i < draft.elements.length; i++) {
-                        const currentWs = draft.elements[i].element.prefix.whitespace;
-                        // Preserve original newlines - only adjust spacing when elements are on same line
-                        if (!currentWs.includes("\n")) {
-                            draft.elements[i].element.prefix.whitespace = this.style.other.afterComma ? " " : "";
-                        }
+            }
+            if (draft.elements.length > 1) {
+                // Apply afterComma rule to elements after the first
+                for (let i = 1; i < draft.elements.length; i++) {
+                    const currentWs = draft.elements[i].element.prefix.whitespace;
+                    // Preserve original newlines - only adjust spacing when elements are on same line
+                    if (!currentWs.includes("\n")) {
+                        draft.elements[i].element.prefix.whitespace = this.style.other.afterComma ? " " : "";
                     }
                 }
-            });
+            }
         });
     }
-    visitExportDeclaration(exportDeclaration, p) {
-        const _super = Object.create(null, {
-            visitExportDeclaration: { get: () => super.visitExportDeclaration }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitExportDeclaration.call(this, exportDeclaration, p);
-            return (0, mutative_1.create)(ret, draft => {
-                if (draft.exportClause) {
-                    draft.exportClause.prefix.whitespace = " ";
-                    if (draft.exportClause.kind == tree_1.JS.Kind.NamedExports) {
-                        const ne = draft.exportClause;
-                        if (ne.elements.elements.length > 0) {
-                            // Check if this is a multi-line export (any element's prefix has a newline)
-                            const isMultiLine = ne.elements.elements.some(e => e.element.prefix.whitespace.includes("\n"));
-                            if (!isMultiLine) {
-                                // Single-line: adjust brace spacing
-                                ne.elements.elements[0].element.prefix.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
-                                ne.elements.elements[ne.elements.elements.length - 1].after.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
-                            }
-                            else {
-                                // Multi-line: apply beforeComma rule to last element's after (for trailing commas)
-                                // If it has only spaces (no newline), it's the space before a trailing comma
-                                const lastAfter = ne.elements.elements[ne.elements.elements.length - 1].after.whitespace;
-                                if (!lastAfter.includes("\n") && lastAfter.trim() === "") {
-                                    ne.elements.elements[ne.elements.elements.length - 1].after.whitespace = this.style.other.beforeComma ? " " : "";
-                                }
+    async visitExportDeclaration(exportDeclaration, p) {
+        const ret = await super.visitExportDeclaration(exportDeclaration, p);
+        return (0, mutative_1.create)(ret, draft => {
+            if (draft.exportClause) {
+                draft.exportClause.prefix.whitespace = " ";
+                if (draft.exportClause.kind == tree_1.JS.Kind.NamedExports) {
+                    const ne = draft.exportClause;
+                    if (ne.elements.elements.length > 0) {
+                        // Check if this is a multi-line export (any element's prefix has a newline)
+                        const isMultiLine = ne.elements.elements.some(e => e.element.prefix.whitespace.includes("\n"));
+                        if (!isMultiLine) {
+                            // Single-line: adjust brace spacing
+                            ne.elements.elements[0].element.prefix.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
+                            ne.elements.elements[ne.elements.elements.length - 1].after.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
+                        }
+                        else {
+                            // Multi-line: apply beforeComma rule to last element's after (for trailing commas)
+                            // If it has only spaces (no newline), it's the space before a trailing comma
+                            const lastAfter = ne.elements.elements[ne.elements.elements.length - 1].after.whitespace;
+                            if (!lastAfter.includes("\n") && lastAfter.trim() === "") {
+                                ne.elements.elements[ne.elements.elements.length - 1].after.whitespace = this.style.other.beforeComma ? " " : "";
                             }
                         }
                     }
                 }
-                draft.typeOnly.before.whitespace = draft.typeOnly.element ? " " : "";
-                if (draft.moduleSpecifier) {
-                    draft.moduleSpecifier.before.whitespace = " ";
-                    draft.moduleSpecifier.element.prefix.whitespace = " ";
-                }
-            });
+            }
+            draft.typeOnly.before.whitespace = draft.typeOnly.element ? " " : "";
+            if (draft.moduleSpecifier) {
+                draft.moduleSpecifier.before.whitespace = " ";
+                draft.moduleSpecifier.element.prefix.whitespace = " ";
+            }
         });
     }
-    visitForLoop(forLoop, p) {
-        const _super = Object.create(null, {
-            visitForLoop: { get: () => super.visitForLoop }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitForLoop.call(this, forLoop, p);
-            return (0, visitor_2.produceAsync)(ret, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.control.prefix.whitespace = this.style.beforeParentheses.forParentheses ? " " : "";
-                draft.control.init = yield Promise.all(draft.control.init.map((oneInit, index) => __awaiter(this, void 0, void 0, function* () {
-                    if (oneInit.element.kind === java_1.J.Kind.VariableDeclarations) {
-                        const vd = oneInit.element;
-                        if (vd.modifiers && vd.modifiers.length > 0) {
-                            vd.modifiers[0].prefix.whitespace = "";
-                        }
+    async visitForLoop(forLoop, p) {
+        const ret = await super.visitForLoop(forLoop, p);
+        return (0, visitor_2.produceAsync)(ret, async (draft) => {
+            draft.control.prefix.whitespace = this.style.beforeParentheses.forParentheses ? " " : "";
+            draft.control.init = await Promise.all(draft.control.init.map(async (oneInit, index) => {
+                if (oneInit.element.kind === java_1.J.Kind.VariableDeclarations) {
+                    const vd = oneInit.element;
+                    if (vd.modifiers && vd.modifiers.length > 0) {
+                        vd.modifiers[0].prefix.whitespace = "";
                     }
-                    oneInit.after.whitespace = "";
-                    this.spaceBeforeRightPaddedElementDraft(oneInit, index === 0 ? this.style.within.forParentheses : true);
-                    return oneInit;
-                })));
-                if (draft.control.condition) {
-                    draft.control.condition.element.prefix.whitespace = " ";
-                    draft.control.condition.after.whitespace = this.style.other.beforeForSemicolon ? " " : "";
                 }
-                draft.control.update.forEach((oneUpdate, index) => {
-                    oneUpdate.element.prefix.whitespace = " ";
-                    oneUpdate.after.whitespace = (index === draft.control.update.length - 1 ? this.style.within.forParentheses : this.style.other.beforeForSemicolon) ? " " : "";
-                });
-                this.spaceBeforeRightPaddedElementDraft(draft.body, this.style.beforeLeftBrace.forLeftBrace);
-                this.spaceAfterRightPaddedDraft(draft.body, false);
+                oneInit.after.whitespace = "";
+                this.spaceBeforeRightPaddedElementDraft(oneInit, index === 0 ? this.style.within.forParentheses : true);
+                return oneInit;
             }));
-        });
-    }
-    visitIf(iff, p) {
-        const _super = Object.create(null, {
-            visitIf: { get: () => super.visitIf }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitIf.call(this, iff, p);
-            return (0, visitor_2.produceAsync)(ret, (draft) => __awaiter(this, void 0, void 0, function* () {
-                this.spaceBeforeDraft(draft.ifCondition, this.style.beforeParentheses.ifParentheses);
-                this.spaceBeforeRightPaddedElementDraft(draft.ifCondition.tree, this.style.within.ifParentheses);
-                this.spaceAfterRightPaddedDraft(draft.ifCondition.tree, this.style.within.ifParentheses);
-                this.spaceBeforeRightPaddedElementDraft(draft.thenPart, this.style.beforeLeftBrace.ifLeftBrace);
-                this.spaceAfterRightPaddedDraft(draft.thenPart, false);
-            }));
-        });
-    }
-    visitImportDeclaration(jsImport, p) {
-        const _super = Object.create(null, {
-            visitImportDeclaration: { get: () => super.visitImportDeclaration }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitImportDeclaration.call(this, jsImport, p);
-            return (0, mutative_1.create)(ret, draft => {
-                if (draft.importClause) {
-                    // Space after 'import' keyword:
-                    // - If there's a default import (name), space goes in importClause.prefix
-                    // - If typeOnly (import type ...), space goes in importClause.prefix (before 'type')
-                    // - If only namedBindings (no default, no type), space goes in namedBindings.prefix (importClause.prefix is empty)
-                    const hasDefaultImport = !!draft.importClause.name;
-                    draft.importClause.prefix.whitespace = (hasDefaultImport || draft.importClause.typeOnly) ? " " : "";
-                    if (draft.importClause.name) {
-                        // For import equals declarations (import X = Y), use assignment spacing
-                        // For regular imports (import X from 'Y'), no space after name
-                        draft.importClause.name.after.whitespace = draft.initializer
-                            ? (this.style.aroundOperators.assignment ? " " : "")
-                            : "";
-                    }
-                    if (draft.importClause.namedBindings) {
-                        // Space before namedBindings - always needed
-                        draft.importClause.namedBindings.prefix.whitespace = " ";
-                        if (draft.importClause.namedBindings.kind == tree_1.JS.Kind.NamedImports) {
-                            const ni = draft.importClause.namedBindings;
-                            // Check if this is a multi-line import (any element's prefix has a newline)
-                            const isMultiLine = ni.elements.elements.some(e => e.element.prefix.whitespace.includes("\n"));
-                            if (!isMultiLine) {
-                                // Single-line: adjust brace spacing
-                                ni.elements.elements[0].element.prefix.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
-                                ni.elements.elements[ni.elements.elements.length - 1].after.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
-                            }
-                            else {
-                                // Multi-line: apply beforeComma rule to last element's after (for trailing commas)
-                                // If it has only spaces (no newline), it's the space before a trailing comma
-                                const lastAfter = ni.elements.elements[ni.elements.elements.length - 1].after.whitespace;
-                                if (!lastAfter.includes("\n") && lastAfter.trim() === "") {
-                                    ni.elements.elements[ni.elements.elements.length - 1].after.whitespace = this.style.other.beforeComma ? " " : "";
-                                }
+            if (draft.control.condition) {
+                draft.control.condition.element.prefix.whitespace = " ";
+                draft.control.condition.after.whitespace = this.style.other.beforeForSemicolon ? " " : "";
+            }
+            draft.control.update.forEach((oneUpdate, index) => {
+                oneUpdate.element.prefix.whitespace = " ";
+                oneUpdate.after.whitespace = (index === draft.control.update.length - 1 ? this.style.within.forParentheses : this.style.other.beforeForSemicolon) ? " " : "";
+            });
+            this.spaceBeforeRightPaddedElementDraft(draft.body, this.style.beforeLeftBrace.forLeftBrace);
+            this.spaceAfterRightPaddedDraft(draft.body, false);
+        });
+    }
+    async visitIf(iff, p) {
+        const ret = await super.visitIf(iff, p);
+        return (0, visitor_2.produceAsync)(ret, async (draft) => {
+            this.spaceBeforeDraft(draft.ifCondition, this.style.beforeParentheses.ifParentheses);
+            this.spaceBeforeRightPaddedElementDraft(draft.ifCondition.tree, this.style.within.ifParentheses);
+            this.spaceAfterRightPaddedDraft(draft.ifCondition.tree, this.style.within.ifParentheses);
+            this.spaceBeforeRightPaddedElementDraft(draft.thenPart, this.style.beforeLeftBrace.ifLeftBrace);
+            this.spaceAfterRightPaddedDraft(draft.thenPart, false);
+        });
+    }
+    async visitImportDeclaration(jsImport, p) {
+        const ret = await super.visitImportDeclaration(jsImport, p);
+        return (0, mutative_1.create)(ret, draft => {
+            if (draft.importClause) {
+                // Space after 'import' keyword:
+                // - If there's a default import (name), space goes in importClause.prefix
+                // - If typeOnly (import type ...), space goes in importClause.prefix (before 'type')
+                // - If only namedBindings (no default, no type), space goes in namedBindings.prefix (importClause.prefix is empty)
+                const hasDefaultImport = !!draft.importClause.name;
+                draft.importClause.prefix.whitespace = (hasDefaultImport || draft.importClause.typeOnly) ? " " : "";
+                if (draft.importClause.name) {
+                    // For import equals declarations (import X = Y), use assignment spacing
+                    // For regular imports (import X from 'Y'), no space after name
+                    draft.importClause.name.after.whitespace = draft.initializer
+                        ? (this.style.aroundOperators.assignment ? " " : "")
+                        : "";
+                }
+                if (draft.importClause.namedBindings) {
+                    // Space before namedBindings - always needed
+                    draft.importClause.namedBindings.prefix.whitespace = " ";
+                    if (draft.importClause.namedBindings.kind == tree_1.JS.Kind.NamedImports) {
+                        const ni = draft.importClause.namedBindings;
+                        // Check if this is a multi-line import (any element's prefix has a newline)
+                        const isMultiLine = ni.elements.elements.some(e => e.element.prefix.whitespace.includes("\n"));
+                        if (!isMultiLine) {
+                            // Single-line: adjust brace spacing
+                            ni.elements.elements[0].element.prefix.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
+                            ni.elements.elements[ni.elements.elements.length - 1].after.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
+                        }
+                        else {
+                            // Multi-line: apply beforeComma rule to last element's after (for trailing commas)
+                            // If it has only spaces (no newline), it's the space before a trailing comma
+                            const lastAfter = ni.elements.elements[ni.elements.elements.length - 1].after.whitespace;
+                            if (!lastAfter.includes("\n") && lastAfter.trim() === "") {
+                                ni.elements.elements[ni.elements.elements.length - 1].after.whitespace = this.style.other.beforeComma ? " " : "";
                             }
                         }
                     }
                 }
-                if (draft.moduleSpecifier) {
-                    draft.moduleSpecifier.before.whitespace = " ";
-                    draft.moduleSpecifier.element.prefix.whitespace = draft.importClause ? " " : "";
-                }
-            });
-        });
-    }
-    visitIndexSignatureDeclaration(indexSignatureDeclaration, p) {
-        const _super = Object.create(null, {
-            visitIndexSignatureDeclaration: { get: () => super.visitIndexSignatureDeclaration }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitIndexSignatureDeclaration.call(this, indexSignatureDeclaration, p);
-            return (0, mutative_1.create)(ret, draft => {
-                draft.typeExpression.before.whitespace = this.style.other.beforeTypeReferenceColon ? " " : "";
-                draft.typeExpression.element.prefix.whitespace = this.style.other.afterTypeReferenceColon ? " " : "";
-            });
+            }
+            if (draft.moduleSpecifier) {
+                draft.moduleSpecifier.before.whitespace = " ";
+                draft.moduleSpecifier.element.prefix.whitespace = draft.importClause ? " " : "";
+            }
         });
     }
-    visitMethodDeclaration(methodDecl, p) {
-        const _super = Object.create(null, {
-            visitMethodDeclaration: { get: () => super.visitMethodDeclaration }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitMethodDeclaration.call(this, methodDecl, p);
-            return (0, visitor_2.produceAsync)(ret, (draft) => __awaiter(this, void 0, void 0, function* () {
-                if (draft.body) {
-                    this.spaceBeforeDraft(draft.body, this.style.beforeLeftBrace.functionLeftBrace);
-                }
-                if (draft.parameters.elements.length > 0 && draft.parameters.elements[0].element.kind != java_1.J.Kind.Empty) {
-                    draft.parameters.elements.forEach((param, index) => {
-                        this.spaceAfterRightPaddedDraft(param, index === draft.parameters.elements.length - 1 ? this.style.within.functionDeclarationParentheses : this.style.other.beforeComma);
-                        this.spaceBeforeDraft(param.element, index === 0 ? this.style.within.functionDeclarationParentheses : this.style.other.afterComma);
-                        param.element.variables[0].element.name.prefix.whitespace = "";
-                        param.element.variables[0].after.whitespace = "";
-                    });
-                }
-                else if (draft.parameters.elements.length == 1) {
-                    this.spaceBeforeRightPaddedElementDraft(draft.parameters.elements[0], this.style.within.functionDeclarationParentheses);
-                    this.spaceAfterRightPaddedDraft(draft.parameters.elements[0], false);
-                }
-                this.spaceBeforeContainerDraft(draft.parameters, this.style.beforeParentheses.functionDeclarationParentheses);
-                // Handle generator asterisk spacing
-                // - space before * is in the Generator marker's prefix
-                // - space after * is in the method name's prefix
-                const generatorIndex = ret.markers.markers.findIndex(m => m.kind === tree_1.JS.Markers.Generator);
-                if (generatorIndex >= 0) {
-                    const generator = draft.markers.markers[generatorIndex];
-                    generator.prefix.whitespace = this.style.other.beforeAsteriskInGenerator ? " " : "";
-                    draft.name.prefix.whitespace = this.style.other.afterAsteriskInGenerator ? " " : "";
-                }
-                // TODO typeParameters handling - see visitClassDeclaration
-            }));
+    async visitIndexSignatureDeclaration(indexSignatureDeclaration, p) {
+        const ret = await super.visitIndexSignatureDeclaration(indexSignatureDeclaration, p);
+        return (0, mutative_1.create)(ret, draft => {
+            draft.typeExpression.before.whitespace = this.style.other.beforeTypeReferenceColon ? " " : "";
+            draft.typeExpression.element.prefix.whitespace = this.style.other.afterTypeReferenceColon ? " " : "";
         });
     }
-    visitMethodInvocation(methodInv, p) {
-        const _super = Object.create(null, {
-            visitMethodInvocation: { get: () => super.visitMethodInvocation }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitMethodInvocation.call(this, methodInv, p);
-            return (0, visitor_2.produceAsync)(ret, (draft) => __awaiter(this, void 0, void 0, function* () {
-                if (draft.select) {
-                    this.spaceBeforeContainerDraft(draft.arguments, this.style.beforeParentheses.functionCallParentheses);
-                }
-                if (ret.arguments.elements.length > 0 && ret.arguments.elements[0].element.kind != java_1.J.Kind.Empty) {
-                    draft.arguments.elements.forEach((arg, index) => {
-                        this.spaceAfterRightPaddedDraft(arg, index === draft.arguments.elements.length - 1 ? this.style.within.functionCallParentheses : this.style.other.beforeComma);
-                        this.spaceBeforeDraft(arg.element, index === 0 ? this.style.within.functionCallParentheses : this.style.other.afterComma);
-                    });
-                }
-                else if (ret.arguments.elements.length == 1) {
-                    this.spaceBeforeRightPaddedElementDraft(draft.arguments.elements[0], this.style.within.functionCallParentheses);
-                    this.spaceAfterRightPaddedDraft(draft.arguments.elements[0], false);
-                }
-                // TODO typeParameters handling - see visitClassDeclaration
-            }));
+    async visitMethodDeclaration(methodDecl, p) {
+        const ret = await super.visitMethodDeclaration(methodDecl, p);
+        return (0, visitor_2.produceAsync)(ret, async (draft) => {
+            if (draft.body) {
+                this.spaceBeforeDraft(draft.body, this.style.beforeLeftBrace.functionLeftBrace);
+            }
+            if (draft.parameters.elements.length > 0 && draft.parameters.elements[0].element.kind != java_1.J.Kind.Empty) {
+                draft.parameters.elements.forEach((param, index) => {
+                    this.spaceAfterRightPaddedDraft(param, index === draft.parameters.elements.length - 1 ? this.style.within.functionDeclarationParentheses : this.style.other.beforeComma);
+                    this.spaceBeforeDraft(param.element, index === 0 ? this.style.within.functionDeclarationParentheses : this.style.other.afterComma);
+                    param.element.variables[0].element.name.prefix.whitespace = "";
+                    param.element.variables[0].after.whitespace = "";
+                });
+            }
+            else if (draft.parameters.elements.length == 1) {
+                this.spaceBeforeRightPaddedElementDraft(draft.parameters.elements[0], this.style.within.functionDeclarationParentheses);
+                this.spaceAfterRightPaddedDraft(draft.parameters.elements[0], false);
+            }
+            this.spaceBeforeContainerDraft(draft.parameters, this.style.beforeParentheses.functionDeclarationParentheses);
+            // Handle generator asterisk spacing
+            // - space before * is in the Generator marker's prefix
+            // - space after * is in the method name's prefix
+            const generatorIndex = ret.markers.markers.findIndex(m => m.kind === tree_1.JS.Markers.Generator);
+            if (generatorIndex >= 0) {
+                const generator = draft.markers.markers[generatorIndex];
+                generator.prefix.whitespace = this.style.other.beforeAsteriskInGenerator ? " " : "";
+                draft.name.prefix.whitespace = this.style.other.afterAsteriskInGenerator ? " " : "";
+            }
+            // TODO typeParameters handling - see visitClassDeclaration
         });
     }
-    visitPropertyAssignment(propertyAssignment, p) {
-        const _super = Object.create(null, {
-            visitPropertyAssignment: { get: () => super.visitPropertyAssignment }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const pa = yield _super.visitPropertyAssignment.call(this, propertyAssignment, p);
-            // Only adjust the space before the colon/equals if there's an initializer (not a shorthand property)
-            if (pa.initializer) {
-                return (0, visitor_2.produceAsync)(pa, draft => {
-                    draft.name.after.whitespace = this.style.other.beforePropertyNameValueSeparator ? " " : "";
+    async visitMethodInvocation(methodInv, p) {
+        const ret = await super.visitMethodInvocation(methodInv, p);
+        return (0, visitor_2.produceAsync)(ret, async (draft) => {
+            if (draft.select) {
+                this.spaceBeforeContainerDraft(draft.arguments, this.style.beforeParentheses.functionCallParentheses);
+            }
+            if (ret.arguments.elements.length > 0 && ret.arguments.elements[0].element.kind != java_1.J.Kind.Empty) {
+                draft.arguments.elements.forEach((arg, index) => {
+                    this.spaceAfterRightPaddedDraft(arg, index === draft.arguments.elements.length - 1 ? this.style.within.functionCallParentheses : this.style.other.beforeComma);
+                    this.spaceBeforeDraft(arg.element, index === 0 ? this.style.within.functionCallParentheses : this.style.other.afterComma);
                 });
             }
-            return pa;
+            else if (ret.arguments.elements.length == 1) {
+                this.spaceBeforeRightPaddedElementDraft(draft.arguments.elements[0], this.style.within.functionCallParentheses);
+                this.spaceAfterRightPaddedDraft(draft.arguments.elements[0], false);
+            }
+            // TODO typeParameters handling - see visitClassDeclaration
         });
     }
-    visitSwitch(switchNode, p) {
-        const _super = Object.create(null, {
-            visitSwitch: { get: () => super.visitSwitch }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitSwitch.call(this, switchNode, p);
-            return (0, visitor_2.produceAsync)(ret, (draft) => __awaiter(this, void 0, void 0, function* () {
-                this.spaceBeforeDraft(draft.selector, this.style.beforeParentheses.switchParentheses);
-                this.spaceBeforeRightPaddedElementDraft(draft.selector.tree, this.style.within.switchParentheses);
-                this.spaceAfterRightPaddedDraft(draft.selector.tree, this.style.within.switchParentheses);
-                this.spaceBeforeDraft(draft.cases, this.style.beforeLeftBrace.switchLeftBrace);
-                for (const case_ of draft.cases.statements) {
-                    if (case_.element.kind === java_1.J.Kind.Case) {
-                        case_.element.caseLabels.elements[0].after.whitespace = "";
-                    }
+    async visitPropertyAssignment(propertyAssignment, p) {
+        const pa = await super.visitPropertyAssignment(propertyAssignment, p);
+        // Only adjust the space before the colon/equals if there's an initializer (not a shorthand property)
+        if (pa.initializer) {
+            return (0, visitor_2.produceAsync)(pa, draft => {
+                draft.name.after.whitespace = this.style.other.beforePropertyNameValueSeparator ? " " : "";
+            });
+        }
+        return pa;
+    }
+    async visitSwitch(switchNode, p) {
+        const ret = await super.visitSwitch(switchNode, p);
+        return (0, visitor_2.produceAsync)(ret, async (draft) => {
+            this.spaceBeforeDraft(draft.selector, this.style.beforeParentheses.switchParentheses);
+            this.spaceBeforeRightPaddedElementDraft(draft.selector.tree, this.style.within.switchParentheses);
+            this.spaceAfterRightPaddedDraft(draft.selector.tree, this.style.within.switchParentheses);
+            this.spaceBeforeDraft(draft.cases, this.style.beforeLeftBrace.switchLeftBrace);
+            for (const case_ of draft.cases.statements) {
+                if (case_.element.kind === java_1.J.Kind.Case) {
+                    case_.element.caseLabels.elements[0].after.whitespace = "";
                 }
-            }));
+            }
         });
     }
-    visitTernary(ternary, p) {
-        const _super = Object.create(null, {
-            visitTernary: { get: () => super.visitTernary }
+    async visitTernary(ternary, p) {
+        const ret = await super.visitTernary(ternary, p);
+        return (0, visitor_2.produceAsync)(ret, async (draft) => {
+            this.spaceBeforeLeftPaddedElementDraft(draft.truePart, this.style.ternaryOperator.beforeQuestionMark, this.style.ternaryOperator.afterQuestionMark);
+            this.spaceBeforeLeftPaddedElementDraft(draft.falsePart, this.style.ternaryOperator.beforeColon, this.style.ternaryOperator.afterColon);
+        });
+    }
+    async visitTry(try_, p) {
+        const ret = await super.visitTry(try_, p);
+        return (0, visitor_2.produceAsync)(ret, async (draft) => {
+            draft.body.prefix.whitespace = this.style.beforeLeftBrace.tryLeftBrace ? " " : "";
+            draft.catches.forEach(catch_ => {
+                this.spaceBeforeDraft(catch_, this.style.beforeKeywords.catchKeyword);
+                catch_.parameter.prefix.whitespace = this.style.beforeParentheses.catchParentheses ? " " : "";
+                this.spaceBeforeRightPaddedElementDraft(catch_.parameter.tree, this.style.within.catchParentheses);
+                this.spaceAfterRightPaddedDraft(catch_.parameter.tree, this.style.within.catchParentheses);
+                if (catch_.parameter.tree.element.variables.length > 0) {
+                    catch_.parameter.tree.element.variables[catch_.parameter.tree.element.variables.length - 1].after.whitespace = "";
+                }
+                catch_.body.prefix.whitespace = this.style.beforeLeftBrace.catchLeftBrace ? " " : "";
+            });
+            if (draft.finally) {
+                this.spaceBeforeLeftPaddedElementDraft(draft.finally, this.style.beforeKeywords.finallyKeyword, this.style.beforeLeftBrace.finallyLeftBrace);
+            }
         });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitTernary.call(this, ternary, p);
-            return (0, visitor_2.produceAsync)(ret, (draft) => __awaiter(this, void 0, void 0, function* () {
-                this.spaceBeforeLeftPaddedElementDraft(draft.truePart, this.style.ternaryOperator.beforeQuestionMark, this.style.ternaryOperator.afterQuestionMark);
-                this.spaceBeforeLeftPaddedElementDraft(draft.falsePart, this.style.ternaryOperator.beforeColon, this.style.ternaryOperator.afterColon);
-            }));
+    }
+    async visitTypeDeclaration(typeDeclaration, p) {
+        const ret = await super.visitTypeDeclaration(typeDeclaration, p);
+        return (0, mutative_1.create)(ret, draft => {
+            if (draft.modifiers.length > 0) {
+                draft.name.before.whitespace = " ";
+            }
+            draft.name.element.prefix.whitespace = " ";
+            // Preserve newlines - only modify if no newlines present
+            if (!draft.initializer.before.whitespace.includes("\n")) {
+                draft.initializer.before.whitespace = this.style.aroundOperators.assignment ? " " : "";
+            }
+            if (!draft.initializer.element.prefix.whitespace.includes("\n")) {
+                draft.initializer.element.prefix.whitespace = this.style.aroundOperators.assignment ? " " : "";
+            }
         });
     }
-    visitTry(try_, p) {
-        const _super = Object.create(null, {
-            visitTry: { get: () => super.visitTry }
+    async visitTypeInfo(typeInfo, p) {
+        const ret = await super.visitTypeInfo(typeInfo, p);
+        return (0, visitor_2.produceAsync)(ret, async (draft) => {
+            draft.prefix.whitespace = this.style.other.beforeTypeReferenceColon ? " " : "";
+            this.spaceBeforeDraft(draft.typeIdentifier, this.style.other.afterTypeReferenceColon);
         });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitTry.call(this, try_, p);
-            return (0, visitor_2.produceAsync)(ret, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.body.prefix.whitespace = this.style.beforeLeftBrace.tryLeftBrace ? " " : "";
-                draft.catches.forEach(catch_ => {
-                    this.spaceBeforeDraft(catch_, this.style.beforeKeywords.catchKeyword);
-                    catch_.parameter.prefix.whitespace = this.style.beforeParentheses.catchParentheses ? " " : "";
-                    this.spaceBeforeRightPaddedElementDraft(catch_.parameter.tree, this.style.within.catchParentheses);
-                    this.spaceAfterRightPaddedDraft(catch_.parameter.tree, this.style.within.catchParentheses);
-                    if (catch_.parameter.tree.element.variables.length > 0) {
-                        catch_.parameter.tree.element.variables[catch_.parameter.tree.element.variables.length - 1].after.whitespace = "";
-                    }
-                    catch_.body.prefix.whitespace = this.style.beforeLeftBrace.catchLeftBrace ? " " : "";
+    }
+    async visitTypeLiteral(typeLiteral, p) {
+        const ret = await super.visitTypeLiteral(typeLiteral, p);
+        // Apply objectLiteralTypeBraces spacing for single-line type literals
+        if (ret.members && ret.members.statements.length > 0) {
+            const stmts = ret.members.statements;
+            const isSingleLine = !ret.members.end.whitespace.includes("\n") &&
+                stmts.every(s => !s.element.prefix.whitespace.includes("\n"));
+            if (isSingleLine) {
+                return (0, mutative_1.create)(ret, draft => {
+                    const space = this.style.within.objectLiteralTypeBraces ? " " : "";
+                    draft.members.statements[0].element.prefix.whitespace = space;
+                    // For type literals, the space before } is in members.end, not in last statement's after
+                    draft.members.end.whitespace = space;
                 });
-                if (draft.finally) {
-                    this.spaceBeforeLeftPaddedElementDraft(draft.finally, this.style.beforeKeywords.finallyKeyword, this.style.beforeLeftBrace.finallyLeftBrace);
-                }
-            }));
+            }
+        }
+        return ret;
+    }
+    async visitUnary(unary, p) {
+        const ret = await super.visitUnary(unary, p);
+        return (0, mutative_1.create)(ret, draft => {
+            const spacing = this.style.aroundOperators.unary;
+            switch (draft.operator.element) {
+                case java_1.J.Unary.Type.Not:
+                    draft.expression.prefix.whitespace = this.style.aroundOperators.afterUnaryNotAndNotNull ? " " : "";
+                    break;
+                case java_1.J.Unary.Type.PreIncrement:
+                case java_1.J.Unary.Type.PreDecrement:
+                case java_1.J.Unary.Type.Negative:
+                case java_1.J.Unary.Type.Positive:
+                case java_1.J.Unary.Type.Complement:
+                    draft.expression.prefix.whitespace = spacing ? " " : "";
+                    break;
+                case java_1.J.Unary.Type.PostIncrement:
+                case java_1.J.Unary.Type.PostDecrement:
+                    // postfix: don't add space after operand
+                    break;
+            }
         });
     }
-    visitTypeDeclaration(typeDeclaration, p) {
-        const _super = Object.create(null, {
-            visitTypeDeclaration: { get: () => super.visitTypeDeclaration }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitTypeDeclaration.call(this, typeDeclaration, p);
-            return (0, mutative_1.create)(ret, draft => {
-                if (draft.modifiers.length > 0) {
-                    draft.name.before.whitespace = " ";
-                }
-                draft.name.element.prefix.whitespace = " ";
+    async visitVariable(variable, p) {
+        var _a, _b;
+        const ret = await super.visitVariable(variable, p);
+        if (((_b = (_a = variable.initializer) === null || _a === void 0 ? void 0 : _a.element) === null || _b === void 0 ? void 0 : _b.kind) == tree_1.JS.Kind.StatementExpression
+            && variable.initializer.element.statement.kind == java_1.J.Kind.MethodDeclaration) {
+            return ret;
+        }
+        return (0, visitor_2.produceAsync)(ret, async (draft) => {
+            if (draft.initializer) {
                 // Preserve newlines - only modify if no newlines present
                 if (!draft.initializer.before.whitespace.includes("\n")) {
                     draft.initializer.before.whitespace = this.style.aroundOperators.assignment ? " " : "";
@@ -582,136 +532,40 @@ class SpacesVisitor extends visitor_1.JavaScriptVisitor {
                 if (!draft.initializer.element.prefix.whitespace.includes("\n")) {
                     draft.initializer.element.prefix.whitespace = this.style.aroundOperators.assignment ? " " : "";
                 }
-            });
-        });
-    }
-    visitTypeInfo(typeInfo, p) {
-        const _super = Object.create(null, {
-            visitTypeInfo: { get: () => super.visitTypeInfo }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitTypeInfo.call(this, typeInfo, p);
-            return (0, visitor_2.produceAsync)(ret, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.prefix.whitespace = this.style.other.beforeTypeReferenceColon ? " " : "";
-                this.spaceBeforeDraft(draft.typeIdentifier, this.style.other.afterTypeReferenceColon);
-            }));
-        });
-    }
-    visitTypeLiteral(typeLiteral, p) {
-        const _super = Object.create(null, {
-            visitTypeLiteral: { get: () => super.visitTypeLiteral }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitTypeLiteral.call(this, typeLiteral, p);
-            // Apply objectLiteralTypeBraces spacing for single-line type literals
-            if (ret.members && ret.members.statements.length > 0) {
-                const stmts = ret.members.statements;
-                const isSingleLine = !ret.members.end.whitespace.includes("\n") &&
-                    stmts.every(s => !s.element.prefix.whitespace.includes("\n"));
-                if (isSingleLine) {
-                    return (0, mutative_1.create)(ret, draft => {
-                        const space = this.style.within.objectLiteralTypeBraces ? " " : "";
-                        draft.members.statements[0].element.prefix.whitespace = space;
-                        // For type literals, the space before } is in members.end, not in last statement's after
-                        draft.members.end.whitespace = space;
-                    });
-                }
             }
-            return ret;
         });
     }
-    visitUnary(unary, p) {
-        const _super = Object.create(null, {
-            visitUnary: { get: () => super.visitUnary }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitUnary.call(this, unary, p);
-            return (0, mutative_1.create)(ret, draft => {
-                const spacing = this.style.aroundOperators.unary;
-                switch (draft.operator.element) {
-                    case java_1.J.Unary.Type.Not:
-                        draft.expression.prefix.whitespace = this.style.aroundOperators.afterUnaryNotAndNotNull ? " " : "";
-                        break;
-                    case java_1.J.Unary.Type.PreIncrement:
-                    case java_1.J.Unary.Type.PreDecrement:
-                    case java_1.J.Unary.Type.Negative:
-                    case java_1.J.Unary.Type.Positive:
-                    case java_1.J.Unary.Type.Complement:
-                        draft.expression.prefix.whitespace = spacing ? " " : "";
-                        break;
-                    case java_1.J.Unary.Type.PostIncrement:
-                    case java_1.J.Unary.Type.PostDecrement:
-                        // postfix: don't add space after operand
-                        break;
-                }
-            });
-        });
-    }
-    visitVariable(variable, p) {
-        const _super = Object.create(null, {
-            visitVariable: { get: () => super.visitVariable }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const ret = yield _super.visitVariable.call(this, variable, p);
-            if (((_b = (_a = variable.initializer) === null || _a === void 0 ? void 0 : _a.element) === null || _b === void 0 ? void 0 : _b.kind) == tree_1.JS.Kind.StatementExpression
-                && variable.initializer.element.statement.kind == java_1.J.Kind.MethodDeclaration) {
-                return ret;
-            }
-            return (0, visitor_2.produceAsync)(ret, (draft) => __awaiter(this, void 0, void 0, function* () {
-                if (draft.initializer) {
-                    // Preserve newlines - only modify if no newlines present
-                    if (!draft.initializer.before.whitespace.includes("\n")) {
-                        draft.initializer.before.whitespace = this.style.aroundOperators.assignment ? " " : "";
-                    }
-                    if (!draft.initializer.element.prefix.whitespace.includes("\n")) {
-                        draft.initializer.element.prefix.whitespace = this.style.aroundOperators.assignment ? " " : "";
+    async visitWhileLoop(whileLoop, p) {
+        const ret = await super.visitWhileLoop(whileLoop, p);
+        return (0, visitor_2.produceAsync)(ret, async (draft) => {
+            this.spaceBeforeRightPaddedElementDraft(draft.body, this.style.beforeLeftBrace.whileLeftBrace);
+            this.spaceAfterRightPaddedDraft(draft.body, false);
+            this.spaceBeforeDraft(draft.condition, this.style.beforeParentheses.whileParentheses);
+            this.spaceBeforeRightPaddedElementDraft(draft.condition.tree, this.style.within.whileParentheses);
+            this.spaceAfterRightPaddedDraft(draft.condition.tree, this.style.within.whileParentheses);
+        });
+    }
+    async visitTypeParameter(typeParam, p) {
+        const ret = await super.visitTypeParameter(typeParam, p);
+        return (0, mutative_1.create)(ret, draft => {
+            if (draft.bounds && draft.bounds.elements.length >= 2) {
+                const constraintType = draft.bounds.elements[0];
+                const defaultType = draft.bounds.elements[1];
+                const hasConstraint = constraintType.element.kind !== java_1.J.Kind.Empty;
+                const hasDefault = defaultType.element.kind !== java_1.J.Kind.Empty;
+                if (hasConstraint) {
+                    // Space before '=' for default type (in the `after` of constraint type)
+                    if (hasDefault && !constraintType.after.whitespace.includes("\n")) {
+                        constraintType.after.whitespace = this.style.aroundOperators.assignment ? " " : "";
                     }
                 }
-            }));
-        });
-    }
-    visitWhileLoop(whileLoop, p) {
-        const _super = Object.create(null, {
-            visitWhileLoop: { get: () => super.visitWhileLoop }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitWhileLoop.call(this, whileLoop, p);
-            return (0, visitor_2.produceAsync)(ret, (draft) => __awaiter(this, void 0, void 0, function* () {
-                this.spaceBeforeRightPaddedElementDraft(draft.body, this.style.beforeLeftBrace.whileLeftBrace);
-                this.spaceAfterRightPaddedDraft(draft.body, false);
-                this.spaceBeforeDraft(draft.condition, this.style.beforeParentheses.whileParentheses);
-                this.spaceBeforeRightPaddedElementDraft(draft.condition.tree, this.style.within.whileParentheses);
-                this.spaceAfterRightPaddedDraft(draft.condition.tree, this.style.within.whileParentheses);
-            }));
-        });
-    }
-    visitTypeParameter(typeParam, p) {
-        const _super = Object.create(null, {
-            visitTypeParameter: { get: () => super.visitTypeParameter }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitTypeParameter.call(this, typeParam, p);
-            return (0, mutative_1.create)(ret, draft => {
-                if (draft.bounds && draft.bounds.elements.length >= 2) {
-                    const constraintType = draft.bounds.elements[0];
-                    const defaultType = draft.bounds.elements[1];
-                    const hasConstraint = constraintType.element.kind !== java_1.J.Kind.Empty;
-                    const hasDefault = defaultType.element.kind !== java_1.J.Kind.Empty;
-                    if (hasConstraint) {
-                        // Space before '=' for default type (in the `after` of constraint type)
-                        if (hasDefault && !constraintType.after.whitespace.includes("\n")) {
-                            constraintType.after.whitespace = this.style.aroundOperators.assignment ? " " : "";
-                        }
-                    }
-                    else if (hasDefault) {
-                        // No constraint, just default: space before '=' is in bounds.before
-                        if (!draft.bounds.before.whitespace.includes("\n")) {
-                            draft.bounds.before.whitespace = this.style.aroundOperators.assignment ? " " : "";
-                        }
+                else if (hasDefault) {
+                    // No constraint, just default: space before '=' is in bounds.before
+                    if (!draft.bounds.before.whitespace.includes("\n")) {
+                        draft.bounds.before.whitespace = this.style.aroundOperators.assignment ? " " : "";
                     }
                 }
-            });
+            }
         });
     }
     /**
@@ -804,33 +658,28 @@ class SpacesVisitor extends visitor_1.JavaScriptVisitor {
     static isNotSingleSpace(str) {
         return this.isOnlySpaces(str) && str !== " ";
     }
-    visitNewClass(newClass, p) {
-        const _super = Object.create(null, {
-            visitNewClass: { get: () => super.visitNewClass }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = yield _super.visitNewClass.call(this, newClass, p);
-            // Only handle object literals (NewClass with no class/constructor)
-            if (ret.class) {
-                return ret;
-            }
-            // Handle object literal brace spacing: { foo: 1 } vs {foo: 1}
-            if (ret.body && ret.body.statements.length > 0) {
-                return (0, mutative_1.create)(ret, draft => {
-                    const stmts = draft.body.statements;
-                    // Check if this is a multi-line object literal
-                    const isMultiLine = stmts.some(s => s.element.prefix.whitespace.includes("\n")) ||
-                        draft.body.end.whitespace.includes("\n");
-                    if (!isMultiLine) {
-                        // Single-line: apply objectLiteralBraces spacing
-                        const space = this.style.within.objectLiteralBraces ? " " : "";
-                        stmts[0].element.prefix.whitespace = space;
-                        draft.body.end.whitespace = space;
-                    }
-                });
-            }
+    async visitNewClass(newClass, p) {
+        const ret = await super.visitNewClass(newClass, p);
+        // Only handle object literals (NewClass with no class/constructor)
+        if (ret.class) {
             return ret;
-        });
+        }
+        // Handle object literal brace spacing: { foo: 1 } vs {foo: 1}
+        if (ret.body && ret.body.statements.length > 0) {
+            return (0, mutative_1.create)(ret, draft => {
+                const stmts = draft.body.statements;
+                // Check if this is a multi-line object literal
+                const isMultiLine = stmts.some(s => s.element.prefix.whitespace.includes("\n")) ||
+                    draft.body.end.whitespace.includes("\n");
+                if (!isMultiLine) {
+                    // Single-line: apply objectLiteralBraces spacing
+                    const space = this.style.within.objectLiteralBraces ? " " : "";
+                    stmts[0].element.prefix.whitespace = space;
+                    draft.body.end.whitespace = space;
+                }
+            });
+        }
+        return ret;
     }
 }
 exports.SpacesVisitor = SpacesVisitor;
@@ -840,190 +689,150 @@ class WrappingAndBracesVisitor extends visitor_1.JavaScriptVisitor {
         this.style = style;
         this.stopAfter = stopAfter;
     }
-    visit(tree, p, parent) {
-        const _super = Object.create(null, {
-            visit: { get: () => super.visit }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (((_a = this.cursor) === null || _a === void 0 ? void 0 : _a.getNearestMessage("stop")) != null) {
-                return tree;
-            }
-            return _super.visit.call(this, tree, p, parent);
-        });
-    }
-    postVisit(tree, p) {
-        const _super = Object.create(null, {
-            postVisit: { get: () => super.postVisit }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (this.stopAfter != null && (0, tree_2.isScope)(this.stopAfter, tree)) {
-                (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.root.messages.set("stop", true);
-            }
-            return _super.postVisit.call(this, tree, p);
-        });
+    async visit(tree, p, parent) {
+        var _a;
+        if (((_a = this.cursor) === null || _a === void 0 ? void 0 : _a.getNearestMessage("stop")) != null) {
+            return tree;
+        }
+        return super.visit(tree, p, parent);
     }
-    visitVariableDeclarations(multiVariable, p) {
-        const _super = Object.create(null, {
-            visitVariableDeclarations: { get: () => super.visitVariableDeclarations }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const v = yield _super.visitVariableDeclarations.call(this, multiVariable, p);
-            const parent = (_a = this.cursor.parentTree()) === null || _a === void 0 ? void 0 : _a.value;
-            if ((parent === null || parent === void 0 ? void 0 : parent.kind) === java_1.J.Kind.Block) {
-                return (0, mutative_1.create)(v, draft => {
-                    draft.leadingAnnotations = this.withNewlines(draft.leadingAnnotations);
-                    if (draft.leadingAnnotations.length > 0) {
-                        if (draft.modifiers.length > 0) {
-                            draft.modifiers = this.withNewlineModifiers(draft.modifiers);
-                        }
-                        else if (draft.typeExpression && !draft.typeExpression.prefix.whitespace.includes("\n")) {
-                            draft.typeExpression.prefix.whitespace = "\n" + draft.typeExpression.prefix.whitespace;
-                        }
-                    }
-                });
-            }
-            return v;
-        });
+    async postVisit(tree, p) {
+        var _a;
+        if (this.stopAfter != null && (0, tree_2.isScope)(this.stopAfter, tree)) {
+            (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.root.messages.set("stop", true);
+        }
+        return super.postVisit(tree, p);
     }
-    visitMethodDeclaration(method, p) {
-        const _super = Object.create(null, {
-            visitMethodDeclaration: { get: () => super.visitMethodDeclaration }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const m = yield _super.visitMethodDeclaration.call(this, method, p);
-            return (0, mutative_1.create)(m, draft => {
+    async visitVariableDeclarations(multiVariable, p) {
+        var _a;
+        const v = await super.visitVariableDeclarations(multiVariable, p);
+        const parent = (_a = this.cursor.parentTree()) === null || _a === void 0 ? void 0 : _a.value;
+        if ((parent === null || parent === void 0 ? void 0 : parent.kind) === java_1.J.Kind.Block) {
+            return (0, mutative_1.create)(v, draft => {
                 draft.leadingAnnotations = this.withNewlines(draft.leadingAnnotations);
                 if (draft.leadingAnnotations.length > 0) {
                     if (draft.modifiers.length > 0) {
                         draft.modifiers = this.withNewlineModifiers(draft.modifiers);
                     }
-                    else if (draft.typeParameters && !draft.typeParameters.prefix.whitespace.includes("\n")) {
-                        draft.typeParameters.prefix.whitespace = "\n" + draft.typeParameters.prefix.whitespace;
-                    }
-                    else if (draft.returnTypeExpression && !draft.returnTypeExpression.prefix.whitespace.includes("\n")) {
-                        draft.returnTypeExpression.prefix.whitespace = "\n" + draft.returnTypeExpression.prefix.whitespace;
-                    }
-                    else if (!draft.name.prefix.whitespace.includes("\n")) {
-                        draft.name.prefix.whitespace = "\n" + draft.name.prefix.whitespace;
+                    else if (draft.typeExpression && !draft.typeExpression.prefix.whitespace.includes("\n")) {
+                        draft.typeExpression.prefix.whitespace = "\n" + draft.typeExpression.prefix.whitespace;
                     }
                 }
             });
-        });
+        }
+        return v;
     }
-    visitElse(elsePart, p) {
-        const _super = Object.create(null, {
-            visitElse: { get: () => super.visitElse }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const e = yield _super.visitElse.call(this, elsePart, p);
-            const hasBody = e.body.element.kind === java_1.J.Kind.Block || e.body.element.kind === java_1.J.Kind.If;
-            return (0, mutative_1.create)(e, draft => {
-                if (hasBody) {
-                    const shouldHaveNewline = this.style.ifStatement.elseOnNewLine;
-                    const hasNewline = draft.prefix.whitespace.includes("\n");
-                    if (shouldHaveNewline && !hasNewline) {
-                        draft.prefix.whitespace = "\n" + draft.prefix.whitespace;
-                    }
-                    else if (!shouldHaveNewline && hasNewline) {
-                        draft.prefix.whitespace = "";
-                    }
+    async visitMethodDeclaration(method, p) {
+        const m = await super.visitMethodDeclaration(method, p);
+        return (0, mutative_1.create)(m, draft => {
+            draft.leadingAnnotations = this.withNewlines(draft.leadingAnnotations);
+            if (draft.leadingAnnotations.length > 0) {
+                if (draft.modifiers.length > 0) {
+                    draft.modifiers = this.withNewlineModifiers(draft.modifiers);
                 }
-            });
+                else if (draft.typeParameters && !draft.typeParameters.prefix.whitespace.includes("\n")) {
+                    draft.typeParameters.prefix.whitespace = "\n" + draft.typeParameters.prefix.whitespace;
+                }
+                else if (draft.returnTypeExpression && !draft.returnTypeExpression.prefix.whitespace.includes("\n")) {
+                    draft.returnTypeExpression.prefix.whitespace = "\n" + draft.returnTypeExpression.prefix.whitespace;
+                }
+                else if (!draft.name.prefix.whitespace.includes("\n")) {
+                    draft.name.prefix.whitespace = "\n" + draft.name.prefix.whitespace;
+                }
+            }
         });
     }
-    visitClassDeclaration(classDecl, p) {
-        const _super = Object.create(null, {
-            visitClassDeclaration: { get: () => super.visitClassDeclaration }
+    async visitElse(elsePart, p) {
+        const e = await super.visitElse(elsePart, p);
+        const hasBody = e.body.element.kind === java_1.J.Kind.Block || e.body.element.kind === java_1.J.Kind.If;
+        return (0, mutative_1.create)(e, draft => {
+            if (hasBody) {
+                const shouldHaveNewline = this.style.ifStatement.elseOnNewLine;
+                const hasNewline = draft.prefix.whitespace.includes("\n");
+                if (shouldHaveNewline && !hasNewline) {
+                    draft.prefix.whitespace = "\n" + draft.prefix.whitespace;
+                }
+                else if (!shouldHaveNewline && hasNewline) {
+                    draft.prefix.whitespace = "";
+                }
+            }
         });
-        return __awaiter(this, void 0, void 0, function* () {
-            const j = yield _super.visitClassDeclaration.call(this, classDecl, p);
-            return (0, mutative_1.create)(j, draft => {
-                draft.leadingAnnotations = this.withNewlines(draft.leadingAnnotations);
-                if (draft.leadingAnnotations.length > 0) {
-                    if (draft.modifiers.length > 0) {
-                        draft.modifiers = this.withNewlineModifiers(draft.modifiers);
-                    }
-                    else {
-                        const kind = draft.classKind;
-                        if (!kind.prefix.whitespace.includes("\n")) {
-                            kind.prefix.whitespace = "\n" + kind.prefix.whitespace;
-                        }
+    }
+    async visitClassDeclaration(classDecl, p) {
+        const j = await super.visitClassDeclaration(classDecl, p);
+        return (0, mutative_1.create)(j, draft => {
+            draft.leadingAnnotations = this.withNewlines(draft.leadingAnnotations);
+            if (draft.leadingAnnotations.length > 0) {
+                if (draft.modifiers.length > 0) {
+                    draft.modifiers = this.withNewlineModifiers(draft.modifiers);
+                }
+                else {
+                    const kind = draft.classKind;
+                    if (!kind.prefix.whitespace.includes("\n")) {
+                        kind.prefix.whitespace = "\n" + kind.prefix.whitespace;
                     }
                 }
-            });
+            }
         });
     }
-    visitBlock(block, p) {
-        const _super = Object.create(null, {
-            visitBlock: { get: () => super.visitBlock }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const b = yield _super.visitBlock.call(this, block, p);
-            return (0, mutative_1.create)(b, draft => {
-                var _a;
-                const parentKind = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.value.kind;
-                // Check if this is a "simple" block (empty or contains only a single J.Empty)
-                const isSimpleBlock = draft.statements.length === 0 ||
-                    (draft.statements.length === 1 && draft.statements[0].element.kind === java_1.J.Kind.Empty);
-                // Helper to format block on one line
-                const formatOnOneLine = () => {
-                    // Format as {} - remove any newlines from end whitespace
-                    if (draft.end.whitespace.includes("\n")) {
-                        draft.end.whitespace = draft.end.whitespace.replace(/\n\s*/g, "");
-                    }
-                    // Also remove newlines from statement padding if there's a J.Empty
-                    if (draft.statements.length === 1) {
-                        if (draft.statements[0].element.prefix.whitespace.includes("\n")) {
-                            draft.statements[0].element.prefix.whitespace = "";
-                        }
-                        if (draft.statements[0].after.whitespace.includes("\n")) {
-                            draft.statements[0].after.whitespace = "";
-                        }
+    async visitBlock(block, p) {
+        const b = await super.visitBlock(block, p);
+        return (0, mutative_1.create)(b, draft => {
+            var _a;
+            const parentKind = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.value.kind;
+            // Check if this is a "simple" block (empty or contains only a single J.Empty)
+            const isSimpleBlock = draft.statements.length === 0 ||
+                (draft.statements.length === 1 && draft.statements[0].element.kind === java_1.J.Kind.Empty);
+            // Helper to format block on one line
+            const formatOnOneLine = () => {
+                // Format as {} - remove any newlines from end whitespace
+                if (draft.end.whitespace.includes("\n")) {
+                    draft.end.whitespace = draft.end.whitespace.replace(/\n\s*/g, "");
+                }
+                // Also remove newlines from statement padding if there's a J.Empty
+                if (draft.statements.length === 1) {
+                    if (draft.statements[0].element.prefix.whitespace.includes("\n")) {
+                        draft.statements[0].element.prefix.whitespace = "";
                     }
-                };
-                // Object literals and type literals: always format empty ones as {} on single line
-                if (parentKind === java_1.J.Kind.NewClass || parentKind === tree_1.JS.Kind.TypeLiteral) {
-                    if (isSimpleBlock) {
-                        formatOnOneLine();
+                    if (draft.statements[0].after.whitespace.includes("\n")) {
+                        draft.statements[0].after.whitespace = "";
                     }
-                    return;
                 }
+            };
+            // Object literals and type literals: always format empty ones as {} on single line
+            if (parentKind === java_1.J.Kind.NewClass || parentKind === tree_1.JS.Kind.TypeLiteral) {
                 if (isSimpleBlock) {
-                    // Determine which style option applies based on parent
-                    const isMethodOrFunctionBody = parentKind === java_1.J.Kind.Lambda ||
-                        parentKind === java_1.J.Kind.MethodDeclaration;
-                    const keepInOneLine = isMethodOrFunctionBody
-                        ? this.style.keepWhenReformatting.simpleMethodsInOneLine
-                        : this.style.keepWhenReformatting.simpleBlocksInOneLine;
-                    if (keepInOneLine) {
-                        formatOnOneLine();
-                    }
-                    else {
-                        // Format with newline between { and }
-                        if (!draft.end.whitespace.includes("\n")) {
-                            draft.end = this.withNewlineSpace(draft.end);
-                        }
-                    }
+                    formatOnOneLine();
+                }
+                return;
+            }
+            if (isSimpleBlock) {
+                // Determine which style option applies based on parent
+                const isMethodOrFunctionBody = parentKind === java_1.J.Kind.Lambda ||
+                    parentKind === java_1.J.Kind.MethodDeclaration;
+                const keepInOneLine = isMethodOrFunctionBody
+                    ? this.style.keepWhenReformatting.simpleMethodsInOneLine
+                    : this.style.keepWhenReformatting.simpleBlocksInOneLine;
+                if (keepInOneLine) {
+                    formatOnOneLine();
                 }
                 else {
-                    // Non-simple blocks: ensure closing brace is on its own line
-                    if (!draft.end.whitespace.includes("\n") && !draft.statements[draft.statements.length - 1].after.whitespace.includes("\n")) {
+                    // Format with newline between { and }
+                    if (!draft.end.whitespace.includes("\n")) {
                         draft.end = this.withNewlineSpace(draft.end);
                     }
                 }
-            });
+            }
+            else {
+                // Non-simple blocks: ensure closing brace is on its own line
+                if (!draft.end.whitespace.includes("\n") && !draft.statements[draft.statements.length - 1].after.whitespace.includes("\n")) {
+                    draft.end = this.withNewlineSpace(draft.end);
+                }
+            }
         });
     }
-    visitSwitch(aSwitch, p) {
-        const _super = Object.create(null, {
-            visitSwitch: { get: () => super.visitSwitch }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            return _super.visitSwitch.call(this, aSwitch, p);
-        });
+    async visitSwitch(aSwitch, p) {
+        return super.visitSwitch(aSwitch, p);
     }
     withNewlines(list) {
         return list.map((a, index) => {
@@ -1070,161 +879,131 @@ class BlankLinesVisitor extends visitor_1.JavaScriptVisitor {
         this.style = style;
         this.stopAfter = stopAfter;
     }
-    preVisit(tree, p) {
-        const _super = Object.create(null, {
-            preVisit: { get: () => super.preVisit }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
+    async preVisit(tree, p) {
+        var _a, _b, _c;
+        let ret = await super.preVisit(tree, p);
+        if (ret.kind === tree_1.JS.Kind.CompilationUnit) {
+            ret = (0, mutative_1.create)(ret, draft => {
+                if (draft.prefix.comments.length == 0) {
+                    draft.prefix.whitespace = "";
+                }
+            });
+        }
+        if (ret.kind === java_1.J.Kind.MethodDeclaration
+            && ((_c = (_b = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.value.kind) === java_1.J.Kind.ClassDeclaration) {
+            ret = (0, mutative_1.create)(ret, draft => {
+                this.ensurePrefixHasNewLine(draft);
+            });
+        }
+        return ret;
+    }
+    async visit(tree, p, cursor) {
+        var _a;
+        if (((_a = this.cursor) === null || _a === void 0 ? void 0 : _a.getNearestMessage("stop")) != null) {
+            return tree;
+        }
+        return super.visit(tree, p, cursor);
+    }
+    async visitClassDeclaration(classDecl, p) {
+        let ret = await super.visitClassDeclaration(classDecl, p);
+        if (!ret.body)
+            return ret;
+        return (0, mutative_1.create)(ret, draft => {
             var _a, _b, _c;
-            let ret = yield _super.preVisit.call(this, tree, p);
-            if (ret.kind === tree_1.JS.Kind.CompilationUnit) {
-                ret = (0, mutative_1.create)(ret, draft => {
-                    if (draft.prefix.comments.length == 0) {
-                        draft.prefix.whitespace = "";
+            const statements = draft.body.statements;
+            if (statements.length > 0) {
+                this.keepMaximumBlankLines(draft.body.statements[0].element, 0);
+                const isInterface = draft.classKind.type === java_1.J.ClassDeclaration.Kind.Type.Interface;
+                for (let i = 1; i < statements.length; i++) {
+                    const previousElement = statements[i - 1].element;
+                    let currentElement = statements[i].element;
+                    if (previousElement.kind == java_1.J.Kind.VariableDeclarations || currentElement.kind == java_1.J.Kind.VariableDeclarations) {
+                        const fieldBlankLines = isInterface
+                            ? (_a = this.style.minimum.aroundFieldInInterface) !== null && _a !== void 0 ? _a : 0
+                            : this.style.minimum.aroundField;
+                        this.minimumBlankLines(currentElement, fieldBlankLines);
                     }
-                });
-            }
-            if (ret.kind === java_1.J.Kind.MethodDeclaration
-                && ((_c = (_b = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.value.kind) === java_1.J.Kind.ClassDeclaration) {
-                ret = (0, mutative_1.create)(ret, draft => {
-                    this.ensurePrefixHasNewLine(draft);
-                });
+                    if (previousElement.kind == java_1.J.Kind.MethodDeclaration || currentElement.kind == java_1.J.Kind.MethodDeclaration) {
+                        const methodBlankLines = isInterface
+                            ? (_b = this.style.minimum.aroundMethodInInterface) !== null && _b !== void 0 ? _b : 0
+                            : this.style.minimum.aroundMethod;
+                        this.minimumBlankLines(currentElement, methodBlankLines);
+                    }
+                    this.keepMaximumBlankLines(currentElement, this.style.keepMaximum.inCode);
+                    draft.body.statements[i].element = currentElement;
+                }
             }
-            return ret;
-        });
-    }
-    visit(tree, p, cursor) {
-        const _super = Object.create(null, {
-            visit: { get: () => super.visit }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (((_a = this.cursor) === null || _a === void 0 ? void 0 : _a.getNearestMessage("stop")) != null) {
-                return tree;
+            const cu = this.cursor.firstEnclosing((x) => x.kind === tree_1.JS.Kind.CompilationUnit);
+            const topLevelIndex = cu === null || cu === void 0 ? void 0 : cu.statements.findIndex(s => s.element.id == draft.id);
+            if (topLevelIndex !== undefined) {
+                const isImportJustBeforeThis = topLevelIndex > 0 && (cu === null || cu === void 0 ? void 0 : cu.statements[topLevelIndex - 1].element.kind) === tree_1.JS.Kind.Import;
+                if (isImportJustBeforeThis) {
+                    this.minimumBlankLines(draft, (_c = this.style.minimum.afterImports) !== null && _c !== void 0 ? _c : 0);
+                }
+                if (topLevelIndex > 0) {
+                    this.minimumBlankLines(draft, this.style.minimum.aroundClass);
+                }
+                this.keepMaximumBlankLines(draft, this.style.keepMaximum.inCode);
             }
-            return _super.visit.call(this, tree, p, cursor);
         });
     }
-    visitClassDeclaration(classDecl, p) {
-        const _super = Object.create(null, {
-            visitClassDeclaration: { get: () => super.visitClassDeclaration }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            let ret = yield _super.visitClassDeclaration.call(this, classDecl, p);
-            if (!ret.body)
-                return ret;
-            return (0, mutative_1.create)(ret, draft => {
-                var _a, _b, _c;
-                const statements = draft.body.statements;
-                if (statements.length > 0) {
-                    this.keepMaximumBlankLines(draft.body.statements[0].element, 0);
-                    const isInterface = draft.classKind.type === java_1.J.ClassDeclaration.Kind.Type.Interface;
-                    for (let i = 1; i < statements.length; i++) {
-                        const previousElement = statements[i - 1].element;
-                        let currentElement = statements[i].element;
-                        if (previousElement.kind == java_1.J.Kind.VariableDeclarations || currentElement.kind == java_1.J.Kind.VariableDeclarations) {
-                            const fieldBlankLines = isInterface
-                                ? (_a = this.style.minimum.aroundFieldInInterface) !== null && _a !== void 0 ? _a : 0
-                                : this.style.minimum.aroundField;
-                            this.minimumBlankLines(currentElement, fieldBlankLines);
-                        }
-                        if (previousElement.kind == java_1.J.Kind.MethodDeclaration || currentElement.kind == java_1.J.Kind.MethodDeclaration) {
-                            const methodBlankLines = isInterface
-                                ? (_b = this.style.minimum.aroundMethodInInterface) !== null && _b !== void 0 ? _b : 0
-                                : this.style.minimum.aroundMethod;
-                            this.minimumBlankLines(currentElement, methodBlankLines);
-                        }
-                        this.keepMaximumBlankLines(currentElement, this.style.keepMaximum.inCode);
-                        draft.body.statements[i].element = currentElement;
+    async visitStatement(statement, p) {
+        var _a, _b, _c;
+        const ret = await super.visitStatement(statement, p);
+        const parent = (_a = this.cursor.parentTree()) === null || _a === void 0 ? void 0 : _a.value;
+        const grandparent = (_c = (_b = this.cursor.parentTree()) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.value;
+        return (0, mutative_1.create)(ret, draft => {
+            var _a, _b;
+            if ((grandparent === null || grandparent === void 0 ? void 0 : grandparent.kind) === java_1.J.Kind.ClassDeclaration && (parent === null || parent === void 0 ? void 0 : parent.kind) === java_1.J.Kind.Block) {
+                const classDecl = grandparent;
+                const block = parent;
+                const isFirst = block.statements.length > 0 && block.statements[0].element.id === draft.id;
+                if (!isFirst) {
+                    if (draft.kind === java_1.J.Kind.VariableDeclarations) {
+                        const declMax = classDecl.classKind.type === java_1.J.ClassDeclaration.Kind.Type.Interface
+                            ? (_a = this.style.minimum.aroundFieldInInterface) !== null && _a !== void 0 ? _a : 0
+                            : this.style.minimum.aroundField;
+                        this.minimumBlankLines(draft, declMax);
                     }
-                }
-                const cu = this.cursor.firstEnclosing((x) => x.kind === tree_1.JS.Kind.CompilationUnit);
-                const topLevelIndex = cu === null || cu === void 0 ? void 0 : cu.statements.findIndex(s => s.element.id == draft.id);
-                if (topLevelIndex !== undefined) {
-                    const isImportJustBeforeThis = topLevelIndex > 0 && (cu === null || cu === void 0 ? void 0 : cu.statements[topLevelIndex - 1].element.kind) === tree_1.JS.Kind.Import;
-                    if (isImportJustBeforeThis) {
-                        this.minimumBlankLines(draft, (_c = this.style.minimum.afterImports) !== null && _c !== void 0 ? _c : 0);
+                    else if (draft.kind === java_1.J.Kind.MethodDeclaration) {
+                        const declMax = classDecl.classKind.type === java_1.J.ClassDeclaration.Kind.Type.Interface
+                            ? (_b = this.style.minimum.aroundMethodInInterface) !== null && _b !== void 0 ? _b : 0
+                            : this.style.minimum.aroundMethod;
+                        this.minimumBlankLines(draft, declMax);
+                    }
+                    else if (draft.kind === java_1.J.Kind.Block) {
+                        this.minimumBlankLines(draft, this.style.minimum.aroundFunction);
                     }
-                    if (topLevelIndex > 0) {
+                    else if (draft.kind === java_1.J.Kind.ClassDeclaration) {
                         this.minimumBlankLines(draft, this.style.minimum.aroundClass);
                     }
                     this.keepMaximumBlankLines(draft, this.style.keepMaximum.inCode);
                 }
-            });
-        });
-    }
-    visitStatement(statement, p) {
-        const _super = Object.create(null, {
-            visitStatement: { get: () => super.visitStatement }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            const ret = yield _super.visitStatement.call(this, statement, p);
-            const parent = (_a = this.cursor.parentTree()) === null || _a === void 0 ? void 0 : _a.value;
-            const grandparent = (_c = (_b = this.cursor.parentTree()) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.value;
-            return (0, mutative_1.create)(ret, draft => {
-                var _a, _b;
-                if ((grandparent === null || grandparent === void 0 ? void 0 : grandparent.kind) === java_1.J.Kind.ClassDeclaration && (parent === null || parent === void 0 ? void 0 : parent.kind) === java_1.J.Kind.Block) {
-                    const classDecl = grandparent;
-                    const block = parent;
-                    const isFirst = block.statements.length > 0 && block.statements[0].element.id === draft.id;
-                    if (!isFirst) {
-                        if (draft.kind === java_1.J.Kind.VariableDeclarations) {
-                            const declMax = classDecl.classKind.type === java_1.J.ClassDeclaration.Kind.Type.Interface
-                                ? (_a = this.style.minimum.aroundFieldInInterface) !== null && _a !== void 0 ? _a : 0
-                                : this.style.minimum.aroundField;
-                            this.minimumBlankLines(draft, declMax);
-                        }
-                        else if (draft.kind === java_1.J.Kind.MethodDeclaration) {
-                            const declMax = classDecl.classKind.type === java_1.J.ClassDeclaration.Kind.Type.Interface
-                                ? (_b = this.style.minimum.aroundMethodInInterface) !== null && _b !== void 0 ? _b : 0
-                                : this.style.minimum.aroundMethod;
-                            this.minimumBlankLines(draft, declMax);
-                        }
-                        else if (draft.kind === java_1.J.Kind.Block) {
-                            this.minimumBlankLines(draft, this.style.minimum.aroundFunction);
-                        }
-                        else if (draft.kind === java_1.J.Kind.ClassDeclaration) {
-                            this.minimumBlankLines(draft, this.style.minimum.aroundClass);
-                        }
-                        this.keepMaximumBlankLines(draft, this.style.keepMaximum.inCode);
-                    }
-                }
-                else if ((parent === null || parent === void 0 ? void 0 : parent.kind) === java_1.J.Kind.Block && (grandparent === null || grandparent === void 0 ? void 0 : grandparent.kind) !== java_1.J.Kind.NewClass && (grandparent === null || grandparent === void 0 ? void 0 : grandparent.kind) !== tree_1.JS.Kind.TypeLiteral ||
-                    ((parent === null || parent === void 0 ? void 0 : parent.kind) === tree_1.JS.Kind.CompilationUnit && parent.statements[0].element.id != draft.id) ||
-                    ((parent === null || parent === void 0 ? void 0 : parent.kind) === java_1.J.Kind.Case && this.isInsideCaseStatements(parent, draft))) {
-                    if (draft.kind != java_1.J.Kind.Case) {
-                        this.ensurePrefixHasNewLine(draft);
-                    }
+            }
+            else if ((parent === null || parent === void 0 ? void 0 : parent.kind) === java_1.J.Kind.Block && (grandparent === null || grandparent === void 0 ? void 0 : grandparent.kind) !== java_1.J.Kind.NewClass && (grandparent === null || grandparent === void 0 ? void 0 : grandparent.kind) !== tree_1.JS.Kind.TypeLiteral ||
+                ((parent === null || parent === void 0 ? void 0 : parent.kind) === tree_1.JS.Kind.CompilationUnit && parent.statements[0].element.id != draft.id) ||
+                ((parent === null || parent === void 0 ? void 0 : parent.kind) === java_1.J.Kind.Case && this.isInsideCaseStatements(parent, draft))) {
+                if (draft.kind != java_1.J.Kind.Case) {
+                    this.ensurePrefixHasNewLine(draft);
                 }
-            });
+            }
         });
     }
-    visitBlock(block, p) {
-        const _super = Object.create(null, {
-            visitBlock: { get: () => super.visitBlock }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const b = yield _super.visitBlock.call(this, block, p);
-            return (0, mutative_1.create)(b, draft => {
-                var _a;
-                const parentKind = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.value.kind;
-                // Skip newline for object literals (NewClass) and type literals (TypeLiteral)
-                if (parentKind != java_1.J.Kind.NewClass && parentKind != tree_1.JS.Kind.TypeLiteral) {
-                    draft.end = (0, java_1.replaceLastWhitespace)(draft.end, ws => ws.includes("\n") ? ws : ws.replace(/[ \t]+$/, '') + "\n");
-                }
-            });
+    async visitBlock(block, p) {
+        const b = await super.visitBlock(block, p);
+        return (0, mutative_1.create)(b, draft => {
+            var _a;
+            const parentKind = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.value.kind;
+            // Skip newline for object literals (NewClass) and type literals (TypeLiteral)
+            if (parentKind != java_1.J.Kind.NewClass && parentKind != tree_1.JS.Kind.TypeLiteral) {
+                draft.end = (0, java_1.replaceLastWhitespace)(draft.end, ws => ws.includes("\n") ? ws : ws.replace(/[ \t]+$/, '') + "\n");
+            }
         });
     }
-    visitEnumValue(enumValue, p) {
-        const _super = Object.create(null, {
-            visitEnumValue: { get: () => super.visitEnumValue }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const e = yield _super.visitEnumValue.call(this, enumValue, p);
-            this.keepMaximumBlankLines(e, this.style.keepMaximum.inCode);
-            return e;
-        });
+    async visitEnumValue(enumValue, p) {
+        const e = await super.visitEnumValue(enumValue, p);
+        this.keepMaximumBlankLines(e, this.style.keepMaximum.inCode);
+        return e;
     }
     /**
      * Check if a statement is inside a Case's statements container or body,
@@ -1281,17 +1060,12 @@ class BlankLinesVisitor extends visitor_1.JavaScriptVisitor {
     static countNewlines(s) {
         return [...s].filter(c => c === "\n").length;
     }
-    postVisit(tree, p) {
-        const _super = Object.create(null, {
-            postVisit: { get: () => super.postVisit }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (this.stopAfter != null && (0, tree_2.isScope)(this.stopAfter, tree)) {
-                (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.root.messages.set("stop", true);
-            }
-            return _super.postVisit.call(this, tree, p);
-        });
+    async postVisit(tree, p) {
+        var _a;
+        if (this.stopAfter != null && (0, tree_2.isScope)(this.stopAfter, tree)) {
+            (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.root.messages.set("stop", true);
+        }
+        return super.postVisit(tree, p);
     }
 }
 exports.BlankLinesVisitor = BlankLinesVisitor;