@openrewrite/rewrite 0.31.0 → 0.32.0

package/dist/src/javascript/printer.js

@@ -0,0 +1,1671 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaScriptPrinter = void 0;
+const J = __importStar(require("../java"));
+const java_1 = require("../java");
+const JS = __importStar(require("."));
+const core_1 = require("../core");
+const _1 = require(".");
+class JavaScriptPrinter extends _1.JavaScriptVisitor {
+    constructor(cursor) {
+        super();
+        this.JAVA_SCRIPT_MARKER_WRAPPER = (out) => `/*~~${out}${out.length === 0 ? "" : "~~"}>*/`;
+        this.cursor = cursor;
+    }
+    visit(tree, p) {
+        return super.visit(tree, p);
+    }
+    visitJsCompilationUnit(cu, p) {
+        this.beforeSyntax(cu, 34, p);
+        this.visitJsRightPaddedLocal(cu.padding.statements, _1.JsRightPadded.Location.COMPILATION_UNIT_STATEMENTS, "", p);
+        this.visitSpace(cu.eof, 33, p);
+        this.afterSyntax(cu, p);
+        return cu;
+    }
+    visitAlias(alias, p) {
+        this.beforeSyntax(alias, _1.JsSpace.Location.ALIAS_PREFIX, p);
+        this.visitJsRightPadded(alias.padding.propertyName, _1.JsRightPadded.Location.ALIAS_PROPERTY_NAME, p);
+        p.append("as");
+        this.visit(alias.alias, p);
+        this.afterSyntax(alias, p);
+        return alias;
+    }
+    visitAwait(awaitExpr, p) {
+        this.beforeSyntax(awaitExpr, _1.JsSpace.Location.AWAIT_PREFIX, p);
+        p.append("await");
+        this.visit(awaitExpr.expression, p);
+        this.afterSyntax(awaitExpr, p);
+        return awaitExpr;
+    }
+    visitBindingElement(binding, p) {
+        this.beforeSyntax(binding, _1.JsSpace.Location.BINDING_ELEMENT_PREFIX, p);
+        if (binding.propertyName) {
+            this.visitJsRightPadded(binding.padding.propertyName, _1.JsRightPadded.Location.BINDING_ELEMENT_PROPERTY_NAME, p);
+            p.append(":");
+        }
+        this.visit(binding.name, p);
+        this.visitJsLeftPaddedLocal("=", binding.padding.initializer, _1.JsLeftPadded.Location.BINDING_ELEMENT_INITIALIZER, p);
+        this.afterSyntax(binding, p);
+        return binding;
+    }
+    visitDelete(del, p) {
+        this.beforeSyntax(del, _1.JsSpace.Location.DELETE_PREFIX, p);
+        p.append("delete");
+        this.visit(del.expression, p);
+        this.afterSyntax(del, p);
+        return del;
+    }
+    visitTrailingTokenStatement(statement, p) {
+        this.beforeSyntax(statement, _1.JsSpace.Location.TRAILING_TOKEN_STATEMENT_PREFIX, p);
+        this.visitJsRightPadded(statement.padding.expression, _1.JsRightPadded.Location.TRAILING_TOKEN_STATEMENT_EXPRESSION, p);
+        this.afterSyntax(statement, p);
+        return statement;
+    }
+    visitInferType(inferType, p) {
+        this.beforeSyntax(inferType, _1.JsSpace.Location.INFER_TYPE_PREFIX, p);
+        this.visitJsLeftPaddedLocal("infer", inferType.padding.typeParameter, _1.JsLeftPadded.Location.INFER_TYPE_TYPE_PARAMETER, p);
+        this.afterSyntax(inferType, p);
+        return inferType;
+    }
+    visitJsImport(jsImport, p) {
+        this.beforeSyntax(jsImport, _1.JsSpace.Location.JS_IMPORT_PREFIX, p);
+        jsImport.modifiers.forEach(m => this.visitModifier(m, p));
+        p.append("import");
+        this.visit(jsImport.importClause, p);
+        this.visitJsLeftPaddedLocal(jsImport.importClause ? "from" : "", jsImport.padding.moduleSpecifier, _1.JsLeftPadded.Location.JS_IMPORT_MODULE_SPECIFIER, p);
+        this.visit(jsImport.attributes, p);
+        this.afterSyntax(jsImport, p);
+        return jsImport;
+    }
+    visitJsImportClause(jsImportClause, p) {
+        this.beforeSyntax(jsImportClause, _1.JsSpace.Location.JS_IMPORT_CLAUSE_PREFIX, p);
+        if (jsImportClause.typeOnly) {
+            p.append("type");
+        }
+        const name = jsImportClause.padding.name;
+        this.visitJsRightPadded(name, _1.JsRightPadded.Location.JS_IMPORT_CLAUSE_NAME, p);
+        if (name && jsImportClause.namedBindings) {
+            p.append(",");
+        }
+        this.visit(jsImportClause.namedBindings, p);
+        this.afterSyntax(jsImportClause, p);
+        return jsImportClause;
+    }
+    visitTypeTreeExpression(typeTreeExpression, p) {
+        this.beforeSyntax(typeTreeExpression, _1.JsSpace.Location.TYPE_TREE_EXPRESSION_PREFIX, p);
+        this.visit(typeTreeExpression.expression, p);
+        this.afterSyntax(typeTreeExpression, p);
+        return typeTreeExpression;
+    }
+    visitNamespaceDeclaration(namespaceDeclaration, p) {
+        this.beforeSyntax(namespaceDeclaration, _1.JsSpace.Location.NAMESPACE_DECLARATION_PREFIX, p);
+        namespaceDeclaration.modifiers.forEach(it => this.visitModifier(it, p));
+        this.visitSpace(namespaceDeclaration.padding.keywordType.before, _1.JsSpace.Location.NAMESPACE_DECLARATION_KEYWORD_TYPE_PREFIX, p);
+        switch (namespaceDeclaration.keywordType) {
+            case _1.NamespaceDeclaration.KeywordType.Namespace:
+                p.append("namespace");
+                break;
+            case _1.NamespaceDeclaration.KeywordType.Module:
+                p.append("module");
+                break;
+            default:
+                break;
+        }
+        this.visitJsRightPadded(namespaceDeclaration.padding.name, _1.JsRightPadded.Location.NAMESPACE_DECLARATION_NAME, p);
+        if (namespaceDeclaration.body) {
+            this.visit(namespaceDeclaration.body, p);
+        }
+        this.afterSyntax(namespaceDeclaration, p);
+        return namespaceDeclaration;
+    }
+    visitSatisfiesExpression(satisfiesExpression, p) {
+        this.beforeSyntax(satisfiesExpression, _1.JsSpace.Location.SATISFIES_EXPRESSION_PREFIX, p);
+        this.visit(satisfiesExpression.expression, p);
+        this.visitJsLeftPaddedLocal("satisfies", satisfiesExpression.padding.satisfiesType, _1.JsLeftPadded.Location.SATISFIES_EXPRESSION_SATISFIES_TYPE, p);
+        this.afterSyntax(satisfiesExpression, p);
+        return satisfiesExpression;
+    }
+    visitVoid(aVoid, p) {
+        this.beforeSyntax(aVoid, _1.JsSpace.Location.VOID_PREFIX, p);
+        p.append("void");
+        this.visit(aVoid.expression, p);
+        this.afterSyntax(aVoid, p);
+        return aVoid;
+    }
+    visitJsYield(yield_, p) {
+        this.beforeSyntax(yield_, _1.JsSpace.Location.YIELD_PREFIX, p);
+        p.append("yield");
+        if (yield_.delegated) {
+            this.visitJsLeftPaddedLocal("*", yield_.padding.delegated, _1.JsLeftPadded.Location.YIELD_DELEGATED, p);
+        }
+        this.visit(yield_.expression, p);
+        this.afterSyntax(yield_, p);
+        return yield_;
+    }
+    visitTry(try_, p) {
+        this.beforeSyntax(try_, 129, p);
+        p.append("try");
+        this.visit(try_.body, p);
+        this.visitNodes(try_.catches, p);
+        this.visitJLeftPaddedLocal("finally", try_.padding.finally, java_1.JLeftPadded.Location.TRY_FINALLY, p);
+        this.afterSyntax(try_, p);
+        return try_;
+    }
+    visitCatch(catch_, p) {
+        this.beforeSyntax(catch_, 30, p);
+        p.append("catch");
+        if (catch_.parameter.tree.variables.length > 0) {
+            this.visit(catch_.parameter, p);
+        }
+        this.visit(catch_.body, p);
+        this.afterSyntax(catch_, p);
+        return catch_;
+    }
+    visitJSTry(jsTry, p) {
+        this.beforeSyntax(jsTry, _1.JsSpace.Location.JSTRY_PREFIX, p);
+        p.append("try");
+        this.visit(jsTry.body, p);
+        this.visit(jsTry.catches, p);
+        this.visitJsLeftPaddedLocal("finally", jsTry.padding.finallie, _1.JsLeftPadded.Location.JSTRY_FINALLIE, p);
+        this.afterSyntax(jsTry, p);
+        return jsTry;
+    }
+    visitJSTryJSCatch(jsCatch, p) {
+        this.beforeSyntax(jsCatch, _1.JsSpace.Location.JSTRY_JSCATCH_PREFIX, p);
+        p.append("catch");
+        this.visit(jsCatch.parameter, p);
+        this.visit(jsCatch.body, p);
+        this.afterSyntax(jsCatch, p);
+        return jsCatch;
+    }
+    visitJSVariableDeclarations(multiVariable, p) {
+        this.beforeSyntax(multiVariable, _1.JsSpace.Location.JSVARIABLE_DECLARATIONS_PREFIX, p);
+        this.visitNodes(multiVariable.leadingAnnotations, p);
+        multiVariable.modifiers.forEach(it => this.visitModifier(it, p));
+        const variables = multiVariable.padding.variables;
+        for (let i = 0; i < variables.length; i++) {
+            const variable = variables[i];
+            this.beforeSyntax(variable.element, _1.JsSpace.Location.JSVARIABLE_DECLARATIONS_JSNAMED_VARIABLE_PREFIX, p);
+            if (multiVariable.varargs) {
+                p.append("...");
+            }
+            this.visit(variable.element.name, p);
+            this.visitSpace(variable.after, _1.JsSpace.Location.JSVARIABLE_DECLARATIONS_VARIABLES_SUFFIX, p);
+            if (multiVariable.typeExpression) {
+                this.visit(multiVariable.typeExpression, p);
+            }
+            if (variable.element.initializer) {
+                this.visitJsLeftPaddedLocal("=", variable.element.padding.initializer, _1.JsLeftPadded.Location.JSVARIABLE_DECLARATIONS_JSNAMED_VARIABLE_INITIALIZER, p);
+            }
+            this.afterSyntax(variable.element, p);
+            if (i < variables.length - 1) {
+                p.append(",");
+            }
+            else if (variable.markers.findFirst(java_1.Semicolon) !== undefined) {
+                p.append(";");
+            }
+        }
+        this.afterSyntax(multiVariable, p);
+        return multiVariable;
+    }
+    visitJSVariableDeclarationsJSNamedVariable(variable, p) {
+        this.beforeSyntax(variable, _1.JsSpace.Location.JSVARIABLE_DECLARATIONS_JSNAMED_VARIABLE_PREFIX, p);
+        this.visit(variable.name, p);
+        const initializer = variable.padding.initializer;
+        this.visitJsLeftPaddedLocal("=", initializer, _1.JsLeftPadded.Location.JSVARIABLE_DECLARATIONS_JSNAMED_VARIABLE_INITIALIZER, p);
+        this.afterSyntax(variable, p);
+        return variable;
+    }
+    visitArrayDimension(arrayDimension, p) {
+        this.beforeSyntax(arrayDimension, 37, p);
+        p.append("[");
+        this.visitJRightPaddedLocalSingle(arrayDimension.padding.index, java_1.JRightPadded.Location.ARRAY_INDEX, "]", p);
+        this.afterSyntax(arrayDimension, p);
+        return arrayDimension;
+    }
+    visitArrayType(arrayType, p) {
+        this.beforeSyntax(arrayType, 8, p);
+        let type = arrayType;
+        while (type instanceof J.ArrayType) {
+            type = type.elementType;
+        }
+        this.visit(type, p);
+        this.visitNodes(arrayType.annotations, p);
+        if (arrayType.dimension) {
+            this.visitSpace(arrayType.dimension.before, 37, p);
+            p.append("[");
+            this.visitSpace(arrayType.dimension.element, 38, p);
+            p.append("]");
+            if (arrayType.elementType instanceof J.ArrayType) {
+                this.printDimensions(arrayType.elementType, p);
+            }
+        }
+        this.afterSyntax(arrayType, p);
+        return arrayType;
+    }
+    printDimensions(arrayType, p) {
+        var _a, _b, _c, _d;
+        this.beforeSyntax(arrayType, 8, p);
+        this.visitNodes(arrayType.annotations, p);
+        this.visitSpace((_b = (_a = arrayType.dimension) === null || _a === void 0 ? void 0 : _a.before) !== null && _b !== void 0 ? _b : java_1.Space.EMPTY, 37, p);
+        p.append("[");
+        this.visitSpace((_d = (_c = arrayType.dimension) === null || _c === void 0 ? void 0 : _c.element) !== null && _d !== void 0 ? _d : java_1.Space.EMPTY, 38, p);
+        p.append("]");
+        if (arrayType.elementType instanceof J.ArrayType) {
+            this.printDimensions(arrayType.elementType, p);
+        }
+        this.afterSyntax(arrayType, p);
+    }
+    visitTernary(ternary, p) {
+        this.beforeSyntax(ternary, 123, p);
+        this.visit(ternary.condition, p);
+        this.visitJLeftPaddedLocal("?", ternary.padding.truePart, java_1.JLeftPadded.Location.TERNARY_TRUE, p);
+        this.visitJLeftPaddedLocal(":", ternary.padding.falsePart, java_1.JLeftPadded.Location.TERNARY_FALSE, p);
+        this.afterSyntax(ternary, p);
+        return ternary;
+    }
+    visitThrow(thrown, p) {
+        this.beforeSyntax(thrown, 127, p);
+        p.append("throw");
+        this.visit(thrown.exception, p);
+        this.afterSyntax(thrown, p);
+        return thrown;
+    }
+    visitIf(iff, p) {
+        this.beforeSyntax(iff, 62, p);
+        p.append("if");
+        this.visit(iff.ifCondition, p);
+        this.visitStatementLocal(iff.padding.thenPart, java_1.JRightPadded.Location.IF_THEN, p);
+        this.visit(iff.elsePart, p);
+        this.afterSyntax(iff, p);
+        return iff;
+    }
+    visitElse(else_, p) {
+        this.beforeSyntax(else_, 41, p);
+        p.append("else");
+        this.visitStatementLocal(else_.padding.body, java_1.JRightPadded.Location.IF_ELSE, p);
+        this.afterSyntax(else_, p);
+        return else_;
+    }
+    visitDoWhileLoop(doWhileLoop, p) {
+        this.beforeSyntax(doWhileLoop, 40, p);
+        p.append("do");
+        this.visitStatementLocal(doWhileLoop.padding.body, java_1.JRightPadded.Location.WHILE_BODY, p);
+        this.visitJLeftPaddedLocal("while", doWhileLoop.padding.whileCondition, java_1.JLeftPadded.Location.WHILE_CONDITION, p);
+        this.afterSyntax(doWhileLoop, p);
+        return doWhileLoop;
+    }
+    visitWhileLoop(whileLoop, p) {
+        this.beforeSyntax(whileLoop, 149, p);
+        p.append("while");
+        this.visit(whileLoop.condition, p);
+        this.visitStatementLocal(whileLoop.padding.body, java_1.JRightPadded.Location.WHILE_BODY, p);
+        this.afterSyntax(whileLoop, p);
+        return whileLoop;
+    }
+    visitInstanceOf(instanceOf, p) {
+        this.beforeSyntax(instanceOf, 70, p);
+        this.visitJRightPaddedLocalSingle(instanceOf.padding.expression, java_1.JRightPadded.Location.INSTANCEOF, "instanceof", p);
+        this.visit(instanceOf.clazz, p);
+        this.visit(instanceOf.pattern, p);
+        this.afterSyntax(instanceOf, p);
+        return instanceOf;
+    }
+    visitLiteral(literal, p) {
+        var _a, _b, _c;
+        this.beforeSyntax(literal, 80, 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;
+                    }
+                }
+            }
+        }
+        this.afterSyntax(literal, p);
+        return literal;
+    }
+    visitScopedVariableDeclarations(variableDeclarations, p) {
+        this.beforeSyntax(variableDeclarations, _1.JsSpace.Location.SCOPED_VARIABLE_DECLARATIONS_PREFIX, p);
+        variableDeclarations.modifiers.forEach(m => this.visitModifier(m, p));
+        const scope = variableDeclarations.padding.scope;
+        if (scope) {
+            this.visitSpace(scope.before, _1.JsSpace.Location.SCOPED_VARIABLE_DECLARATIONS_SCOPE_PREFIX, p);
+            switch (scope.element) {
+                case JS.ScopedVariableDeclarations.Scope.Let:
+                    p.append("let");
+                    break;
+                case JS.ScopedVariableDeclarations.Scope.Const:
+                    p.append("const");
+                    break;
+                case JS.ScopedVariableDeclarations.Scope.Var:
+                    p.append("var");
+                    break;
+                case JS.ScopedVariableDeclarations.Scope.Using:
+                    p.append("using");
+                    break;
+                case JS.ScopedVariableDeclarations.Scope.Import:
+                    p.append("import");
+                    break;
+            }
+        }
+        this.visitJsRightPaddedLocal(variableDeclarations.padding.variables, _1.JsRightPadded.Location.SCOPED_VARIABLE_DECLARATIONS_VARIABLES, ",", p);
+        this.afterSyntax(variableDeclarations, p);
+        return variableDeclarations;
+    }
+    visitVariableDeclarations(multiVariable, p) {
+        this.beforeSyntax(multiVariable, 144, p);
+        this.visitNodes(multiVariable.leadingAnnotations, p);
+        multiVariable.modifiers.forEach(it => this.visitModifier(it, p));
+        const variables = multiVariable.padding.variables;
+        for (let i = 0; i < variables.length; i++) {
+            const variable = variables[i];
+            this.beforeSyntax(variable.element, 146, p);
+            if (multiVariable.varargs) {
+                p.append("...");
+            }
+            this.visit(variable.element.name, p);
+            this.visitSpace(variable.after, 95, p);
+            if (multiVariable.typeExpression) {
+                this.visit(multiVariable.typeExpression, p);
+            }
+            if (variable.element.initializer) {
+                this.visitJLeftPaddedLocal("=", variable.element.padding.initializer, java_1.JLeftPadded.Location.VARIABLE_INITIALIZER, p);
+            }
+            this.afterSyntax(variable.element, p);
+            if (i < variables.length - 1) {
+                p.append(",");
+            }
+            else if (variable.markers.findFirst(java_1.Semicolon)) {
+                p.append(";");
+            }
+        }
+        this.afterSyntax(multiVariable, p);
+        return multiVariable;
+    }
+    visitVariable(variable, p) {
+        this.beforeSyntax(variable, 146, p);
+        this.visit(variable.name, p);
+        const initializer = variable.padding.initializer;
+        this.visitJLeftPaddedLocal("=", initializer, java_1.JLeftPadded.Location.VARIABLE_INITIALIZER, p);
+        this.afterSyntax(variable, p);
+        return variable;
+    }
+    visitIdentifier(ident, p) {
+        this.visitSpace(java_1.Space.EMPTY, 4, p);
+        this.visitNodes(ident.annotations, p);
+        this.beforeSyntax(ident, 60, p);
+        p.append(ident.simpleName);
+        this.afterSyntax(ident, p);
+        return ident;
+    }
+    visitFunctionDeclaration(functionDeclaration, p) {
+        this.beforeSyntax(functionDeclaration, _1.JsSpace.Location.FUNCTION_DECLARATION_PREFIX, p);
+        functionDeclaration.modifiers.forEach((m) => this.visitModifier(m, p));
+        this.visitJsLeftPaddedLocal("function", functionDeclaration.padding.asteriskToken, _1.JsLeftPadded.Location.FUNCTION_DECLARATION_ASTERISK_TOKEN, p);
+        this.visitJsLeftPaddedLocal(functionDeclaration.asteriskToken ? "*" : "", functionDeclaration.padding.name, _1.JsLeftPadded.Location.FUNCTION_DECLARATION_NAME, p);
+        const typeParameters = functionDeclaration.typeParameters;
+        if (typeParameters !== null) {
+            this.visitNodes(typeParameters.annotations, p);
+            this.visitSpace(typeParameters.prefix, 136, p);
+            this.visitMarkers(typeParameters.markers, p);
+            p.append("<");
+            this.visitJRightPaddedLocal(typeParameters.padding.typeParameters, java_1.JRightPadded.Location.TYPE_PARAMETER, ",", p);
+            p.append(">");
+        }
+        this.visitJsContainerLocal("(", functionDeclaration.padding.parameters, _1.JsContainer.Location.FUNCTION_DECLARATION_PARAMETERS, ",", ")", p);
+        if (functionDeclaration.returnTypeExpression !== null) {
+            this.visit(functionDeclaration.returnTypeExpression, p);
+        }
+        if (functionDeclaration.body !== null) {
+            this.visit(functionDeclaration.body, p);
+        }
+        this.afterSyntax(functionDeclaration, p);
+        return functionDeclaration;
+    }
+    visitBlock(block, p) {
+        this.beforeSyntax(block, 19, p);
+        if (block.static) {
+            p.append("static");
+            this.visitRightPadded(block.padding.static, java_1.JRightPadded.Location.STATIC_INIT, p);
+        }
+        p.append("{");
+        this.visitStatements(block.padding.statements, java_1.JRightPadded.Location.BLOCK_STATEMENT, p);
+        this.visitSpace(block.end, 18, p);
+        p.append("}");
+        this.afterSyntax(block, p);
+        return block;
+    }
+    visitTypeInfo(typeInfo, p) {
+        this.beforeSyntax(typeInfo, _1.JsSpace.Location.TYPE_INFO_PREFIX, p);
+        p.append(":");
+        this.visit(typeInfo.typeIdentifier, p);
+        this.afterSyntax(typeInfo, p);
+        return typeInfo;
+    }
+    visitReturn(return_, p) {
+        this.beforeSyntax(return_, 115, p);
+        p.append("return");
+        this.visit(return_.expression, p);
+        this.afterSyntax(return_, p);
+        return return_;
+    }
+    visitModifier(mod, p) {
+        var _a;
+        this.visitNodes(mod.annotations, p);
+        let keyword;
+        switch (mod.type) {
+            case J.Modifier.Type.Default:
+                keyword = "default";
+                break;
+            case J.Modifier.Type.Public:
+                keyword = "public";
+                break;
+            case J.Modifier.Type.Protected:
+                keyword = "protected";
+                break;
+            case J.Modifier.Type.Private:
+                keyword = "private";
+                break;
+            case J.Modifier.Type.Abstract:
+                keyword = "abstract";
+                break;
+            case J.Modifier.Type.Async:
+                keyword = "async";
+                break;
+            case J.Modifier.Type.Static:
+                keyword = "static";
+                break;
+            case J.Modifier.Type.Final:
+                keyword = "final";
+                break;
+            case J.Modifier.Type.Native:
+                keyword = "native";
+                break;
+            case J.Modifier.Type.NonSealed:
+                keyword = "non-sealed";
+                break;
+            case J.Modifier.Type.Sealed:
+                keyword = "sealed";
+                break;
+            case J.Modifier.Type.Strictfp:
+                keyword = "strictfp";
+                break;
+            case J.Modifier.Type.Synchronized:
+                keyword = "synchronized";
+                break;
+            case J.Modifier.Type.Transient:
+                keyword = "transient";
+                break;
+            case J.Modifier.Type.Volatile:
+                keyword = "volatile";
+                break;
+            default:
+                keyword = (_a = mod.keyword) !== null && _a !== void 0 ? _a : "";
+        }
+        this.beforeSyntax(mod, 93, p);
+        p.append(keyword);
+        this.afterSyntax(mod, p);
+        return mod;
+    }
+    visitFunctionType(functionType, p) {
+        this.beforeSyntax(functionType, _1.JsSpace.Location.FUNCTION_TYPE_PREFIX, p);
+        functionType.modifiers.forEach(m => this.visitModifier(m, p));
+        if (functionType.constructorType) {
+            this.visitJsLeftPaddedLocal("new", functionType.padding.constructorType, _1.JsLeftPadded.Location.FUNCTION_TYPE_CONSTRUCTOR_TYPE, p);
+        }
+        const typeParameters = functionType.typeParameters;
+        if (typeParameters) {
+            this.visitNodes(typeParameters.annotations, p);
+            this.visitSpace(typeParameters.prefix, 136, p);
+            this.visitMarkers(typeParameters.markers, p);
+            p.append("<");
+            this.visitJRightPaddedLocal(typeParameters.padding.typeParameters, java_1.JRightPadded.Location.TYPE_PARAMETER, ",", p);
+            p.append(">");
+        }
+        this.visitJsContainerLocal("(", functionType.padding.parameters, _1.JsContainer.Location.FUNCTION_TYPE_PARAMETERS, ",", ")", p);
+        this.visitJsLeftPaddedLocal("=>", functionType.padding.returnType, _1.JsLeftPadded.Location.FUNCTION_TYPE_RETURN_TYPE, p);
+        this.afterSyntax(functionType, p);
+        return functionType;
+    }
+    visitClassDeclaration(classDecl, p) {
+        let kind = "";
+        switch (classDecl.padding.kind.type) {
+            case J.ClassDeclaration.Kind.Type.Class:
+                kind = "class";
+                break;
+            case J.ClassDeclaration.Kind.Type.Enum:
+                kind = "enum";
+                break;
+            case J.ClassDeclaration.Kind.Type.Interface:
+                kind = "interface";
+                break;
+            case J.ClassDeclaration.Kind.Type.Annotation:
+                kind = "@interface";
+                break;
+            case J.ClassDeclaration.Kind.Type.Record:
+                kind = "record";
+                break;
+        }
+        this.beforeSyntax(classDecl, 31, p);
+        this.visitSpace(java_1.Space.EMPTY, 4, p);
+        this.visitNodes(classDecl.leadingAnnotations, p);
+        classDecl.modifiers.forEach(m => this.visitModifier(m, p));
+        this.visitNodes(classDecl.padding.kind.annotations, p);
+        this.visitSpace(classDecl.padding.kind.prefix, 32, p);
+        p.append(kind);
+        this.visit(classDecl.name, p);
+        this.visitJContainerLocal("<", classDecl.padding.typeParameters, java_1.JContainer.Location.TYPE_PARAMETERS, ",", ">", p);
+        this.visitJContainerLocal("(", classDecl.padding.primaryConstructor, java_1.JContainer.Location.RECORD_STATE_VECTOR, ",", ")", p);
+        this.visitJLeftPaddedLocal("extends", classDecl.padding.extends, java_1.JLeftPadded.Location.EXTENDS, p);
+        this.visitJContainerLocal(classDecl.padding.kind.type === J.ClassDeclaration.Kind.Type.Interface ? "extends" : "implements", classDecl.padding.implements, java_1.JContainer.Location.IMPLEMENTS, ",", null, p);
+        this.visit(classDecl.body, p);
+        this.afterSyntax(classDecl, p);
+        return classDecl;
+    }
+    visitMethodDeclaration(method, p) {
+        this.beforeSyntax(method, 87, p);
+        this.visitSpace(java_1.Space.EMPTY, 4, p);
+        this.visitNodes(method.leadingAnnotations, p);
+        method.modifiers.forEach(m => this.visitModifier(m, p));
+        this.visit(method.padding.name.identifier, p);
+        const typeParameters = method.annotations.typeParameters;
+        if (typeParameters) {
+            this.visitNodes(typeParameters.annotations, p);
+            this.visitSpace(typeParameters.prefix, 136, p);
+            this.visitMarkers(typeParameters.markers, p);
+            p.append("<");
+            this.visitJRightPaddedLocal(typeParameters.padding.typeParameters, java_1.JRightPadded.Location.TYPE_PARAMETER, ",", p);
+            p.append(">");
+        }
+        this.visitJContainerLocal("(", method.padding.parameters, java_1.JContainer.Location.METHOD_DECLARATION_PARAMETERS, ",", ")", p);
+        if (method.returnTypeExpression) {
+            this.visit(method.returnTypeExpression, p);
+        }
+        this.visit(method.body, p);
+        this.afterSyntax(method, p);
+        return method;
+    }
+    visitJSMethodDeclaration(method, p) {
+        this.beforeSyntax(method, _1.JsSpace.Location.JSMETHOD_DECLARATION_PREFIX, p);
+        this.visitSpace(java_1.Space.EMPTY, 4, p);
+        this.visitNodes(method.leadingAnnotations, p);
+        method.modifiers.forEach(it => this.visitModifier(it, p));
+        this.visit(method.name, p);
+        const typeParameters = method.typeParameters;
+        if (typeParameters) {
+            this.visitNodes(typeParameters.annotations, p);
+            this.visitSpace(typeParameters.prefix, 136, p);
+            this.visitMarkers(typeParameters.markers, p);
+            p.append("<");
+            this.visitJRightPaddedLocal(typeParameters.padding.typeParameters, java_1.JRightPadded.Location.TYPE_PARAMETER, ",", p);
+            p.append(">");
+        }
+        this.visitJsContainerLocal("(", method.padding.parameters, _1.JsContainer.Location.JSMETHOD_DECLARATION_PARAMETERS, ",", ")", p);
+        if (method.returnTypeExpression) {
+            this.visit(method.returnTypeExpression, p);
+        }
+        this.visit(method.body, p);
+        this.afterSyntax(method, p);
+        return method;
+    }
+    visitMethodInvocation(method, p) {
+        this.beforeSyntax(method, 91, p);
+        if (method.name.toString().length === 0) {
+            this.visitRightPadded(method.padding.select, java_1.JRightPadded.Location.METHOD_SELECT, p);
+        }
+        else {
+            this.visitJRightPaddedLocalSingle(method.padding.select, java_1.JRightPadded.Location.METHOD_SELECT, "", p);
+            this.visit(method.name, p);
+        }
+        this.visitJContainerLocal("<", method.padding.typeParameters, java_1.JContainer.Location.TYPE_PARAMETERS, ",", ">", p);
+        this.visitJContainerLocal("(", method.padding.arguments, java_1.JContainer.Location.METHOD_INVOCATION_ARGUMENTS, ",", ")", p);
+        this.afterSyntax(method, p);
+        return method;
+    }
+    visitTypeParameter(typeParameter, p) {
+        this.beforeSyntax(typeParameter, 137, p);
+        this.visitNodes(typeParameter.annotations, p);
+        typeParameter.modifiers.forEach(m => this.visitModifier(m, p));
+        this.visit(typeParameter.name, p);
+        const bounds = typeParameter.padding.bounds;
+        if (bounds) {
+            this.visitSpace(bounds.before, java_1.JContainer.Location.beforeLocation(java_1.JContainer.Location.TYPE_BOUNDS), p);
+            const constraintType = bounds.padding.elements[0];
+            if (!(constraintType.element instanceof J.Empty)) {
+                p.append("extends");
+                this.visitRightPadded(constraintType, java_1.JContainer.Location.elementLocation(java_1.JContainer.Location.TYPE_BOUNDS), p);
+            }
+            const defaultType = bounds.padding.elements[1];
+            if (!(defaultType.element instanceof J.Empty)) {
+                p.append("=");
+                this.visitRightPadded(defaultType, java_1.JContainer.Location.elementLocation(java_1.JContainer.Location.TYPE_BOUNDS), p);
+            }
+        }
+        this.afterSyntax(typeParameter, p);
+        return typeParameter;
+    }
+    visitArrowFunction(arrowFunction, p) {
+        this.beforeSyntax(arrowFunction, _1.JsSpace.Location.ARROW_FUNCTION_PREFIX, p);
+        this.visitNodes(arrowFunction.leadingAnnotations, p);
+        arrowFunction.modifiers.forEach(m => this.visitModifier(m, p));
+        const typeParameters = arrowFunction.typeParameters;
+        if (typeParameters) {
+            this.visitNodes(typeParameters.annotations, p);
+            this.visitSpace(typeParameters.prefix, 136, p);
+            this.visitMarkers(typeParameters.markers, p);
+            p.append("<");
+            this.visitJRightPaddedLocal(typeParameters.padding.typeParameters, java_1.JRightPadded.Location.TYPE_PARAMETER, ",", p);
+            p.append(">");
+        }
+        if (arrowFunction.parameters.parenthesized) {
+            this.visitSpace(arrowFunction.parameters.prefix, 77, p);
+            p.append("(");
+            this.visitJRightPaddedLocal(arrowFunction.parameters.padding.parameters, java_1.JRightPadded.Location.LAMBDA_PARAM, ",", p);
+            p.append(")");
+        }
+        else {
+            this.visitJRightPaddedLocal(arrowFunction.parameters.padding.parameters, java_1.JRightPadded.Location.LAMBDA_PARAM, ",", p);
+        }
+        if (arrowFunction.returnTypeExpression) {
+            this.visit(arrowFunction.returnTypeExpression, p);
+        }
+        this.visitJsLeftPaddedLocal("=>", arrowFunction.padding.body, _1.JsLeftPadded.Location.ARROW_FUNCTION_BODY, p);
+        this.afterSyntax(arrowFunction, p);
+        return arrowFunction;
+    }
+    visitConditionalType(conditionalType, p) {
+        this.beforeSyntax(conditionalType, _1.JsSpace.Location.CONDITIONAL_TYPE_PREFIX, p);
+        this.visit(conditionalType.checkType, p);
+        this.visitJsContainerLocal("extends", conditionalType.padding.condition, _1.JsContainer.Location.CONDITIONAL_TYPE_CONDITION, "", "", p);
+        this.afterSyntax(conditionalType, p);
+        return conditionalType;
+    }
+    visitExpressionWithTypeArguments(type, p) {
+        this.beforeSyntax(type, _1.JsSpace.Location.EXPRESSION_WITH_TYPE_ARGUMENTS_PREFIX, p);
+        this.visit(type.clazz, p);
+        this.visitJsContainerLocal("<", type.padding.typeArguments, _1.JsContainer.Location.EXPRESSION_WITH_TYPE_ARGUMENTS_TYPE_ARGUMENTS, ",", ">", p);
+        this.afterSyntax(type, p);
+        return type;
+    }
+    visitImportType(importType, p) {
+        this.beforeSyntax(importType, _1.JsSpace.Location.IMPORT_TYPE_PREFIX, p);
+        if (importType.hasTypeof) {
+            p.append("typeof");
+            this.visitJsRightPadded(importType.padding.hasTypeof, _1.JsRightPadded.Location.IMPORT_TYPE_HAS_TYPEOF, p);
+        }
+        p.append("import");
+        this.visitJsContainerLocal("(", importType.padding.argumentAndAttributes, _1.JsContainer.Location.IMPORT_TYPE_ARGUMENT_AND_ATTRIBUTES, ",", ")", p);
+        this.visitJsLeftPaddedLocal(".", importType.padding.qualifier, _1.JsLeftPadded.Location.IMPORT_TYPE_QUALIFIER, p);
+        this.visitJsContainerLocal("<", importType.padding.typeArguments, _1.JsContainer.Location.IMPORT_TYPE_TYPE_ARGUMENTS, ",", ">", p);
+        this.afterSyntax(importType, p);
+        return importType;
+    }
+    visitTypeDeclaration(typeDeclaration, p) {
+        this.beforeSyntax(typeDeclaration, _1.JsSpace.Location.TYPE_DECLARATION_PREFIX, p);
+        typeDeclaration.modifiers.forEach(m => this.visitModifier(m, p));
+        this.visitJsLeftPaddedLocal("type", typeDeclaration.padding.name, _1.JsLeftPadded.Location.TYPE_DECLARATION_NAME, p);
+        const typeParameters = typeDeclaration.typeParameters;
+        if (typeParameters) {
+            this.visitNodes(typeParameters.annotations, p);
+            this.visitSpace(typeParameters.prefix, 136, p);
+            this.visitMarkers(typeParameters.markers, p);
+            p.append("<");
+            this.visitJRightPaddedLocal(typeParameters.padding.typeParameters, java_1.JRightPadded.Location.TYPE_PARAMETER, ",", p);
+            p.append(">");
+        }
+        this.visitJsLeftPaddedLocal("=", typeDeclaration.padding.initializer, _1.JsLeftPadded.Location.TYPE_DECLARATION_INITIALIZER, p);
+        this.afterSyntax(typeDeclaration, p);
+        return typeDeclaration;
+    }
+    visitLiteralType(literalType, p) {
+        this.beforeSyntax(literalType, _1.JsSpace.Location.LITERAL_TYPE_PREFIX, p);
+        this.visit(literalType.literal, p);
+        this.afterSyntax(literalType, p);
+        return literalType;
+    }
+    visitNamedImports(namedImports, p) {
+        this.beforeSyntax(namedImports, _1.JsSpace.Location.NAMED_IMPORTS_PREFIX, p);
+        this.visitJsContainerLocal("{", namedImports.padding.elements, _1.JsContainer.Location.NAMED_IMPORTS_ELEMENTS, ",", "}", p);
+        this.afterSyntax(namedImports, p);
+        return namedImports;
+    }
+    visitJsImportSpecifier(jis, p) {
+        this.beforeSyntax(jis, _1.JsSpace.Location.JS_IMPORT_SPECIFIER_PREFIX, p);
+        if (jis.importType) {
+            this.visitJsLeftPaddedLocal("type", jis.padding.importType, _1.JsLeftPadded.Location.JS_IMPORT_SPECIFIER_IMPORT_TYPE, p);
+        }
+        this.visit(jis.specifier, p);
+        this.afterSyntax(jis, p);
+        return jis;
+    }
+    visitExportDeclaration(ed, p) {
+        this.beforeSyntax(ed, _1.JsSpace.Location.EXPORT_DECLARATION_PREFIX, p);
+        p.append("export");
+        ed.modifiers.forEach(it => this.visitModifier(it, p));
+        if (ed.typeOnly) {
+            this.visitJsLeftPaddedLocal("type", ed.padding.typeOnly, _1.JsLeftPadded.Location.EXPORT_DECLARATION_TYPE_ONLY, p);
+        }
+        this.visit(ed.exportClause, p);
+        this.visitJsLeftPaddedLocal("from", ed.padding.moduleSpecifier, _1.JsLeftPadded.Location.EXPORT_DECLARATION_MODULE_SPECIFIER, p);
+        this.visit(ed.attributes, p);
+        this.afterSyntax(ed, p);
+        return ed;
+    }
+    visitExportAssignment(es, p) {
+        this.beforeSyntax(es, _1.JsSpace.Location.EXPORT_ASSIGNMENT_PREFIX, p);
+        p.append("export");
+        es.modifiers.forEach(it => this.visitModifier(it, p));
+        if (es.exportEquals) {
+            this.visitJsLeftPaddedLocal("=", es.padding.exportEquals, _1.JsLeftPadded.Location.EXPORT_ASSIGNMENT_EXPORT_EQUALS, p);
+        }
+        this.visit(es.expression, p);
+        this.afterSyntax(es, p);
+        return es;
+    }
+    visitIndexedAccessType(iat, p) {
+        this.beforeSyntax(iat, _1.JsSpace.Location.INDEXED_ACCESS_TYPE_PREFIX, p);
+        this.visit(iat.objectType, p);
+        this.visit(iat.indexType, p);
+        this.afterSyntax(iat, p);
+        return iat;
+    }
+    visitIndexedAccessTypeIndexType(iatit, p) {
+        this.beforeSyntax(iatit, _1.JsSpace.Location.INDEXED_ACCESS_TYPE_INDEX_TYPE_PREFIX, p);
+        p.append("[");
+        this.visitJsRightPadded(iatit.padding.element, _1.JsRightPadded.Location.INDEXED_ACCESS_TYPE_INDEX_TYPE_ELEMENT, p);
+        p.append("]");
+        this.afterSyntax(iatit, p);
+        return iatit;
+    }
+    visitWithStatement(withStatement, p) {
+        this.beforeSyntax(withStatement, _1.JsSpace.Location.WITH_STATEMENT_PREFIX, p);
+        p.append("with");
+        this.visit(withStatement.expression, p);
+        this.visitJsRightPadded(withStatement.padding.body, _1.JsRightPadded.Location.WITH_STATEMENT_BODY, p);
+        this.afterSyntax(withStatement, p);
+        return withStatement;
+    }
+    visitExportSpecifier(es, p) {
+        this.beforeSyntax(es, _1.JsSpace.Location.EXPORT_SPECIFIER_PREFIX, p);
+        if (es.typeOnly) {
+            this.visitJsLeftPaddedLocal("type", es.padding.typeOnly, _1.JsLeftPadded.Location.EXPORT_SPECIFIER_TYPE_ONLY, p);
+        }
+        this.visit(es.specifier, p);
+        this.afterSyntax(es, p);
+        return es;
+    }
+    visitNamedExports(ne, p) {
+        this.beforeSyntax(ne, _1.JsSpace.Location.NAMED_EXPORTS_PREFIX, p);
+        this.visitJsContainerLocal("{", ne.padding.elements, _1.JsContainer.Location.NAMED_EXPORTS_ELEMENTS, ",", "}", p);
+        this.afterSyntax(ne, p);
+        return ne;
+    }
+    visitImportAttributes(importAttributes, p) {
+        this.beforeSyntax(importAttributes, _1.JsSpace.Location.IMPORT_ATTRIBUTES_PREFIX, p);
+        p.append(JS.ImportAttributes.Token[importAttributes.token].toLowerCase());
+        this.visitJsContainerLocal("{", importAttributes.padding.elements, _1.JsContainer.Location.IMPORT_ATTRIBUTES_ELEMENTS, ",", "}", p);
+        this.afterSyntax(importAttributes, p);
+        return importAttributes;
+    }
+    visitImportAttribute(importAttribute, p) {
+        this.beforeSyntax(importAttribute, _1.JsSpace.Location.IMPORT_ATTRIBUTE_PREFIX, p);
+        this.visit(importAttribute.name, p);
+        this.visitJsLeftPaddedLocal(":", importAttribute.padding.value, _1.JsLeftPadded.Location.IMPORT_ATTRIBUTE_VALUE, p);
+        this.afterSyntax(importAttribute, p);
+        return importAttribute;
+    }
+    visitImportTypeAttributes(importAttributes, p) {
+        this.beforeSyntax(importAttributes, _1.JsSpace.Location.IMPORT_TYPE_ATTRIBUTES_PREFIX, p);
+        p.append("{");
+        this.visitJsRightPadded(importAttributes.padding.token, _1.JsRightPadded.Location.IMPORT_TYPE_ATTRIBUTES_TOKEN, p);
+        p.append(":");
+        this.visitJsContainerLocal("{", importAttributes.padding.elements, _1.JsContainer.Location.IMPORT_TYPE_ATTRIBUTES_ELEMENTS, ",", "}", p);
+        this.visitSpace(importAttributes.end, _1.JsSpace.Location.IMPORT_TYPE_ATTRIBUTES_END, p);
+        p.append("}");
+        this.afterSyntax(importAttributes, p);
+        return importAttributes;
+    }
+    visitArrayBindingPattern(abp, p) {
+        this.beforeSyntax(abp, _1.JsSpace.Location.ARRAY_BINDING_PATTERN_PREFIX, p);
+        this.visitJsContainerLocal("[", abp.padding.elements, _1.JsContainer.Location.ARRAY_BINDING_PATTERN_ELEMENTS, ",", "]", p);
+        this.afterSyntax(abp, p);
+        return abp;
+    }
+    visitMappedType(mappedType, p) {
+        this.beforeSyntax(mappedType, _1.JsSpace.Location.MAPPED_TYPE_PREFIX, p);
+        p.append("{");
+        if (mappedType.prefixToken != null) {
+            this.visitJsLeftPadded(mappedType.padding.prefixToken, _1.JsLeftPadded.Location.MAPPED_TYPE_PREFIX_TOKEN, p);
+        }
+        if (mappedType.hasReadonly) {
+            this.visitJsLeftPaddedLocal("readonly", mappedType.padding.hasReadonly, _1.JsLeftPadded.Location.MAPPED_TYPE_HAS_READONLY, p);
+        }
+        this.visitMappedTypeKeysRemapping(mappedType.keysRemapping, p);
+        if (mappedType.suffixToken != null) {
+            this.visitJsLeftPadded(mappedType.padding.suffixToken, _1.JsLeftPadded.Location.MAPPED_TYPE_SUFFIX_TOKEN, p);
+        }
+        if (mappedType.hasQuestionToken) {
+            this.visitJsLeftPaddedLocal("?", mappedType.padding.hasQuestionToken, _1.JsLeftPadded.Location.MAPPED_TYPE_HAS_QUESTION_TOKEN, p);
+        }
+        const colon = mappedType.valueType[0] instanceof J.Empty ? "" : ":";
+        this.visitJsContainerLocal(colon, mappedType.padding.valueType, _1.JsContainer.Location.MAPPED_TYPE_VALUE_TYPE, "", "", p);
+        p.append("}");
+        this.afterSyntax(mappedType, p);
+        return mappedType;
+    }
+    visitMappedTypeKeysRemapping(mappedTypeKeys, p) {
+        this.beforeSyntax(mappedTypeKeys, _1.JsSpace.Location.MAPPED_TYPE_KEYS_REMAPPING_PREFIX, p);
+        p.append("[");
+        this.visitJsRightPadded(mappedTypeKeys.padding.typeParameter, _1.JsRightPadded.Location.MAPPED_TYPE_KEYS_REMAPPING_TYPE_PARAMETER, p);
+        if (mappedTypeKeys.nameType != null) {
+            p.append("as");
+            this.visitJsRightPadded(mappedTypeKeys.padding.nameType, _1.JsRightPadded.Location.MAPPED_TYPE_KEYS_REMAPPING_NAME_TYPE, p);
+        }
+        p.append("]");
+        this.afterSyntax(mappedTypeKeys, p);
+        return mappedTypeKeys;
+    }
+    visitMappedTypeMappedTypeParameter(mappedTypeParameter, p) {
+        this.beforeSyntax(mappedTypeParameter, _1.JsSpace.Location.MAPPED_TYPE_MAPPED_TYPE_PARAMETER_PREFIX, p);
+        this.visit(mappedTypeParameter.name, p);
+        this.visitJsLeftPaddedLocal("in", mappedTypeParameter.padding.iterateType, _1.JsLeftPadded.Location.MAPPED_TYPE_MAPPED_TYPE_PARAMETER_ITERATE_TYPE, p);
+        this.afterSyntax(mappedTypeParameter, p);
+        return mappedTypeParameter;
+    }
+    visitObjectBindingDeclarations(objectBindingDeclarations, p) {
+        this.beforeSyntax(objectBindingDeclarations, _1.JsSpace.Location.OBJECT_BINDING_DECLARATIONS_PREFIX, p);
+        this.visitNodes(objectBindingDeclarations.leadingAnnotations, p);
+        objectBindingDeclarations.modifiers.forEach(m => this.visitModifier(m, p));
+        this.visit(objectBindingDeclarations.typeExpression, p);
+        this.visitJsContainerLocal("{", objectBindingDeclarations.padding.bindings, _1.JsContainer.Location.OBJECT_BINDING_DECLARATIONS_BINDINGS, ",", "}", p);
+        this.visitJsLeftPaddedLocal("=", objectBindingDeclarations.padding.initializer, _1.JsLeftPadded.Location.OBJECT_BINDING_DECLARATIONS_INITIALIZER, p);
+        this.afterSyntax(objectBindingDeclarations, p);
+        return objectBindingDeclarations;
+    }
+    visitTaggedTemplateExpression(taggedTemplateExpression, p) {
+        this.beforeSyntax(taggedTemplateExpression, _1.JsSpace.Location.TAGGED_TEMPLATE_EXPRESSION_PREFIX, p);
+        this.visitJsRightPadded(taggedTemplateExpression.padding.tag, _1.JsRightPadded.Location.TAGGED_TEMPLATE_EXPRESSION_TAG, p);
+        this.visitJsContainerLocal("<", taggedTemplateExpression.padding.typeArguments, _1.JsContainer.Location.TAGGED_TEMPLATE_EXPRESSION_TYPE_ARGUMENTS, ",", ">", p);
+        this.visit(taggedTemplateExpression.templateExpression, p);
+        this.afterSyntax(taggedTemplateExpression, p);
+        return taggedTemplateExpression;
+    }
+    visitTemplateExpression(templateExpression, p) {
+        this.beforeSyntax(templateExpression, _1.JsSpace.Location.TEMPLATE_EXPRESSION_PREFIX, p);
+        this.visit(templateExpression.head, p);
+        this.visitJsRightPaddedLocal(templateExpression.padding.templateSpans, _1.JsRightPadded.Location.TEMPLATE_EXPRESSION_TEMPLATE_SPANS, "", p);
+        this.afterSyntax(templateExpression, p);
+        return templateExpression;
+    }
+    visitTemplateExpressionTemplateSpan(value, p) {
+        this.beforeSyntax(value, _1.JsSpace.Location.TEMPLATE_EXPRESSION_TEMPLATE_SPAN_PREFIX, p);
+        this.visit(value.expression, p);
+        this.visit(value.tail, p);
+        this.afterSyntax(value, p);
+        return value;
+    }
+    visitTuple(tuple, p) {
+        this.beforeSyntax(tuple, _1.JsSpace.Location.TUPLE_PREFIX, p);
+        this.visitJsContainerLocal("[", tuple.padding.elements, _1.JsContainer.Location.TUPLE_ELEMENTS, ",", "]", p);
+        this.afterSyntax(tuple, p);
+        return tuple;
+    }
+    visitTypeQuery(typeQuery, p) {
+        this.beforeSyntax(typeQuery, _1.JsSpace.Location.TYPE_QUERY_PREFIX, p);
+        p.append("typeof");
+        this.visit(typeQuery.typeExpression, p);
+        this.visitJsContainerLocal("<", typeQuery.padding.typeArguments, _1.JsContainer.Location.TYPE_QUERY_TYPE_ARGUMENTS, ",", ">", p);
+        this.afterSyntax(typeQuery, p);
+        return typeQuery;
+    }
+    visitTypeOf(typeOf, p) {
+        this.beforeSyntax(typeOf, _1.JsSpace.Location.TYPE_OF_PREFIX, p);
+        p.append("typeof");
+        this.visit(typeOf.expression, p);
+        this.afterSyntax(typeOf, p);
+        return typeOf;
+    }
+    visitTypeOperator(typeOperator, p) {
+        this.beforeSyntax(typeOperator, _1.JsSpace.Location.TYPE_OPERATOR_PREFIX, p);
+        let keyword = "";
+        if (typeOperator.operator === JS.TypeOperator.Type.ReadOnly) {
+            keyword = "readonly";
+        }
+        else if (typeOperator.operator === JS.TypeOperator.Type.KeyOf) {
+            keyword = "keyof";
+        }
+        else if (typeOperator.operator === JS.TypeOperator.Type.Unique) {
+            keyword = "unique";
+        }
+        p.append(keyword);
+        this.visitJsLeftPadded(typeOperator.padding.expression, _1.JsLeftPadded.Location.TYPE_OPERATOR_EXPRESSION, p);
+        this.afterSyntax(typeOperator, p);
+        return typeOperator;
+    }
+    visitTypePredicate(typePredicate, p) {
+        this.beforeSyntax(typePredicate, _1.JsSpace.Location.TYPE_PREDICATE_PREFIX, p);
+        if (typePredicate.asserts) {
+            this.visitJsLeftPaddedLocal("asserts", typePredicate.padding.asserts, _1.JsLeftPadded.Location.TYPE_PREDICATE_ASSERTS, p);
+        }
+        this.visit(typePredicate.parameterName, p);
+        this.visitJsLeftPaddedLocal("is", typePredicate.padding.expression, _1.JsLeftPadded.Location.TYPE_PREDICATE_EXPRESSION, p);
+        this.afterSyntax(typePredicate, p);
+        return typePredicate;
+    }
+    visitIndexSignatureDeclaration(isd, p) {
+        this.beforeSyntax(isd, _1.JsSpace.Location.INDEX_SIGNATURE_DECLARATION_PREFIX, p);
+        isd.modifiers.forEach(m => this.visitModifier(m, p));
+        this.visitJsContainerLocal("[", isd.padding.parameters, _1.JsContainer.Location.INDEX_SIGNATURE_DECLARATION_PARAMETERS, "", "]", p);
+        this.visitJsLeftPaddedLocal(":", isd.padding.typeExpression, _1.JsLeftPadded.Location.INDEX_SIGNATURE_DECLARATION_TYPE_EXPRESSION, p);
+        this.afterSyntax(isd, p);
+        return isd;
+    }
+    visitAnnotation(annotation, p) {
+        this.beforeSyntax(annotation, 5, p);
+        p.append("@");
+        this.visit(annotation.annotationType, p);
+        this.visitJContainerLocal("(", annotation.padding.arguments, java_1.JContainer.Location.ANNOTATION_ARGUMENTS, ",", ")", p);
+        this.afterSyntax(annotation, p);
+        return annotation;
+    }
+    visitNewArray(newArray, p) {
+        this.beforeSyntax(newArray, 98, p);
+        this.visit(newArray.typeExpression, p);
+        this.visitNodes(newArray.dimensions, p);
+        this.visitJContainerLocal("[", newArray.padding.initializer, java_1.JContainer.Location.NEW_ARRAY_INITIALIZER, ",", "]", p);
+        this.afterSyntax(newArray, p);
+        return newArray;
+    }
+    visitNewClass(newClass, p) {
+        this.beforeSyntax(newClass, 102, p);
+        this.visitJRightPaddedLocalSingle(newClass.padding.enclosing, java_1.JRightPadded.Location.NEW_CLASS_ENCLOSING, ".", p);
+        this.visitSpace(newClass.new, 103, p);
+        if (newClass.clazz) {
+            p.append("new");
+            this.visit(newClass.clazz, p);
+            if (!newClass.padding.arguments.markers.findFirst(J.OmitParentheses)) {
+                this.visitJContainerLocal("(", newClass.padding.arguments, java_1.JContainer.Location.NEW_CLASS_ARGUMENTS, ",", ")", p);
+            }
+        }
+        this.visit(newClass.body, p);
+        this.afterSyntax(newClass, p);
+        return newClass;
+    }
+    visitSwitch(switch_, p) {
+        this.beforeSyntax(switch_, 119, p);
+        p.append("switch");
+        this.visit(switch_.selector, p);
+        this.visit(switch_.cases, p);
+        this.afterSyntax(switch_, p);
+        return switch_;
+    }
+    visitCase(case_, p) {
+        this.beforeSyntax(case_, 23, p);
+        const elem = case_.caseLabels[0];
+        if (!(elem instanceof J.Identifier) || elem.simpleName !== "default") {
+            p.append("case");
+        }
+        this.visitJContainerLocal("", case_.padding.caseLabels, java_1.JContainer.Location.CASE_CASE_LABELS, ",", "", p);
+        this.visitSpace(case_.padding.statements.before, 22, p);
+        p.append(case_.type === J.Case.Type.Statement ? ":" : "->");
+        this.visitStatements(case_.padding.statements.padding.elements, java_1.JRightPadded.Location.CASE, p);
+        this.afterSyntax(case_, p);
+        return case_;
+    }
+    visitLabel(label, p) {
+        this.beforeSyntax(label, 73, p);
+        this.visitJRightPaddedLocalSingle(label.padding.label, java_1.JRightPadded.Location.LABEL, ":", p);
+        this.visit(label.statement, p);
+        this.afterSyntax(label, p);
+        return label;
+    }
+    visitContinue(continueStatement, p) {
+        this.beforeSyntax(continueStatement, 35, p);
+        p.append("continue");
+        this.visit(continueStatement.label, p);
+        this.afterSyntax(continueStatement, p);
+        return continueStatement;
+    }
+    visitBreak(breakStatement, p) {
+        this.beforeSyntax(breakStatement, 21, p);
+        p.append("break");
+        this.visit(breakStatement.label, p);
+        this.afterSyntax(breakStatement, p);
+        return breakStatement;
+    }
+    visitFieldAccess(fieldAccess, p) {
+        this.beforeSyntax(fieldAccess, 49, p);
+        this.visit(fieldAccess.target, p);
+        this.visitJLeftPaddedLocal(".", fieldAccess.padding.name, java_1.JLeftPadded.Location.FIELD_ACCESS_NAME, p);
+        this.afterSyntax(fieldAccess, p);
+        return fieldAccess;
+    }
+    visitTypeLiteral(tl, p) {
+        this.beforeSyntax(tl, _1.JsSpace.Location.TYPE_LITERAL_PREFIX, p);
+        this.visit(tl.members, p);
+        this.afterSyntax(tl, p);
+        return tl;
+    }
+    visitParentheses(parens, p) {
+        this.beforeSyntax(parens, 109, p);
+        p.append('(');
+        this.visitJRightPaddedLocalSingle(parens.padding.tree, java_1.JRightPadded.Location.PARENTHESES, ")", p);
+        this.afterSyntax(parens, p);
+        return parens;
+    }
+    visitParameterizedType(type, p) {
+        this.beforeSyntax(type, 108, p);
+        this.visit(type.clazz, p);
+        this.visitJContainerLocal("<", type.padding.typeParameters, java_1.JContainer.Location.TYPE_PARAMETERS, ",", ">", p);
+        this.afterSyntax(type, p);
+        return type;
+    }
+    visitAssignment(assignment, p) {
+        this.beforeSyntax(assignment, 15, p);
+        this.visit(assignment.variable, p);
+        this.visitJLeftPaddedLocal("=", assignment.padding.assignment, java_1.JLeftPadded.Location.ASSIGNMENT, p);
+        this.afterSyntax(assignment, p);
+        return assignment;
+    }
+    visitPropertyAssignment(propertyAssignment, p) {
+        this.beforeSyntax(propertyAssignment, _1.JsSpace.Location.PROPERTY_ASSIGNMENT_PREFIX, p);
+        this.visitJsRightPadded(propertyAssignment.padding.name, _1.JsRightPadded.Location.PROPERTY_ASSIGNMENT_NAME, p);
+        if (propertyAssignment.initializer) {
+            if (propertyAssignment.assigmentToken === JS.PropertyAssignment.AssigmentToken.Colon) {
+                p.append(':');
+            }
+            else if (propertyAssignment.assigmentToken === JS.PropertyAssignment.AssigmentToken.Equals) {
+                p.append('=');
+            }
+            this.visit(propertyAssignment.initializer, p);
+        }
+        this.afterSyntax(propertyAssignment, p);
+        return propertyAssignment;
+    }
+    visitAssignmentOperation(assignOp, p) {
+        let keyword = "";
+        switch (assignOp.operator) {
+            case J.AssignmentOperation.Type.Addition:
+                keyword = "+=";
+                break;
+            case J.AssignmentOperation.Type.Subtraction:
+                keyword = "-=";
+                break;
+            case J.AssignmentOperation.Type.Multiplication:
+                keyword = "*=";
+                break;
+            case J.AssignmentOperation.Type.Division:
+                keyword = "/=";
+                break;
+            case J.AssignmentOperation.Type.Modulo:
+                keyword = "%=";
+                break;
+            case J.AssignmentOperation.Type.BitAnd:
+                keyword = "&=";
+                break;
+            case J.AssignmentOperation.Type.BitOr:
+                keyword = "|=";
+                break;
+            case J.AssignmentOperation.Type.BitXor:
+                keyword = "^=";
+                break;
+            case J.AssignmentOperation.Type.LeftShift:
+                keyword = "<<=";
+                break;
+            case J.AssignmentOperation.Type.RightShift:
+                keyword = ">>=";
+                break;
+            case J.AssignmentOperation.Type.UnsignedRightShift:
+                keyword = ">>>=";
+                break;
+        }
+        this.beforeSyntax(assignOp, 13, p);
+        this.visit(assignOp.variable, p);
+        this.visitSpace(assignOp.padding.operator.before, 14, p);
+        p.append(keyword);
+        this.visit(assignOp.assignment, p);
+        this.afterSyntax(assignOp, p);
+        return assignOp;
+    }
+    visitJsAssignmentOperation(assignOp, p) {
+        let keyword = "";
+        switch (assignOp.operator) {
+            case JS.JsAssignmentOperation.Type.QuestionQuestion:
+                keyword = "??=";
+                break;
+            case JS.JsAssignmentOperation.Type.And:
+                keyword = "&&=";
+                break;
+            case JS.JsAssignmentOperation.Type.Or:
+                keyword = "||=";
+                break;
+            case JS.JsAssignmentOperation.Type.Power:
+                keyword = "**";
+                break;
+            case JS.JsAssignmentOperation.Type.Exp:
+                keyword = "**=";
+                break;
+        }
+        this.beforeSyntax(assignOp, _1.JsSpace.Location.JS_ASSIGNMENT_OPERATION_PREFIX, p);
+        this.visit(assignOp.variable, p);
+        this.visitSpace(assignOp.padding.operator.before, _1.JsSpace.Location.JS_ASSIGNMENT_OPERATION_OPERATOR_PREFIX, p);
+        p.append(keyword);
+        this.visit(assignOp.assignment, p);
+        this.afterSyntax(assignOp, p);
+        return assignOp;
+    }
+    visitEnumValue(enum_, p) {
+        this.beforeSyntax(enum_, 43, p);
+        this.visit(enum_.name, p);
+        const initializer = enum_.initializer;
+        if (initializer) {
+            this.visitSpace(initializer.prefix, 102, p);
+            p.append("=");
+            const expression = initializer.arguments[0];
+            this.visit(expression, p);
+            return enum_;
+        }
+        this.afterSyntax(enum_, p);
+        return enum_;
+    }
+    visitEnumValueSet(enums, p) {
+        this.beforeSyntax(enums, 44, p);
+        this.visitJRightPaddedLocal(enums.padding.enums, java_1.JRightPadded.Location.ENUM_VALUE, ",", p);
+        if (enums.terminatedWithSemicolon) {
+            p.append(",");
+        }
+        this.afterSyntax(enums, p);
+        return enums;
+    }
+    visitBinary(binary, p) {
+        let keyword = "";
+        switch (binary.operator) {
+            case J.Binary.Type.Addition:
+                keyword = "+";
+                break;
+            case J.Binary.Type.Subtraction:
+                keyword = "-";
+                break;
+            case J.Binary.Type.Multiplication:
+                keyword = "*";
+                break;
+            case J.Binary.Type.Division:
+                keyword = "/";
+                break;
+            case J.Binary.Type.Modulo:
+                keyword = "%";
+                break;
+            case J.Binary.Type.LessThan:
+                keyword = "<";
+                break;
+            case J.Binary.Type.GreaterThan:
+                keyword = ">";
+                break;
+            case J.Binary.Type.LessThanOrEqual:
+                keyword = "<=";
+                break;
+            case J.Binary.Type.GreaterThanOrEqual:
+                keyword = ">=";
+                break;
+            case J.Binary.Type.Equal:
+                keyword = "==";
+                break;
+            case J.Binary.Type.NotEqual:
+                keyword = "!=";
+                break;
+            case J.Binary.Type.BitAnd:
+                keyword = "&";
+                break;
+            case J.Binary.Type.BitOr:
+                keyword = "|";
+                break;
+            case J.Binary.Type.BitXor:
+                keyword = "^";
+                break;
+            case J.Binary.Type.LeftShift:
+                keyword = "<<";
+                break;
+            case J.Binary.Type.RightShift:
+                keyword = ">>";
+                break;
+            case J.Binary.Type.UnsignedRightShift:
+                keyword = ">>>";
+                break;
+            case J.Binary.Type.Or:
+                keyword = "||";
+                break;
+            case J.Binary.Type.And:
+                keyword = "&&";
+                break;
+        }
+        this.beforeSyntax(binary, 17, p);
+        this.visit(binary.left, p);
+        this.visitSpace(binary.padding.operator.before, 16, p);
+        p.append(keyword);
+        this.visit(binary.right, p);
+        this.afterSyntax(binary, p);
+        return binary;
+    }
+    visitJsBinary(binary, p) {
+        this.beforeSyntax(binary, _1.JsSpace.Location.JS_BINARY_PREFIX, p);
+        this.visit(binary.left, p);
+        let keyword = "";
+        switch (binary.operator) {
+            case JS.JsBinary.Type.As:
+                keyword = "as";
+                break;
+            case JS.JsBinary.Type.IdentityEquals:
+                keyword = "===";
+                break;
+            case JS.JsBinary.Type.IdentityNotEquals:
+                keyword = "!==";
+                break;
+            case JS.JsBinary.Type.In:
+                keyword = "in";
+                break;
+            case JS.JsBinary.Type.QuestionQuestion:
+                keyword = "??";
+                break;
+            case JS.JsBinary.Type.Comma:
+                keyword = ",";
+                break;
+        }
+        this.visitSpace(binary.padding.operator.before, _1.JsSpace.Location.JS_BINARY_OPERATOR, p);
+        p.append(keyword);
+        this.visit(binary.right, p);
+        this.afterSyntax(binary, p);
+        return binary;
+    }
+    visitUnary(unary, p) {
+        this.beforeSyntax(unary, 140, p);
+        switch (unary.operator) {
+            case J.Unary.Type.PreIncrement:
+                p.append("++");
+                this.visit(unary.expression, p);
+                break;
+            case J.Unary.Type.PreDecrement:
+                p.append("--");
+                this.visit(unary.expression, p);
+                break;
+            case J.Unary.Type.PostIncrement:
+                this.visit(unary.expression, p);
+                this.visitSpace(unary.padding.operator.before, 139, p);
+                p.append("++");
+                break;
+            case J.Unary.Type.PostDecrement:
+                this.visit(unary.expression, p);
+                this.visitSpace(unary.padding.operator.before, 139, p);
+                p.append("--");
+                break;
+            case J.Unary.Type.Positive:
+                p.append('+');
+                this.visit(unary.expression, p);
+                break;
+            case J.Unary.Type.Negative:
+                p.append('-');
+                this.visit(unary.expression, p);
+                break;
+            case J.Unary.Type.Complement:
+                p.append('~');
+                this.visit(unary.expression, p);
+                break;
+            case J.Unary.Type.Not:
+            default:
+                p.append('!');
+                this.visit(unary.expression, p);
+        }
+        this.afterSyntax(unary, p);
+        return unary;
+    }
+    visitJsUnary(unary, p) {
+        this.beforeSyntax(unary, _1.JsSpace.Location.UNARY_PREFIX, p);
+        switch (unary.operator) {
+            case JS.Unary.Type.Spread:
+                this.visitSpace(unary.padding.operator.before, _1.JsSpace.Location.UNARY_OPERATOR, p);
+                p.append("...");
+                this.visit(unary.expression, p);
+                break;
+            case JS.Unary.Type.Optional:
+                this.visit(unary.expression, p);
+                this.visitSpace(unary.padding.operator.before, _1.JsSpace.Location.UNARY_OPERATOR, p);
+                p.append("?");
+                break;
+            case JS.Unary.Type.Exclamation:
+                this.visit(unary.expression, p);
+                this.visitSpace(unary.padding.operator.before, _1.JsSpace.Location.UNARY_OPERATOR, p);
+                p.append("!");
+                break;
+            case JS.Unary.Type.QuestionDot:
+                this.visit(unary.expression, p);
+                this.visitSpace(unary.padding.operator.before, _1.JsSpace.Location.UNARY_OPERATOR, p);
+                p.append("?");
+                break;
+            case JS.Unary.Type.QuestionDotWithDot:
+                this.visit(unary.expression, p);
+                this.visitSpace(unary.padding.operator.before, _1.JsSpace.Location.UNARY_OPERATOR, p);
+                p.append("?.");
+                break;
+            case JS.Unary.Type.Asterisk:
+                p.append("*");
+                this.visitSpace(unary.padding.operator.before, _1.JsSpace.Location.UNARY_OPERATOR, p);
+                this.visit(unary.expression, p);
+                break;
+            default:
+                break;
+        }
+        this.afterSyntax(unary, p);
+        return unary;
+    }
+    visitUnion(union, p) {
+        this.beforeSyntax(union, _1.JsSpace.Location.UNION_PREFIX, p);
+        this.visitJsRightPaddedLocal(union.padding.types, _1.JsRightPadded.Location.UNION_TYPES, "|", p);
+        this.afterSyntax(union, p);
+        return union;
+    }
+    visitIntersection(intersection, p) {
+        this.beforeSyntax(intersection, _1.JsSpace.Location.INTERSECTION_PREFIX, p);
+        this.visitJsRightPaddedLocal(intersection.padding.types, _1.JsRightPadded.Location.INTERSECTION_TYPES, "&", p);
+        this.afterSyntax(intersection, p);
+        return intersection;
+    }
+    visitForLoop(forLoop, p) {
+        this.beforeSyntax(forLoop, 58, p);
+        p.append("for");
+        const ctrl = forLoop.control;
+        this.visitSpace(ctrl.prefix, 54, p);
+        p.append('(');
+        this.visitJRightPaddedLocal(ctrl.padding.init, java_1.JRightPadded.Location.FOR_INIT, ",", p);
+        p.append(';');
+        this.visitJRightPaddedLocalSingle(ctrl.padding.condition, java_1.JRightPadded.Location.FOR_CONDITION, ";", p);
+        this.visitJRightPaddedLocal(ctrl.padding.update, java_1.JRightPadded.Location.FOR_UPDATE, ",", p);
+        p.append(')');
+        this.visitStatementLocal(forLoop.padding.body, java_1.JRightPadded.Location.FOR_BODY, p);
+        this.afterSyntax(forLoop, p);
+        return forLoop;
+    }
+    visitJSForOfLoop(loop, p) {
+        this.beforeSyntax(loop, _1.JsSpace.Location.JSFOR_OF_LOOP_PREFIX, p);
+        p.append("for");
+        if (loop.await) {
+            this.visitJsLeftPaddedLocal("await", loop.padding.await, _1.JsLeftPadded.Location.JSFOR_OF_LOOP_AWAIT, p);
+        }
+        const control = loop.control;
+        this.visitSpace(control.prefix, _1.JsSpace.Location.JSFOR_IN_OF_LOOP_CONTROL_PREFIX, p);
+        p.append('(');
+        this.visitJsRightPadded(control.padding.variable, _1.JsRightPadded.Location.JSFOR_IN_OF_LOOP_CONTROL_VARIABLE, p);
+        p.append("of");
+        this.visitJsRightPadded(control.padding.iterable, _1.JsRightPadded.Location.JSFOR_IN_OF_LOOP_CONTROL_ITERABLE, p);
+        p.append(')');
+        this.visitJsRightPadded(loop.padding.body, _1.JsRightPadded.Location.JSFOR_OF_LOOP_BODY, p);
+        this.afterSyntax(loop, p);
+        return loop;
+    }
+    visitJSForInLoop(loop, p) {
+        this.beforeSyntax(loop, _1.JsSpace.Location.JSFOR_IN_LOOP_PREFIX, p);
+        p.append("for");
+        const control = loop.control;
+        this.visitSpace(control.prefix, _1.JsSpace.Location.JSFOR_IN_OF_LOOP_CONTROL_PREFIX, p);
+        p.append('(');
+        this.visitJsRightPadded(control.padding.variable, _1.JsRightPadded.Location.JSFOR_IN_OF_LOOP_CONTROL_VARIABLE, p);
+        p.append("in");
+        this.visitJsRightPadded(control.padding.iterable, _1.JsRightPadded.Location.JSFOR_IN_OF_LOOP_CONTROL_ITERABLE, p);
+        p.append(')');
+        this.visitJsRightPadded(loop.padding.body, _1.JsRightPadded.Location.JSFOR_IN_LOOP_BODY, p);
+        this.afterSyntax(loop, p);
+        return loop;
+    }
+    visitStatements(statements, location, p) {
+        var _a, _b;
+        const objectLiteral = ((_a = this.getParentCursor(0)) === null || _a === void 0 ? void 0 : _a.value()) instanceof J.Block &&
+            ((_b = this.getParentCursor(1)) === null || _b === void 0 ? void 0 : _b.value()) instanceof J.NewClass;
+        for (let i = 0; i < statements.length; i++) {
+            const paddedStat = statements[i];
+            this.visitStatementLocal(paddedStat, location, p);
+            if (i < statements.length - 1 && objectLiteral) {
+                p.append(",");
+            }
+        }
+    }
+    visitStatementLocal(paddedStat, location, p) {
+        if (paddedStat !== null) {
+            this.visit(paddedStat.element, p);
+            this.visitSpace(paddedStat.after, java_1.JRightPadded.Location.afterLocation(location), p);
+            this.visitMarkers(paddedStat.markers, p);
+        }
+    }
+    getParentCursor(levels) {
+        let cursor = this.cursor;
+        for (let i = 0; i < levels && cursor !== null; i++) {
+            cursor = cursor.parent;
+        }
+        return cursor;
+    }
+    afterSyntax(j, p) {
+        this.afterSyntaxMarkers(j.markers, p);
+    }
+    afterSyntaxMarkers(markers, p) {
+        for (const marker of markers.markers) {
+            p.out.concat(p.markerPrinter.afterSyntax(marker, new core_1.Cursor(this.cursor, marker), this.JAVA_SCRIPT_MARKER_WRAPPER));
+        }
+    }
+    beforeSyntax(j, loc, p) {
+        this.beforeSyntaxExt(j.prefix, j.markers, loc, p);
+    }
+    beforeSyntaxExt(prefix, markers, loc, p) {
+        for (const marker of markers.markers) {
+            p.out.concat(p.markerPrinter.beforePrefix(marker, new core_1.Cursor(this.cursor, marker), this.JAVA_SCRIPT_MARKER_WRAPPER));
+        }
+        if (loc !== null) {
+            this.visitSpace(prefix, loc, p);
+        }
+        this.visitMarkers(markers, p);
+        for (const marker of markers.markers) {
+            p.out.concat(p.markerPrinter.beforeSyntax(marker, new core_1.Cursor(this.cursor, marker), this.JAVA_SCRIPT_MARKER_WRAPPER));
+        }
+    }
+    visitSpace(space, loc, p) {
+        p.append(space.whitespace);
+        const comments = space.comments;
+        for (let i = 0; i < comments.length; i++) {
+            const comment = comments[i];
+            this.visitMarkers(comment.markers, p);
+            this.printComment(comment, this.cursor, p);
+            p.append(comment.suffix);
+        }
+        return space;
+    }
+    visitJRightPaddedLocal(nodes, location, suffixBetween, p) {
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            this.visit(node.element, p);
+            if (location) {
+                const loc = java_1.JRightPadded.Location.afterLocation(location);
+                this.visitSpace(node.after, loc, p);
+            }
+            this.visitMarkers(node.markers, p);
+            if (i < nodes.length - 1) {
+                p.append(suffixBetween);
+            }
+        }
+    }
+    visitJRightPaddedLocalSingle(node, location, suffix, p) {
+        if (node) {
+            this.visit(node.element, p);
+            if (location) {
+                const loc = java_1.JRightPadded.Location.afterLocation(location);
+                this.visitSpace(node.after, loc, p);
+            }
+            this.visitMarkers(node.markers, p);
+            p.append(suffix);
+        }
+    }
+    visitJsRightPaddedLocal(nodes, location, suffixBetween, p) {
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            this.visit(node.element, p);
+            if (location) {
+                const loc = _1.JsRightPadded.Location.afterLocation(location);
+                this.visitSpace(node.after, loc, p);
+            }
+            this.visitMarkers(node.markers, p);
+            if (i < nodes.length - 1) {
+                p.append(suffixBetween);
+            }
+        }
+    }
+    visitJsRightPaddedLocalSingle(node, location, suffix, p) {
+        if (node) {
+            this.visit(node.element, p);
+            if (location) {
+                const loc = _1.JsRightPadded.Location.afterLocation(location);
+                this.visitSpace(node.after, loc, p);
+            }
+            this.visitMarkers(node.markers, p);
+            p.append(suffix);
+        }
+    }
+    visitJLeftPaddedLocal(prefix, leftPadded, location, p) {
+        if (leftPadded) {
+            const loc = java_1.JLeftPadded.Location.beforeLocation(location);
+            this.beforeSyntaxExt(leftPadded.before, leftPadded.markers, loc, p);
+            if (prefix) {
+                p.append(prefix);
+            }
+            if (typeof leftPadded.element !== 'boolean') {
+                this.visit(leftPadded.element, p);
+            }
+            this.afterSyntaxMarkers(leftPadded.markers, p);
+        }
+    }
+    visitJsLeftPaddedLocal(prefix, leftPadded, location, p) {
+        if (leftPadded) {
+            const loc = _1.JsLeftPadded.Location.beforeLocation(location);
+            this.beforeSyntaxExt(leftPadded.before, leftPadded.markers, loc, p);
+            if (prefix) {
+                p.append(prefix);
+            }
+            if (typeof leftPadded.element !== 'boolean') {
+                this.visit(leftPadded.element, p);
+            }
+            this.afterSyntaxMarkers(leftPadded.markers, p);
+        }
+    }
+    visitJContainerLocal(before, container, location, suffixBetween, after, p) {
+        if (container === null) {
+            return;
+        }
+        const beforeLocation = java_1.JContainer.Location.beforeLocation(location);
+        const elementLocation = java_1.JContainer.Location.elementLocation(location);
+        this.beforeSyntaxExt(container.before, container.markers, beforeLocation, p);
+        p.append(before);
+        this.visitJRightPaddedLocal(container.padding.elements, elementLocation, suffixBetween, p);
+        this.afterSyntaxMarkers(container.markers, p);
+        p.append(after === null ? "" : after);
+    }
+    visitJsContainerLocal(before, container, location, suffixBetween, after, p) {
+        if (container === null) {
+            return;
+        }
+        const beforeLocation = _1.JsContainer.Location.beforeLocation(location);
+        const elementLocation = _1.JsContainer.Location.elementLocation(location);
+        this.beforeSyntaxExt(container.before, container.markers, beforeLocation, p);
+        p.append(before);
+        this.visitJsRightPaddedLocal(container.padding.elements, elementLocation, suffixBetween, p);
+        this.afterSyntaxMarkers(container.markers, p);
+        p.append(after === null ? "" : after);
+    }
+    visitMarker(marker, p) {
+        if (marker instanceof java_1.Semicolon) {
+            p.append(';');
+        }
+        if (marker instanceof java_1.TrailingComma) {
+            p.append(',');
+            this.visitSpace(marker.suffix, 155, p);
+        }
+        return marker;
+    }
+    printComment(comment, cursor, p) {
+        for (const marker of comment.markers.markers) {
+            p.append(p.markerPrinter.beforeSyntax(marker, new core_1.Cursor(cursor, this), this.JAVA_SCRIPT_MARKER_WRAPPER));
+        }
+        if (comment instanceof J.TextComment) {
+            p.append(comment.multiline ? `/*${comment.text}*/` : `//${comment.text}`);
+        }
+        for (const marker of comment.markers.markers) {
+            p.append(p.markerPrinter.afterSyntax(marker, new core_1.Cursor(cursor, this), this.JAVA_SCRIPT_MARKER_WRAPPER));
+        }
+    }
+    visitNodes(nodes, p) {
+        if (nodes) {
+            for (const node of nodes) {
+                this.visit(node, p);
+            }
+        }
+    }
+    visitControlParentheses(controlParens, p) {
+        var _a;
+        this.beforeSyntax(controlParens, 36, p);
+        if (((_a = this.getParentCursor(1)) === null || _a === void 0 ? void 0 : _a.value()) instanceof J.TypeCast) {
+            p.append('<');
+            this.visitJRightPaddedLocalSingle(controlParens.padding.tree, java_1.JRightPadded.Location.PARENTHESES, ">", p);
+        }
+        else {
+            p.append('(');
+            this.visitJRightPaddedLocalSingle(controlParens.padding.tree, java_1.JRightPadded.Location.PARENTHESES, ")", p);
+        }
+        this.afterSyntax(controlParens, p);
+        return controlParens;
+    }
+}
+exports.JavaScriptPrinter = JavaScriptPrinter;
+//# sourceMappingURL=printer.js.map