@openrewrite/rewrite 8.72.2 → 8.72.4

package/dist/javascript/print.js

@@ -1,14 +1,5 @@
 "use strict";
 // noinspection DuplicatedCode
-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.JavaScriptPrinter = void 0;
 /*
@@ -37,1704 +28,1480 @@ class JavaScriptPrinter extends visitor_1.JavaScriptVisitor {
         super(...arguments);
         this.JAVA_SCRIPT_MARKER_WRAPPER = (out) => `/*~~${out}${out.length === 0 ? "" : "~~"}>*/`;
     }
-    visitJsCompilationUnit(cu, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(cu, p);
-            yield this.visitRightPaddedLocal(cu.statements, "", p);
-            yield this.visitSpace(cu.eof, p);
-            yield this.afterSyntax(cu, p);
-            return cu;
-        });
-    }
-    visitAlias(alias, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(alias, p);
-            yield this.visitRightPadded(alias.propertyName, p);
-            p.append("as");
-            yield this.visit(alias.alias, p);
-            yield this.afterSyntax(alias, p);
-            return alias;
-        });
-    }
-    visitAwait(awaitExpr, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(awaitExpr, p);
-            p.append("await");
-            yield this.visit(awaitExpr.expression, p);
-            yield this.afterSyntax(awaitExpr, p);
-            return awaitExpr;
-        });
-    }
-    visitBindingElement(binding, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(binding, p);
-            if (binding.propertyName) {
-                yield this.visitRightPadded(binding.propertyName, p);
-                p.append(":");
-            }
-            yield this.visit(binding.name, p);
-            binding.initializer && (yield this.visitLeftPaddedLocal("=", binding.initializer, p));
-            yield this.afterSyntax(binding, p);
-            return binding;
-        });
-    }
-    visitDelete(del, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(del, p);
-            p.append("delete");
-            yield this.visit(del.expression, p);
-            yield this.afterSyntax(del, p);
-            return del;
-        });
-    }
-    visitExpressionStatement(statement, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(statement, p);
-            yield this.visit(statement.expression, p);
-            yield this.afterSyntax(statement, p);
-            return statement;
-        });
-    }
-    visitStatementExpression(statementExpression, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(statementExpression, p);
-            yield this.visit(statementExpression.statement, p);
-            yield this.afterSyntax(statementExpression, p);
-            return statementExpression;
-        });
-    }
-    visitSpread(spread, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(spread, p);
-            p.append("...");
-            yield this.visit(spread.expression, p);
-            yield this.afterSyntax(spread, p);
-            return spread;
-        });
-    }
-    visitInferType(inferType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(inferType, p);
-            yield this.visitLeftPaddedLocal("infer", inferType.typeParameter, p);
-            yield this.afterSyntax(inferType, p);
-            return inferType;
-        });
-    }
-    visitJsxTag(element, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(element, p);
-            // Print < first, then the space after < (openName.before), then the tag name
-            p.append("<");
-            yield this.visitSpace(element.openName.before, p);
-            yield this.visit(element.openName.element, p);
-            if (element.typeArguments) {
-                yield this.visitContainerLocal("<", element.typeArguments, ",", ">", p);
-            }
-            yield this.visitSpace(element.afterName, p);
-            yield this.visitRightPaddedLocal(element.attributes, "", p);
-            if (element.selfClosing) {
-                yield this.visitSpace(element.selfClosing, p);
-                p.append("/>");
-            }
-            else {
-                p.append(">");
-                if (element.children) {
-                    for (let i = 0; i < element.children.length; i++) {
-                        yield this.visit(element.children[i], p);
-                    }
-                    // Print </ first, then the space after </ (closingName.before), then the tag name
-                    p.append("</");
-                    yield this.visitSpace(element.closingName.before, p);
-                    yield this.visit(element.closingName.element, p);
-                    yield this.visitSpace(element.afterClosingName, p);
-                    p.append(">");
-                }
-            }
-            yield this.afterSyntax(element, p);
-            return element;
-        });
-    }
-    visitJsxAttribute(attribute, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(attribute, p);
-            yield this.visit(attribute.key, p);
-            if (attribute.value) {
-                p.append("=");
-                yield this.visit(attribute.value.element, p);
-            }
-            yield this.afterSyntax(attribute, p);
-            return attribute;
-        });
-    }
-    visitJsxSpreadAttribute(spread, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(spread, p);
-            p.append("{");
-            yield this.visitSpace(spread.dots, p);
-            p.append("...");
-            yield this.visitRightPaddedLocal([spread.expression], "}", p);
-            p.append("}");
-            yield this.afterSyntax(spread, p);
-            return spread;
-        });
-    }
-    visitJsxEmbeddedExpression(expr, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(expr, p);
-            p.append("{");
-            if (expr.expression) {
-                yield this.visitRightPaddedLocal([expr.expression], "}", p);
-            }
-            p.append("}");
-            yield this.afterSyntax(expr, p);
-            return expr;
-        });
-    }
-    visitJsxNamespacedName(ns, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(ns, p);
-            yield this.visit(ns.namespace, p);
+    async visitJsCompilationUnit(cu, p) {
+        await this.beforeSyntax(cu, p);
+        await this.visitRightPaddedLocal(cu.statements, "", p);
+        await this.visitSpace(cu.eof, p);
+        await this.afterSyntax(cu, p);
+        return cu;
+    }
+    async visitAlias(alias, p) {
+        await this.beforeSyntax(alias, p);
+        await this.visitRightPadded(alias.propertyName, p);
+        p.append("as");
+        await this.visit(alias.alias, p);
+        await this.afterSyntax(alias, p);
+        return alias;
+    }
+    async visitAwait(awaitExpr, p) {
+        await this.beforeSyntax(awaitExpr, p);
+        p.append("await");
+        await this.visit(awaitExpr.expression, p);
+        await this.afterSyntax(awaitExpr, p);
+        return awaitExpr;
+    }
+    async visitBindingElement(binding, p) {
+        await this.beforeSyntax(binding, p);
+        if (binding.propertyName) {
+            await this.visitRightPadded(binding.propertyName, p);
             p.append(":");
-            yield this.visitLeftPadded(ns.name, p);
-            yield this.afterSyntax(ns, p);
-            return ns;
-        });
-    }
-    visitImportDeclaration(jsImport, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const it of jsImport.modifiers) {
-                yield this.visitDefined(it, p);
-            }
-            yield this.beforeSyntax(jsImport, p);
-            p.append("import");
-            jsImport.importClause && (yield this.visit(jsImport.importClause, p));
-            yield this.visitLeftPaddedLocal(jsImport.importClause ? "from" : "", jsImport.moduleSpecifier, p);
-            jsImport.attributes && (yield this.visit(jsImport.attributes, p));
-            if (jsImport.initializer) {
-                p.append("=");
-                yield this.visitLeftPadded(jsImport.initializer, p);
-            }
-            yield this.afterSyntax(jsImport, p);
-            return jsImport;
-        });
-    }
-    visitImportClause(jsImportClause, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(jsImportClause, p);
-            if (jsImportClause.typeOnly) {
-                p.append("type");
-            }
-            if (jsImportClause.name) {
-                yield this.visitRightPadded(jsImportClause.name, p);
-                if (jsImportClause.namedBindings) {
-                    p.append(",");
+        }
+        await this.visit(binding.name, p);
+        binding.initializer && await this.visitLeftPaddedLocal("=", binding.initializer, p);
+        await this.afterSyntax(binding, p);
+        return binding;
+    }
+    async visitDelete(del, p) {
+        await this.beforeSyntax(del, p);
+        p.append("delete");
+        await this.visit(del.expression, p);
+        await this.afterSyntax(del, p);
+        return del;
+    }
+    async visitExpressionStatement(statement, p) {
+        await this.beforeSyntax(statement, p);
+        await this.visit(statement.expression, p);
+        await this.afterSyntax(statement, p);
+        return statement;
+    }
+    async visitStatementExpression(statementExpression, p) {
+        await this.beforeSyntax(statementExpression, p);
+        await this.visit(statementExpression.statement, p);
+        await this.afterSyntax(statementExpression, p);
+        return statementExpression;
+    }
+    async visitSpread(spread, p) {
+        await this.beforeSyntax(spread, p);
+        p.append("...");
+        await this.visit(spread.expression, p);
+        await this.afterSyntax(spread, p);
+        return spread;
+    }
+    async visitInferType(inferType, p) {
+        await this.beforeSyntax(inferType, p);
+        await this.visitLeftPaddedLocal("infer", inferType.typeParameter, p);
+        await this.afterSyntax(inferType, p);
+        return inferType;
+    }
+    async visitJsxTag(element, p) {
+        await this.beforeSyntax(element, p);
+        // Print < first, then the space after < (openName.before), then the tag name
+        p.append("<");
+        await this.visitSpace(element.openName.before, p);
+        await this.visit(element.openName.element, p);
+        if (element.typeArguments) {
+            await this.visitContainerLocal("<", element.typeArguments, ",", ">", p);
+        }
+        await this.visitSpace(element.afterName, p);
+        await this.visitRightPaddedLocal(element.attributes, "", p);
+        if (element.selfClosing) {
+            await this.visitSpace(element.selfClosing, p);
+            p.append("/>");
+        }
+        else {
+            p.append(">");
+            if (element.children) {
+                for (let i = 0; i < element.children.length; i++) {
+                    await this.visit(element.children[i], p);
                 }
+                // Print </ first, then the space after </ (closingName.before), then the tag name
+                p.append("</");
+                await this.visitSpace(element.closingName.before, p);
+                await this.visit(element.closingName.element, p);
+                await this.visitSpace(element.afterClosingName, p);
+                p.append(">");
             }
-            jsImportClause.namedBindings && (yield this.visit(jsImportClause.namedBindings, p));
-            yield this.afterSyntax(jsImportClause, p);
-            return jsImportClause;
-        });
-    }
-    visitTypeTreeExpression(typeTreeExpression, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(typeTreeExpression, p);
-            yield this.visit(typeTreeExpression.expression, p);
-            yield this.afterSyntax(typeTreeExpression, p);
-            return typeTreeExpression;
-        });
-    }
-    visitNamespaceDeclaration(namespaceDeclaration, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(namespaceDeclaration, p);
-            for (const it of namespaceDeclaration.modifiers) {
-                yield this.visitModifier(it, p);
-            }
-            yield this.visitSpace(namespaceDeclaration.keywordType.before, p);
-            switch (namespaceDeclaration.keywordType.element) {
-                case tree_1.JS.NamespaceDeclaration.KeywordType.Namespace:
-                    p.append("namespace");
-                    break;
-                case tree_1.JS.NamespaceDeclaration.KeywordType.Module:
-                    p.append("module");
-                    break;
-                default:
-                    break;
-            }
-            yield this.visitRightPadded(namespaceDeclaration.name, p);
-            if (namespaceDeclaration.body) {
-                yield this.visit(namespaceDeclaration.body, p);
-            }
-            yield this.afterSyntax(namespaceDeclaration, p);
-            return namespaceDeclaration;
-        });
-    }
-    visitSatisfiesExpression(satisfiesExpression, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(satisfiesExpression, p);
-            yield this.visit(satisfiesExpression.expression, p);
-            yield this.visitLeftPaddedLocal("satisfies", satisfiesExpression.satisfiesType, p);
-            yield this.afterSyntax(satisfiesExpression, p);
-            return satisfiesExpression;
-        });
-    }
-    visitVoid(aVoid, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(aVoid, p);
-            p.append("void");
-            yield this.visit(aVoid.expression, p);
-            yield this.afterSyntax(aVoid, p);
-            return aVoid;
-        });
-    }
-    visitYield(aYield, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(aYield, p);
-            p.append("yield");
-            const delegated = (0, markers_1.findMarker)(aYield, tree_1.JS.Markers.DelegatedYield);
-            if (delegated) {
-                yield this.visitSpace(delegated.prefix, p);
-                p.append("*");
-            }
-            aYield.value && (yield this.visit(aYield.value, p));
-            yield this.afterSyntax(aYield, p);
-            return aYield;
-        });
-    }
-    visitTry(aTry, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(aTry, p);
-            p.append("try");
-            yield this.visit(aTry.body, p);
-            yield this.visitNodes(aTry.catches, p);
-            aTry.finally && (yield this.visitLeftPaddedLocal("finally", aTry.finally, p));
-            yield this.afterSyntax(aTry, p);
-            return aTry;
-        });
-    }
-    visitTryCatch(aCatch, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(aCatch, p);
-            p.append("catch");
-            if (aCatch.parameter.tree.element.variables.length > 0) {
-                yield this.visit(aCatch.parameter, p);
-            }
-            yield this.visit(aCatch.body, p);
-            yield this.afterSyntax(aCatch, p);
-            return aCatch;
-        });
-    }
-    visitArrayDimension(arrayDimension, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(arrayDimension, p);
-            p.append("[");
-            yield this.visitRightPaddedLocalSingle(arrayDimension.index, "]", p);
-            yield this.afterSyntax(arrayDimension, p);
-            return arrayDimension;
-        });
-    }
-    visitArrayType(arrayType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(arrayType, p);
-            let type = arrayType;
-            while (type.kind === java_1.J.Kind.ArrayType) {
-                type = type.elementType;
-            }
-            yield this.visit(type, p);
-            yield this.visitNodes(arrayType.annotations, p);
-            if (arrayType.dimension) {
-                yield this.visitSpace(arrayType.dimension.before, p);
-                p.append("[");
-                yield this.visitSpace(arrayType.dimension.element, p);
-                p.append("]");
-                if (arrayType.elementType.kind === java_1.J.Kind.ArrayType) {
-                    yield this.printDimensions(arrayType.elementType, p);
-                }
+        }
+        await this.afterSyntax(element, p);
+        return element;
+    }
+    async visitJsxAttribute(attribute, p) {
+        await this.beforeSyntax(attribute, p);
+        await this.visit(attribute.key, p);
+        if (attribute.value) {
+            p.append("=");
+            await this.visit(attribute.value.element, p);
+        }
+        await this.afterSyntax(attribute, p);
+        return attribute;
+    }
+    async visitJsxSpreadAttribute(spread, p) {
+        await this.beforeSyntax(spread, p);
+        p.append("{");
+        await this.visitSpace(spread.dots, p);
+        p.append("...");
+        await this.visitRightPaddedLocal([spread.expression], "}", p);
+        p.append("}");
+        await this.afterSyntax(spread, p);
+        return spread;
+    }
+    async visitJsxEmbeddedExpression(expr, p) {
+        await this.beforeSyntax(expr, p);
+        p.append("{");
+        if (expr.expression) {
+            await this.visitRightPaddedLocal([expr.expression], "}", p);
+        }
+        p.append("}");
+        await this.afterSyntax(expr, p);
+        return expr;
+    }
+    async visitJsxNamespacedName(ns, p) {
+        await this.beforeSyntax(ns, p);
+        await this.visit(ns.namespace, p);
+        p.append(":");
+        await this.visitLeftPadded(ns.name, p);
+        await this.afterSyntax(ns, p);
+        return ns;
+    }
+    async visitImportDeclaration(jsImport, p) {
+        for (const it of jsImport.modifiers) {
+            await this.visitDefined(it, p);
+        }
+        await this.beforeSyntax(jsImport, p);
+        p.append("import");
+        jsImport.importClause && await this.visit(jsImport.importClause, p);
+        await this.visitLeftPaddedLocal(jsImport.importClause ? "from" : "", jsImport.moduleSpecifier, p);
+        jsImport.attributes && await this.visit(jsImport.attributes, p);
+        if (jsImport.initializer) {
+            p.append("=");
+            await this.visitLeftPadded(jsImport.initializer, p);
+        }
+        await this.afterSyntax(jsImport, p);
+        return jsImport;
+    }
+    async visitImportClause(jsImportClause, p) {
+        await this.beforeSyntax(jsImportClause, p);
+        if (jsImportClause.typeOnly) {
+            p.append("type");
+        }
+        if (jsImportClause.name) {
+            await this.visitRightPadded(jsImportClause.name, p);
+            if (jsImportClause.namedBindings) {
+                p.append(",");
             }
-            yield this.afterSyntax(arrayType, p);
-            return arrayType;
-        });
-    }
-    printDimensions(arrayType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
-            yield this.beforeSyntax(arrayType, p);
-            yield this.visitNodes(arrayType.annotations, p);
-            yield this.visitSpace((_b = (_a = arrayType.dimension) === null || _a === void 0 ? void 0 : _a.before) !== null && _b !== void 0 ? _b : java_1.emptySpace, p);
+        }
+        jsImportClause.namedBindings && await this.visit(jsImportClause.namedBindings, p);
+        await this.afterSyntax(jsImportClause, p);
+        return jsImportClause;
+    }
+    async visitTypeTreeExpression(typeTreeExpression, p) {
+        await this.beforeSyntax(typeTreeExpression, p);
+        await this.visit(typeTreeExpression.expression, p);
+        await this.afterSyntax(typeTreeExpression, p);
+        return typeTreeExpression;
+    }
+    async visitNamespaceDeclaration(namespaceDeclaration, p) {
+        await this.beforeSyntax(namespaceDeclaration, p);
+        for (const it of namespaceDeclaration.modifiers) {
+            await this.visitModifier(it, p);
+        }
+        await this.visitSpace(namespaceDeclaration.keywordType.before, p);
+        switch (namespaceDeclaration.keywordType.element) {
+            case tree_1.JS.NamespaceDeclaration.KeywordType.Namespace:
+                p.append("namespace");
+                break;
+            case tree_1.JS.NamespaceDeclaration.KeywordType.Module:
+                p.append("module");
+                break;
+            default:
+                break;
+        }
+        await this.visitRightPadded(namespaceDeclaration.name, p);
+        if (namespaceDeclaration.body) {
+            await this.visit(namespaceDeclaration.body, p);
+        }
+        await this.afterSyntax(namespaceDeclaration, p);
+        return namespaceDeclaration;
+    }
+    async visitSatisfiesExpression(satisfiesExpression, p) {
+        await this.beforeSyntax(satisfiesExpression, p);
+        await this.visit(satisfiesExpression.expression, p);
+        await this.visitLeftPaddedLocal("satisfies", satisfiesExpression.satisfiesType, p);
+        await this.afterSyntax(satisfiesExpression, p);
+        return satisfiesExpression;
+    }
+    async visitVoid(aVoid, p) {
+        await this.beforeSyntax(aVoid, p);
+        p.append("void");
+        await this.visit(aVoid.expression, p);
+        await this.afterSyntax(aVoid, p);
+        return aVoid;
+    }
+    async visitYield(aYield, p) {
+        await this.beforeSyntax(aYield, p);
+        p.append("yield");
+        const delegated = (0, markers_1.findMarker)(aYield, tree_1.JS.Markers.DelegatedYield);
+        if (delegated) {
+            await this.visitSpace(delegated.prefix, p);
+            p.append("*");
+        }
+        aYield.value && await this.visit(aYield.value, p);
+        await this.afterSyntax(aYield, p);
+        return aYield;
+    }
+    async visitTry(aTry, p) {
+        await this.beforeSyntax(aTry, p);
+        p.append("try");
+        await this.visit(aTry.body, p);
+        await this.visitNodes(aTry.catches, p);
+        aTry.finally && await this.visitLeftPaddedLocal("finally", aTry.finally, p);
+        await this.afterSyntax(aTry, p);
+        return aTry;
+    }
+    async visitTryCatch(aCatch, p) {
+        await this.beforeSyntax(aCatch, p);
+        p.append("catch");
+        if (aCatch.parameter.tree.element.variables.length > 0) {
+            await this.visit(aCatch.parameter, p);
+        }
+        await this.visit(aCatch.body, p);
+        await this.afterSyntax(aCatch, p);
+        return aCatch;
+    }
+    async visitArrayDimension(arrayDimension, p) {
+        await this.beforeSyntax(arrayDimension, p);
+        p.append("[");
+        await this.visitRightPaddedLocalSingle(arrayDimension.index, "]", p);
+        await this.afterSyntax(arrayDimension, p);
+        return arrayDimension;
+    }
+    async visitArrayType(arrayType, p) {
+        await this.beforeSyntax(arrayType, p);
+        let type = arrayType;
+        while (type.kind === java_1.J.Kind.ArrayType) {
+            type = type.elementType;
+        }
+        await this.visit(type, p);
+        await this.visitNodes(arrayType.annotations, p);
+        if (arrayType.dimension) {
+            await this.visitSpace(arrayType.dimension.before, p);
             p.append("[");
-            yield this.visitSpace((_d = (_c = arrayType.dimension) === null || _c === void 0 ? void 0 : _c.element) !== null && _d !== void 0 ? _d : java_1.emptySpace, p);
+            await this.visitSpace(arrayType.dimension.element, p);
             p.append("]");
             if (arrayType.elementType.kind === java_1.J.Kind.ArrayType) {
-                yield this.printDimensions(arrayType.elementType, p);
-            }
-            yield this.afterSyntax(arrayType, p);
-        });
-    }
-    visitTernary(ternary, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(ternary, p);
-            yield this.visit(ternary.condition, p);
-            yield this.visitLeftPaddedLocal("?", ternary.truePart, p);
-            yield this.visitLeftPaddedLocal(":", ternary.falsePart, p);
-            yield this.afterSyntax(ternary, p);
-            return ternary;
-        });
-    }
-    visitThrow(thrown, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(thrown, p);
-            p.append("throw");
-            yield this.visit(thrown.exception, p);
-            yield this.afterSyntax(thrown, p);
-            return thrown;
-        });
-    }
-    visitIf(iff, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(iff, p);
-            p.append("if");
-            yield this.visit(iff.ifCondition, p);
-            yield this.visitStatementLocal(iff.thenPart, p);
-            iff.elsePart && (yield this.visit(iff.elsePart, p));
-            yield this.afterSyntax(iff, p);
-            return iff;
-        });
-    }
-    visitElse(else_, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(else_, p);
-            p.append("else");
-            yield this.visitStatementLocal(else_.body, p);
-            yield this.afterSyntax(else_, p);
-            return else_;
-        });
-    }
-    visitDoWhileLoop(doWhileLoop, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(doWhileLoop, p);
-            p.append("do");
-            yield this.visitStatementLocal(doWhileLoop.body, p);
-            yield this.visitLeftPaddedLocal("while", doWhileLoop.whileCondition, p);
-            yield this.afterSyntax(doWhileLoop, p);
-            return doWhileLoop;
-        });
-    }
-    visitWhileLoop(whileLoop, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(whileLoop, p);
-            p.append("while");
-            yield this.visit(whileLoop.condition, p);
-            yield this.visitStatementLocal(whileLoop.body, p);
-            yield this.afterSyntax(whileLoop, p);
-            return whileLoop;
-        });
-    }
-    visitInstanceOf(instanceOf, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(instanceOf, p);
-            yield this.visitRightPaddedLocalSingle(instanceOf.expression, "instanceof", p);
-            yield this.visit(instanceOf.class, p);
-            instanceOf.pattern && (yield this.visit(instanceOf.pattern, p));
-            yield this.afterSyntax(instanceOf, p);
-            return instanceOf;
-        });
-    }
-    visitLiteral(literal, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            yield this.beforeSyntax(literal, p);
-            const unicodeEscapes = literal.unicodeEscapes;
-            if (!unicodeEscapes) {
-                p.append(literal.valueSource);
+                await this.printDimensions(arrayType.elementType, p);
             }
-            else if (literal.valueSource) {
-                const surrogateIter = unicodeEscapes[Symbol.iterator]();
-                let surrogate = (_a = surrogateIter.next().value) !== null && _a !== void 0 ? _a : null;
-                let i = 0;
-                if (surrogate && surrogate.valueSourceIndex === 0) {
-                    p.append("\\u").append(surrogate.codePoint);
-                    surrogate = (_b = surrogateIter.next().value) !== null && _b !== void 0 ? _b : null;
-                }
-                const valueSource = literal.valueSource;
-                for (let j = 0; j < valueSource.length; j++) {
-                    const c = valueSource[j];
-                    p.append(c);
-                    if (surrogate && surrogate.valueSourceIndex === ++i) {
-                        while (surrogate && surrogate.valueSourceIndex === i) {
-                            p.append("\\u").append(surrogate.codePoint);
-                            surrogate = (_c = surrogateIter.next().value) !== null && _c !== void 0 ? _c : null;
-                        }
+        }
+        await this.afterSyntax(arrayType, p);
+        return arrayType;
+    }
+    async printDimensions(arrayType, p) {
+        var _a, _b, _c, _d;
+        await this.beforeSyntax(arrayType, p);
+        await this.visitNodes(arrayType.annotations, p);
+        await this.visitSpace((_b = (_a = arrayType.dimension) === null || _a === void 0 ? void 0 : _a.before) !== null && _b !== void 0 ? _b : java_1.emptySpace, p);
+        p.append("[");
+        await this.visitSpace((_d = (_c = arrayType.dimension) === null || _c === void 0 ? void 0 : _c.element) !== null && _d !== void 0 ? _d : java_1.emptySpace, p);
+        p.append("]");
+        if (arrayType.elementType.kind === java_1.J.Kind.ArrayType) {
+            await this.printDimensions(arrayType.elementType, p);
+        }
+        await this.afterSyntax(arrayType, p);
+    }
+    async visitTernary(ternary, p) {
+        await this.beforeSyntax(ternary, p);
+        await this.visit(ternary.condition, p);
+        await this.visitLeftPaddedLocal("?", ternary.truePart, p);
+        await this.visitLeftPaddedLocal(":", ternary.falsePart, p);
+        await this.afterSyntax(ternary, p);
+        return ternary;
+    }
+    async visitThrow(thrown, p) {
+        await this.beforeSyntax(thrown, p);
+        p.append("throw");
+        await this.visit(thrown.exception, p);
+        await this.afterSyntax(thrown, p);
+        return thrown;
+    }
+    async visitIf(iff, p) {
+        await this.beforeSyntax(iff, p);
+        p.append("if");
+        await this.visit(iff.ifCondition, p);
+        await this.visitStatementLocal(iff.thenPart, p);
+        iff.elsePart && await this.visit(iff.elsePart, p);
+        await this.afterSyntax(iff, p);
+        return iff;
+    }
+    async visitElse(else_, p) {
+        await this.beforeSyntax(else_, p);
+        p.append("else");
+        await this.visitStatementLocal(else_.body, p);
+        await this.afterSyntax(else_, p);
+        return else_;
+    }
+    async visitDoWhileLoop(doWhileLoop, p) {
+        await this.beforeSyntax(doWhileLoop, p);
+        p.append("do");
+        await this.visitStatementLocal(doWhileLoop.body, p);
+        await this.visitLeftPaddedLocal("while", doWhileLoop.whileCondition, p);
+        await this.afterSyntax(doWhileLoop, p);
+        return doWhileLoop;
+    }
+    async visitWhileLoop(whileLoop, p) {
+        await this.beforeSyntax(whileLoop, p);
+        p.append("while");
+        await this.visit(whileLoop.condition, p);
+        await this.visitStatementLocal(whileLoop.body, p);
+        await this.afterSyntax(whileLoop, p);
+        return whileLoop;
+    }
+    async visitInstanceOf(instanceOf, p) {
+        await this.beforeSyntax(instanceOf, p);
+        await this.visitRightPaddedLocalSingle(instanceOf.expression, "instanceof", p);
+        await this.visit(instanceOf.class, p);
+        instanceOf.pattern && await this.visit(instanceOf.pattern, p);
+        await this.afterSyntax(instanceOf, p);
+        return instanceOf;
+    }
+    async visitLiteral(literal, p) {
+        var _a, _b, _c;
+        await this.beforeSyntax(literal, p);
+        const unicodeEscapes = literal.unicodeEscapes;
+        if (!unicodeEscapes) {
+            p.append(literal.valueSource);
+        }
+        else if (literal.valueSource) {
+            const surrogateIter = unicodeEscapes[Symbol.iterator]();
+            let surrogate = (_a = surrogateIter.next().value) !== null && _a !== void 0 ? _a : null;
+            let i = 0;
+            if (surrogate && surrogate.valueSourceIndex === 0) {
+                p.append("\\u").append(surrogate.codePoint);
+                surrogate = (_b = surrogateIter.next().value) !== null && _b !== void 0 ? _b : null;
+            }
+            const valueSource = literal.valueSource;
+            for (let j = 0; j < valueSource.length; j++) {
+                const c = valueSource[j];
+                p.append(c);
+                if (surrogate && surrogate.valueSourceIndex === ++i) {
+                    while (surrogate && surrogate.valueSourceIndex === i) {
+                        p.append("\\u").append(surrogate.codePoint);
+                        surrogate = (_c = surrogateIter.next().value) !== null && _c !== void 0 ? _c : null;
                     }
                 }
             }
-            yield this.afterSyntax(literal, p);
-            return literal;
-        });
-    }
-    visitScopedVariableDeclarations(variableDeclarations, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(variableDeclarations, p);
-            for (const m of variableDeclarations.modifiers) {
-                yield this.visitModifier(m, p);
-            }
-            yield this.visitRightPaddedLocal(variableDeclarations.variables, ",", p);
-            yield this.afterSyntax(variableDeclarations, p);
-            return variableDeclarations;
-        });
-    }
-    visitShebang(shebang, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(shebang, p);
-            p.append(shebang.text);
-            yield this.afterSyntax(shebang, p);
-            return shebang;
-        });
-    }
-    visitVariableDeclarations(multiVariable, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(multiVariable, p);
-            yield this.visitNodes(multiVariable.leadingAnnotations, p);
-            for (const it of multiVariable.modifiers) {
-                yield this.visitModifier(it, p);
-            }
-            const variables = multiVariable.variables;
-            for (let i = 0; i < variables.length; i++) {
-                const variable = variables[i];
-                yield this.beforeSyntax(variable.element, p);
-                if (multiVariable.varargs) {
-                    p.append("...");
-                }
-                yield this.visit(variable.element.name, p);
-                // print non-null assertions or optional
-                yield this.postVisit(variable.element, p);
-                yield this.visitSpace(variable.after, p);
-                if (multiVariable.typeExpression) {
-                    yield this.visit(multiVariable.typeExpression, p);
-                }
-                if (variable.element.initializer) {
-                    yield this.visitLeftPaddedLocal("=", variable.element.initializer, p);
-                }
-                yield this.afterSyntax(variable.element, p);
-                if (i < variables.length - 1) {
-                    p.append(",");
-                }
-                else if ((0, markers_1.findMarker)(variable, java_1.J.Markers.Semicolon)) {
-                    p.append(";");
-                }
-            }
-            yield this.afterSyntax(multiVariable, p);
-            return multiVariable;
-        });
-    }
-    visitVariable(variable, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(variable, p);
-            yield this.visit(variable.name, p);
-            variable.initializer && (yield this.visitLeftPaddedLocal("=", variable.initializer, p));
-            yield this.afterSyntax(variable, p);
-            return variable;
-        });
-    }
-    visitIdentifier(ident, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.visitSpace(java_1.emptySpace, p);
-            yield this.visitNodes(ident.annotations, p);
-            yield this.beforeSyntax(ident, p);
-            p.append(ident.simpleName);
-            yield this.afterSyntax(ident, p);
-            return ident;
-        });
-    }
-    visitBlock(block, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(block, p);
-            if (block.static.element) {
-                p.append("static");
-                yield this.visitRightPadded(block.static, p);
-            }
-            p.append("{");
-            yield this.visitStatements(block.statements, p);
-            yield this.visitSpace(block.end, p);
-            p.append("}");
-            yield this.afterSyntax(block, p);
-            return block;
-        });
-    }
-    visitTypeInfo(typeInfo, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(typeInfo, p);
-            p.append(":");
-            yield this.visit(typeInfo.typeIdentifier, p);
-            yield this.afterSyntax(typeInfo, p);
-            return typeInfo;
-        });
-    }
-    visitReturn(return_, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(return_, p);
-            p.append("return");
-            return_.expression && (yield this.visit(return_.expression, p));
-            yield this.afterSyntax(return_, p);
-            return return_;
-        });
-    }
-    visitModifier(mod, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            yield this.visitNodes(mod.annotations, p);
-            let keyword;
-            switch (mod.type) {
-                case java_1.J.ModifierType.Default:
-                    keyword = "default";
-                    break;
-                case java_1.J.ModifierType.Public:
-                    keyword = "public";
-                    break;
-                case java_1.J.ModifierType.Protected:
-                    keyword = "protected";
-                    break;
-                case java_1.J.ModifierType.Private:
-                    keyword = "private";
-                    break;
-                case java_1.J.ModifierType.Abstract:
-                    keyword = "abstract";
-                    break;
-                case java_1.J.ModifierType.Async:
-                    keyword = "async";
-                    break;
-                case java_1.J.ModifierType.Static:
-                    keyword = "static";
-                    break;
-                case java_1.J.ModifierType.Final:
-                    keyword = "const";
-                    break;
-                case java_1.J.ModifierType.Native:
-                    keyword = "native";
-                    break;
-                case java_1.J.ModifierType.NonSealed:
-                    keyword = "non-sealed";
-                    break;
-                case java_1.J.ModifierType.Sealed:
-                    keyword = "sealed";
-                    break;
-                case java_1.J.ModifierType.Strictfp:
-                    keyword = "strictfp";
-                    break;
-                case java_1.J.ModifierType.Synchronized:
-                    keyword = "synchronized";
-                    break;
-                case java_1.J.ModifierType.Transient:
-                    keyword = "transient";
-                    break;
-                case java_1.J.ModifierType.Volatile:
-                    keyword = "volatile";
-                    break;
-                default:
-                    keyword = (_a = mod.keyword) !== null && _a !== void 0 ? _a : "";
-            }
-            yield this.beforeSyntax(mod, p);
-            p.append(keyword);
-            yield this.afterSyntax(mod, p);
-            return mod;
-        });
-    }
-    visitFunctionCall(functionCall, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(functionCall, p);
-            if (functionCall.function) {
-                yield this.visitRightPadded(functionCall.function, p);
-                if (functionCall.function.element.markers.markers.find(m => m.kind === tree_1.JS.Markers.Optional)) {
-                    p.append("?.");
-                }
-            }
-            functionCall.typeParameters && (yield this.visitContainerLocal("<", functionCall.typeParameters, ",", ">", p));
-            yield this.visitContainerLocal("(", functionCall.arguments, ",", ")", p);
-            yield this.afterSyntax(functionCall, p);
-            return functionCall;
-        });
-    }
-    visitFunctionType(functionType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(functionType, p);
-            for (const m of functionType.modifiers) {
-                yield this.visitModifier(m, p);
-            }
-            if (functionType.constructorType.element) {
-                yield this.visitLeftPaddedLocal("new", functionType.constructorType, p);
-            }
-            const typeParameters = functionType.typeParameters;
-            if (typeParameters) {
-                yield this.visitNodes(typeParameters.annotations, p);
-                yield this.visitSpace(typeParameters.prefix, p);
-                yield this.visitMarkers(typeParameters.markers, p);
-                p.append("<");
-                yield this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
-                p.append(">");
-            }
-            yield this.visitContainerLocal("(", functionType.parameters, ",", ")", p);
-            yield this.visitLeftPaddedLocal("=>", functionType.returnType, p);
-            yield this.afterSyntax(functionType, p);
-            return functionType;
-        });
-    }
-    visitClassDeclaration(classDecl, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let kind = "";
-            switch (classDecl.classKind.type) {
-                case java_1.J.ClassDeclaration.Kind.Type.Class:
-                    kind = "class";
-                    break;
-                case java_1.J.ClassDeclaration.Kind.Type.Enum:
-                    kind = "enum";
-                    break;
-                case java_1.J.ClassDeclaration.Kind.Type.Interface:
-                    kind = "interface";
-                    break;
-                case java_1.J.ClassDeclaration.Kind.Type.Annotation:
-                    kind = "@interface";
-                    break;
-                case java_1.J.ClassDeclaration.Kind.Type.Record:
-                    kind = "record";
-                    break;
-            }
-            yield this.beforeSyntax(classDecl, p);
-            yield this.visitSpace(java_1.emptySpace, p);
-            yield this.visitNodes(classDecl.leadingAnnotations, p);
-            for (const m of classDecl.modifiers) {
-                yield this.visitModifier(m, p);
-            }
-            yield this.visitNodes(classDecl.classKind.annotations, p);
-            yield this.visitSpace(classDecl.classKind.prefix, p);
-            p.append(kind);
-            yield this.visit(classDecl.name, p);
-            classDecl.typeParameters && (yield this.visitContainerLocal("<", classDecl.typeParameters, ",", ">", p));
-            classDecl.primaryConstructor && (yield this.visitContainerLocal("(", classDecl.primaryConstructor, ",", ")", p));
-            classDecl.extends && (yield this.visitLeftPaddedLocal("extends", classDecl.extends, p));
-            classDecl.implements && (yield this.visitContainerLocal(classDecl.classKind.type === java_1.J.ClassDeclaration.Kind.Type.Interface ? "extends" : "implements", classDecl.implements, ",", null, p));
-            yield this.visit(classDecl.body, p);
-            yield this.afterSyntax(classDecl, p);
-            return classDecl;
-        });
-    }
-    visitMethodDeclaration(method, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(method, p);
-            yield this.visitSpace(java_1.emptySpace, p);
-            yield this.visitNodes(method.leadingAnnotations, p);
-            for (const m of method.modifiers) {
-                yield this.visitModifier(m, p);
-            }
-            let m;
-            if ((m = (0, markers_1.findMarker)(method, tree_1.JS.Markers.FunctionDeclaration))) {
-                yield this.visitSpace(m.prefix, p);
-                p.append("function");
-            }
-            const asterisk = (0, markers_1.findMarker)(method, tree_1.JS.Markers.Generator);
-            if (asterisk) {
-                yield this.visitSpace(asterisk.prefix, p);
-                p.append("*");
-            }
-            yield this.visit(method.name, p);
-            const typeParameters = method.typeParameters;
-            if (typeParameters) {
-                yield this.visitNodes(typeParameters.annotations, p);
-                yield this.visitSpace(typeParameters.prefix, p);
-                yield this.visitMarkers(typeParameters.markers, p);
-                p.append("<");
-                yield this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
-                p.append(">");
-            }
-            yield this.visitContainerLocal("(", method.parameters, ",", ")", p);
-            if (method.returnTypeExpression) {
-                yield this.visit(method.returnTypeExpression, p);
-            }
-            method.body && (yield this.visit(method.body, p));
-            yield this.afterSyntax(method, p);
-            return method;
-        });
-    }
-    visitComputedPropertyMethodDeclaration(method, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(method, p);
-            yield this.visitSpace(java_1.emptySpace, p);
-            yield this.visitNodes(method.leadingAnnotations, p);
-            for (const it of method.modifiers) {
-                yield this.visitModifier(it, p);
-            }
-            const generator = (0, markers_1.findMarker)(method, tree_1.JS.Markers.Generator);
-            if (generator) {
-                yield this.visitSpace(generator.prefix, p);
-                p.append("*");
-            }
-            yield this.visit(method.name, p);
-            const typeParameters = method.typeParameters;
-            if (typeParameters) {
-                yield this.visitNodes(typeParameters.annotations, p);
-                yield this.visitSpace(typeParameters.prefix, p);
-                yield this.visitMarkers(typeParameters.markers, p);
-                p.append("<");
-                yield this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
-                p.append(">");
-            }
-            yield this.visitContainerLocal("(", method.parameters, ",", ")", p);
-            if (method.returnTypeExpression) {
-                yield this.visit(method.returnTypeExpression, p);
+        }
+        await this.afterSyntax(literal, p);
+        return literal;
+    }
+    async visitScopedVariableDeclarations(variableDeclarations, p) {
+        await this.beforeSyntax(variableDeclarations, p);
+        for (const m of variableDeclarations.modifiers) {
+            await this.visitModifier(m, p);
+        }
+        await this.visitRightPaddedLocal(variableDeclarations.variables, ",", p);
+        await this.afterSyntax(variableDeclarations, p);
+        return variableDeclarations;
+    }
+    async visitShebang(shebang, p) {
+        await this.beforeSyntax(shebang, p);
+        p.append(shebang.text);
+        await this.afterSyntax(shebang, p);
+        return shebang;
+    }
+    async visitVariableDeclarations(multiVariable, p) {
+        await this.beforeSyntax(multiVariable, p);
+        await this.visitNodes(multiVariable.leadingAnnotations, p);
+        for (const it of multiVariable.modifiers) {
+            await this.visitModifier(it, p);
+        }
+        const variables = multiVariable.variables;
+        for (let i = 0; i < variables.length; i++) {
+            const variable = variables[i];
+            await this.beforeSyntax(variable.element, p);
+            if (multiVariable.varargs) {
+                p.append("...");
+            }
+            await this.visit(variable.element.name, p);
+            // print non-null assertions or optional
+            await this.postVisit(variable.element, p);
+            await this.visitSpace(variable.after, p);
+            if (multiVariable.typeExpression) {
+                await this.visit(multiVariable.typeExpression, p);
+            }
+            if (variable.element.initializer) {
+                await this.visitLeftPaddedLocal("=", variable.element.initializer, p);
+            }
+            await this.afterSyntax(variable.element, p);
+            if (i < variables.length - 1) {
+                p.append(",");
             }
-            method.body && (yield this.visit(method.body, p));
-            yield this.afterSyntax(method, p);
-            return method;
-        });
-    }
-    visitMethodInvocation(method, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(method, p);
-            if (method.name.simpleName.length === 0) {
-                method.select && (yield this.visitRightPadded(method.select, p));
+            else if ((0, markers_1.findMarker)(variable, java_1.J.Markers.Semicolon)) {
+                p.append(";");
             }
-            else {
-                if (method.select) {
-                    yield this.visitRightPadded(method.select, p);
-                    if (!method.select.element.markers.markers.find(m => m.kind === tree_1.JS.Markers.Optional)) {
-                        p.append(".");
-                    }
-                    else {
-                        p.append("?.");
-                    }
-                }
-                yield this.visit(method.name, p);
-            }
-            method.typeParameters && (yield this.visitContainerLocal("<", method.typeParameters, ",", ">", p));
-            yield this.visitContainerLocal("(", method.arguments, ",", ")", p);
-            yield this.afterSyntax(method, p);
-            return method;
-        });
-    }
-    visitTypeParameter(typeParameter, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(typeParameter, p);
-            yield this.visitNodes(typeParameter.annotations, p);
-            for (const m of typeParameter.modifiers) {
-                yield this.visitModifier(m, p);
+        }
+        await this.afterSyntax(multiVariable, p);
+        return multiVariable;
+    }
+    async visitVariable(variable, p) {
+        await this.beforeSyntax(variable, p);
+        await this.visit(variable.name, p);
+        variable.initializer && await this.visitLeftPaddedLocal("=", variable.initializer, p);
+        await this.afterSyntax(variable, p);
+        return variable;
+    }
+    async visitIdentifier(ident, p) {
+        await this.visitSpace(java_1.emptySpace, p);
+        await this.visitNodes(ident.annotations, p);
+        await this.beforeSyntax(ident, p);
+        p.append(ident.simpleName);
+        await this.afterSyntax(ident, p);
+        return ident;
+    }
+    async visitBlock(block, p) {
+        await this.beforeSyntax(block, p);
+        if (block.static.element) {
+            p.append("static");
+            await this.visitRightPadded(block.static, p);
+        }
+        p.append("{");
+        await this.visitStatements(block.statements, p);
+        await this.visitSpace(block.end, p);
+        p.append("}");
+        await this.afterSyntax(block, p);
+        return block;
+    }
+    async visitTypeInfo(typeInfo, p) {
+        await this.beforeSyntax(typeInfo, p);
+        p.append(":");
+        await this.visit(typeInfo.typeIdentifier, p);
+        await this.afterSyntax(typeInfo, p);
+        return typeInfo;
+    }
+    async visitReturn(return_, p) {
+        await this.beforeSyntax(return_, p);
+        p.append("return");
+        return_.expression && await this.visit(return_.expression, p);
+        await this.afterSyntax(return_, p);
+        return return_;
+    }
+    async visitModifier(mod, p) {
+        var _a;
+        await this.visitNodes(mod.annotations, p);
+        let keyword;
+        switch (mod.type) {
+            case java_1.J.ModifierType.Default:
+                keyword = "default";
+                break;
+            case java_1.J.ModifierType.Public:
+                keyword = "public";
+                break;
+            case java_1.J.ModifierType.Protected:
+                keyword = "protected";
+                break;
+            case java_1.J.ModifierType.Private:
+                keyword = "private";
+                break;
+            case java_1.J.ModifierType.Abstract:
+                keyword = "abstract";
+                break;
+            case java_1.J.ModifierType.Async:
+                keyword = "async";
+                break;
+            case java_1.J.ModifierType.Static:
+                keyword = "static";
+                break;
+            case java_1.J.ModifierType.Final:
+                keyword = "const";
+                break;
+            case java_1.J.ModifierType.Native:
+                keyword = "native";
+                break;
+            case java_1.J.ModifierType.NonSealed:
+                keyword = "non-sealed";
+                break;
+            case java_1.J.ModifierType.Sealed:
+                keyword = "sealed";
+                break;
+            case java_1.J.ModifierType.Strictfp:
+                keyword = "strictfp";
+                break;
+            case java_1.J.ModifierType.Synchronized:
+                keyword = "synchronized";
+                break;
+            case java_1.J.ModifierType.Transient:
+                keyword = "transient";
+                break;
+            case java_1.J.ModifierType.Volatile:
+                keyword = "volatile";
+                break;
+            default:
+                keyword = (_a = mod.keyword) !== null && _a !== void 0 ? _a : "";
+        }
+        await this.beforeSyntax(mod, p);
+        p.append(keyword);
+        await this.afterSyntax(mod, p);
+        return mod;
+    }
+    async visitFunctionCall(functionCall, p) {
+        await this.beforeSyntax(functionCall, p);
+        if (functionCall.function) {
+            await this.visitRightPadded(functionCall.function, p);
+            if (functionCall.function.element.markers.markers.find(m => m.kind === tree_1.JS.Markers.Optional)) {
+                p.append("?.");
             }
-            yield this.visit(typeParameter.name, p);
-            const bounds = typeParameter.bounds;
-            if (bounds) {
-                yield this.visitSpace(bounds.before, p);
-                const constraintType = bounds.elements[0];
-                if (!(constraintType.element.kind === java_1.J.Kind.Empty)) {
-                    p.append("extends");
-                    yield this.visitRightPadded(constraintType, p);
+        }
+        functionCall.typeParameters && await this.visitContainerLocal("<", functionCall.typeParameters, ",", ">", p);
+        await this.visitContainerLocal("(", functionCall.arguments, ",", ")", p);
+        await this.afterSyntax(functionCall, p);
+        return functionCall;
+    }
+    async visitFunctionType(functionType, p) {
+        await this.beforeSyntax(functionType, p);
+        for (const m of functionType.modifiers) {
+            await this.visitModifier(m, p);
+        }
+        if (functionType.constructorType.element) {
+            await this.visitLeftPaddedLocal("new", functionType.constructorType, p);
+        }
+        const typeParameters = functionType.typeParameters;
+        if (typeParameters) {
+            await this.visitNodes(typeParameters.annotations, p);
+            await this.visitSpace(typeParameters.prefix, p);
+            await this.visitMarkers(typeParameters.markers, p);
+            p.append("<");
+            await this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
+            p.append(">");
+        }
+        await this.visitContainerLocal("(", functionType.parameters, ",", ")", p);
+        await this.visitLeftPaddedLocal("=>", functionType.returnType, p);
+        await this.afterSyntax(functionType, p);
+        return functionType;
+    }
+    async visitClassDeclaration(classDecl, p) {
+        let kind = "";
+        switch (classDecl.classKind.type) {
+            case java_1.J.ClassDeclaration.Kind.Type.Class:
+                kind = "class";
+                break;
+            case java_1.J.ClassDeclaration.Kind.Type.Enum:
+                kind = "enum";
+                break;
+            case java_1.J.ClassDeclaration.Kind.Type.Interface:
+                kind = "interface";
+                break;
+            case java_1.J.ClassDeclaration.Kind.Type.Annotation:
+                kind = "@interface";
+                break;
+            case java_1.J.ClassDeclaration.Kind.Type.Record:
+                kind = "record";
+                break;
+        }
+        await this.beforeSyntax(classDecl, p);
+        await this.visitSpace(java_1.emptySpace, p);
+        await this.visitNodes(classDecl.leadingAnnotations, p);
+        for (const m of classDecl.modifiers) {
+            await this.visitModifier(m, p);
+        }
+        await this.visitNodes(classDecl.classKind.annotations, p);
+        await this.visitSpace(classDecl.classKind.prefix, p);
+        p.append(kind);
+        await this.visit(classDecl.name, p);
+        classDecl.typeParameters && await this.visitContainerLocal("<", classDecl.typeParameters, ",", ">", p);
+        classDecl.primaryConstructor && await this.visitContainerLocal("(", classDecl.primaryConstructor, ",", ")", p);
+        classDecl.extends && await this.visitLeftPaddedLocal("extends", classDecl.extends, p);
+        classDecl.implements && await this.visitContainerLocal(classDecl.classKind.type === java_1.J.ClassDeclaration.Kind.Type.Interface ? "extends" : "implements", classDecl.implements, ",", null, p);
+        await this.visit(classDecl.body, p);
+        await this.afterSyntax(classDecl, p);
+        return classDecl;
+    }
+    async visitMethodDeclaration(method, p) {
+        await this.beforeSyntax(method, p);
+        await this.visitSpace(java_1.emptySpace, p);
+        await this.visitNodes(method.leadingAnnotations, p);
+        for (const m of method.modifiers) {
+            await this.visitModifier(m, p);
+        }
+        let m;
+        if ((m = (0, markers_1.findMarker)(method, tree_1.JS.Markers.FunctionDeclaration))) {
+            await this.visitSpace(m.prefix, p);
+            p.append("function");
+        }
+        const asterisk = (0, markers_1.findMarker)(method, tree_1.JS.Markers.Generator);
+        if (asterisk) {
+            await this.visitSpace(asterisk.prefix, p);
+            p.append("*");
+        }
+        await this.visit(method.name, p);
+        const typeParameters = method.typeParameters;
+        if (typeParameters) {
+            await this.visitNodes(typeParameters.annotations, p);
+            await this.visitSpace(typeParameters.prefix, p);
+            await this.visitMarkers(typeParameters.markers, p);
+            p.append("<");
+            await this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
+            p.append(">");
+        }
+        await this.visitContainerLocal("(", method.parameters, ",", ")", p);
+        if (method.returnTypeExpression) {
+            await this.visit(method.returnTypeExpression, p);
+        }
+        method.body && await this.visit(method.body, p);
+        await this.afterSyntax(method, p);
+        return method;
+    }
+    async visitComputedPropertyMethodDeclaration(method, p) {
+        await this.beforeSyntax(method, p);
+        await this.visitSpace(java_1.emptySpace, p);
+        await this.visitNodes(method.leadingAnnotations, p);
+        for (const it of method.modifiers) {
+            await this.visitModifier(it, p);
+        }
+        const generator = (0, markers_1.findMarker)(method, tree_1.JS.Markers.Generator);
+        if (generator) {
+            await this.visitSpace(generator.prefix, p);
+            p.append("*");
+        }
+        await this.visit(method.name, p);
+        const typeParameters = method.typeParameters;
+        if (typeParameters) {
+            await this.visitNodes(typeParameters.annotations, p);
+            await this.visitSpace(typeParameters.prefix, p);
+            await this.visitMarkers(typeParameters.markers, p);
+            p.append("<");
+            await this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
+            p.append(">");
+        }
+        await this.visitContainerLocal("(", method.parameters, ",", ")", p);
+        if (method.returnTypeExpression) {
+            await this.visit(method.returnTypeExpression, p);
+        }
+        method.body && await this.visit(method.body, p);
+        await this.afterSyntax(method, p);
+        return method;
+    }
+    async visitMethodInvocation(method, p) {
+        await this.beforeSyntax(method, p);
+        if (method.name.simpleName.length === 0) {
+            method.select && await this.visitRightPadded(method.select, p);
+        }
+        else {
+            if (method.select) {
+                await this.visitRightPadded(method.select, p);
+                if (!method.select.element.markers.markers.find(m => m.kind === tree_1.JS.Markers.Optional)) {
+                    p.append(".");
                 }
-                const defaultType = bounds.elements[1];
-                if (!(defaultType.element.kind === java_1.J.Kind.Empty)) {
-                    p.append("=");
-                    yield this.visitRightPadded(defaultType, p);
+                else {
+                    p.append("?.");
                 }
             }
-            yield this.afterSyntax(typeParameter, p);
-            return typeParameter;
-        });
-    }
-    visitArrowFunction(arrowFunction, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(arrowFunction, p);
-            yield this.visitNodes(arrowFunction.leadingAnnotations, p);
-            for (const m of arrowFunction.modifiers) {
-                yield this.visitModifier(m, p);
-            }
-            const typeParameters = arrowFunction.typeParameters;
-            if (typeParameters) {
-                yield this.visitNodes(typeParameters.annotations, p);
-                yield this.visitSpace(typeParameters.prefix, p);
-                yield this.visitMarkers(typeParameters.markers, p);
-                p.append("<");
-                yield this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
-                p.append(">");
-            }
-            const lambda = arrowFunction.lambda;
-            if (lambda.parameters.parenthesized) {
-                yield this.visitSpace(lambda.parameters.prefix, p);
-                p.append("(");
-                yield this.visitRightPaddedLocal(lambda.parameters.parameters, ",", p);
-                p.append(")");
-            }
-            else {
-                yield this.visitRightPaddedLocal(lambda.parameters.parameters, ",", p);
-            }
-            if (arrowFunction.returnTypeExpression) {
-                yield this.visit(arrowFunction.returnTypeExpression, p);
-            }
-            yield this.visitSpace(lambda.arrow, p);
-            p.append("=>");
-            yield this.visit(lambda.body, p);
-            yield this.afterSyntax(arrowFunction, p);
-            return arrowFunction;
-        });
-    }
-    visitConditionalType(conditionalType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(conditionalType, p);
-            yield this.visit(conditionalType.checkType, p);
-            yield this.visitLeftPaddedLocal("extends", conditionalType.condition, p);
-            yield this.afterSyntax(conditionalType, p);
-            return conditionalType;
-        });
-    }
-    visitExpressionWithTypeArguments(type, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(type, p);
-            yield this.visit(type.clazz, p);
-            type.typeArguments && (yield this.visitContainerLocal("<", type.typeArguments, ",", ">", p));
-            yield this.afterSyntax(type, p);
-            return type;
-        });
-    }
-    visitImportType(importType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(importType, p);
-            if (importType.hasTypeof.element) {
-                p.append("typeof");
-                yield this.visitRightPadded(importType.hasTypeof, p);
-            }
-            p.append("import");
-            yield this.visitContainerLocal("(", importType.argumentAndAttributes, ",", ")", p);
-            importType.qualifier && (yield this.visitLeftPaddedLocal(".", importType.qualifier, p));
-            importType.typeArguments && (yield this.visitContainerLocal("<", importType.typeArguments, ",", ">", p));
-            yield this.afterSyntax(importType, p);
-            return importType;
-        });
-    }
-    visitTypeDeclaration(typeDeclaration, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(typeDeclaration, p);
-            for (const m of typeDeclaration.modifiers) {
-                yield this.visitModifier(m, p);
-            }
-            yield this.visitLeftPaddedLocal("type", typeDeclaration.name, p);
-            const typeParameters = typeDeclaration.typeParameters;
-            if (typeParameters) {
-                yield this.visitNodes(typeParameters.annotations, p);
-                yield this.visitSpace(typeParameters.prefix, p);
-                yield this.visitMarkers(typeParameters.markers, p);
-                p.append("<");
-                yield this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
-                p.append(">");
-            }
-            yield this.visitLeftPaddedLocal("=", typeDeclaration.initializer, p);
-            yield this.afterSyntax(typeDeclaration, p);
-            return typeDeclaration;
-        });
-    }
-    visitLiteralType(literalType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(literalType, p);
-            yield this.visit(literalType.literal, p);
-            yield this.afterSyntax(literalType, p);
-            return literalType;
-        });
-    }
-    visitNamedImports(namedImports, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(namedImports, p);
-            yield this.visitContainerLocal("{", namedImports.elements, ",", "}", p);
-            yield this.afterSyntax(namedImports, p);
-            return namedImports;
-        });
-    }
-    visitImportSpecifier(jis, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(jis, p);
-            if (jis.importType.element) {
-                yield this.visitLeftPaddedLocal("type", jis.importType, p);
-            }
-            yield this.visit(jis.specifier, p);
-            yield this.afterSyntax(jis, p);
-            return jis;
-        });
-    }
-    visitExportDeclaration(ed, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(ed, p);
-            p.append("export");
-            for (const it of ed.modifiers) {
-                yield this.visitModifier(it, p);
-            }
-            if (ed.typeOnly.element) {
-                yield this.visitLeftPaddedLocal("type", ed.typeOnly, p);
-            }
-            ed.exportClause && (yield this.visit(ed.exportClause, p));
-            ed.moduleSpecifier && (yield this.visitLeftPaddedLocal("from", ed.moduleSpecifier, p));
-            ed.attributes && (yield this.visit(ed.attributes, p));
-            yield this.afterSyntax(ed, p);
-            return ed;
-        });
-    }
-    visitExportAssignment(es, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(es, p);
-            p.append("export");
-            yield this.visitLeftPaddedLocal(es.exportEquals ? "=" : "default", es.expression, p);
-            yield this.afterSyntax(es, p);
-            return es;
-        });
-    }
-    visitIndexedAccessType(iat, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(iat, p);
-            yield this.visit(iat.objectType, p);
-            // expect that this element is printed accordingly
-            // <space_before>[<inner_space_before>index<inner_right_padded_suffix_space>]<right_padded_suffix_space>
-            yield this.visit(iat.indexType, p);
-            yield this.afterSyntax(iat, p);
-            return iat;
-        });
-    }
-    visitIndexedAccessTypeIndexType(indexType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(indexType, p);
-            p.append("[");
-            yield this.visitRightPadded(indexType.element, p);
-            p.append("]");
-            yield this.afterSyntax(indexType, p);
-            return indexType;
-        });
-    }
-    visitWithStatement(withStatement, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(withStatement, p);
-            p.append("with");
-            yield this.visit(withStatement.expression, p);
-            yield this.visitRightPadded(withStatement.body, p);
-            yield this.afterSyntax(withStatement, p);
-            return withStatement;
-        });
-    }
-    visitExportSpecifier(es, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(es, p);
-            if (es.typeOnly.element) {
-                yield this.visitLeftPaddedLocal("type", es.typeOnly, p);
-            }
-            yield this.visit(es.specifier, p);
-            yield this.afterSyntax(es, p);
-            return es;
-        });
-    }
-    visitNamedExports(ne, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(ne, p);
-            yield this.visitContainerLocal("{", ne.elements, ",", "}", p);
-            yield this.afterSyntax(ne, p);
-            return ne;
-        });
-    }
-    visitImportAttributes(importAttributes, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(importAttributes, p);
-            p.append((importAttributes.token === tree_1.JS.ImportAttributes.Token.With ? "with" : "assert"));
-            yield this.visitContainerLocal("{", importAttributes.elements, ",", "}", p);
-            yield this.afterSyntax(importAttributes, p);
-            return importAttributes;
-        });
-    }
-    visitImportAttribute(importAttribute, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(importAttribute, p);
-            yield this.visit(importAttribute.name, p);
-            yield this.visitLeftPaddedLocal(":", importAttribute.value, p);
-            yield this.afterSyntax(importAttribute, p);
-            return importAttribute;
-        });
-    }
-    visitImportTypeAttributes(importAttributes, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(importAttributes, p);
-            p.append("{");
-            yield this.visitRightPadded(importAttributes.token, p);
-            p.append(":");
-            yield this.visitContainerLocal("{", importAttributes.elements, ",", "}", p);
-            yield this.visitSpace(importAttributes.end, p);
-            p.append("}");
-            yield this.afterSyntax(importAttributes, p);
-            return importAttributes;
-        });
-    }
-    visitArrayBindingPattern(abp, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(abp, p);
-            yield this.visitContainerLocal("[", abp.elements, ",", "]", p);
-            yield this.afterSyntax(abp, p);
-            return abp;
-        });
-    }
-    visitMappedType(mappedType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(mappedType, p);
-            p.append("{");
-            if (mappedType.prefixToken) {
-                yield this.visitLeftPadded(mappedType.prefixToken, p);
-            }
-            if (mappedType.hasReadonly.element) {
-                yield this.visitLeftPaddedLocal("readonly", mappedType.hasReadonly, p);
-            }
-            yield this.visitMappedTypeKeysRemapping(mappedType.keysRemapping, p);
-            if (mappedType.suffixToken) {
-                yield this.visitLeftPadded(mappedType.suffixToken, p);
-            }
-            if (mappedType.hasQuestionToken.element) {
-                yield this.visitLeftPaddedLocal("?", mappedType.hasQuestionToken, p);
-            }
-            const colon = mappedType.valueType.elements[0].element.kind === java_1.J.Kind.Empty ? "" : ":";
-            yield this.visitContainerLocal(colon, mappedType.valueType, "", "", p);
-            p.append("}");
-            yield this.afterSyntax(mappedType, p);
-            return mappedType;
-        });
-    }
-    visitMappedTypeKeysRemapping(mappedTypeKeys, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(mappedTypeKeys, p);
-            p.append("[");
-            yield this.visitRightPadded(mappedTypeKeys.typeParameter, p);
-            if (mappedTypeKeys.nameType) {
-                p.append("as");
-                yield this.visitRightPadded(mappedTypeKeys.nameType, p);
-            }
-            p.append("]");
-            yield this.afterSyntax(mappedTypeKeys, p);
-            return mappedTypeKeys;
-        });
-    }
-    visitMappedTypeParameter(mappedTypeParameter, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(mappedTypeParameter, p);
-            yield this.visit(mappedTypeParameter.name, p);
-            yield this.visitLeftPaddedLocal("in", mappedTypeParameter.iterateType, p);
-            yield this.afterSyntax(mappedTypeParameter, p);
-            return mappedTypeParameter;
-        });
-    }
-    visitObjectBindingPattern(objectBindingPattern, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(objectBindingPattern, p);
-            yield this.visitNodes(objectBindingPattern.leadingAnnotations, p);
-            for (const m of objectBindingPattern.modifiers) {
-                yield this.visitModifier(m, p);
+            await this.visit(method.name, p);
+        }
+        method.typeParameters && await this.visitContainerLocal("<", method.typeParameters, ",", ">", p);
+        await this.visitContainerLocal("(", method.arguments, ",", ")", p);
+        await this.afterSyntax(method, p);
+        return method;
+    }
+    async visitTypeParameter(typeParameter, p) {
+        await this.beforeSyntax(typeParameter, p);
+        await this.visitNodes(typeParameter.annotations, p);
+        for (const m of typeParameter.modifiers) {
+            await this.visitModifier(m, p);
+        }
+        await this.visit(typeParameter.name, p);
+        const bounds = typeParameter.bounds;
+        if (bounds) {
+            await this.visitSpace(bounds.before, p);
+            const constraintType = bounds.elements[0];
+            if (!(constraintType.element.kind === java_1.J.Kind.Empty)) {
+                p.append("extends");
+                await this.visitRightPadded(constraintType, p);
+            }
+            const defaultType = bounds.elements[1];
+            if (!(defaultType.element.kind === java_1.J.Kind.Empty)) {
+                p.append("=");
+                await this.visitRightPadded(defaultType, p);
             }
-            objectBindingPattern.typeExpression && (yield this.visit(objectBindingPattern.typeExpression, p));
-            yield this.visitContainerLocal("{", objectBindingPattern.bindings, ",", "}", p);
-            objectBindingPattern.initializer && (yield this.visitLeftPaddedLocal("=", objectBindingPattern.initializer, p));
-            yield this.afterSyntax(objectBindingPattern, p);
-            return objectBindingPattern;
-        });
-    }
-    visitTaggedTemplateExpression(taggedTemplateExpression, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(taggedTemplateExpression, p);
-            taggedTemplateExpression.tag && (yield this.visitRightPadded(taggedTemplateExpression.tag, p));
-            taggedTemplateExpression.typeArguments && (yield this.visitContainerLocal("<", taggedTemplateExpression.typeArguments, ",", ">", p));
-            yield this.visit(taggedTemplateExpression.templateExpression, p);
-            yield this.afterSyntax(taggedTemplateExpression, p);
-            return taggedTemplateExpression;
-        });
-    }
-    visitTemplateExpression(templateExpression, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(templateExpression, p);
-            yield this.visit(templateExpression.head, p);
-            yield this.visitRightPaddedLocal(templateExpression.spans, "", p);
-            yield this.afterSyntax(templateExpression, p);
-            return templateExpression;
-        });
-    }
-    visitTemplateExpressionSpan(value, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(value, p);
-            yield this.visit(value.expression, p);
-            yield this.visit(value.tail, p);
-            yield this.afterSyntax(value, p);
-            return value;
-        });
-    }
-    visitTuple(tuple, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(tuple, p);
-            yield this.visitContainerLocal("[", tuple.elements, ",", "]", p);
-            yield this.afterSyntax(tuple, p);
-            return tuple;
-        });
-    }
-    visitTypeQuery(typeQuery, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(typeQuery, p);
-            p.append("typeof");
-            yield this.visit(typeQuery.typeExpression, p);
-            typeQuery.typeArguments && (yield this.visitContainerLocal("<", typeQuery.typeArguments, ",", ">", p));
-            yield this.afterSyntax(typeQuery, p);
-            return typeQuery;
-        });
-    }
-    visitTypeOf(typeOf, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(typeOf, p);
+        }
+        await this.afterSyntax(typeParameter, p);
+        return typeParameter;
+    }
+    async visitArrowFunction(arrowFunction, p) {
+        await this.beforeSyntax(arrowFunction, p);
+        await this.visitNodes(arrowFunction.leadingAnnotations, p);
+        for (const m of arrowFunction.modifiers) {
+            await this.visitModifier(m, p);
+        }
+        const typeParameters = arrowFunction.typeParameters;
+        if (typeParameters) {
+            await this.visitNodes(typeParameters.annotations, p);
+            await this.visitSpace(typeParameters.prefix, p);
+            await this.visitMarkers(typeParameters.markers, p);
+            p.append("<");
+            await this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
+            p.append(">");
+        }
+        const lambda = arrowFunction.lambda;
+        if (lambda.parameters.parenthesized) {
+            await this.visitSpace(lambda.parameters.prefix, p);
+            p.append("(");
+            await this.visitRightPaddedLocal(lambda.parameters.parameters, ",", p);
+            p.append(")");
+        }
+        else {
+            await this.visitRightPaddedLocal(lambda.parameters.parameters, ",", p);
+        }
+        if (arrowFunction.returnTypeExpression) {
+            await this.visit(arrowFunction.returnTypeExpression, p);
+        }
+        await this.visitSpace(lambda.arrow, p);
+        p.append("=>");
+        await this.visit(lambda.body, p);
+        await this.afterSyntax(arrowFunction, p);
+        return arrowFunction;
+    }
+    async visitConditionalType(conditionalType, p) {
+        await this.beforeSyntax(conditionalType, p);
+        await this.visit(conditionalType.checkType, p);
+        await this.visitLeftPaddedLocal("extends", conditionalType.condition, p);
+        await this.afterSyntax(conditionalType, p);
+        return conditionalType;
+    }
+    async visitExpressionWithTypeArguments(type, p) {
+        await this.beforeSyntax(type, p);
+        await this.visit(type.clazz, p);
+        type.typeArguments && await this.visitContainerLocal("<", type.typeArguments, ",", ">", p);
+        await this.afterSyntax(type, p);
+        return type;
+    }
+    async visitImportType(importType, p) {
+        await this.beforeSyntax(importType, p);
+        if (importType.hasTypeof.element) {
             p.append("typeof");
-            yield this.visit(typeOf.expression, p);
-            yield this.afterSyntax(typeOf, p);
-            return typeOf;
-        });
-    }
-    visitComputedPropertyName(computedPropertyName, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(computedPropertyName, p);
-            p.append("[");
-            yield this.visitRightPaddedLocalSingle(computedPropertyName.expression, "]", p);
-            yield this.afterSyntax(computedPropertyName, p);
-            return computedPropertyName;
-        });
-    }
-    visitTypeOperator(typeOperator, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(typeOperator, p);
-            let keyword = "";
-            if (typeOperator.operator === tree_1.JS.TypeOperator.Type.ReadOnly) {
-                keyword = "readonly";
-            }
-            else if (typeOperator.operator === tree_1.JS.TypeOperator.Type.KeyOf) {
-                keyword = "keyof";
-            }
-            else if (typeOperator.operator === tree_1.JS.TypeOperator.Type.Unique) {
-                keyword = "unique";
-            }
-            p.append(keyword);
-            yield this.visitLeftPadded(typeOperator.expression, p);
-            yield this.afterSyntax(typeOperator, p);
-            return typeOperator;
-        });
-    }
-    visitTypePredicate(typePredicate, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(typePredicate, p);
-            if (typePredicate.asserts.element) {
-                yield this.visitLeftPaddedLocal("asserts", typePredicate.asserts, p);
-            }
-            yield this.visit(typePredicate.parameterName, p);
-            typePredicate.expression && (yield this.visitLeftPaddedLocal("is", typePredicate.expression, p));
-            yield this.afterSyntax(typePredicate, p);
-            return typePredicate;
-        });
-    }
-    visitIndexSignatureDeclaration(isd, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(isd, p);
-            for (const m of isd.modifiers) {
-                yield this.visitModifier(m, p);
-            }
-            yield this.visitContainerLocal("[", isd.parameters, "", "]", p);
-            yield this.visitLeftPaddedLocal(":", isd.typeExpression, p);
-            yield this.afterSyntax(isd, p);
-            return isd;
-        });
-    }
-    visitAnnotation(annotation, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(annotation, p);
-            p.append("@");
-            yield this.visit(annotation.annotationType, p);
-            annotation.arguments && (yield this.visitContainerLocal("(", annotation.arguments, ",", ")", p));
-            yield this.afterSyntax(annotation, p);
-            return annotation;
-        });
-    }
-    visitNewArray(newArray, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(newArray, p);
-            newArray.typeExpression && (yield this.visit(newArray.typeExpression, p));
-            yield this.visitNodes(newArray.dimensions, p);
-            newArray.initializer && (yield this.visitContainerLocal("[", newArray.initializer, ",", "]", p));
-            yield this.afterSyntax(newArray, p);
-            return newArray;
-        });
-    }
-    visitNewClass(newClass, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(newClass, p);
-            newClass.enclosing && (yield this.visitRightPaddedLocalSingle(newClass.enclosing, ".", p));
-            yield this.visitSpace(newClass.new, p);
-            if (newClass.class) {
-                p.append("new");
-                yield this.visit(newClass.class, p);
-                if (!newClass.arguments.markers.markers.find(m => m.kind === java_1.J.Markers.OmitParentheses)) {
-                    yield this.visitContainerLocal("(", newClass.arguments, ",", ")", p);
-                }
-            }
-            newClass.body && (yield this.visit(newClass.body, p));
-            yield this.afterSyntax(newClass, p);
-            return newClass;
-        });
-    }
-    visitSwitch(switch_, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(switch_, p);
-            p.append("switch");
-            yield this.visit(switch_.selector, p);
-            yield this.visit(switch_.cases, p);
-            yield this.afterSyntax(switch_, p);
-            return switch_;
-        });
-    }
-    visitCase(case_, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(case_, p);
-            const elem = case_.caseLabels.elements[0].element;
-            if (elem.kind !== java_1.J.Kind.Identifier || elem.simpleName !== "default") {
-                p.append("case");
-            }
-            yield this.visitContainerLocal("", case_.caseLabels, ",", "", p);
-            yield this.visitSpace(case_.statements.before, p);
-            p.append(case_.type === java_1.J.Case.Type.Statement ? ":" : "->");
-            yield this.visitStatements(case_.statements.elements, p);
-            yield this.afterSyntax(case_, p);
-            return case_;
-        });
-    }
-    visitLabel(label, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(label, p);
-            yield this.visitRightPaddedLocalSingle(label.label, ":", p);
-            yield this.visit(label.statement, p);
-            yield this.afterSyntax(label, p);
-            return label;
-        });
-    }
-    visitContinue(continueStatement, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(continueStatement, p);
-            p.append("continue");
-            continueStatement.label && (yield this.visit(continueStatement.label, p));
-            yield this.afterSyntax(continueStatement, p);
-            return continueStatement;
-        });
-    }
-    visitBreak(breakStatement, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(breakStatement, p);
-            p.append("break");
-            breakStatement.label && (yield this.visit(breakStatement.label, p));
-            yield this.afterSyntax(breakStatement, p);
-            return breakStatement;
-        });
-    }
-    visitFieldAccess(fieldAccess, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(fieldAccess, p);
-            yield this.visit(fieldAccess.target, p);
-            yield this.visitLeftPaddedLocal(".", fieldAccess.name, p);
-            yield this.afterSyntax(fieldAccess, p);
-            return fieldAccess;
-        });
-    }
-    visitTypeLiteral(tl, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(tl, p);
-            yield this.visit(tl.members, p);
-            yield this.afterSyntax(tl, p);
-            return tl;
-        });
-    }
-    visitParentheses(parens, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(parens, p);
-            p.append('(');
-            yield this.visitRightPaddedLocalSingle(parens.tree, ")", p);
-            yield this.afterSyntax(parens, p);
-            return parens;
-        });
-    }
-    visitParameterizedType(type, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(type, p);
-            yield this.visit(type.class, p);
-            type.typeParameters && (yield this.visitContainerLocal("<", type.typeParameters, ",", ">", p));
-            yield this.afterSyntax(type, p);
-            return type;
-        });
-    }
-    visitAs(as_, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(as_, p);
-            yield this.visitRightPadded(as_.left, p);
+            await this.visitRightPadded(importType.hasTypeof, p);
+        }
+        p.append("import");
+        await this.visitContainerLocal("(", importType.argumentAndAttributes, ",", ")", p);
+        importType.qualifier && await this.visitLeftPaddedLocal(".", importType.qualifier, p);
+        importType.typeArguments && await this.visitContainerLocal("<", importType.typeArguments, ",", ">", p);
+        await this.afterSyntax(importType, p);
+        return importType;
+    }
+    async visitTypeDeclaration(typeDeclaration, p) {
+        await this.beforeSyntax(typeDeclaration, p);
+        for (const m of typeDeclaration.modifiers) {
+            await this.visitModifier(m, p);
+        }
+        await this.visitLeftPaddedLocal("type", typeDeclaration.name, p);
+        const typeParameters = typeDeclaration.typeParameters;
+        if (typeParameters) {
+            await this.visitNodes(typeParameters.annotations, p);
+            await this.visitSpace(typeParameters.prefix, p);
+            await this.visitMarkers(typeParameters.markers, p);
+            p.append("<");
+            await this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
+            p.append(">");
+        }
+        await this.visitLeftPaddedLocal("=", typeDeclaration.initializer, p);
+        await this.afterSyntax(typeDeclaration, p);
+        return typeDeclaration;
+    }
+    async visitLiteralType(literalType, p) {
+        await this.beforeSyntax(literalType, p);
+        await this.visit(literalType.literal, p);
+        await this.afterSyntax(literalType, p);
+        return literalType;
+    }
+    async visitNamedImports(namedImports, p) {
+        await this.beforeSyntax(namedImports, p);
+        await this.visitContainerLocal("{", namedImports.elements, ",", "}", p);
+        await this.afterSyntax(namedImports, p);
+        return namedImports;
+    }
+    async visitImportSpecifier(jis, p) {
+        await this.beforeSyntax(jis, p);
+        if (jis.importType.element) {
+            await this.visitLeftPaddedLocal("type", jis.importType, p);
+        }
+        await this.visit(jis.specifier, p);
+        await this.afterSyntax(jis, p);
+        return jis;
+    }
+    async visitExportDeclaration(ed, p) {
+        await this.beforeSyntax(ed, p);
+        p.append("export");
+        for (const it of ed.modifiers) {
+            await this.visitModifier(it, p);
+        }
+        if (ed.typeOnly.element) {
+            await this.visitLeftPaddedLocal("type", ed.typeOnly, p);
+        }
+        ed.exportClause && await this.visit(ed.exportClause, p);
+        ed.moduleSpecifier && await this.visitLeftPaddedLocal("from", ed.moduleSpecifier, p);
+        ed.attributes && await this.visit(ed.attributes, p);
+        await this.afterSyntax(ed, p);
+        return ed;
+    }
+    async visitExportAssignment(es, p) {
+        await this.beforeSyntax(es, p);
+        p.append("export");
+        await this.visitLeftPaddedLocal(es.exportEquals ? "=" : "default", es.expression, p);
+        await this.afterSyntax(es, p);
+        return es;
+    }
+    async visitIndexedAccessType(iat, p) {
+        await this.beforeSyntax(iat, p);
+        await this.visit(iat.objectType, p);
+        // expect that this element is printed accordingly
+        // <space_before>[<inner_space_before>index<inner_right_padded_suffix_space>]<right_padded_suffix_space>
+        await this.visit(iat.indexType, p);
+        await this.afterSyntax(iat, p);
+        return iat;
+    }
+    async visitIndexedAccessTypeIndexType(indexType, p) {
+        await this.beforeSyntax(indexType, p);
+        p.append("[");
+        await this.visitRightPadded(indexType.element, p);
+        p.append("]");
+        await this.afterSyntax(indexType, p);
+        return indexType;
+    }
+    async visitWithStatement(withStatement, p) {
+        await this.beforeSyntax(withStatement, p);
+        p.append("with");
+        await this.visit(withStatement.expression, p);
+        await this.visitRightPadded(withStatement.body, p);
+        await this.afterSyntax(withStatement, p);
+        return withStatement;
+    }
+    async visitExportSpecifier(es, p) {
+        await this.beforeSyntax(es, p);
+        if (es.typeOnly.element) {
+            await this.visitLeftPaddedLocal("type", es.typeOnly, p);
+        }
+        await this.visit(es.specifier, p);
+        await this.afterSyntax(es, p);
+        return es;
+    }
+    async visitNamedExports(ne, p) {
+        await this.beforeSyntax(ne, p);
+        await this.visitContainerLocal("{", ne.elements, ",", "}", p);
+        await this.afterSyntax(ne, p);
+        return ne;
+    }
+    async visitImportAttributes(importAttributes, p) {
+        await this.beforeSyntax(importAttributes, p);
+        p.append((importAttributes.token === tree_1.JS.ImportAttributes.Token.With ? "with" : "assert"));
+        await this.visitContainerLocal("{", importAttributes.elements, ",", "}", p);
+        await this.afterSyntax(importAttributes, p);
+        return importAttributes;
+    }
+    async visitImportAttribute(importAttribute, p) {
+        await this.beforeSyntax(importAttribute, p);
+        await this.visit(importAttribute.name, p);
+        await this.visitLeftPaddedLocal(":", importAttribute.value, p);
+        await this.afterSyntax(importAttribute, p);
+        return importAttribute;
+    }
+    async visitImportTypeAttributes(importAttributes, p) {
+        await this.beforeSyntax(importAttributes, p);
+        p.append("{");
+        await this.visitRightPadded(importAttributes.token, p);
+        p.append(":");
+        await this.visitContainerLocal("{", importAttributes.elements, ",", "}", p);
+        await this.visitSpace(importAttributes.end, p);
+        p.append("}");
+        await this.afterSyntax(importAttributes, p);
+        return importAttributes;
+    }
+    async visitArrayBindingPattern(abp, p) {
+        await this.beforeSyntax(abp, p);
+        await this.visitContainerLocal("[", abp.elements, ",", "]", p);
+        await this.afterSyntax(abp, p);
+        return abp;
+    }
+    async visitMappedType(mappedType, p) {
+        await this.beforeSyntax(mappedType, p);
+        p.append("{");
+        if (mappedType.prefixToken) {
+            await this.visitLeftPadded(mappedType.prefixToken, p);
+        }
+        if (mappedType.hasReadonly.element) {
+            await this.visitLeftPaddedLocal("readonly", mappedType.hasReadonly, p);
+        }
+        await this.visitMappedTypeKeysRemapping(mappedType.keysRemapping, p);
+        if (mappedType.suffixToken) {
+            await this.visitLeftPadded(mappedType.suffixToken, p);
+        }
+        if (mappedType.hasQuestionToken.element) {
+            await this.visitLeftPaddedLocal("?", mappedType.hasQuestionToken, p);
+        }
+        const colon = mappedType.valueType.elements[0].element.kind === java_1.J.Kind.Empty ? "" : ":";
+        await this.visitContainerLocal(colon, mappedType.valueType, "", "", p);
+        p.append("}");
+        await this.afterSyntax(mappedType, p);
+        return mappedType;
+    }
+    async visitMappedTypeKeysRemapping(mappedTypeKeys, p) {
+        await this.beforeSyntax(mappedTypeKeys, p);
+        p.append("[");
+        await this.visitRightPadded(mappedTypeKeys.typeParameter, p);
+        if (mappedTypeKeys.nameType) {
             p.append("as");
-            yield this.visit(as_.right, p);
-            yield this.afterSyntax(as_, p);
-            return as_;
-        });
-    }
-    visitAssignment(assignment, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(assignment, p);
-            yield this.visit(assignment.variable, p);
-            yield this.visitLeftPaddedLocal("=", assignment.assignment, p);
-            yield this.afterSyntax(assignment, p);
-            return assignment;
-        });
-    }
-    visitPropertyAssignment(propertyAssignment, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(propertyAssignment, p);
-            yield this.visitRightPadded(propertyAssignment.name, p);
-            if (propertyAssignment.initializer) {
-                // if the property is not null, we should print it like `{ a: b }`
-                // otherwise, it is a shorthand assignment where we have stuff like `{ a }` only
-                if (propertyAssignment.assigmentToken === tree_1.JS.PropertyAssignment.Token.Colon) {
-                    p.append(':');
-                }
-                else if (propertyAssignment.assigmentToken === tree_1.JS.PropertyAssignment.Token.Equals) {
-                    p.append('=');
-                }
-                yield this.visit(propertyAssignment.initializer, p);
-            }
-            yield this.afterSyntax(propertyAssignment, p);
-            return propertyAssignment;
-        });
-    }
-    visitAssignmentOperation(assignOp, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let keyword = "";
-            switch (assignOp.operator.element) {
-                case java_1.J.AssignmentOperation.Type.Addition:
-                    keyword = "+=";
-                    break;
-                case java_1.J.AssignmentOperation.Type.Subtraction:
-                    keyword = "-=";
-                    break;
-                case java_1.J.AssignmentOperation.Type.Multiplication:
-                    keyword = "*=";
-                    break;
-                case java_1.J.AssignmentOperation.Type.Division:
-                    keyword = "/=";
-                    break;
-                case java_1.J.AssignmentOperation.Type.Modulo:
-                    keyword = "%=";
-                    break;
-                case java_1.J.AssignmentOperation.Type.BitAnd:
-                    keyword = "&=";
-                    break;
-                case java_1.J.AssignmentOperation.Type.BitOr:
-                    keyword = "|=";
-                    break;
-                case java_1.J.AssignmentOperation.Type.BitXor:
-                    keyword = "^=";
-                    break;
-                case java_1.J.AssignmentOperation.Type.LeftShift:
-                    keyword = "<<=";
-                    break;
-                case java_1.J.AssignmentOperation.Type.RightShift:
-                    keyword = ">>=";
-                    break;
-                case java_1.J.AssignmentOperation.Type.UnsignedRightShift:
-                    keyword = ">>>=";
-                    break;
-            }
-            yield this.beforeSyntax(assignOp, p);
-            yield this.visit(assignOp.variable, p);
-            yield this.visitSpace(assignOp.operator.before, p);
-            p.append(keyword);
-            yield this.visit(assignOp.assignment, p);
-            yield this.afterSyntax(assignOp, p);
-            return assignOp;
-        });
-    }
-    visitAssignmentOperationExtensions(assignOp, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let keyword = "";
-            switch (assignOp.operator.element) {
-                case tree_1.JS.AssignmentOperation.Type.QuestionQuestion:
-                    keyword = "??=";
-                    break;
-                case tree_1.JS.AssignmentOperation.Type.And:
-                    keyword = "&&=";
-                    break;
-                case tree_1.JS.AssignmentOperation.Type.Or:
-                    keyword = "||=";
-                    break;
-                case tree_1.JS.AssignmentOperation.Type.Power:
-                    keyword = "**";
-                    break;
-                case tree_1.JS.AssignmentOperation.Type.Exp:
-                    keyword = "**=";
-                    break;
-            }
-            yield this.beforeSyntax(assignOp, p);
-            yield this.visit(assignOp.variable, p);
-            yield this.visitSpace(assignOp.operator.before, p);
-            p.append(keyword);
-            yield this.visit(assignOp.assignment, p);
-            yield this.afterSyntax(assignOp, p);
-            return assignOp;
-        });
-    }
-    visitEnumValue(enum_, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(enum_, p);
-            yield this.visit(enum_.name, p);
-            const initializer = enum_.initializer;
-            if (initializer) {
-                yield this.visitSpace(initializer.prefix, p);
-                p.append("=");
-                // There can be only one argument
-                const expression = initializer.arguments.elements[0];
-                yield this.visitRightPadded(expression, p);
-                return enum_;
+            await this.visitRightPadded(mappedTypeKeys.nameType, p);
+        }
+        p.append("]");
+        await this.afterSyntax(mappedTypeKeys, p);
+        return mappedTypeKeys;
+    }
+    async visitMappedTypeParameter(mappedTypeParameter, p) {
+        await this.beforeSyntax(mappedTypeParameter, p);
+        await this.visit(mappedTypeParameter.name, p);
+        await this.visitLeftPaddedLocal("in", mappedTypeParameter.iterateType, p);
+        await this.afterSyntax(mappedTypeParameter, p);
+        return mappedTypeParameter;
+    }
+    async visitObjectBindingPattern(objectBindingPattern, p) {
+        await this.beforeSyntax(objectBindingPattern, p);
+        await this.visitNodes(objectBindingPattern.leadingAnnotations, p);
+        for (const m of objectBindingPattern.modifiers) {
+            await this.visitModifier(m, p);
+        }
+        objectBindingPattern.typeExpression && await this.visit(objectBindingPattern.typeExpression, p);
+        await this.visitContainerLocal("{", objectBindingPattern.bindings, ",", "}", p);
+        objectBindingPattern.initializer && await this.visitLeftPaddedLocal("=", objectBindingPattern.initializer, p);
+        await this.afterSyntax(objectBindingPattern, p);
+        return objectBindingPattern;
+    }
+    async visitTaggedTemplateExpression(taggedTemplateExpression, p) {
+        await this.beforeSyntax(taggedTemplateExpression, p);
+        taggedTemplateExpression.tag && await this.visitRightPadded(taggedTemplateExpression.tag, p);
+        taggedTemplateExpression.typeArguments && await this.visitContainerLocal("<", taggedTemplateExpression.typeArguments, ",", ">", p);
+        await this.visit(taggedTemplateExpression.templateExpression, p);
+        await this.afterSyntax(taggedTemplateExpression, p);
+        return taggedTemplateExpression;
+    }
+    async visitTemplateExpression(templateExpression, p) {
+        await this.beforeSyntax(templateExpression, p);
+        await this.visit(templateExpression.head, p);
+        await this.visitRightPaddedLocal(templateExpression.spans, "", p);
+        await this.afterSyntax(templateExpression, p);
+        return templateExpression;
+    }
+    async visitTemplateExpressionSpan(value, p) {
+        await this.beforeSyntax(value, p);
+        await this.visit(value.expression, p);
+        await this.visit(value.tail, p);
+        await this.afterSyntax(value, p);
+        return value;
+    }
+    async visitTuple(tuple, p) {
+        await this.beforeSyntax(tuple, p);
+        await this.visitContainerLocal("[", tuple.elements, ",", "]", p);
+        await this.afterSyntax(tuple, p);
+        return tuple;
+    }
+    async visitTypeQuery(typeQuery, p) {
+        await this.beforeSyntax(typeQuery, p);
+        p.append("typeof");
+        await this.visit(typeQuery.typeExpression, p);
+        typeQuery.typeArguments && await this.visitContainerLocal("<", typeQuery.typeArguments, ",", ">", p);
+        await this.afterSyntax(typeQuery, p);
+        return typeQuery;
+    }
+    async visitTypeOf(typeOf, p) {
+        await this.beforeSyntax(typeOf, p);
+        p.append("typeof");
+        await this.visit(typeOf.expression, p);
+        await this.afterSyntax(typeOf, p);
+        return typeOf;
+    }
+    async visitComputedPropertyName(computedPropertyName, p) {
+        await this.beforeSyntax(computedPropertyName, p);
+        p.append("[");
+        await this.visitRightPaddedLocalSingle(computedPropertyName.expression, "]", p);
+        await this.afterSyntax(computedPropertyName, p);
+        return computedPropertyName;
+    }
+    async visitTypeOperator(typeOperator, p) {
+        await this.beforeSyntax(typeOperator, p);
+        let keyword = "";
+        if (typeOperator.operator === tree_1.JS.TypeOperator.Type.ReadOnly) {
+            keyword = "readonly";
+        }
+        else if (typeOperator.operator === tree_1.JS.TypeOperator.Type.KeyOf) {
+            keyword = "keyof";
+        }
+        else if (typeOperator.operator === tree_1.JS.TypeOperator.Type.Unique) {
+            keyword = "unique";
+        }
+        p.append(keyword);
+        await this.visitLeftPadded(typeOperator.expression, p);
+        await this.afterSyntax(typeOperator, p);
+        return typeOperator;
+    }
+    async visitTypePredicate(typePredicate, p) {
+        await this.beforeSyntax(typePredicate, p);
+        if (typePredicate.asserts.element) {
+            await this.visitLeftPaddedLocal("asserts", typePredicate.asserts, p);
+        }
+        await this.visit(typePredicate.parameterName, p);
+        typePredicate.expression && await this.visitLeftPaddedLocal("is", typePredicate.expression, p);
+        await this.afterSyntax(typePredicate, p);
+        return typePredicate;
+    }
+    async visitIndexSignatureDeclaration(isd, p) {
+        await this.beforeSyntax(isd, p);
+        for (const m of isd.modifiers) {
+            await this.visitModifier(m, p);
+        }
+        await this.visitContainerLocal("[", isd.parameters, "", "]", p);
+        await this.visitLeftPaddedLocal(":", isd.typeExpression, p);
+        await this.afterSyntax(isd, p);
+        return isd;
+    }
+    async visitAnnotation(annotation, p) {
+        await this.beforeSyntax(annotation, p);
+        p.append("@");
+        await this.visit(annotation.annotationType, p);
+        annotation.arguments && await this.visitContainerLocal("(", annotation.arguments, ",", ")", p);
+        await this.afterSyntax(annotation, p);
+        return annotation;
+    }
+    async visitNewArray(newArray, p) {
+        await this.beforeSyntax(newArray, p);
+        newArray.typeExpression && await this.visit(newArray.typeExpression, p);
+        await this.visitNodes(newArray.dimensions, p);
+        newArray.initializer && await this.visitContainerLocal("[", newArray.initializer, ",", "]", p);
+        await this.afterSyntax(newArray, p);
+        return newArray;
+    }
+    async visitNewClass(newClass, p) {
+        await this.beforeSyntax(newClass, p);
+        newClass.enclosing && await this.visitRightPaddedLocalSingle(newClass.enclosing, ".", p);
+        await this.visitSpace(newClass.new, p);
+        if (newClass.class) {
+            p.append("new");
+            await this.visit(newClass.class, p);
+            if (!newClass.arguments.markers.markers.find(m => m.kind === java_1.J.Markers.OmitParentheses)) {
+                await this.visitContainerLocal("(", newClass.arguments, ",", ")", p);
             }
-            yield this.afterSyntax(enum_, p);
+        }
+        newClass.body && await this.visit(newClass.body, p);
+        await this.afterSyntax(newClass, p);
+        return newClass;
+    }
+    async visitSwitch(switch_, p) {
+        await this.beforeSyntax(switch_, p);
+        p.append("switch");
+        await this.visit(switch_.selector, p);
+        await this.visit(switch_.cases, p);
+        await this.afterSyntax(switch_, p);
+        return switch_;
+    }
+    async visitCase(case_, p) {
+        await this.beforeSyntax(case_, p);
+        const elem = case_.caseLabels.elements[0].element;
+        if (elem.kind !== java_1.J.Kind.Identifier || elem.simpleName !== "default") {
+            p.append("case");
+        }
+        await this.visitContainerLocal("", case_.caseLabels, ",", "", p);
+        await this.visitSpace(case_.statements.before, p);
+        p.append(case_.type === java_1.J.Case.Type.Statement ? ":" : "->");
+        await this.visitStatements(case_.statements.elements, p);
+        await this.afterSyntax(case_, p);
+        return case_;
+    }
+    async visitLabel(label, p) {
+        await this.beforeSyntax(label, p);
+        await this.visitRightPaddedLocalSingle(label.label, ":", p);
+        await this.visit(label.statement, p);
+        await this.afterSyntax(label, p);
+        return label;
+    }
+    async visitContinue(continueStatement, p) {
+        await this.beforeSyntax(continueStatement, p);
+        p.append("continue");
+        continueStatement.label && await this.visit(continueStatement.label, p);
+        await this.afterSyntax(continueStatement, p);
+        return continueStatement;
+    }
+    async visitBreak(breakStatement, p) {
+        await this.beforeSyntax(breakStatement, p);
+        p.append("break");
+        breakStatement.label && await this.visit(breakStatement.label, p);
+        await this.afterSyntax(breakStatement, p);
+        return breakStatement;
+    }
+    async visitFieldAccess(fieldAccess, p) {
+        await this.beforeSyntax(fieldAccess, p);
+        await this.visit(fieldAccess.target, p);
+        await this.visitLeftPaddedLocal(".", fieldAccess.name, p);
+        await this.afterSyntax(fieldAccess, p);
+        return fieldAccess;
+    }
+    async visitTypeLiteral(tl, p) {
+        await this.beforeSyntax(tl, p);
+        await this.visit(tl.members, p);
+        await this.afterSyntax(tl, p);
+        return tl;
+    }
+    async visitParentheses(parens, p) {
+        await this.beforeSyntax(parens, p);
+        p.append('(');
+        await this.visitRightPaddedLocalSingle(parens.tree, ")", p);
+        await this.afterSyntax(parens, p);
+        return parens;
+    }
+    async visitParameterizedType(type, p) {
+        await this.beforeSyntax(type, p);
+        await this.visit(type.class, p);
+        type.typeParameters && await this.visitContainerLocal("<", type.typeParameters, ",", ">", p);
+        await this.afterSyntax(type, p);
+        return type;
+    }
+    async visitAs(as_, p) {
+        await this.beforeSyntax(as_, p);
+        await this.visitRightPadded(as_.left, p);
+        p.append("as");
+        await this.visit(as_.right, p);
+        await this.afterSyntax(as_, p);
+        return as_;
+    }
+    async visitAssignment(assignment, p) {
+        await this.beforeSyntax(assignment, p);
+        await this.visit(assignment.variable, p);
+        await this.visitLeftPaddedLocal("=", assignment.assignment, p);
+        await this.afterSyntax(assignment, p);
+        return assignment;
+    }
+    async visitPropertyAssignment(propertyAssignment, p) {
+        await this.beforeSyntax(propertyAssignment, p);
+        await this.visitRightPadded(propertyAssignment.name, p);
+        if (propertyAssignment.initializer) {
+            // if the property is not null, we should print it like `{ a: b }`
+            // otherwise, it is a shorthand assignment where we have stuff like `{ a }` only
+            if (propertyAssignment.assigmentToken === tree_1.JS.PropertyAssignment.Token.Colon) {
+                p.append(':');
+            }
+            else if (propertyAssignment.assigmentToken === tree_1.JS.PropertyAssignment.Token.Equals) {
+                p.append('=');
+            }
+            await this.visit(propertyAssignment.initializer, p);
+        }
+        await this.afterSyntax(propertyAssignment, p);
+        return propertyAssignment;
+    }
+    async visitAssignmentOperation(assignOp, p) {
+        let keyword = "";
+        switch (assignOp.operator.element) {
+            case java_1.J.AssignmentOperation.Type.Addition:
+                keyword = "+=";
+                break;
+            case java_1.J.AssignmentOperation.Type.Subtraction:
+                keyword = "-=";
+                break;
+            case java_1.J.AssignmentOperation.Type.Multiplication:
+                keyword = "*=";
+                break;
+            case java_1.J.AssignmentOperation.Type.Division:
+                keyword = "/=";
+                break;
+            case java_1.J.AssignmentOperation.Type.Modulo:
+                keyword = "%=";
+                break;
+            case java_1.J.AssignmentOperation.Type.BitAnd:
+                keyword = "&=";
+                break;
+            case java_1.J.AssignmentOperation.Type.BitOr:
+                keyword = "|=";
+                break;
+            case java_1.J.AssignmentOperation.Type.BitXor:
+                keyword = "^=";
+                break;
+            case java_1.J.AssignmentOperation.Type.LeftShift:
+                keyword = "<<=";
+                break;
+            case java_1.J.AssignmentOperation.Type.RightShift:
+                keyword = ">>=";
+                break;
+            case java_1.J.AssignmentOperation.Type.UnsignedRightShift:
+                keyword = ">>>=";
+                break;
+        }
+        await this.beforeSyntax(assignOp, p);
+        await this.visit(assignOp.variable, p);
+        await this.visitSpace(assignOp.operator.before, p);
+        p.append(keyword);
+        await this.visit(assignOp.assignment, p);
+        await this.afterSyntax(assignOp, p);
+        return assignOp;
+    }
+    async visitAssignmentOperationExtensions(assignOp, p) {
+        let keyword = "";
+        switch (assignOp.operator.element) {
+            case tree_1.JS.AssignmentOperation.Type.QuestionQuestion:
+                keyword = "??=";
+                break;
+            case tree_1.JS.AssignmentOperation.Type.And:
+                keyword = "&&=";
+                break;
+            case tree_1.JS.AssignmentOperation.Type.Or:
+                keyword = "||=";
+                break;
+            case tree_1.JS.AssignmentOperation.Type.Power:
+                keyword = "**";
+                break;
+            case tree_1.JS.AssignmentOperation.Type.Exp:
+                keyword = "**=";
+                break;
+        }
+        await this.beforeSyntax(assignOp, p);
+        await this.visit(assignOp.variable, p);
+        await this.visitSpace(assignOp.operator.before, p);
+        p.append(keyword);
+        await this.visit(assignOp.assignment, p);
+        await this.afterSyntax(assignOp, p);
+        return assignOp;
+    }
+    async visitEnumValue(enum_, p) {
+        await this.beforeSyntax(enum_, p);
+        await this.visit(enum_.name, p);
+        const initializer = enum_.initializer;
+        if (initializer) {
+            await this.visitSpace(initializer.prefix, p);
+            p.append("=");
+            // There can be only one argument
+            const expression = initializer.arguments.elements[0];
+            await this.visitRightPadded(expression, p);
             return enum_;
-        });
+        }
+        await this.afterSyntax(enum_, p);
+        return enum_;
+    }
+    async visitEnumValueSet(enums, p) {
+        await this.beforeSyntax(enums, p);
+        await this.visitRightPaddedLocal(enums.enums, ",", p);
+        if (enums.terminatedWithSemicolon) {
+            p.append(",");
+        }
+        await this.afterSyntax(enums, p);
+        return enums;
+    }
+    async visitBinary(binary, p) {
+        let keyword = "";
+        switch (binary.operator.element) {
+            case java_1.J.Binary.Type.Addition:
+                keyword = "+";
+                break;
+            case java_1.J.Binary.Type.Subtraction:
+                keyword = "-";
+                break;
+            case java_1.J.Binary.Type.Multiplication:
+                keyword = "*";
+                break;
+            case java_1.J.Binary.Type.Division:
+                keyword = "/";
+                break;
+            case java_1.J.Binary.Type.Modulo:
+                keyword = "%";
+                break;
+            case java_1.J.Binary.Type.LessThan:
+                keyword = "<";
+                break;
+            case java_1.J.Binary.Type.GreaterThan:
+                keyword = ">";
+                break;
+            case java_1.J.Binary.Type.LessThanOrEqual:
+                keyword = "<=";
+                break;
+            case java_1.J.Binary.Type.GreaterThanOrEqual:
+                keyword = ">=";
+                break;
+            case java_1.J.Binary.Type.Equal:
+                keyword = "==";
+                break;
+            case java_1.J.Binary.Type.NotEqual:
+                keyword = "!=";
+                break;
+            case java_1.J.Binary.Type.BitAnd:
+                keyword = "&";
+                break;
+            case java_1.J.Binary.Type.BitOr:
+                keyword = "|";
+                break;
+            case java_1.J.Binary.Type.BitXor:
+                keyword = "^";
+                break;
+            case java_1.J.Binary.Type.LeftShift:
+                keyword = "<<";
+                break;
+            case java_1.J.Binary.Type.RightShift:
+                keyword = ">>";
+                break;
+            case java_1.J.Binary.Type.UnsignedRightShift:
+                keyword = ">>>";
+                break;
+            case java_1.J.Binary.Type.Or:
+                keyword = "||";
+                break;
+            case java_1.J.Binary.Type.And:
+                keyword = "&&";
+                break;
+        }
+        await this.beforeSyntax(binary, p);
+        await this.visit(binary.left, p);
+        await this.visitSpace(binary.operator.before, p);
+        p.append(keyword);
+        await this.visit(binary.right, p);
+        await this.afterSyntax(binary, p);
+        return binary;
+    }
+    async visitBinaryExtensions(binary, p) {
+        await this.beforeSyntax(binary, p);
+        await this.visit(binary.left, p);
+        let keyword = "";
+        switch (binary.operator.element) {
+            case tree_1.JS.Binary.Type.IdentityEquals:
+                keyword = "===";
+                break;
+            case tree_1.JS.Binary.Type.IdentityNotEquals:
+                keyword = "!==";
+                break;
+            case tree_1.JS.Binary.Type.In:
+                keyword = "in";
+                break;
+            case tree_1.JS.Binary.Type.QuestionQuestion:
+                keyword = "??";
+                break;
+            case tree_1.JS.Binary.Type.Comma:
+                keyword = ",";
+                break;
+        }
+        await this.visitSpace(binary.operator.before, p);
+        p.append(keyword);
+        await this.visit(binary.right, p);
+        await this.afterSyntax(binary, p);
+        return binary;
+    }
+    async visitUnary(unary, p) {
+        await this.beforeSyntax(unary, p);
+        switch (unary.operator.element) {
+            case java_1.J.Unary.Type.PreIncrement:
+                p.append("++");
+                await this.visit(unary.expression, p);
+                break;
+            case java_1.J.Unary.Type.PreDecrement:
+                p.append("--");
+                await this.visit(unary.expression, p);
+                break;
+            case java_1.J.Unary.Type.PostIncrement:
+                await this.visit(unary.expression, p);
+                await this.visitSpace(unary.operator.before, p);
+                p.append("++");
+                break;
+            case java_1.J.Unary.Type.PostDecrement:
+                await this.visit(unary.expression, p);
+                await this.visitSpace(unary.operator.before, p);
+                p.append("--");
+                break;
+            case java_1.J.Unary.Type.Positive:
+                p.append('+');
+                await this.visit(unary.expression, p);
+                break;
+            case java_1.J.Unary.Type.Negative:
+                p.append('-');
+                await this.visit(unary.expression, p);
+                break;
+            case java_1.J.Unary.Type.Complement:
+                p.append('~');
+                await this.visit(unary.expression, p);
+                break;
+            case java_1.J.Unary.Type.Not:
+            default:
+                p.append('!');
+                await this.visit(unary.expression, p);
+        }
+        await this.afterSyntax(unary, p);
+        return unary;
+    }
+    async visitUnion(union, p) {
+        await this.beforeSyntax(union, p);
+        await this.visitRightPaddedLocal(union.types, "|", p);
+        await this.afterSyntax(union, p);
+        return union;
+    }
+    async visitIntersection(intersection, p) {
+        await this.beforeSyntax(intersection, p);
+        await this.visitRightPaddedLocal(intersection.types, "&", p);
+        await this.afterSyntax(intersection, p);
+        return intersection;
+    }
+    async visitForLoop(forLoop, p) {
+        await this.beforeSyntax(forLoop, p);
+        p.append("for");
+        const ctrl = forLoop.control;
+        await this.visitSpace(ctrl.prefix, p);
+        p.append('(');
+        await this.visitRightPaddedLocal(ctrl.init, ",", p);
+        p.append(';');
+        ctrl.condition && await this.visitRightPaddedLocalSingle(ctrl.condition, ";", p);
+        await this.visitRightPaddedLocal(ctrl.update, ",", p);
+        p.append(')');
+        await this.visitStatementLocal(forLoop.body, p);
+        await this.afterSyntax(forLoop, p);
+        return forLoop;
+    }
+    async visitForOfLoop(loop, p) {
+        await this.beforeSyntax(loop, p);
+        p.append("for");
+        if (loop.await) {
+            await this.visitSpace(loop.await, p);
+            p.append("await");
+        }
+        const control = loop.loop.control;
+        await this.visitSpace(control.prefix, p);
+        p.append('(');
+        await this.visitRightPadded(control.variable, p);
+        p.append("of");
+        await this.visitRightPadded(control.iterable, p);
+        p.append(')');
+        await this.visitRightPadded(loop.loop.body, p);
+        await this.afterSyntax(loop, p);
+        return loop;
+    }
+    async visitForInLoop(loop, p) {
+        await this.beforeSyntax(loop, p);
+        p.append("for");
+        const control = loop.control;
+        await this.visitSpace(control.prefix, p);
+        p.append('(');
+        await this.visitRightPadded(control.variable, p);
+        p.append("in");
+        await this.visitRightPadded(control.iterable, p);
+        p.append(')');
+        await this.visitRightPadded(loop.body, p);
+        await this.afterSyntax(loop, p);
+        return loop;
     }
-    visitEnumValueSet(enums, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(enums, p);
-            yield this.visitRightPaddedLocal(enums.enums, ",", p);
-            if (enums.terminatedWithSemicolon) {
+    // ---- print utils
+    async visitStatements(statements, p) {
+        var _a, _b;
+        const objectLiteral = ((_a = this.getParentCursor(0)) === null || _a === void 0 ? void 0 : _a.value.kind) === java_1.J.Kind.Block &&
+            ((_b = this.getParentCursor(1)) === null || _b === void 0 ? void 0 : _b.value.kind) === java_1.J.Kind.NewClass;
+        for (let i = 0; i < statements.length; i++) {
+            const paddedStat = statements[i];
+            await this.visitStatementLocal(paddedStat, p);
+            if (i < statements.length - 1 && objectLiteral) {
                 p.append(",");
             }
-            yield this.afterSyntax(enums, p);
-            return enums;
-        });
-    }
-    visitBinary(binary, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let keyword = "";
-            switch (binary.operator.element) {
-                case java_1.J.Binary.Type.Addition:
-                    keyword = "+";
-                    break;
-                case java_1.J.Binary.Type.Subtraction:
-                    keyword = "-";
-                    break;
-                case java_1.J.Binary.Type.Multiplication:
-                    keyword = "*";
-                    break;
-                case java_1.J.Binary.Type.Division:
-                    keyword = "/";
-                    break;
-                case java_1.J.Binary.Type.Modulo:
-                    keyword = "%";
-                    break;
-                case java_1.J.Binary.Type.LessThan:
-                    keyword = "<";
-                    break;
-                case java_1.J.Binary.Type.GreaterThan:
-                    keyword = ">";
-                    break;
-                case java_1.J.Binary.Type.LessThanOrEqual:
-                    keyword = "<=";
-                    break;
-                case java_1.J.Binary.Type.GreaterThanOrEqual:
-                    keyword = ">=";
-                    break;
-                case java_1.J.Binary.Type.Equal:
-                    keyword = "==";
-                    break;
-                case java_1.J.Binary.Type.NotEqual:
-                    keyword = "!=";
-                    break;
-                case java_1.J.Binary.Type.BitAnd:
-                    keyword = "&";
-                    break;
-                case java_1.J.Binary.Type.BitOr:
-                    keyword = "|";
-                    break;
-                case java_1.J.Binary.Type.BitXor:
-                    keyword = "^";
-                    break;
-                case java_1.J.Binary.Type.LeftShift:
-                    keyword = "<<";
-                    break;
-                case java_1.J.Binary.Type.RightShift:
-                    keyword = ">>";
-                    break;
-                case java_1.J.Binary.Type.UnsignedRightShift:
-                    keyword = ">>>";
-                    break;
-                case java_1.J.Binary.Type.Or:
-                    keyword = "||";
-                    break;
-                case java_1.J.Binary.Type.And:
-                    keyword = "&&";
-                    break;
-            }
-            yield this.beforeSyntax(binary, p);
-            yield this.visit(binary.left, p);
-            yield this.visitSpace(binary.operator.before, p);
-            p.append(keyword);
-            yield this.visit(binary.right, p);
-            yield this.afterSyntax(binary, p);
-            return binary;
-        });
-    }
-    visitBinaryExtensions(binary, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(binary, p);
-            yield this.visit(binary.left, p);
-            let keyword = "";
-            switch (binary.operator.element) {
-                case tree_1.JS.Binary.Type.IdentityEquals:
-                    keyword = "===";
-                    break;
-                case tree_1.JS.Binary.Type.IdentityNotEquals:
-                    keyword = "!==";
-                    break;
-                case tree_1.JS.Binary.Type.In:
-                    keyword = "in";
-                    break;
-                case tree_1.JS.Binary.Type.QuestionQuestion:
-                    keyword = "??";
-                    break;
-                case tree_1.JS.Binary.Type.Comma:
-                    keyword = ",";
-                    break;
-            }
-            yield this.visitSpace(binary.operator.before, p);
-            p.append(keyword);
-            yield this.visit(binary.right, p);
-            yield this.afterSyntax(binary, p);
-            return binary;
-        });
-    }
-    visitUnary(unary, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(unary, p);
-            switch (unary.operator.element) {
-                case java_1.J.Unary.Type.PreIncrement:
-                    p.append("++");
-                    yield this.visit(unary.expression, p);
-                    break;
-                case java_1.J.Unary.Type.PreDecrement:
-                    p.append("--");
-                    yield this.visit(unary.expression, p);
-                    break;
-                case java_1.J.Unary.Type.PostIncrement:
-                    yield this.visit(unary.expression, p);
-                    yield this.visitSpace(unary.operator.before, p);
-                    p.append("++");
-                    break;
-                case java_1.J.Unary.Type.PostDecrement:
-                    yield this.visit(unary.expression, p);
-                    yield this.visitSpace(unary.operator.before, p);
-                    p.append("--");
-                    break;
-                case java_1.J.Unary.Type.Positive:
-                    p.append('+');
-                    yield this.visit(unary.expression, p);
-                    break;
-                case java_1.J.Unary.Type.Negative:
-                    p.append('-');
-                    yield this.visit(unary.expression, p);
-                    break;
-                case java_1.J.Unary.Type.Complement:
-                    p.append('~');
-                    yield this.visit(unary.expression, p);
-                    break;
-                case java_1.J.Unary.Type.Not:
-                default:
-                    p.append('!');
-                    yield this.visit(unary.expression, p);
-            }
-            yield this.afterSyntax(unary, p);
-            return unary;
-        });
-    }
-    visitUnion(union, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(union, p);
-            yield this.visitRightPaddedLocal(union.types, "|", p);
-            yield this.afterSyntax(union, p);
-            return union;
-        });
-    }
-    visitIntersection(intersection, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(intersection, p);
-            yield this.visitRightPaddedLocal(intersection.types, "&", p);
-            yield this.afterSyntax(intersection, p);
-            return intersection;
-        });
-    }
-    visitForLoop(forLoop, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(forLoop, p);
-            p.append("for");
-            const ctrl = forLoop.control;
-            yield this.visitSpace(ctrl.prefix, p);
-            p.append('(');
-            yield this.visitRightPaddedLocal(ctrl.init, ",", p);
-            p.append(';');
-            ctrl.condition && (yield this.visitRightPaddedLocalSingle(ctrl.condition, ";", p));
-            yield this.visitRightPaddedLocal(ctrl.update, ",", p);
-            p.append(')');
-            yield this.visitStatementLocal(forLoop.body, p);
-            yield this.afterSyntax(forLoop, p);
-            return forLoop;
-        });
-    }
-    visitForOfLoop(loop, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(loop, p);
-            p.append("for");
-            if (loop.await) {
-                yield this.visitSpace(loop.await, p);
-                p.append("await");
-            }
-            const control = loop.loop.control;
-            yield this.visitSpace(control.prefix, p);
-            p.append('(');
-            yield this.visitRightPadded(control.variable, p);
-            p.append("of");
-            yield this.visitRightPadded(control.iterable, p);
-            p.append(')');
-            yield this.visitRightPadded(loop.loop.body, p);
-            yield this.afterSyntax(loop, p);
-            return loop;
-        });
-    }
-    visitForInLoop(loop, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntax(loop, p);
-            p.append("for");
-            const control = loop.control;
-            yield this.visitSpace(control.prefix, p);
-            p.append('(');
-            yield this.visitRightPadded(control.variable, p);
-            p.append("in");
-            yield this.visitRightPadded(control.iterable, p);
-            p.append(')');
-            yield this.visitRightPadded(loop.body, p);
-            yield this.afterSyntax(loop, p);
-            return loop;
-        });
+        }
     }
-    // ---- print utils
-    visitStatements(statements, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const objectLiteral = ((_a = this.getParentCursor(0)) === null || _a === void 0 ? void 0 : _a.value.kind) === java_1.J.Kind.Block &&
-                ((_b = this.getParentCursor(1)) === null || _b === void 0 ? void 0 : _b.value.kind) === java_1.J.Kind.NewClass;
-            for (let i = 0; i < statements.length; i++) {
-                const paddedStat = statements[i];
-                yield this.visitStatementLocal(paddedStat, p);
-                if (i < statements.length - 1 && objectLiteral) {
-                    p.append(",");
-                }
-            }
-        });
-    }
-    visitStatementLocal(paddedStat, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (paddedStat) {
-                yield this.visit(paddedStat.element, p);
-                yield this.visitSpace(paddedStat.after, p);
-                yield this.visitMarkers(paddedStat.markers, p);
-            }
-        });
+    async visitStatementLocal(paddedStat, p) {
+        if (paddedStat) {
+            await this.visit(paddedStat.element, p);
+            await this.visitSpace(paddedStat.after, p);
+            await this.visitMarkers(paddedStat.markers, p);
+        }
     }
     getParentCursor(levels) {
         let cursor = this.cursor;
@@ -1743,149 +1510,123 @@ class JavaScriptPrinter extends visitor_1.JavaScriptVisitor {
         }
         return cursor;
     }
-    afterSyntax(j, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.afterSyntaxMarkers(j.markers, p);
-        });
+    async afterSyntax(j, p) {
+        await this.afterSyntaxMarkers(j.markers, p);
     }
-    afterSyntaxMarkers(markers, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const marker of markers.markers) {
-                p.append(p.markerPrinter.afterSyntax(marker, new tree_2.Cursor(marker, this.cursor), this.JAVA_SCRIPT_MARKER_WRAPPER));
-            }
-        });
+    async afterSyntaxMarkers(markers, p) {
+        for (const marker of markers.markers) {
+            p.append(p.markerPrinter.afterSyntax(marker, new tree_2.Cursor(marker, this.cursor), this.JAVA_SCRIPT_MARKER_WRAPPER));
+        }
     }
-    beforeSyntax(j, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.beforeSyntaxExt(j.prefix, j.markers, p);
-        });
+    async beforeSyntax(j, p) {
+        await this.beforeSyntaxExt(j.prefix, j.markers, p);
     }
-    beforeSyntaxExt(prefix, markers, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const marker of markers.markers) {
-                p.append(p.markerPrinter.beforePrefix(marker, new tree_2.Cursor(marker, this.cursor), this.JAVA_SCRIPT_MARKER_WRAPPER));
-            }
-            yield this.visitSpace(prefix, p);
-            yield this.visitMarkers(markers, p);
-            for (const marker of markers.markers) {
-                p.append(p.markerPrinter.beforeSyntax(marker, new tree_2.Cursor(marker, this.cursor), this.JAVA_SCRIPT_MARKER_WRAPPER));
-            }
-        });
-    }
-    visitSpace(space, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            p.append(space.whitespace);
-            const comments = space.comments;
-            for (let i = 0; i < comments.length; i++) {
-                const comment = comments[i];
-                yield this.visitMarkers(comment.markers, p);
-                this.printComment(comment, this.cursor, p);
-                p.append(comment.suffix);
-            }
-            return space;
-        });
-    }
-    visitRightPaddedLocal(nodes, suffixBetween, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let i = 0; i < nodes.length; i++) {
-                const node = nodes[i];
-                yield this.visit(node.element, p);
-                yield this.visitSpace(node.after, p);
-                yield this.visitMarkers(node.markers, p);
-                if (i < nodes.length - 1) {
-                    p.append(suffixBetween);
-                }
-            }
-        });
+    async beforeSyntaxExt(prefix, markers, p) {
+        for (const marker of markers.markers) {
+            p.append(p.markerPrinter.beforePrefix(marker, new tree_2.Cursor(marker, this.cursor), this.JAVA_SCRIPT_MARKER_WRAPPER));
+        }
+        await this.visitSpace(prefix, p);
+        await this.visitMarkers(markers, p);
+        for (const marker of markers.markers) {
+            p.append(p.markerPrinter.beforeSyntax(marker, new tree_2.Cursor(marker, this.cursor), this.JAVA_SCRIPT_MARKER_WRAPPER));
+        }
     }
-    visitRightPadded(right, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if ((0, tree_2.isTree)(right.element)) {
-                yield this.visit(right.element, p);
-            }
-            yield this.visitSpace(right.after, p);
-            yield this.visitMarkers(right.markers, p);
-            return right;
-        });
-    }
-    visitRightPaddedLocalSingle(node, suffix, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (node) {
-                yield this.visit(node.element, p);
-                yield this.visitSpace(node.after, p);
-                yield this.visitMarkers(node.markers, p);
-                p.append(suffix);
-            }
-        });
-    }
-    visitLeftPaddedLocal(prefix, leftPadded, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (leftPadded) {
-                yield this.beforeSyntaxExt(leftPadded.before, leftPadded.markers, p);
-                if (prefix) {
-                    p.append(prefix);
-                }
-                if (typeof leftPadded.element === 'string') {
-                    p.append(leftPadded.element);
-                }
-                else if (typeof leftPadded.element !== 'boolean') {
-                    yield this.visit(leftPadded.element, p);
-                }
-                yield this.afterSyntaxMarkers(leftPadded.markers, p);
+    async visitSpace(space, p) {
+        p.append(space.whitespace);
+        const comments = space.comments;
+        for (let i = 0; i < comments.length; i++) {
+            const comment = comments[i];
+            await this.visitMarkers(comment.markers, p);
+            this.printComment(comment, this.cursor, p);
+            p.append(comment.suffix);
+        }
+        return space;
+    }
+    async visitRightPaddedLocal(nodes, suffixBetween, p) {
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            await this.visit(node.element, p);
+            await this.visitSpace(node.after, p);
+            await this.visitMarkers(node.markers, p);
+            if (i < nodes.length - 1) {
+                p.append(suffixBetween);
             }
-        });
+        }
     }
-    visitContainerLocal(before, container, suffixBetween, after, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!container) {
-                return;
+    async visitRightPadded(right, p) {
+        if ((0, tree_2.isTree)(right.element)) {
+            await this.visit(right.element, p);
+        }
+        await this.visitSpace(right.after, p);
+        await this.visitMarkers(right.markers, p);
+        return right;
+    }
+    async visitRightPaddedLocalSingle(node, suffix, p) {
+        if (node) {
+            await this.visit(node.element, p);
+            await this.visitSpace(node.after, p);
+            await this.visitMarkers(node.markers, p);
+            p.append(suffix);
+        }
+    }
+    async visitLeftPaddedLocal(prefix, leftPadded, p) {
+        if (leftPadded) {
+            await this.beforeSyntaxExt(leftPadded.before, leftPadded.markers, p);
+            if (prefix) {
+                p.append(prefix);
             }
-            yield this.beforeSyntaxExt(container.before, container.markers, p);
-            p.append(before);
-            yield this.visitRightPaddedLocal(container.elements, suffixBetween, p);
-            yield this.afterSyntaxMarkers(container.markers, p);
-            p.append(after === null ? "" : after);
-        });
-    }
-    visitMarker(marker, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (marker.kind === java_1.J.Markers.Semicolon) {
-                p.append(';');
+            if (typeof leftPadded.element === 'string') {
+                p.append(leftPadded.element);
             }
-            if (marker.kind === java_1.J.Markers.TrailingComma) {
-                p.append(',');
-                yield this.visitSpace(marker.suffix, p);
+            else if (typeof leftPadded.element !== 'boolean') {
+                await this.visit(leftPadded.element, p);
             }
-            return marker;
-        });
-    }
-    preVisit(tree, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Note: Spread is now handled as JS.Spread AST element via visitSpread
-            return tree;
-        });
-    }
-    postVisit(tree, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f;
-            for (const marker of tree.markers.markers) {
-                if (marker.kind === tree_1.JS.Markers.NonNullAssertion) {
-                    yield this.visitSpace(marker.prefix, p);
-                    p.append("!");
-                }
-                if (marker.kind === tree_1.JS.Markers.Optional) {
-                    yield this.visitSpace(marker.prefix, p);
-                    if (((_b = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.kind) !== java_1.J.Kind.MethodInvocation &&
-                        ((_d = (_c = this.cursor.parent) === null || _c === void 0 ? void 0 : _c.value) === null || _d === void 0 ? void 0 : _d.kind) !== tree_1.JS.Kind.FunctionCall) {
-                        p.append("?");
-                        if (((_f = (_e = this.cursor.parent) === null || _e === void 0 ? void 0 : _e.value) === null || _f === void 0 ? void 0 : _f.kind) === java_1.J.Kind.ArrayAccess) {
-                            p.append(".");
-                        }
+            await this.afterSyntaxMarkers(leftPadded.markers, p);
+        }
+    }
+    async visitContainerLocal(before, container, suffixBetween, after, p) {
+        if (!container) {
+            return;
+        }
+        await this.beforeSyntaxExt(container.before, container.markers, p);
+        p.append(before);
+        await this.visitRightPaddedLocal(container.elements, suffixBetween, p);
+        await this.afterSyntaxMarkers(container.markers, p);
+        p.append(after === null ? "" : after);
+    }
+    async visitMarker(marker, p) {
+        if (marker.kind === java_1.J.Markers.Semicolon) {
+            p.append(';');
+        }
+        if (marker.kind === java_1.J.Markers.TrailingComma) {
+            p.append(',');
+            await this.visitSpace(marker.suffix, p);
+        }
+        return marker;
+    }
+    async preVisit(tree, p) {
+        // Note: Spread is now handled as JS.Spread AST element via visitSpread
+        return tree;
+    }
+    async postVisit(tree, p) {
+        var _a, _b, _c, _d, _e, _f;
+        for (const marker of tree.markers.markers) {
+            if (marker.kind === tree_1.JS.Markers.NonNullAssertion) {
+                await this.visitSpace(marker.prefix, p);
+                p.append("!");
+            }
+            if (marker.kind === tree_1.JS.Markers.Optional) {
+                await this.visitSpace(marker.prefix, p);
+                if (((_b = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.kind) !== java_1.J.Kind.MethodInvocation &&
+                    ((_d = (_c = this.cursor.parent) === null || _c === void 0 ? void 0 : _c.value) === null || _d === void 0 ? void 0 : _d.kind) !== tree_1.JS.Kind.FunctionCall) {
+                    p.append("?");
+                    if (((_f = (_e = this.cursor.parent) === null || _e === void 0 ? void 0 : _e.value) === null || _f === void 0 ? void 0 : _f.kind) === java_1.J.Kind.ArrayAccess) {
+                        p.append(".");
                     }
                 }
             }
-            return tree;
-        });
+        }
+        return tree;
     }
     printComment(comment, cursor, p) {
         for (const marker of comment.markers.markers) {
@@ -1899,30 +1640,26 @@ class JavaScriptPrinter extends visitor_1.JavaScriptVisitor {
             p.append(p.markerPrinter.afterSyntax(marker, new tree_2.Cursor(this, cursor), this.JAVA_SCRIPT_MARKER_WRAPPER));
         }
     }
-    visitNodes(nodes, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (nodes) {
-                for (const node of nodes) {
-                    yield this.visit(node, p);
-                }
+    async visitNodes(nodes, p) {
+        if (nodes) {
+            for (const node of nodes) {
+                await this.visit(node, p);
             }
-        });
-    }
-    visitControlParentheses(controlParens, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            yield this.beforeSyntax(controlParens, p);
-            if (((_a = this.getParentCursor(1)) === null || _a === void 0 ? void 0 : _a.value.kind) === java_1.J.Kind.TypeCast) {
-                p.append('<');
-                yield this.visitRightPaddedLocalSingle(controlParens.tree, ">", p);
-            }
-            else {
-                p.append('(');
-                yield this.visitRightPaddedLocalSingle(controlParens.tree, ")", p);
-            }
-            yield this.afterSyntax(controlParens, p);
-            return controlParens;
-        });
+        }
+    }
+    async visitControlParentheses(controlParens, p) {
+        var _a;
+        await this.beforeSyntax(controlParens, p);
+        if (((_a = this.getParentCursor(1)) === null || _a === void 0 ? void 0 : _a.value.kind) === java_1.J.Kind.TypeCast) {
+            p.append('<');
+            await this.visitRightPaddedLocalSingle(controlParens.tree, ">", p);
+        }
+        else {
+            p.append('(');
+            await this.visitRightPaddedLocalSingle(controlParens.tree, ")", p);
+        }
+        await this.afterSyntax(controlParens, p);
+        return controlParens;
     }
 }
 exports.JavaScriptPrinter = JavaScriptPrinter;