@openrewrite/rewrite 8.72.2 → 8.72.4

package/dist/javascript/visitor.js

@@ -1,14 +1,5 @@
 "use strict";
 // noinspection JSUnusedGlobalSymbols
-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.JavaScriptVisitor = void 0;
 /*
@@ -31,1262 +22,1107 @@ const java_1 = require("../java");
 const mutative_1 = require("mutative");
 const tree_1 = require("./tree");
 class JavaScriptVisitor extends java_1.JavaVisitor {
-    isAcceptable(sourceFile) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, tree_1.isJavaScript)(sourceFile);
-        });
+    async isAcceptable(sourceFile) {
+        return (0, tree_1.isJavaScript)(sourceFile);
     }
     // noinspection JSUnusedGlobalSymbols,JSUnusedLocalSymbols
-    visitExpression(expression, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return expression;
-        });
+    async visitExpression(expression, p) {
+        return expression;
     }
     // noinspection JSUnusedGlobalSymbols,JSUnusedLocalSymbols
-    visitStatement(statement, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return statement;
-        });
+    async visitStatement(statement, p) {
+        return statement;
     }
     // noinspection JSUnusedLocalSymbols
-    visitSpace(space, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return space;
-        });
+    async visitSpace(space, p) {
+        return space;
     }
     // noinspection JSUnusedLocalSymbols
-    visitType(javaType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return javaType;
-        });
+    async visitType(javaType, p) {
+        return javaType;
     }
     // noinspection JSUnusedLocalSymbols
-    visitTypeName(nameTree, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return nameTree;
-        });
-    }
-    produceJavaScript(before, p, recipe) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [draft, finishDraft] = (0, mutative_1.create)(before);
-            draft.prefix = yield this.visitSpace(before.prefix, p);
-            draft.markers = yield this.visitMarkers(before.markers, p);
-            if (recipe) {
-                yield recipe(draft);
-            }
-            return finishDraft();
-        });
-    }
-    visitAlias(alias, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(alias, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Alias) {
-                return expression;
-            }
-            alias = expression;
-            const updates = {
-                prefix: yield this.visitSpace(alias.prefix, p),
-                markers: yield this.visitMarkers(alias.markers, p),
-                propertyName: yield this.visitRightPadded(alias.propertyName, p),
-                alias: yield this.visitDefined(alias.alias, p)
-            };
-            return (0, util_1.updateIfChanged)(alias, updates);
-        });
-    }
-    visitArrowFunction(arrowFunction, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(arrowFunction, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ArrowFunction) {
-                return expression;
-            }
-            arrowFunction = expression;
-            const statement = yield this.visitStatement(arrowFunction, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.ArrowFunction) {
-                return statement;
-            }
-            arrowFunction = statement;
-            const updates = {
-                prefix: yield this.visitSpace(arrowFunction.prefix, p),
-                markers: yield this.visitMarkers(arrowFunction.markers, p),
-                leadingAnnotations: yield (0, util_1.mapAsync)(arrowFunction.leadingAnnotations, item => this.visitDefined(item, p)),
-                modifiers: yield (0, util_1.mapAsync)(arrowFunction.modifiers, item => this.visitDefined(item, p)),
-                typeParameters: arrowFunction.typeParameters && (yield this.visitDefined(arrowFunction.typeParameters, p)),
-                lambda: yield this.visitDefined(arrowFunction.lambda, p),
-                returnTypeExpression: arrowFunction.returnTypeExpression && (yield this.visitDefined(arrowFunction.returnTypeExpression, p))
-            };
-            return (0, util_1.updateIfChanged)(arrowFunction, updates);
-        });
-    }
-    visitAs(as_, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(as_.prefix, p),
-                markers: yield this.visitMarkers(as_.markers, p),
-                left: yield this.visitRightPadded(as_.left, p),
-                right: yield this.visitDefined(as_.right, p),
-                type: as_.type && (yield this.visitType(as_.type, p))
-            };
-            return (0, util_1.updateIfChanged)(as_, updates);
-        });
-    }
-    visitAwait(await_, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(await_, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Await) {
-                return expression;
-            }
-            await_ = expression;
-            const updates = {
-                prefix: yield this.visitSpace(await_.prefix, p),
-                markers: yield this.visitMarkers(await_.markers, p),
-                expression: yield this.visitDefined(await_.expression, p),
-                type: await_.type && (yield this.visitType(await_.type, p))
-            };
-            return (0, util_1.updateIfChanged)(await_, updates);
-        });
-    }
-    visitJsxTag(element, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(element.prefix, p),
-                markers: yield this.visitMarkers(element.markers, p),
-                openName: yield this.visitLeftPadded(element.openName, p),
-                typeArguments: element.typeArguments && (yield this.visitContainer(element.typeArguments, p)),
-                afterName: yield this.visitSpace(element.afterName, p),
-                attributes: yield (0, util_1.mapAsync)(element.attributes, attr => this.visitRightPadded(attr, p)),
-                selfClosing: element.selfClosing && (yield this.visitSpace(element.selfClosing, p)),
-                children: element.children && (yield (0, util_1.mapAsync)(element.children, child => this.visit(child, p))),
-                closingName: element.closingName && (yield this.visitLeftPadded(element.closingName, p)),
-                afterClosingName: element.afterClosingName && (yield this.visitSpace(element.afterClosingName, p))
-            };
-            return (0, util_1.updateIfChanged)(element, updates);
-        });
-    }
-    visitJsxAttribute(attribute, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(attribute.prefix, p),
-                markers: yield this.visitMarkers(attribute.markers, p),
-                key: yield this.visitDefined(attribute.key, p),
-                value: attribute.value && (yield this.visitLeftPadded(attribute.value, p))
-            };
-            return (0, util_1.updateIfChanged)(attribute, updates);
-        });
-    }
-    visitJsxSpreadAttribute(spread, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(spread.prefix, p),
-                markers: yield this.visitMarkers(spread.markers, p),
-                dots: yield this.visitSpace(spread.dots, p),
-                expression: yield this.visitRightPadded(spread.expression, p)
-            };
-            return (0, util_1.updateIfChanged)(spread, updates);
-        });
-    }
-    visitJsxEmbeddedExpression(expr, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(expr.prefix, p),
-                markers: yield this.visitMarkers(expr.markers, p),
-                expression: yield this.visitRightPadded(expr.expression, p)
-            };
-            return (0, util_1.updateIfChanged)(expr, updates);
-        });
-    }
-    visitJsxNamespacedName(ns, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(ns.prefix, p),
-                markers: yield this.visitMarkers(ns.markers, p),
-                namespace: yield this.visitDefined(ns.namespace, p),
-                name: yield this.visitLeftPadded(ns.name, p)
-            };
-            return (0, util_1.updateIfChanged)(ns, updates);
-        });
-    }
-    visitJsCompilationUnit(compilationUnit, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(compilationUnit.prefix, p),
-                markers: yield this.visitMarkers(compilationUnit.markers, p),
-                statements: yield (0, util_1.mapAsync)(compilationUnit.statements, stmt => this.visitRightPadded(stmt, p)),
-                eof: yield this.visitSpace(compilationUnit.eof, p)
-            };
-            return (0, util_1.updateIfChanged)(compilationUnit, updates);
-        });
-    }
-    visitConditionalType(conditionalType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(conditionalType, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ConditionalType) {
-                return expression;
-            }
-            conditionalType = expression;
-            const updates = {
-                prefix: yield this.visitSpace(conditionalType.prefix, p),
-                markers: yield this.visitMarkers(conditionalType.markers, p),
-                checkType: yield this.visitDefined(conditionalType.checkType, p),
-                condition: yield this.visitLeftPadded(conditionalType.condition, p),
-                type: conditionalType.type && (yield this.visitType(conditionalType.type, p))
-            };
-            return (0, util_1.updateIfChanged)(conditionalType, updates);
-        });
-    }
-    visitDelete(delete_, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(delete_, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Delete) {
-                return expression;
-            }
-            delete_ = expression;
-            const statement = yield this.visitStatement(delete_, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.Delete) {
-                return statement;
-            }
-            delete_ = statement;
-            const updates = {
-                prefix: yield this.visitSpace(delete_.prefix, p),
-                markers: yield this.visitMarkers(delete_.markers, p),
-                expression: yield this.visitDefined(delete_.expression, p)
-            };
-            return (0, util_1.updateIfChanged)(delete_, updates);
-        });
-    }
-    visitExpressionStatement(expressionStatement, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(expressionStatement, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ExpressionStatement) {
-                return expression;
-            }
-            expressionStatement = expression;
-            const statement = yield this.visitStatement(expressionStatement, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.ExpressionStatement) {
-                return statement;
-            }
-            expressionStatement = statement;
-            const updates = {
-                prefix: yield this.visitSpace(expressionStatement.prefix, p),
-                markers: yield this.visitMarkers(expressionStatement.markers, p),
-                expression: yield this.visitDefined(expressionStatement.expression, p)
-            };
-            return (0, util_1.updateIfChanged)(expressionStatement, updates);
-        });
-    }
-    visitExpressionWithTypeArguments(expressionWithTypeArguments, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(expressionWithTypeArguments, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ExpressionWithTypeArguments) {
-                return expression;
-            }
-            expressionWithTypeArguments = expression;
-            const updates = {
-                prefix: yield this.visitSpace(expressionWithTypeArguments.prefix, p),
-                markers: yield this.visitMarkers(expressionWithTypeArguments.markers, p),
-                clazz: yield this.visitDefined(expressionWithTypeArguments.clazz, p),
-                typeArguments: expressionWithTypeArguments.typeArguments && (yield this.visitContainer(expressionWithTypeArguments.typeArguments, p)),
-                type: expressionWithTypeArguments.type && (yield this.visitType(expressionWithTypeArguments.type, p))
-            };
-            return (0, util_1.updateIfChanged)(expressionWithTypeArguments, updates);
-        });
-    }
-    visitFunctionCall(functionCall, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(functionCall, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.FunctionCall) {
-                return expression;
-            }
-            functionCall = expression;
-            const statement = yield this.visitStatement(functionCall, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.FunctionCall) {
-                return statement;
-            }
-            functionCall = statement;
-            const updates = {
-                prefix: yield this.visitSpace(functionCall.prefix, p),
-                markers: yield this.visitMarkers(functionCall.markers, p),
-                function: yield this.visitOptionalRightPadded(functionCall.function, p),
-                typeParameters: yield this.visitOptionalContainer(functionCall.typeParameters, p),
-                arguments: yield this.visitContainer(functionCall.arguments, p),
-                methodType: yield this.visitType(functionCall.methodType, p)
-            };
-            return (0, util_1.updateIfChanged)(functionCall, updates);
-        });
-    }
-    visitFunctionType(functionType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(functionType, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.FunctionType) {
-                return expression;
-            }
-            functionType = expression;
-            const updates = {
-                prefix: yield this.visitSpace(functionType.prefix, p),
-                markers: yield this.visitMarkers(functionType.markers, p),
-                constructorType: yield this.visitLeftPadded(functionType.constructorType, p),
-                typeParameters: functionType.typeParameters && (yield this.visitDefined(functionType.typeParameters, p)),
-                parameters: yield this.visitContainer(functionType.parameters, p),
-                returnType: yield this.visitLeftPadded(functionType.returnType, p)
-            };
-            return (0, util_1.updateIfChanged)(functionType, updates);
-        });
-    }
-    visitInferType(inferType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(inferType, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.InferType) {
-                return expression;
-            }
-            inferType = expression;
-            const updates = {
-                prefix: yield this.visitSpace(inferType.prefix, p),
-                markers: yield this.visitMarkers(inferType.markers, p),
-                typeParameter: yield this.visitLeftPadded(inferType.typeParameter, p),
-                type: inferType.type && (yield this.visitType(inferType.type, p))
-            };
-            return (0, util_1.updateIfChanged)(inferType, updates);
-        });
-    }
-    visitImportType(importType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(importType, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ImportType) {
-                return expression;
-            }
-            importType = expression;
-            const updates = {
-                prefix: yield this.visitSpace(importType.prefix, p),
-                markers: yield this.visitMarkers(importType.markers, p),
-                hasTypeof: yield this.visitRightPadded(importType.hasTypeof, p),
-                argumentAndAttributes: yield this.visitContainer(importType.argumentAndAttributes, p),
-                qualifier: importType.qualifier && (yield this.visitLeftPadded(importType.qualifier, p)),
-                typeArguments: importType.typeArguments && (yield this.visitContainer(importType.typeArguments, p)),
-                type: importType.type && (yield this.visitType(importType.type, p))
-            };
-            return (0, util_1.updateIfChanged)(importType, updates);
-        });
-    }
-    visitImportDeclaration(jsImport, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(jsImport, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.Import) {
-                return statement;
-            }
-            jsImport = statement;
-            const updates = {
-                prefix: yield this.visitSpace(jsImport.prefix, p),
-                markers: yield this.visitMarkers(jsImport.markers, p),
-                modifiers: yield (0, util_1.mapAsync)(jsImport.modifiers, item => this.visitDefined(item, p)),
-                importClause: jsImport.importClause && (yield this.visitDefined(jsImport.importClause, p)),
-                moduleSpecifier: jsImport.moduleSpecifier && (yield this.visitLeftPadded(jsImport.moduleSpecifier, p)),
-                attributes: jsImport.attributes && (yield this.visitDefined(jsImport.attributes, p)),
-                initializer: jsImport.initializer && (yield this.visitLeftPadded(jsImport.initializer, p))
-            };
-            return (0, util_1.updateIfChanged)(jsImport, updates);
-        });
-    }
-    visitImportClause(importClause, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(importClause.prefix, p),
-                markers: yield this.visitMarkers(importClause.markers, p),
-                name: importClause.name && (yield this.visitRightPadded(importClause.name, p)),
-                namedBindings: importClause.namedBindings && (yield this.visitDefined(importClause.namedBindings, p))
-            };
-            return (0, util_1.updateIfChanged)(importClause, updates);
-        });
-    }
-    visitNamedImports(namedImports, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(namedImports, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.NamedImports) {
-                return expression;
-            }
-            namedImports = expression;
-            const updates = {
-                prefix: yield this.visitSpace(namedImports.prefix, p),
-                markers: yield this.visitMarkers(namedImports.markers, p),
-                elements: yield this.visitContainer(namedImports.elements, p),
-                type: namedImports.type && (yield this.visitType(namedImports.type, p))
-            };
-            return (0, util_1.updateIfChanged)(namedImports, updates);
-        });
-    }
-    visitImportSpecifier(importSpecifier, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(importSpecifier, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ImportSpecifier) {
-                return expression;
-            }
-            importSpecifier = expression;
-            const updates = {
-                prefix: yield this.visitSpace(importSpecifier.prefix, p),
-                markers: yield this.visitMarkers(importSpecifier.markers, p),
-                importType: yield this.visitLeftPadded(importSpecifier.importType, p),
-                specifier: yield this.visitDefined(importSpecifier.specifier, p),
-                type: importSpecifier.type && (yield this.visitType(importSpecifier.type, p))
-            };
-            return (0, util_1.updateIfChanged)(importSpecifier, updates);
-        });
-    }
-    visitImportAttributes(importAttributes, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(importAttributes.prefix, p),
-                markers: yield this.visitMarkers(importAttributes.markers, p),
-                elements: yield this.visitContainer(importAttributes.elements, p)
-            };
-            return (0, util_1.updateIfChanged)(importAttributes, updates);
-        });
-    }
-    visitImportTypeAttributes(importTypeAttributes, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(importTypeAttributes.prefix, p),
-                markers: yield this.visitMarkers(importTypeAttributes.markers, p),
-                token: yield this.visitRightPadded(importTypeAttributes.token, p),
-                elements: yield this.visitContainer(importTypeAttributes.elements, p),
-                end: yield this.visitSpace(importTypeAttributes.end, p)
-            };
-            return (0, util_1.updateIfChanged)(importTypeAttributes, updates);
-        });
-    }
-    visitImportAttribute(importAttribute, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(importAttribute, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.ImportAttribute) {
-                return statement;
-            }
-            importAttribute = statement;
-            const updates = {
-                prefix: yield this.visitSpace(importAttribute.prefix, p),
-                markers: yield this.visitMarkers(importAttribute.markers, p),
-                name: yield this.visitDefined(importAttribute.name, p),
-                value: yield this.visitLeftPadded(importAttribute.value, p)
-            };
-            return (0, util_1.updateIfChanged)(importAttribute, updates);
-        });
-    }
-    visitBinaryExtensions(jsBinary, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(jsBinary.prefix, p),
-                markers: yield this.visitMarkers(jsBinary.markers, p),
-                left: yield this.visitDefined(jsBinary.left, p),
-                operator: yield this.visitLeftPadded(jsBinary.operator, p),
-                right: yield this.visitDefined(jsBinary.right, p),
-                type: jsBinary.type && (yield this.visitType(jsBinary.type, p))
-            };
-            return (0, util_1.updateIfChanged)(jsBinary, updates);
-        });
-    }
-    visitLiteralType(literalType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(literalType, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.LiteralType) {
-                return expression;
-            }
-            literalType = expression;
-            const updates = {
-                prefix: yield this.visitSpace(literalType.prefix, p),
-                markers: yield this.visitMarkers(literalType.markers, p),
-                literal: yield this.visitDefined(literalType.literal, p),
-                type: (yield this.visitType(literalType.type, p))
-            };
-            return (0, util_1.updateIfChanged)(literalType, updates);
-        });
-    }
-    visitMappedType(mappedType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(mappedType, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.MappedType) {
-                return expression;
-            }
-            mappedType = expression;
-            const updates = {
-                prefix: yield this.visitSpace(mappedType.prefix, p),
-                markers: yield this.visitMarkers(mappedType.markers, p),
-                prefixToken: mappedType.prefixToken && (yield this.visitLeftPadded(mappedType.prefixToken, p)),
-                hasReadonly: yield this.visitLeftPadded(mappedType.hasReadonly, p),
-                keysRemapping: yield this.visitDefined(mappedType.keysRemapping, p),
-                suffixToken: mappedType.suffixToken && (yield this.visitLeftPadded(mappedType.suffixToken, p)),
-                hasQuestionToken: yield this.visitLeftPadded(mappedType.hasQuestionToken, p),
-                valueType: yield this.visitContainer(mappedType.valueType, p),
-                type: mappedType.type && (yield this.visitType(mappedType.type, p))
-            };
-            return (0, util_1.updateIfChanged)(mappedType, updates);
-        });
-    }
-    visitMappedTypeKeysRemapping(keysRemapping, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(keysRemapping.prefix, p),
-                markers: yield this.visitMarkers(keysRemapping.markers, p),
-                typeParameter: yield this.visitRightPadded(keysRemapping.typeParameter, p),
-                nameType: keysRemapping.nameType && (yield this.visitRightPadded(keysRemapping.nameType, p))
-            };
-            return (0, util_1.updateIfChanged)(keysRemapping, updates);
-        });
-    }
-    visitMappedTypeParameter(mappedTypeParameter, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(mappedTypeParameter.prefix, p),
-                markers: yield this.visitMarkers(mappedTypeParameter.markers, p),
-                name: yield this.visitDefined(mappedTypeParameter.name, p),
-                iterateType: yield this.visitLeftPadded(mappedTypeParameter.iterateType, p)
-            };
-            return (0, util_1.updateIfChanged)(mappedTypeParameter, updates);
-        });
-    }
-    visitObjectBindingPattern(objectBindingPattern, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(objectBindingPattern, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ObjectBindingPattern) {
-                return expression;
-            }
-            objectBindingPattern = expression;
-            const updates = {
-                prefix: yield this.visitSpace(objectBindingPattern.prefix, p),
-                markers: yield this.visitMarkers(objectBindingPattern.markers, p),
-                leadingAnnotations: yield (0, util_1.mapAsync)(objectBindingPattern.leadingAnnotations, item => this.visitDefined(item, p)),
-                modifiers: yield (0, util_1.mapAsync)(objectBindingPattern.modifiers, item => this.visitDefined(item, p)),
-                typeExpression: objectBindingPattern.typeExpression && (yield this.visitDefined(objectBindingPattern.typeExpression, p)),
-                bindings: yield this.visitContainer(objectBindingPattern.bindings, p),
-                initializer: objectBindingPattern.initializer && (yield this.visitLeftPadded(objectBindingPattern.initializer, p))
-            };
-            return (0, util_1.updateIfChanged)(objectBindingPattern, updates);
-        });
-    }
-    visitPropertyAssignment(propertyAssignment, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(propertyAssignment, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.PropertyAssignment) {
-                return statement;
-            }
-            propertyAssignment = statement;
-            const updates = {
-                prefix: yield this.visitSpace(propertyAssignment.prefix, p),
-                markers: yield this.visitMarkers(propertyAssignment.markers, p),
-                name: yield this.visitRightPadded(propertyAssignment.name, p),
-                initializer: propertyAssignment.initializer && (yield this.visitDefined(propertyAssignment.initializer, p))
-            };
-            return (0, util_1.updateIfChanged)(propertyAssignment, updates);
-        });
-    }
-    visitSatisfiesExpression(satisfiesExpression, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(satisfiesExpression, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.SatisfiesExpression) {
-                return expression;
-            }
-            satisfiesExpression = expression;
-            const updates = {
-                prefix: yield this.visitSpace(satisfiesExpression.prefix, p),
-                markers: yield this.visitMarkers(satisfiesExpression.markers, p),
-                expression: yield this.visitDefined(satisfiesExpression.expression, p),
-                satisfiesType: yield this.visitLeftPadded(satisfiesExpression.satisfiesType, p),
-                type: satisfiesExpression.type && (yield this.visitType(satisfiesExpression.type, p))
-            };
-            return (0, util_1.updateIfChanged)(satisfiesExpression, updates);
-        });
-    }
-    visitScopedVariableDeclarations(scopedVariableDeclarations, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(scopedVariableDeclarations, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.ScopedVariableDeclarations) {
-                return statement;
-            }
-            scopedVariableDeclarations = statement;
-            const updates = {
-                prefix: yield this.visitSpace(scopedVariableDeclarations.prefix, p),
-                markers: yield this.visitMarkers(scopedVariableDeclarations.markers, p),
-                modifiers: yield (0, util_1.mapAsync)(scopedVariableDeclarations.modifiers, item => this.visitDefined(item, p)),
-                variables: yield (0, util_1.mapAsync)(scopedVariableDeclarations.variables, item => this.visitRightPadded(item, p))
-            };
-            return (0, util_1.updateIfChanged)(scopedVariableDeclarations, updates);
-        });
-    }
-    visitShebang(shebang, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(shebang.prefix, p),
-                markers: yield this.visitMarkers(shebang.markers, p)
-            };
-            return (0, util_1.updateIfChanged)(shebang, updates);
-        });
-    }
-    visitSpread(spread, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(spread, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Spread) {
-                return expression;
-            }
-            spread = expression;
-            const statement = yield this.visitStatement(spread, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.Spread) {
-                return statement;
-            }
-            spread = statement;
-            const updates = {
-                prefix: yield this.visitSpace(spread.prefix, p),
-                markers: yield this.visitMarkers(spread.markers, p),
-                expression: yield this.visitDefined(spread.expression, p),
-                type: yield this.visitType(spread.type, p)
-            };
-            return (0, util_1.updateIfChanged)(spread, updates);
-        });
-    }
-    visitStatementExpression(statementExpression, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(statementExpression, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.StatementExpression) {
-                return expression;
-            }
-            statementExpression = expression;
-            const statement = yield this.visitStatement(statementExpression, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.StatementExpression) {
-                return statement;
-            }
-            statementExpression = statement;
-            const updates = {
-                prefix: yield this.visitSpace(statementExpression.prefix, p),
-                markers: yield this.visitMarkers(statementExpression.markers, p),
-                statement: yield this.visitDefined(statementExpression.statement, p)
-            };
-            return (0, util_1.updateIfChanged)(statementExpression, updates);
-        });
-    }
-    visitTaggedTemplateExpression(taggedTemplateExpression, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(taggedTemplateExpression, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TaggedTemplateExpression) {
-                return expression;
-            }
-            taggedTemplateExpression = expression;
-            const statement = yield this.visitStatement(taggedTemplateExpression, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.TaggedTemplateExpression) {
-                return statement;
-            }
-            taggedTemplateExpression = statement;
-            const updates = {
-                prefix: yield this.visitSpace(taggedTemplateExpression.prefix, p),
-                markers: yield this.visitMarkers(taggedTemplateExpression.markers, p),
-                tag: taggedTemplateExpression.tag && (yield this.visitRightPadded(taggedTemplateExpression.tag, p)),
-                typeArguments: taggedTemplateExpression.typeArguments && (yield this.visitContainer(taggedTemplateExpression.typeArguments, p)),
-                templateExpression: yield this.visitDefined(taggedTemplateExpression.templateExpression, p),
-                type: taggedTemplateExpression.type && (yield this.visitType(taggedTemplateExpression.type, p))
-            };
-            return (0, util_1.updateIfChanged)(taggedTemplateExpression, updates);
-        });
-    }
-    visitTemplateExpression(templateExpression, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(templateExpression, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TemplateExpression) {
-                return expression;
-            }
-            templateExpression = expression;
-            const statement = yield this.visitStatement(templateExpression, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.TemplateExpression) {
-                return statement;
-            }
-            templateExpression = statement;
-            const updates = {
-                prefix: yield this.visitSpace(templateExpression.prefix, p),
-                markers: yield this.visitMarkers(templateExpression.markers, p),
-                head: yield this.visitDefined(templateExpression.head, p),
-                spans: yield (0, util_1.mapAsync)(templateExpression.spans, item => this.visitRightPadded(item, p)),
-                type: templateExpression.type && (yield this.visitType(templateExpression.type, p))
-            };
-            return (0, util_1.updateIfChanged)(templateExpression, updates);
-        });
-    }
-    visitTemplateExpressionSpan(span, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(span.prefix, p),
-                markers: yield this.visitMarkers(span.markers, p),
-                expression: yield this.visitDefined(span.expression, p),
-                tail: yield this.visitDefined(span.tail, p)
-            };
-            return (0, util_1.updateIfChanged)(span, updates);
-        });
-    }
-    visitTuple(tuple, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(tuple, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Tuple) {
-                return expression;
-            }
-            tuple = expression;
-            const updates = {
-                prefix: yield this.visitSpace(tuple.prefix, p),
-                markers: yield this.visitMarkers(tuple.markers, p),
-                elements: yield this.visitContainer(tuple.elements, p),
-                type: tuple.type && (yield this.visitType(tuple.type, p))
-            };
-            return (0, util_1.updateIfChanged)(tuple, updates);
-        });
-    }
-    visitTypeDeclaration(typeDeclaration, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(typeDeclaration, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.TypeDeclaration) {
-                return statement;
-            }
-            typeDeclaration = statement;
-            const updates = {
-                prefix: yield this.visitSpace(typeDeclaration.prefix, p),
-                markers: yield this.visitMarkers(typeDeclaration.markers, p),
-                modifiers: yield (0, util_1.mapAsync)(typeDeclaration.modifiers, item => this.visitDefined(item, p)),
-                name: yield this.visitLeftPadded(typeDeclaration.name, p),
-                typeParameters: typeDeclaration.typeParameters && (yield this.visitDefined(typeDeclaration.typeParameters, p)),
-                initializer: yield this.visitLeftPadded(typeDeclaration.initializer, p),
-                type: typeDeclaration.type && (yield this.visitType(typeDeclaration.type, p))
-            };
-            return (0, util_1.updateIfChanged)(typeDeclaration, updates);
-        });
-    }
-    visitTypeOf(typeOf, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(typeOf, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TypeOf) {
-                return expression;
-            }
-            typeOf = expression;
-            const updates = {
-                prefix: yield this.visitSpace(typeOf.prefix, p),
-                markers: yield this.visitMarkers(typeOf.markers, p),
-                expression: yield this.visitDefined(typeOf.expression, p),
-                type: typeOf.type && (yield this.visitType(typeOf.type, p))
-            };
-            return (0, util_1.updateIfChanged)(typeOf, updates);
-        });
-    }
-    visitTypeTreeExpression(typeTreeExpression, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(typeTreeExpression, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TypeTreeExpression) {
-                return expression;
-            }
-            typeTreeExpression = expression;
-            const updates = {
-                prefix: yield this.visitSpace(typeTreeExpression.prefix, p),
-                markers: yield this.visitMarkers(typeTreeExpression.markers, p),
-                expression: yield this.visitDefined(typeTreeExpression.expression, p)
-            };
-            return (0, util_1.updateIfChanged)(typeTreeExpression, updates);
-        });
-    }
-    visitAssignmentOperationExtensions(assignmentOperation, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(assignmentOperation.prefix, p),
-                markers: yield this.visitMarkers(assignmentOperation.markers, p),
-                variable: yield this.visitDefined(assignmentOperation.variable, p),
-                operator: yield this.visitLeftPadded(assignmentOperation.operator, p),
-                assignment: yield this.visitDefined(assignmentOperation.assignment, p),
-                type: assignmentOperation.type && (yield this.visitType(assignmentOperation.type, p))
-            };
-            return (0, util_1.updateIfChanged)(assignmentOperation, updates);
-        });
-    }
-    visitIndexedAccessType(indexedAccessType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(indexedAccessType, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.IndexedAccessType) {
-                return expression;
-            }
-            indexedAccessType = expression;
-            const updates = {
-                prefix: yield this.visitSpace(indexedAccessType.prefix, p),
-                markers: yield this.visitMarkers(indexedAccessType.markers, p),
-                objectType: yield this.visitDefined(indexedAccessType.objectType, p),
-                indexType: yield this.visitDefined(indexedAccessType.indexType, p),
-                type: indexedAccessType.type && (yield this.visitType(indexedAccessType.type, p))
-            };
-            return (0, util_1.updateIfChanged)(indexedAccessType, updates);
-        });
-    }
-    visitIndexedAccessTypeIndexType(indexType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(indexType.prefix, p),
-                markers: yield this.visitMarkers(indexType.markers, p),
-                element: yield this.visitRightPadded(indexType.element, p),
-                type: indexType.type && (yield this.visitType(indexType.type, p))
-            };
-            return (0, util_1.updateIfChanged)(indexType, updates);
-        });
-    }
-    visitTypeQuery(typeQuery, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(typeQuery, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TypeQuery) {
-                return expression;
-            }
-            typeQuery = expression;
-            const updates = {
-                prefix: yield this.visitSpace(typeQuery.prefix, p),
-                markers: yield this.visitMarkers(typeQuery.markers, p),
-                typeExpression: yield this.visitDefined(typeQuery.typeExpression, p),
-                typeArguments: typeQuery.typeArguments && (yield this.visitContainer(typeQuery.typeArguments, p)),
-                type: typeQuery.type && (yield this.visitType(typeQuery.type, p))
-            };
-            return (0, util_1.updateIfChanged)(typeQuery, updates);
-        });
-    }
-    visitTypeInfo(typeInfo, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(typeInfo, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TypeInfo) {
-                return expression;
-            }
-            typeInfo = expression;
-            const updates = {
-                prefix: yield this.visitSpace(typeInfo.prefix, p),
-                markers: yield this.visitMarkers(typeInfo.markers, p),
-                typeIdentifier: yield this.visitDefined(typeInfo.typeIdentifier, p)
-            };
-            return (0, util_1.updateIfChanged)(typeInfo, updates);
-        });
-    }
-    visitComputedPropertyName(computedPropertyName, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(computedPropertyName, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ComputedPropertyName) {
-                return expression;
-            }
-            computedPropertyName = expression;
-            const updates = {
-                prefix: yield this.visitSpace(computedPropertyName.prefix, p),
-                markers: yield this.visitMarkers(computedPropertyName.markers, p),
-                expression: yield this.visitRightPadded(computedPropertyName.expression, p)
-            };
-            return (0, util_1.updateIfChanged)(computedPropertyName, updates);
-        });
-    }
-    visitTypeOperator(typeOperator, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(typeOperator, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TypeOperator) {
-                return expression;
-            }
-            typeOperator = expression;
-            const updates = {
-                prefix: yield this.visitSpace(typeOperator.prefix, p),
-                markers: yield this.visitMarkers(typeOperator.markers, p),
-                expression: yield this.visitLeftPadded(typeOperator.expression, p)
-            };
-            return (0, util_1.updateIfChanged)(typeOperator, updates);
-        });
-    }
-    visitTypePredicate(typePredicate, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(typePredicate, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TypePredicate) {
-                return expression;
-            }
-            typePredicate = expression;
-            const updates = {
-                prefix: yield this.visitSpace(typePredicate.prefix, p),
-                markers: yield this.visitMarkers(typePredicate.markers, p),
-                asserts: yield this.visitLeftPadded(typePredicate.asserts, p),
-                parameterName: yield this.visitDefined(typePredicate.parameterName, p),
-                expression: typePredicate.expression && (yield this.visitLeftPadded(typePredicate.expression, p)),
-                type: typePredicate.type && (yield this.visitType(typePredicate.type, p))
-            };
-            return (0, util_1.updateIfChanged)(typePredicate, updates);
-        });
-    }
-    visitUnion(union, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(union, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Union) {
-                return expression;
-            }
-            union = expression;
-            const updates = {
-                prefix: yield this.visitSpace(union.prefix, p),
-                markers: yield this.visitMarkers(union.markers, p),
-                types: yield (0, util_1.mapAsync)(union.types, item => this.visitRightPadded(item, p)),
-                type: union.type && (yield this.visitType(union.type, p))
-            };
-            return (0, util_1.updateIfChanged)(union, updates);
-        });
-    }
-    visitIntersection(intersection, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(intersection, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Intersection) {
-                return expression;
-            }
-            intersection = expression;
-            const updates = {
-                prefix: yield this.visitSpace(intersection.prefix, p),
-                markers: yield this.visitMarkers(intersection.markers, p),
-                types: yield (0, util_1.mapAsync)(intersection.types, item => this.visitRightPadded(item, p)),
-                type: intersection.type && (yield this.visitType(intersection.type, p))
-            };
-            return (0, util_1.updateIfChanged)(intersection, updates);
-        });
-    }
-    visitVoid(void_, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(void_, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Void) {
-                return expression;
-            }
-            void_ = expression;
-            const updates = {
-                prefix: yield this.visitSpace(void_.prefix, p),
-                markers: yield this.visitMarkers(void_.markers, p),
-                expression: yield this.visitDefined(void_.expression, p)
-            };
-            return (0, util_1.updateIfChanged)(void_, updates);
-        });
-    }
-    visitWithStatement(withStatement, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(withStatement, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.WithStatement) {
-                return statement;
-            }
-            withStatement = statement;
-            const updates = {
-                prefix: yield this.visitSpace(withStatement.prefix, p),
-                markers: yield this.visitMarkers(withStatement.markers, p),
-                expression: yield this.visitDefined(withStatement.expression, p),
-                body: yield this.visitRightPadded(withStatement.body, p)
-            };
-            return (0, util_1.updateIfChanged)(withStatement, updates);
-        });
-    }
-    visitIndexSignatureDeclaration(indexSignatureDeclaration, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(indexSignatureDeclaration, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.IndexSignatureDeclaration) {
-                return statement;
-            }
-            indexSignatureDeclaration = statement;
-            const updates = {
-                prefix: yield this.visitSpace(indexSignatureDeclaration.prefix, p),
-                markers: yield this.visitMarkers(indexSignatureDeclaration.markers, p),
-                modifiers: yield (0, util_1.mapAsync)(indexSignatureDeclaration.modifiers, item => this.visitDefined(item, p)),
-                parameters: yield this.visitContainer(indexSignatureDeclaration.parameters, p),
-                typeExpression: yield this.visitLeftPadded(indexSignatureDeclaration.typeExpression, p),
-                type: indexSignatureDeclaration.type && (yield this.visitType(indexSignatureDeclaration.type, p))
-            };
-            return (0, util_1.updateIfChanged)(indexSignatureDeclaration, updates);
-        });
-    }
-    visitComputedPropertyMethodDeclaration(computedPropMethod, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(computedPropMethod, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.ComputedPropertyMethodDeclaration) {
-                return statement;
-            }
-            computedPropMethod = statement;
-            const updates = {
-                prefix: yield this.visitSpace(computedPropMethod.prefix, p),
-                markers: yield this.visitMarkers(computedPropMethod.markers, p),
-                leadingAnnotations: yield (0, util_1.mapAsync)(computedPropMethod.leadingAnnotations, item => this.visitDefined(item, p)),
-                modifiers: yield (0, util_1.mapAsync)(computedPropMethod.modifiers, item => this.visitDefined(item, p)),
-                typeParameters: computedPropMethod.typeParameters && (yield this.visitDefined(computedPropMethod.typeParameters, p)),
-                returnTypeExpression: computedPropMethod.returnTypeExpression && (yield this.visitDefined(computedPropMethod.returnTypeExpression, p)),
-                name: yield this.visitDefined(computedPropMethod.name, p),
-                parameters: yield this.visitContainer(computedPropMethod.parameters, p),
-                body: computedPropMethod.body && (yield this.visitDefined(computedPropMethod.body, p)),
-                methodType: computedPropMethod.methodType && (yield this.visitType(computedPropMethod.methodType, p))
-            };
-            return (0, util_1.updateIfChanged)(computedPropMethod, updates);
-        });
-    }
-    visitForOfLoop(forOfLoop, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(forOfLoop.prefix, p),
-                markers: yield this.visitMarkers(forOfLoop.markers, p),
-                loop: yield this.visitDefined(forOfLoop.loop, p)
-            };
-            return (0, util_1.updateIfChanged)(forOfLoop, updates);
-        });
-    }
-    visitForInLoop(forInLoop, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(forInLoop.prefix, p),
-                markers: yield this.visitMarkers(forInLoop.markers, p),
-                control: yield this.visitDefined(forInLoop.control, p),
-                body: yield this.visitRightPadded(forInLoop.body, p)
-            };
-            return (0, util_1.updateIfChanged)(forInLoop, updates);
-        });
-    }
-    visitNamespaceDeclaration(namespaceDeclaration, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(namespaceDeclaration, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.NamespaceDeclaration) {
-                return statement;
-            }
-            namespaceDeclaration = statement;
-            const updates = {
-                prefix: yield this.visitSpace(namespaceDeclaration.prefix, p),
-                markers: yield this.visitMarkers(namespaceDeclaration.markers, p),
-                modifiers: yield (0, util_1.mapAsync)(namespaceDeclaration.modifiers, item => this.visitDefined(item, p)),
-                keywordType: yield this.visitLeftPadded(namespaceDeclaration.keywordType, p),
-                name: yield this.visitRightPadded(namespaceDeclaration.name, p),
-                body: namespaceDeclaration.body && (yield this.visitDefined(namespaceDeclaration.body, p))
-            };
-            return (0, util_1.updateIfChanged)(namespaceDeclaration, updates);
-        });
-    }
-    visitTypeLiteral(typeLiteral, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(typeLiteral.prefix, p),
-                markers: yield this.visitMarkers(typeLiteral.markers, p),
-                members: yield this.visitDefined(typeLiteral.members, p),
-                type: typeLiteral.type && (yield this.visitType(typeLiteral.type, p))
-            };
-            return (0, util_1.updateIfChanged)(typeLiteral, updates);
-        });
-    }
-    visitArrayBindingPattern(arrayBindingPattern, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(arrayBindingPattern.prefix, p),
-                markers: yield this.visitMarkers(arrayBindingPattern.markers, p),
-                elements: yield this.visitContainer(arrayBindingPattern.elements, p),
-                type: arrayBindingPattern.type && (yield this.visitType(arrayBindingPattern.type, p))
-            };
-            return (0, util_1.updateIfChanged)(arrayBindingPattern, updates);
-        });
-    }
-    visitBindingElement(bindingElement, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(bindingElement, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.BindingElement) {
-                return statement;
-            }
-            bindingElement = statement;
-            const updates = {
-                prefix: yield this.visitSpace(bindingElement.prefix, p),
-                markers: yield this.visitMarkers(bindingElement.markers, p),
-                propertyName: bindingElement.propertyName && (yield this.visitRightPadded(bindingElement.propertyName, p)),
-                name: yield this.visitDefined(bindingElement.name, p),
-                initializer: bindingElement.initializer && (yield this.visitLeftPadded(bindingElement.initializer, p)),
-                variableType: bindingElement.variableType && (yield this.visitType(bindingElement.variableType, p))
-            };
-            return (0, util_1.updateIfChanged)(bindingElement, updates);
-        });
-    }
-    visitExportDeclaration(exportDeclaration, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(exportDeclaration, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.ExportDeclaration) {
-                return statement;
-            }
-            exportDeclaration = statement;
-            const updates = {
-                prefix: yield this.visitSpace(exportDeclaration.prefix, p),
-                markers: yield this.visitMarkers(exportDeclaration.markers, p),
-                modifiers: yield (0, util_1.mapAsync)(exportDeclaration.modifiers, item => this.visitDefined(item, p)),
-                typeOnly: yield this.visitLeftPadded(exportDeclaration.typeOnly, p),
-                exportClause: exportDeclaration.exportClause && (yield this.visitDefined(exportDeclaration.exportClause, p)),
-                moduleSpecifier: exportDeclaration.moduleSpecifier && (yield this.visitLeftPadded(exportDeclaration.moduleSpecifier, p)),
-                attributes: exportDeclaration.attributes && (yield this.visitDefined(exportDeclaration.attributes, p))
-            };
-            return (0, util_1.updateIfChanged)(exportDeclaration, updates);
-        });
-    }
-    visitExportAssignment(exportAssignment, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(exportAssignment, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.ExportAssignment) {
-                return statement;
-            }
-            exportAssignment = statement;
-            const updates = {
-                prefix: yield this.visitSpace(exportAssignment.prefix, p),
-                markers: yield this.visitMarkers(exportAssignment.markers, p),
-                expression: yield this.visitLeftPadded(exportAssignment.expression, p)
-            };
-            return (0, util_1.updateIfChanged)(exportAssignment, updates);
-        });
-    }
-    visitNamedExports(namedExports, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(namedExports.prefix, p),
-                markers: yield this.visitMarkers(namedExports.markers, p),
-                elements: yield this.visitContainer(namedExports.elements, p),
-                type: namedExports.type && (yield this.visitType(namedExports.type, p))
-            };
-            return (0, util_1.updateIfChanged)(namedExports, updates);
-        });
-    }
-    visitExportSpecifier(exportSpecifier, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                prefix: yield this.visitSpace(exportSpecifier.prefix, p),
-                markers: yield this.visitMarkers(exportSpecifier.markers, p),
-                typeOnly: yield this.visitLeftPadded(exportSpecifier.typeOnly, p),
-                specifier: yield this.visitDefined(exportSpecifier.specifier, p),
-                type: exportSpecifier.type && (yield this.visitType(exportSpecifier.type, p))
-            };
-            return (0, util_1.updateIfChanged)(exportSpecifier, updates);
-        });
-    }
-    accept(j, p) {
-        const _super = Object.create(null, {
-            accept: { get: () => super.accept }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            if ((0, tree_1.isJavaScript)(j)) {
-                const tree = j;
-                switch (tree.kind) {
-                    case tree_1.JS.Kind.Alias:
-                        return this.visitAlias(tree, p);
-                    case tree_1.JS.Kind.ArrowFunction:
-                        return this.visitArrowFunction(tree, p);
-                    case tree_1.JS.Kind.As:
-                        return this.visitAs(tree, p);
-                    case tree_1.JS.Kind.Await:
-                        return this.visitAwait(tree, p);
-                    case tree_1.JS.Kind.CompilationUnit:
-                        return this.visitJsCompilationUnit(tree, p);
-                    case tree_1.JS.Kind.ComputedPropertyName:
-                        return this.visitComputedPropertyName(tree, p);
-                    case tree_1.JS.Kind.ConditionalType:
-                        return this.visitConditionalType(tree, p);
-                    case tree_1.JS.Kind.Delete:
-                        return this.visitDelete(tree, p);
-                    case tree_1.JS.Kind.ExpressionStatement:
-                        return this.visitExpressionStatement(tree, p);
-                    case tree_1.JS.Kind.ExpressionWithTypeArguments:
-                        return this.visitExpressionWithTypeArguments(tree, p);
-                    case tree_1.JS.Kind.FunctionCall:
-                        return this.visitFunctionCall(tree, p);
-                    case tree_1.JS.Kind.FunctionType:
-                        return this.visitFunctionType(tree, p);
-                    case tree_1.JS.Kind.InferType:
-                        return this.visitInferType(tree, p);
-                    case tree_1.JS.Kind.ImportType:
-                        return this.visitImportType(tree, p);
-                    case tree_1.JS.Kind.Import:
-                        return this.visitImportDeclaration(tree, p);
-                    case tree_1.JS.Kind.ImportClause:
-                        return this.visitImportClause(tree, p);
-                    case tree_1.JS.Kind.NamedImports:
-                        return this.visitNamedImports(tree, p);
-                    case tree_1.JS.Kind.ImportSpecifier:
-                        return this.visitImportSpecifier(tree, p);
-                    case tree_1.JS.Kind.ImportAttributes:
-                        return this.visitImportAttributes(tree, p);
-                    case tree_1.JS.Kind.ImportTypeAttributes:
-                        return this.visitImportTypeAttributes(tree, p);
-                    case tree_1.JS.Kind.ImportAttribute:
-                        return this.visitImportAttribute(tree, p);
-                    case tree_1.JS.Kind.JsxAttribute:
-                        return this.visitJsxAttribute(tree, p);
-                    case tree_1.JS.Kind.JsxSpreadAttribute:
-                        return this.visitJsxSpreadAttribute(tree, p);
-                    case tree_1.JS.Kind.JsxEmbeddedExpression:
-                        return this.visitJsxEmbeddedExpression(tree, p);
-                    case tree_1.JS.Kind.JsxNamespacedName:
-                        return this.visitJsxNamespacedName(tree, p);
-                    case tree_1.JS.Kind.JsxTag:
-                        return this.visitJsxTag(tree, p);
-                    case tree_1.JS.Kind.Binary:
-                        return this.visitBinaryExtensions(tree, p);
-                    case tree_1.JS.Kind.LiteralType:
-                        return this.visitLiteralType(tree, p);
-                    case tree_1.JS.Kind.MappedType:
-                        return this.visitMappedType(tree, p);
-                    case tree_1.JS.Kind.MappedTypeKeysRemapping:
-                        return this.visitMappedTypeKeysRemapping(tree, p);
-                    case tree_1.JS.Kind.MappedTypeParameter:
-                        return this.visitMappedTypeParameter(tree, p);
-                    case tree_1.JS.Kind.ObjectBindingPattern:
-                        return this.visitObjectBindingPattern(tree, p);
-                    case tree_1.JS.Kind.PropertyAssignment:
-                        return this.visitPropertyAssignment(tree, p);
-                    case tree_1.JS.Kind.SatisfiesExpression:
-                        return this.visitSatisfiesExpression(tree, p);
-                    case tree_1.JS.Kind.ScopedVariableDeclarations:
-                        return this.visitScopedVariableDeclarations(tree, p);
-                    case tree_1.JS.Kind.Shebang:
-                        return this.visitShebang(tree, p);
-                    case tree_1.JS.Kind.Spread:
-                        return this.visitSpread(tree, p);
-                    case tree_1.JS.Kind.StatementExpression:
-                        return this.visitStatementExpression(tree, p);
-                    case tree_1.JS.Kind.TaggedTemplateExpression:
-                        return this.visitTaggedTemplateExpression(tree, p);
-                    case tree_1.JS.Kind.TemplateExpression:
-                        return this.visitTemplateExpression(tree, p);
-                    case tree_1.JS.Kind.TemplateExpressionSpan:
-                        return this.visitTemplateExpressionSpan(tree, p);
-                    case tree_1.JS.Kind.Tuple:
-                        return this.visitTuple(tree, p);
-                    case tree_1.JS.Kind.TypeDeclaration:
-                        return this.visitTypeDeclaration(tree, p);
-                    case tree_1.JS.Kind.TypeOf:
-                        return this.visitTypeOf(tree, p);
-                    case tree_1.JS.Kind.TypeTreeExpression:
-                        return this.visitTypeTreeExpression(tree, p);
-                    case tree_1.JS.Kind.AssignmentOperation:
-                        return this.visitAssignmentOperationExtensions(tree, p);
-                    case tree_1.JS.Kind.IndexedAccessType:
-                        return this.visitIndexedAccessType(tree, p);
-                    case tree_1.JS.Kind.IndexType:
-                        return this.visitIndexedAccessTypeIndexType(tree, p);
-                    case tree_1.JS.Kind.TypeQuery:
-                        return this.visitTypeQuery(tree, p);
-                    case tree_1.JS.Kind.TypeInfo:
-                        return this.visitTypeInfo(tree, p);
-                    case tree_1.JS.Kind.TypeOperator:
-                        return this.visitTypeOperator(tree, p);
-                    case tree_1.JS.Kind.TypePredicate:
-                        return this.visitTypePredicate(tree, p);
-                    case tree_1.JS.Kind.Union:
-                        return this.visitUnion(tree, p);
-                    case tree_1.JS.Kind.Intersection:
-                        return this.visitIntersection(tree, p);
-                    case tree_1.JS.Kind.Void:
-                        return this.visitVoid(tree, p);
-                    case tree_1.JS.Kind.WithStatement:
-                        return this.visitWithStatement(tree, p);
-                    case tree_1.JS.Kind.IndexSignatureDeclaration:
-                        return this.visitIndexSignatureDeclaration(tree, p);
-                    case tree_1.JS.Kind.ComputedPropertyMethodDeclaration:
-                        return this.visitComputedPropertyMethodDeclaration(tree, p);
-                    case tree_1.JS.Kind.ForOfLoop:
-                        return this.visitForOfLoop(tree, p);
-                    case tree_1.JS.Kind.ForInLoop:
-                        return this.visitForInLoop(tree, p);
-                    case tree_1.JS.Kind.NamespaceDeclaration:
-                        return this.visitNamespaceDeclaration(tree, p);
-                    case tree_1.JS.Kind.TypeLiteral:
-                        return this.visitTypeLiteral(tree, p);
-                    case tree_1.JS.Kind.ArrayBindingPattern:
-                        return this.visitArrayBindingPattern(tree, p);
-                    case tree_1.JS.Kind.BindingElement:
-                        return this.visitBindingElement(tree, p);
-                    case tree_1.JS.Kind.ExportDeclaration:
-                        return this.visitExportDeclaration(tree, p);
-                    case tree_1.JS.Kind.ExportAssignment:
-                        return this.visitExportAssignment(tree, p);
-                    case tree_1.JS.Kind.NamedExports:
-                        return this.visitNamedExports(tree, p);
-                    case tree_1.JS.Kind.ExportSpecifier:
-                        return this.visitExportSpecifier(tree, p);
-                }
+    async visitTypeName(nameTree, p) {
+        return nameTree;
+    }
+    async produceJavaScript(before, p, recipe) {
+        const [draft, finishDraft] = (0, mutative_1.create)(before);
+        draft.prefix = await this.visitSpace(before.prefix, p);
+        draft.markers = await this.visitMarkers(before.markers, p);
+        if (recipe) {
+            await recipe(draft);
+        }
+        return finishDraft();
+    }
+    async visitAlias(alias, p) {
+        const expression = await this.visitExpression(alias, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Alias) {
+            return expression;
+        }
+        alias = expression;
+        const updates = {
+            prefix: await this.visitSpace(alias.prefix, p),
+            markers: await this.visitMarkers(alias.markers, p),
+            propertyName: await this.visitRightPadded(alias.propertyName, p),
+            alias: await this.visitDefined(alias.alias, p)
+        };
+        return (0, util_1.updateIfChanged)(alias, updates);
+    }
+    async visitArrowFunction(arrowFunction, p) {
+        const expression = await this.visitExpression(arrowFunction, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ArrowFunction) {
+            return expression;
+        }
+        arrowFunction = expression;
+        const statement = await this.visitStatement(arrowFunction, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.ArrowFunction) {
+            return statement;
+        }
+        arrowFunction = statement;
+        const updates = {
+            prefix: await this.visitSpace(arrowFunction.prefix, p),
+            markers: await this.visitMarkers(arrowFunction.markers, p),
+            leadingAnnotations: await (0, util_1.mapAsync)(arrowFunction.leadingAnnotations, item => this.visitDefined(item, p)),
+            modifiers: await (0, util_1.mapAsync)(arrowFunction.modifiers, item => this.visitDefined(item, p)),
+            typeParameters: arrowFunction.typeParameters && await this.visitDefined(arrowFunction.typeParameters, p),
+            lambda: await this.visitDefined(arrowFunction.lambda, p),
+            returnTypeExpression: arrowFunction.returnTypeExpression && await this.visitDefined(arrowFunction.returnTypeExpression, p)
+        };
+        return (0, util_1.updateIfChanged)(arrowFunction, updates);
+    }
+    async visitAs(as_, p) {
+        const updates = {
+            prefix: await this.visitSpace(as_.prefix, p),
+            markers: await this.visitMarkers(as_.markers, p),
+            left: await this.visitRightPadded(as_.left, p),
+            right: await this.visitDefined(as_.right, p),
+            type: as_.type && await this.visitType(as_.type, p)
+        };
+        return (0, util_1.updateIfChanged)(as_, updates);
+    }
+    async visitAwait(await_, p) {
+        const expression = await this.visitExpression(await_, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Await) {
+            return expression;
+        }
+        await_ = expression;
+        const updates = {
+            prefix: await this.visitSpace(await_.prefix, p),
+            markers: await this.visitMarkers(await_.markers, p),
+            expression: await this.visitDefined(await_.expression, p),
+            type: await_.type && await this.visitType(await_.type, p)
+        };
+        return (0, util_1.updateIfChanged)(await_, updates);
+    }
+    async visitJsxTag(element, p) {
+        const updates = {
+            prefix: await this.visitSpace(element.prefix, p),
+            markers: await this.visitMarkers(element.markers, p),
+            openName: await this.visitLeftPadded(element.openName, p),
+            typeArguments: element.typeArguments && await this.visitContainer(element.typeArguments, p),
+            afterName: await this.visitSpace(element.afterName, p),
+            attributes: await (0, util_1.mapAsync)(element.attributes, attr => this.visitRightPadded(attr, p)),
+            selfClosing: element.selfClosing && await this.visitSpace(element.selfClosing, p),
+            children: element.children && await (0, util_1.mapAsync)(element.children, child => this.visit(child, p)),
+            closingName: element.closingName && await this.visitLeftPadded(element.closingName, p),
+            afterClosingName: element.afterClosingName && await this.visitSpace(element.afterClosingName, p)
+        };
+        return (0, util_1.updateIfChanged)(element, updates);
+    }
+    async visitJsxAttribute(attribute, p) {
+        const updates = {
+            prefix: await this.visitSpace(attribute.prefix, p),
+            markers: await this.visitMarkers(attribute.markers, p),
+            key: await this.visitDefined(attribute.key, p),
+            value: attribute.value && await this.visitLeftPadded(attribute.value, p)
+        };
+        return (0, util_1.updateIfChanged)(attribute, updates);
+    }
+    async visitJsxSpreadAttribute(spread, p) {
+        const updates = {
+            prefix: await this.visitSpace(spread.prefix, p),
+            markers: await this.visitMarkers(spread.markers, p),
+            dots: await this.visitSpace(spread.dots, p),
+            expression: await this.visitRightPadded(spread.expression, p)
+        };
+        return (0, util_1.updateIfChanged)(spread, updates);
+    }
+    async visitJsxEmbeddedExpression(expr, p) {
+        const updates = {
+            prefix: await this.visitSpace(expr.prefix, p),
+            markers: await this.visitMarkers(expr.markers, p),
+            expression: await this.visitRightPadded(expr.expression, p)
+        };
+        return (0, util_1.updateIfChanged)(expr, updates);
+    }
+    async visitJsxNamespacedName(ns, p) {
+        const updates = {
+            prefix: await this.visitSpace(ns.prefix, p),
+            markers: await this.visitMarkers(ns.markers, p),
+            namespace: await this.visitDefined(ns.namespace, p),
+            name: await this.visitLeftPadded(ns.name, p)
+        };
+        return (0, util_1.updateIfChanged)(ns, updates);
+    }
+    async visitJsCompilationUnit(compilationUnit, p) {
+        const updates = {
+            prefix: await this.visitSpace(compilationUnit.prefix, p),
+            markers: await this.visitMarkers(compilationUnit.markers, p),
+            statements: await (0, util_1.mapAsync)(compilationUnit.statements, stmt => this.visitRightPadded(stmt, p)),
+            eof: await this.visitSpace(compilationUnit.eof, p)
+        };
+        return (0, util_1.updateIfChanged)(compilationUnit, updates);
+    }
+    async visitConditionalType(conditionalType, p) {
+        const expression = await this.visitExpression(conditionalType, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ConditionalType) {
+            return expression;
+        }
+        conditionalType = expression;
+        const updates = {
+            prefix: await this.visitSpace(conditionalType.prefix, p),
+            markers: await this.visitMarkers(conditionalType.markers, p),
+            checkType: await this.visitDefined(conditionalType.checkType, p),
+            condition: await this.visitLeftPadded(conditionalType.condition, p),
+            type: conditionalType.type && await this.visitType(conditionalType.type, p)
+        };
+        return (0, util_1.updateIfChanged)(conditionalType, updates);
+    }
+    async visitDelete(delete_, p) {
+        const expression = await this.visitExpression(delete_, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Delete) {
+            return expression;
+        }
+        delete_ = expression;
+        const statement = await this.visitStatement(delete_, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.Delete) {
+            return statement;
+        }
+        delete_ = statement;
+        const updates = {
+            prefix: await this.visitSpace(delete_.prefix, p),
+            markers: await this.visitMarkers(delete_.markers, p),
+            expression: await this.visitDefined(delete_.expression, p)
+        };
+        return (0, util_1.updateIfChanged)(delete_, updates);
+    }
+    async visitExpressionStatement(expressionStatement, p) {
+        const expression = await this.visitExpression(expressionStatement, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ExpressionStatement) {
+            return expression;
+        }
+        expressionStatement = expression;
+        const statement = await this.visitStatement(expressionStatement, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.ExpressionStatement) {
+            return statement;
+        }
+        expressionStatement = statement;
+        const updates = {
+            prefix: await this.visitSpace(expressionStatement.prefix, p),
+            markers: await this.visitMarkers(expressionStatement.markers, p),
+            expression: await this.visitDefined(expressionStatement.expression, p)
+        };
+        return (0, util_1.updateIfChanged)(expressionStatement, updates);
+    }
+    async visitExpressionWithTypeArguments(expressionWithTypeArguments, p) {
+        const expression = await this.visitExpression(expressionWithTypeArguments, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ExpressionWithTypeArguments) {
+            return expression;
+        }
+        expressionWithTypeArguments = expression;
+        const updates = {
+            prefix: await this.visitSpace(expressionWithTypeArguments.prefix, p),
+            markers: await this.visitMarkers(expressionWithTypeArguments.markers, p),
+            clazz: await this.visitDefined(expressionWithTypeArguments.clazz, p),
+            typeArguments: expressionWithTypeArguments.typeArguments && await this.visitContainer(expressionWithTypeArguments.typeArguments, p),
+            type: expressionWithTypeArguments.type && await this.visitType(expressionWithTypeArguments.type, p)
+        };
+        return (0, util_1.updateIfChanged)(expressionWithTypeArguments, updates);
+    }
+    async visitFunctionCall(functionCall, p) {
+        const expression = await this.visitExpression(functionCall, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.FunctionCall) {
+            return expression;
+        }
+        functionCall = expression;
+        const statement = await this.visitStatement(functionCall, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.FunctionCall) {
+            return statement;
+        }
+        functionCall = statement;
+        const updates = {
+            prefix: await this.visitSpace(functionCall.prefix, p),
+            markers: await this.visitMarkers(functionCall.markers, p),
+            function: await this.visitOptionalRightPadded(functionCall.function, p),
+            typeParameters: await this.visitOptionalContainer(functionCall.typeParameters, p),
+            arguments: await this.visitContainer(functionCall.arguments, p),
+            methodType: await this.visitType(functionCall.methodType, p)
+        };
+        return (0, util_1.updateIfChanged)(functionCall, updates);
+    }
+    async visitFunctionType(functionType, p) {
+        const expression = await this.visitExpression(functionType, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.FunctionType) {
+            return expression;
+        }
+        functionType = expression;
+        const updates = {
+            prefix: await this.visitSpace(functionType.prefix, p),
+            markers: await this.visitMarkers(functionType.markers, p),
+            constructorType: await this.visitLeftPadded(functionType.constructorType, p),
+            typeParameters: functionType.typeParameters && await this.visitDefined(functionType.typeParameters, p),
+            parameters: await this.visitContainer(functionType.parameters, p),
+            returnType: await this.visitLeftPadded(functionType.returnType, p)
+        };
+        return (0, util_1.updateIfChanged)(functionType, updates);
+    }
+    async visitInferType(inferType, p) {
+        const expression = await this.visitExpression(inferType, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.InferType) {
+            return expression;
+        }
+        inferType = expression;
+        const updates = {
+            prefix: await this.visitSpace(inferType.prefix, p),
+            markers: await this.visitMarkers(inferType.markers, p),
+            typeParameter: await this.visitLeftPadded(inferType.typeParameter, p),
+            type: inferType.type && await this.visitType(inferType.type, p)
+        };
+        return (0, util_1.updateIfChanged)(inferType, updates);
+    }
+    async visitImportType(importType, p) {
+        const expression = await this.visitExpression(importType, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ImportType) {
+            return expression;
+        }
+        importType = expression;
+        const updates = {
+            prefix: await this.visitSpace(importType.prefix, p),
+            markers: await this.visitMarkers(importType.markers, p),
+            hasTypeof: await this.visitRightPadded(importType.hasTypeof, p),
+            argumentAndAttributes: await this.visitContainer(importType.argumentAndAttributes, p),
+            qualifier: importType.qualifier && await this.visitLeftPadded(importType.qualifier, p),
+            typeArguments: importType.typeArguments && await this.visitContainer(importType.typeArguments, p),
+            type: importType.type && await this.visitType(importType.type, p)
+        };
+        return (0, util_1.updateIfChanged)(importType, updates);
+    }
+    async visitImportDeclaration(jsImport, p) {
+        const statement = await this.visitStatement(jsImport, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.Import) {
+            return statement;
+        }
+        jsImport = statement;
+        const updates = {
+            prefix: await this.visitSpace(jsImport.prefix, p),
+            markers: await this.visitMarkers(jsImport.markers, p),
+            modifiers: await (0, util_1.mapAsync)(jsImport.modifiers, item => this.visitDefined(item, p)),
+            importClause: jsImport.importClause && await this.visitDefined(jsImport.importClause, p),
+            moduleSpecifier: jsImport.moduleSpecifier && await this.visitLeftPadded(jsImport.moduleSpecifier, p),
+            attributes: jsImport.attributes && await this.visitDefined(jsImport.attributes, p),
+            initializer: jsImport.initializer && await this.visitLeftPadded(jsImport.initializer, p)
+        };
+        return (0, util_1.updateIfChanged)(jsImport, updates);
+    }
+    async visitImportClause(importClause, p) {
+        const updates = {
+            prefix: await this.visitSpace(importClause.prefix, p),
+            markers: await this.visitMarkers(importClause.markers, p),
+            name: importClause.name && await this.visitRightPadded(importClause.name, p),
+            namedBindings: importClause.namedBindings && await this.visitDefined(importClause.namedBindings, p)
+        };
+        return (0, util_1.updateIfChanged)(importClause, updates);
+    }
+    async visitNamedImports(namedImports, p) {
+        const expression = await this.visitExpression(namedImports, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.NamedImports) {
+            return expression;
+        }
+        namedImports = expression;
+        const updates = {
+            prefix: await this.visitSpace(namedImports.prefix, p),
+            markers: await this.visitMarkers(namedImports.markers, p),
+            elements: await this.visitContainer(namedImports.elements, p),
+            type: namedImports.type && await this.visitType(namedImports.type, p)
+        };
+        return (0, util_1.updateIfChanged)(namedImports, updates);
+    }
+    async visitImportSpecifier(importSpecifier, p) {
+        const expression = await this.visitExpression(importSpecifier, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ImportSpecifier) {
+            return expression;
+        }
+        importSpecifier = expression;
+        const updates = {
+            prefix: await this.visitSpace(importSpecifier.prefix, p),
+            markers: await this.visitMarkers(importSpecifier.markers, p),
+            importType: await this.visitLeftPadded(importSpecifier.importType, p),
+            specifier: await this.visitDefined(importSpecifier.specifier, p),
+            type: importSpecifier.type && await this.visitType(importSpecifier.type, p)
+        };
+        return (0, util_1.updateIfChanged)(importSpecifier, updates);
+    }
+    async visitImportAttributes(importAttributes, p) {
+        const updates = {
+            prefix: await this.visitSpace(importAttributes.prefix, p),
+            markers: await this.visitMarkers(importAttributes.markers, p),
+            elements: await this.visitContainer(importAttributes.elements, p)
+        };
+        return (0, util_1.updateIfChanged)(importAttributes, updates);
+    }
+    async visitImportTypeAttributes(importTypeAttributes, p) {
+        const updates = {
+            prefix: await this.visitSpace(importTypeAttributes.prefix, p),
+            markers: await this.visitMarkers(importTypeAttributes.markers, p),
+            token: await this.visitRightPadded(importTypeAttributes.token, p),
+            elements: await this.visitContainer(importTypeAttributes.elements, p),
+            end: await this.visitSpace(importTypeAttributes.end, p)
+        };
+        return (0, util_1.updateIfChanged)(importTypeAttributes, updates);
+    }
+    async visitImportAttribute(importAttribute, p) {
+        const statement = await this.visitStatement(importAttribute, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.ImportAttribute) {
+            return statement;
+        }
+        importAttribute = statement;
+        const updates = {
+            prefix: await this.visitSpace(importAttribute.prefix, p),
+            markers: await this.visitMarkers(importAttribute.markers, p),
+            name: await this.visitDefined(importAttribute.name, p),
+            value: await this.visitLeftPadded(importAttribute.value, p)
+        };
+        return (0, util_1.updateIfChanged)(importAttribute, updates);
+    }
+    async visitBinaryExtensions(jsBinary, p) {
+        const updates = {
+            prefix: await this.visitSpace(jsBinary.prefix, p),
+            markers: await this.visitMarkers(jsBinary.markers, p),
+            left: await this.visitDefined(jsBinary.left, p),
+            operator: await this.visitLeftPadded(jsBinary.operator, p),
+            right: await this.visitDefined(jsBinary.right, p),
+            type: jsBinary.type && await this.visitType(jsBinary.type, p)
+        };
+        return (0, util_1.updateIfChanged)(jsBinary, updates);
+    }
+    async visitLiteralType(literalType, p) {
+        const expression = await this.visitExpression(literalType, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.LiteralType) {
+            return expression;
+        }
+        literalType = expression;
+        const updates = {
+            prefix: await this.visitSpace(literalType.prefix, p),
+            markers: await this.visitMarkers(literalType.markers, p),
+            literal: await this.visitDefined(literalType.literal, p),
+            type: (await this.visitType(literalType.type, p))
+        };
+        return (0, util_1.updateIfChanged)(literalType, updates);
+    }
+    async visitMappedType(mappedType, p) {
+        const expression = await this.visitExpression(mappedType, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.MappedType) {
+            return expression;
+        }
+        mappedType = expression;
+        const updates = {
+            prefix: await this.visitSpace(mappedType.prefix, p),
+            markers: await this.visitMarkers(mappedType.markers, p),
+            prefixToken: mappedType.prefixToken && await this.visitLeftPadded(mappedType.prefixToken, p),
+            hasReadonly: await this.visitLeftPadded(mappedType.hasReadonly, p),
+            keysRemapping: await this.visitDefined(mappedType.keysRemapping, p),
+            suffixToken: mappedType.suffixToken && await this.visitLeftPadded(mappedType.suffixToken, p),
+            hasQuestionToken: await this.visitLeftPadded(mappedType.hasQuestionToken, p),
+            valueType: await this.visitContainer(mappedType.valueType, p),
+            type: mappedType.type && await this.visitType(mappedType.type, p)
+        };
+        return (0, util_1.updateIfChanged)(mappedType, updates);
+    }
+    async visitMappedTypeKeysRemapping(keysRemapping, p) {
+        const updates = {
+            prefix: await this.visitSpace(keysRemapping.prefix, p),
+            markers: await this.visitMarkers(keysRemapping.markers, p),
+            typeParameter: await this.visitRightPadded(keysRemapping.typeParameter, p),
+            nameType: keysRemapping.nameType && await this.visitRightPadded(keysRemapping.nameType, p)
+        };
+        return (0, util_1.updateIfChanged)(keysRemapping, updates);
+    }
+    async visitMappedTypeParameter(mappedTypeParameter, p) {
+        const updates = {
+            prefix: await this.visitSpace(mappedTypeParameter.prefix, p),
+            markers: await this.visitMarkers(mappedTypeParameter.markers, p),
+            name: await this.visitDefined(mappedTypeParameter.name, p),
+            iterateType: await this.visitLeftPadded(mappedTypeParameter.iterateType, p)
+        };
+        return (0, util_1.updateIfChanged)(mappedTypeParameter, updates);
+    }
+    async visitObjectBindingPattern(objectBindingPattern, p) {
+        const expression = await this.visitExpression(objectBindingPattern, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ObjectBindingPattern) {
+            return expression;
+        }
+        objectBindingPattern = expression;
+        const updates = {
+            prefix: await this.visitSpace(objectBindingPattern.prefix, p),
+            markers: await this.visitMarkers(objectBindingPattern.markers, p),
+            leadingAnnotations: await (0, util_1.mapAsync)(objectBindingPattern.leadingAnnotations, item => this.visitDefined(item, p)),
+            modifiers: await (0, util_1.mapAsync)(objectBindingPattern.modifiers, item => this.visitDefined(item, p)),
+            typeExpression: objectBindingPattern.typeExpression && await this.visitDefined(objectBindingPattern.typeExpression, p),
+            bindings: await this.visitContainer(objectBindingPattern.bindings, p),
+            initializer: objectBindingPattern.initializer && await this.visitLeftPadded(objectBindingPattern.initializer, p)
+        };
+        return (0, util_1.updateIfChanged)(objectBindingPattern, updates);
+    }
+    async visitPropertyAssignment(propertyAssignment, p) {
+        const statement = await this.visitStatement(propertyAssignment, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.PropertyAssignment) {
+            return statement;
+        }
+        propertyAssignment = statement;
+        const updates = {
+            prefix: await this.visitSpace(propertyAssignment.prefix, p),
+            markers: await this.visitMarkers(propertyAssignment.markers, p),
+            name: await this.visitRightPadded(propertyAssignment.name, p),
+            initializer: propertyAssignment.initializer && await this.visitDefined(propertyAssignment.initializer, p)
+        };
+        return (0, util_1.updateIfChanged)(propertyAssignment, updates);
+    }
+    async visitSatisfiesExpression(satisfiesExpression, p) {
+        const expression = await this.visitExpression(satisfiesExpression, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.SatisfiesExpression) {
+            return expression;
+        }
+        satisfiesExpression = expression;
+        const updates = {
+            prefix: await this.visitSpace(satisfiesExpression.prefix, p),
+            markers: await this.visitMarkers(satisfiesExpression.markers, p),
+            expression: await this.visitDefined(satisfiesExpression.expression, p),
+            satisfiesType: await this.visitLeftPadded(satisfiesExpression.satisfiesType, p),
+            type: satisfiesExpression.type && await this.visitType(satisfiesExpression.type, p)
+        };
+        return (0, util_1.updateIfChanged)(satisfiesExpression, updates);
+    }
+    async visitScopedVariableDeclarations(scopedVariableDeclarations, p) {
+        const statement = await this.visitStatement(scopedVariableDeclarations, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.ScopedVariableDeclarations) {
+            return statement;
+        }
+        scopedVariableDeclarations = statement;
+        const updates = {
+            prefix: await this.visitSpace(scopedVariableDeclarations.prefix, p),
+            markers: await this.visitMarkers(scopedVariableDeclarations.markers, p),
+            modifiers: await (0, util_1.mapAsync)(scopedVariableDeclarations.modifiers, item => this.visitDefined(item, p)),
+            variables: await (0, util_1.mapAsync)(scopedVariableDeclarations.variables, item => this.visitRightPadded(item, p))
+        };
+        return (0, util_1.updateIfChanged)(scopedVariableDeclarations, updates);
+    }
+    async visitShebang(shebang, p) {
+        const updates = {
+            prefix: await this.visitSpace(shebang.prefix, p),
+            markers: await this.visitMarkers(shebang.markers, p)
+        };
+        return (0, util_1.updateIfChanged)(shebang, updates);
+    }
+    async visitSpread(spread, p) {
+        const expression = await this.visitExpression(spread, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Spread) {
+            return expression;
+        }
+        spread = expression;
+        const statement = await this.visitStatement(spread, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.Spread) {
+            return statement;
+        }
+        spread = statement;
+        const updates = {
+            prefix: await this.visitSpace(spread.prefix, p),
+            markers: await this.visitMarkers(spread.markers, p),
+            expression: await this.visitDefined(spread.expression, p),
+            type: await this.visitType(spread.type, p)
+        };
+        return (0, util_1.updateIfChanged)(spread, updates);
+    }
+    async visitStatementExpression(statementExpression, p) {
+        const expression = await this.visitExpression(statementExpression, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.StatementExpression) {
+            return expression;
+        }
+        statementExpression = expression;
+        const statement = await this.visitStatement(statementExpression, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.StatementExpression) {
+            return statement;
+        }
+        statementExpression = statement;
+        const updates = {
+            prefix: await this.visitSpace(statementExpression.prefix, p),
+            markers: await this.visitMarkers(statementExpression.markers, p),
+            statement: await this.visitDefined(statementExpression.statement, p)
+        };
+        return (0, util_1.updateIfChanged)(statementExpression, updates);
+    }
+    async visitTaggedTemplateExpression(taggedTemplateExpression, p) {
+        const expression = await this.visitExpression(taggedTemplateExpression, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TaggedTemplateExpression) {
+            return expression;
+        }
+        taggedTemplateExpression = expression;
+        const statement = await this.visitStatement(taggedTemplateExpression, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.TaggedTemplateExpression) {
+            return statement;
+        }
+        taggedTemplateExpression = statement;
+        const updates = {
+            prefix: await this.visitSpace(taggedTemplateExpression.prefix, p),
+            markers: await this.visitMarkers(taggedTemplateExpression.markers, p),
+            tag: taggedTemplateExpression.tag && await this.visitRightPadded(taggedTemplateExpression.tag, p),
+            typeArguments: taggedTemplateExpression.typeArguments && await this.visitContainer(taggedTemplateExpression.typeArguments, p),
+            templateExpression: await this.visitDefined(taggedTemplateExpression.templateExpression, p),
+            type: taggedTemplateExpression.type && await this.visitType(taggedTemplateExpression.type, p)
+        };
+        return (0, util_1.updateIfChanged)(taggedTemplateExpression, updates);
+    }
+    async visitTemplateExpression(templateExpression, p) {
+        const expression = await this.visitExpression(templateExpression, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TemplateExpression) {
+            return expression;
+        }
+        templateExpression = expression;
+        const statement = await this.visitStatement(templateExpression, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.TemplateExpression) {
+            return statement;
+        }
+        templateExpression = statement;
+        const updates = {
+            prefix: await this.visitSpace(templateExpression.prefix, p),
+            markers: await this.visitMarkers(templateExpression.markers, p),
+            head: await this.visitDefined(templateExpression.head, p),
+            spans: await (0, util_1.mapAsync)(templateExpression.spans, item => this.visitRightPadded(item, p)),
+            type: templateExpression.type && await this.visitType(templateExpression.type, p)
+        };
+        return (0, util_1.updateIfChanged)(templateExpression, updates);
+    }
+    async visitTemplateExpressionSpan(span, p) {
+        const updates = {
+            prefix: await this.visitSpace(span.prefix, p),
+            markers: await this.visitMarkers(span.markers, p),
+            expression: await this.visitDefined(span.expression, p),
+            tail: await this.visitDefined(span.tail, p)
+        };
+        return (0, util_1.updateIfChanged)(span, updates);
+    }
+    async visitTuple(tuple, p) {
+        const expression = await this.visitExpression(tuple, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Tuple) {
+            return expression;
+        }
+        tuple = expression;
+        const updates = {
+            prefix: await this.visitSpace(tuple.prefix, p),
+            markers: await this.visitMarkers(tuple.markers, p),
+            elements: await this.visitContainer(tuple.elements, p),
+            type: tuple.type && await this.visitType(tuple.type, p)
+        };
+        return (0, util_1.updateIfChanged)(tuple, updates);
+    }
+    async visitTypeDeclaration(typeDeclaration, p) {
+        const statement = await this.visitStatement(typeDeclaration, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.TypeDeclaration) {
+            return statement;
+        }
+        typeDeclaration = statement;
+        const updates = {
+            prefix: await this.visitSpace(typeDeclaration.prefix, p),
+            markers: await this.visitMarkers(typeDeclaration.markers, p),
+            modifiers: await (0, util_1.mapAsync)(typeDeclaration.modifiers, item => this.visitDefined(item, p)),
+            name: await this.visitLeftPadded(typeDeclaration.name, p),
+            typeParameters: typeDeclaration.typeParameters && await this.visitDefined(typeDeclaration.typeParameters, p),
+            initializer: await this.visitLeftPadded(typeDeclaration.initializer, p),
+            type: typeDeclaration.type && await this.visitType(typeDeclaration.type, p)
+        };
+        return (0, util_1.updateIfChanged)(typeDeclaration, updates);
+    }
+    async visitTypeOf(typeOf, p) {
+        const expression = await this.visitExpression(typeOf, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TypeOf) {
+            return expression;
+        }
+        typeOf = expression;
+        const updates = {
+            prefix: await this.visitSpace(typeOf.prefix, p),
+            markers: await this.visitMarkers(typeOf.markers, p),
+            expression: await this.visitDefined(typeOf.expression, p),
+            type: typeOf.type && await this.visitType(typeOf.type, p)
+        };
+        return (0, util_1.updateIfChanged)(typeOf, updates);
+    }
+    async visitTypeTreeExpression(typeTreeExpression, p) {
+        const expression = await this.visitExpression(typeTreeExpression, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TypeTreeExpression) {
+            return expression;
+        }
+        typeTreeExpression = expression;
+        const updates = {
+            prefix: await this.visitSpace(typeTreeExpression.prefix, p),
+            markers: await this.visitMarkers(typeTreeExpression.markers, p),
+            expression: await this.visitDefined(typeTreeExpression.expression, p)
+        };
+        return (0, util_1.updateIfChanged)(typeTreeExpression, updates);
+    }
+    async visitAssignmentOperationExtensions(assignmentOperation, p) {
+        const updates = {
+            prefix: await this.visitSpace(assignmentOperation.prefix, p),
+            markers: await this.visitMarkers(assignmentOperation.markers, p),
+            variable: await this.visitDefined(assignmentOperation.variable, p),
+            operator: await this.visitLeftPadded(assignmentOperation.operator, p),
+            assignment: await this.visitDefined(assignmentOperation.assignment, p),
+            type: assignmentOperation.type && await this.visitType(assignmentOperation.type, p)
+        };
+        return (0, util_1.updateIfChanged)(assignmentOperation, updates);
+    }
+    async visitIndexedAccessType(indexedAccessType, p) {
+        const expression = await this.visitExpression(indexedAccessType, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.IndexedAccessType) {
+            return expression;
+        }
+        indexedAccessType = expression;
+        const updates = {
+            prefix: await this.visitSpace(indexedAccessType.prefix, p),
+            markers: await this.visitMarkers(indexedAccessType.markers, p),
+            objectType: await this.visitDefined(indexedAccessType.objectType, p),
+            indexType: await this.visitDefined(indexedAccessType.indexType, p),
+            type: indexedAccessType.type && await this.visitType(indexedAccessType.type, p)
+        };
+        return (0, util_1.updateIfChanged)(indexedAccessType, updates);
+    }
+    async visitIndexedAccessTypeIndexType(indexType, p) {
+        const updates = {
+            prefix: await this.visitSpace(indexType.prefix, p),
+            markers: await this.visitMarkers(indexType.markers, p),
+            element: await this.visitRightPadded(indexType.element, p),
+            type: indexType.type && await this.visitType(indexType.type, p)
+        };
+        return (0, util_1.updateIfChanged)(indexType, updates);
+    }
+    async visitTypeQuery(typeQuery, p) {
+        const expression = await this.visitExpression(typeQuery, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TypeQuery) {
+            return expression;
+        }
+        typeQuery = expression;
+        const updates = {
+            prefix: await this.visitSpace(typeQuery.prefix, p),
+            markers: await this.visitMarkers(typeQuery.markers, p),
+            typeExpression: await this.visitDefined(typeQuery.typeExpression, p),
+            typeArguments: typeQuery.typeArguments && await this.visitContainer(typeQuery.typeArguments, p),
+            type: typeQuery.type && await this.visitType(typeQuery.type, p)
+        };
+        return (0, util_1.updateIfChanged)(typeQuery, updates);
+    }
+    async visitTypeInfo(typeInfo, p) {
+        const expression = await this.visitExpression(typeInfo, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TypeInfo) {
+            return expression;
+        }
+        typeInfo = expression;
+        const updates = {
+            prefix: await this.visitSpace(typeInfo.prefix, p),
+            markers: await this.visitMarkers(typeInfo.markers, p),
+            typeIdentifier: await this.visitDefined(typeInfo.typeIdentifier, p)
+        };
+        return (0, util_1.updateIfChanged)(typeInfo, updates);
+    }
+    async visitComputedPropertyName(computedPropertyName, p) {
+        const expression = await this.visitExpression(computedPropertyName, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.ComputedPropertyName) {
+            return expression;
+        }
+        computedPropertyName = expression;
+        const updates = {
+            prefix: await this.visitSpace(computedPropertyName.prefix, p),
+            markers: await this.visitMarkers(computedPropertyName.markers, p),
+            expression: await this.visitRightPadded(computedPropertyName.expression, p)
+        };
+        return (0, util_1.updateIfChanged)(computedPropertyName, updates);
+    }
+    async visitTypeOperator(typeOperator, p) {
+        const expression = await this.visitExpression(typeOperator, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TypeOperator) {
+            return expression;
+        }
+        typeOperator = expression;
+        const updates = {
+            prefix: await this.visitSpace(typeOperator.prefix, p),
+            markers: await this.visitMarkers(typeOperator.markers, p),
+            expression: await this.visitLeftPadded(typeOperator.expression, p)
+        };
+        return (0, util_1.updateIfChanged)(typeOperator, updates);
+    }
+    async visitTypePredicate(typePredicate, p) {
+        const expression = await this.visitExpression(typePredicate, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.TypePredicate) {
+            return expression;
+        }
+        typePredicate = expression;
+        const updates = {
+            prefix: await this.visitSpace(typePredicate.prefix, p),
+            markers: await this.visitMarkers(typePredicate.markers, p),
+            asserts: await this.visitLeftPadded(typePredicate.asserts, p),
+            parameterName: await this.visitDefined(typePredicate.parameterName, p),
+            expression: typePredicate.expression && await this.visitLeftPadded(typePredicate.expression, p),
+            type: typePredicate.type && await this.visitType(typePredicate.type, p)
+        };
+        return (0, util_1.updateIfChanged)(typePredicate, updates);
+    }
+    async visitUnion(union, p) {
+        const expression = await this.visitExpression(union, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Union) {
+            return expression;
+        }
+        union = expression;
+        const updates = {
+            prefix: await this.visitSpace(union.prefix, p),
+            markers: await this.visitMarkers(union.markers, p),
+            types: await (0, util_1.mapAsync)(union.types, item => this.visitRightPadded(item, p)),
+            type: union.type && await this.visitType(union.type, p)
+        };
+        return (0, util_1.updateIfChanged)(union, updates);
+    }
+    async visitIntersection(intersection, p) {
+        const expression = await this.visitExpression(intersection, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Intersection) {
+            return expression;
+        }
+        intersection = expression;
+        const updates = {
+            prefix: await this.visitSpace(intersection.prefix, p),
+            markers: await this.visitMarkers(intersection.markers, p),
+            types: await (0, util_1.mapAsync)(intersection.types, item => this.visitRightPadded(item, p)),
+            type: intersection.type && await this.visitType(intersection.type, p)
+        };
+        return (0, util_1.updateIfChanged)(intersection, updates);
+    }
+    async visitVoid(void_, p) {
+        const expression = await this.visitExpression(void_, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_1.JS.Kind.Void) {
+            return expression;
+        }
+        void_ = expression;
+        const updates = {
+            prefix: await this.visitSpace(void_.prefix, p),
+            markers: await this.visitMarkers(void_.markers, p),
+            expression: await this.visitDefined(void_.expression, p)
+        };
+        return (0, util_1.updateIfChanged)(void_, updates);
+    }
+    async visitWithStatement(withStatement, p) {
+        const statement = await this.visitStatement(withStatement, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.WithStatement) {
+            return statement;
+        }
+        withStatement = statement;
+        const updates = {
+            prefix: await this.visitSpace(withStatement.prefix, p),
+            markers: await this.visitMarkers(withStatement.markers, p),
+            expression: await this.visitDefined(withStatement.expression, p),
+            body: await this.visitRightPadded(withStatement.body, p)
+        };
+        return (0, util_1.updateIfChanged)(withStatement, updates);
+    }
+    async visitIndexSignatureDeclaration(indexSignatureDeclaration, p) {
+        const statement = await this.visitStatement(indexSignatureDeclaration, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.IndexSignatureDeclaration) {
+            return statement;
+        }
+        indexSignatureDeclaration = statement;
+        const updates = {
+            prefix: await this.visitSpace(indexSignatureDeclaration.prefix, p),
+            markers: await this.visitMarkers(indexSignatureDeclaration.markers, p),
+            modifiers: await (0, util_1.mapAsync)(indexSignatureDeclaration.modifiers, item => this.visitDefined(item, p)),
+            parameters: await this.visitContainer(indexSignatureDeclaration.parameters, p),
+            typeExpression: await this.visitLeftPadded(indexSignatureDeclaration.typeExpression, p),
+            type: indexSignatureDeclaration.type && await this.visitType(indexSignatureDeclaration.type, p)
+        };
+        return (0, util_1.updateIfChanged)(indexSignatureDeclaration, updates);
+    }
+    async visitComputedPropertyMethodDeclaration(computedPropMethod, p) {
+        const statement = await this.visitStatement(computedPropMethod, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.ComputedPropertyMethodDeclaration) {
+            return statement;
+        }
+        computedPropMethod = statement;
+        const updates = {
+            prefix: await this.visitSpace(computedPropMethod.prefix, p),
+            markers: await this.visitMarkers(computedPropMethod.markers, p),
+            leadingAnnotations: await (0, util_1.mapAsync)(computedPropMethod.leadingAnnotations, item => this.visitDefined(item, p)),
+            modifiers: await (0, util_1.mapAsync)(computedPropMethod.modifiers, item => this.visitDefined(item, p)),
+            typeParameters: computedPropMethod.typeParameters && await this.visitDefined(computedPropMethod.typeParameters, p),
+            returnTypeExpression: computedPropMethod.returnTypeExpression && await this.visitDefined(computedPropMethod.returnTypeExpression, p),
+            name: await this.visitDefined(computedPropMethod.name, p),
+            parameters: await this.visitContainer(computedPropMethod.parameters, p),
+            body: computedPropMethod.body && await this.visitDefined(computedPropMethod.body, p),
+            methodType: computedPropMethod.methodType && await this.visitType(computedPropMethod.methodType, p)
+        };
+        return (0, util_1.updateIfChanged)(computedPropMethod, updates);
+    }
+    async visitForOfLoop(forOfLoop, p) {
+        const updates = {
+            prefix: await this.visitSpace(forOfLoop.prefix, p),
+            markers: await this.visitMarkers(forOfLoop.markers, p),
+            loop: await this.visitDefined(forOfLoop.loop, p)
+        };
+        return (0, util_1.updateIfChanged)(forOfLoop, updates);
+    }
+    async visitForInLoop(forInLoop, p) {
+        const updates = {
+            prefix: await this.visitSpace(forInLoop.prefix, p),
+            markers: await this.visitMarkers(forInLoop.markers, p),
+            control: await this.visitDefined(forInLoop.control, p),
+            body: await this.visitRightPadded(forInLoop.body, p)
+        };
+        return (0, util_1.updateIfChanged)(forInLoop, updates);
+    }
+    async visitNamespaceDeclaration(namespaceDeclaration, p) {
+        const statement = await this.visitStatement(namespaceDeclaration, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.NamespaceDeclaration) {
+            return statement;
+        }
+        namespaceDeclaration = statement;
+        const updates = {
+            prefix: await this.visitSpace(namespaceDeclaration.prefix, p),
+            markers: await this.visitMarkers(namespaceDeclaration.markers, p),
+            modifiers: await (0, util_1.mapAsync)(namespaceDeclaration.modifiers, item => this.visitDefined(item, p)),
+            keywordType: await this.visitLeftPadded(namespaceDeclaration.keywordType, p),
+            name: await this.visitRightPadded(namespaceDeclaration.name, p),
+            body: namespaceDeclaration.body && await this.visitDefined(namespaceDeclaration.body, p)
+        };
+        return (0, util_1.updateIfChanged)(namespaceDeclaration, updates);
+    }
+    async visitTypeLiteral(typeLiteral, p) {
+        const updates = {
+            prefix: await this.visitSpace(typeLiteral.prefix, p),
+            markers: await this.visitMarkers(typeLiteral.markers, p),
+            members: await this.visitDefined(typeLiteral.members, p),
+            type: typeLiteral.type && await this.visitType(typeLiteral.type, p)
+        };
+        return (0, util_1.updateIfChanged)(typeLiteral, updates);
+    }
+    async visitArrayBindingPattern(arrayBindingPattern, p) {
+        const updates = {
+            prefix: await this.visitSpace(arrayBindingPattern.prefix, p),
+            markers: await this.visitMarkers(arrayBindingPattern.markers, p),
+            elements: await this.visitContainer(arrayBindingPattern.elements, p),
+            type: arrayBindingPattern.type && await this.visitType(arrayBindingPattern.type, p)
+        };
+        return (0, util_1.updateIfChanged)(arrayBindingPattern, updates);
+    }
+    async visitBindingElement(bindingElement, p) {
+        const statement = await this.visitStatement(bindingElement, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.BindingElement) {
+            return statement;
+        }
+        bindingElement = statement;
+        const updates = {
+            prefix: await this.visitSpace(bindingElement.prefix, p),
+            markers: await this.visitMarkers(bindingElement.markers, p),
+            propertyName: bindingElement.propertyName && await this.visitRightPadded(bindingElement.propertyName, p),
+            name: await this.visitDefined(bindingElement.name, p),
+            initializer: bindingElement.initializer && await this.visitLeftPadded(bindingElement.initializer, p),
+            variableType: bindingElement.variableType && await this.visitType(bindingElement.variableType, p)
+        };
+        return (0, util_1.updateIfChanged)(bindingElement, updates);
+    }
+    async visitExportDeclaration(exportDeclaration, p) {
+        const statement = await this.visitStatement(exportDeclaration, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.ExportDeclaration) {
+            return statement;
+        }
+        exportDeclaration = statement;
+        const updates = {
+            prefix: await this.visitSpace(exportDeclaration.prefix, p),
+            markers: await this.visitMarkers(exportDeclaration.markers, p),
+            modifiers: await (0, util_1.mapAsync)(exportDeclaration.modifiers, item => this.visitDefined(item, p)),
+            typeOnly: await this.visitLeftPadded(exportDeclaration.typeOnly, p),
+            exportClause: exportDeclaration.exportClause && await this.visitDefined(exportDeclaration.exportClause, p),
+            moduleSpecifier: exportDeclaration.moduleSpecifier && await this.visitLeftPadded(exportDeclaration.moduleSpecifier, p),
+            attributes: exportDeclaration.attributes && await this.visitDefined(exportDeclaration.attributes, p)
+        };
+        return (0, util_1.updateIfChanged)(exportDeclaration, updates);
+    }
+    async visitExportAssignment(exportAssignment, p) {
+        const statement = await this.visitStatement(exportAssignment, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_1.JS.Kind.ExportAssignment) {
+            return statement;
+        }
+        exportAssignment = statement;
+        const updates = {
+            prefix: await this.visitSpace(exportAssignment.prefix, p),
+            markers: await this.visitMarkers(exportAssignment.markers, p),
+            expression: await this.visitLeftPadded(exportAssignment.expression, p)
+        };
+        return (0, util_1.updateIfChanged)(exportAssignment, updates);
+    }
+    async visitNamedExports(namedExports, p) {
+        const updates = {
+            prefix: await this.visitSpace(namedExports.prefix, p),
+            markers: await this.visitMarkers(namedExports.markers, p),
+            elements: await this.visitContainer(namedExports.elements, p),
+            type: namedExports.type && await this.visitType(namedExports.type, p)
+        };
+        return (0, util_1.updateIfChanged)(namedExports, updates);
+    }
+    async visitExportSpecifier(exportSpecifier, p) {
+        const updates = {
+            prefix: await this.visitSpace(exportSpecifier.prefix, p),
+            markers: await this.visitMarkers(exportSpecifier.markers, p),
+            typeOnly: await this.visitLeftPadded(exportSpecifier.typeOnly, p),
+            specifier: await this.visitDefined(exportSpecifier.specifier, p),
+            type: exportSpecifier.type && await this.visitType(exportSpecifier.type, p)
+        };
+        return (0, util_1.updateIfChanged)(exportSpecifier, updates);
+    }
+    async accept(j, p) {
+        if ((0, tree_1.isJavaScript)(j)) {
+            const tree = j;
+            switch (tree.kind) {
+                case tree_1.JS.Kind.Alias:
+                    return this.visitAlias(tree, p);
+                case tree_1.JS.Kind.ArrowFunction:
+                    return this.visitArrowFunction(tree, p);
+                case tree_1.JS.Kind.As:
+                    return this.visitAs(tree, p);
+                case tree_1.JS.Kind.Await:
+                    return this.visitAwait(tree, p);
+                case tree_1.JS.Kind.CompilationUnit:
+                    return this.visitJsCompilationUnit(tree, p);
+                case tree_1.JS.Kind.ComputedPropertyName:
+                    return this.visitComputedPropertyName(tree, p);
+                case tree_1.JS.Kind.ConditionalType:
+                    return this.visitConditionalType(tree, p);
+                case tree_1.JS.Kind.Delete:
+                    return this.visitDelete(tree, p);
+                case tree_1.JS.Kind.ExpressionStatement:
+                    return this.visitExpressionStatement(tree, p);
+                case tree_1.JS.Kind.ExpressionWithTypeArguments:
+                    return this.visitExpressionWithTypeArguments(tree, p);
+                case tree_1.JS.Kind.FunctionCall:
+                    return this.visitFunctionCall(tree, p);
+                case tree_1.JS.Kind.FunctionType:
+                    return this.visitFunctionType(tree, p);
+                case tree_1.JS.Kind.InferType:
+                    return this.visitInferType(tree, p);
+                case tree_1.JS.Kind.ImportType:
+                    return this.visitImportType(tree, p);
+                case tree_1.JS.Kind.Import:
+                    return this.visitImportDeclaration(tree, p);
+                case tree_1.JS.Kind.ImportClause:
+                    return this.visitImportClause(tree, p);
+                case tree_1.JS.Kind.NamedImports:
+                    return this.visitNamedImports(tree, p);
+                case tree_1.JS.Kind.ImportSpecifier:
+                    return this.visitImportSpecifier(tree, p);
+                case tree_1.JS.Kind.ImportAttributes:
+                    return this.visitImportAttributes(tree, p);
+                case tree_1.JS.Kind.ImportTypeAttributes:
+                    return this.visitImportTypeAttributes(tree, p);
+                case tree_1.JS.Kind.ImportAttribute:
+                    return this.visitImportAttribute(tree, p);
+                case tree_1.JS.Kind.JsxAttribute:
+                    return this.visitJsxAttribute(tree, p);
+                case tree_1.JS.Kind.JsxSpreadAttribute:
+                    return this.visitJsxSpreadAttribute(tree, p);
+                case tree_1.JS.Kind.JsxEmbeddedExpression:
+                    return this.visitJsxEmbeddedExpression(tree, p);
+                case tree_1.JS.Kind.JsxNamespacedName:
+                    return this.visitJsxNamespacedName(tree, p);
+                case tree_1.JS.Kind.JsxTag:
+                    return this.visitJsxTag(tree, p);
+                case tree_1.JS.Kind.Binary:
+                    return this.visitBinaryExtensions(tree, p);
+                case tree_1.JS.Kind.LiteralType:
+                    return this.visitLiteralType(tree, p);
+                case tree_1.JS.Kind.MappedType:
+                    return this.visitMappedType(tree, p);
+                case tree_1.JS.Kind.MappedTypeKeysRemapping:
+                    return this.visitMappedTypeKeysRemapping(tree, p);
+                case tree_1.JS.Kind.MappedTypeParameter:
+                    return this.visitMappedTypeParameter(tree, p);
+                case tree_1.JS.Kind.ObjectBindingPattern:
+                    return this.visitObjectBindingPattern(tree, p);
+                case tree_1.JS.Kind.PropertyAssignment:
+                    return this.visitPropertyAssignment(tree, p);
+                case tree_1.JS.Kind.SatisfiesExpression:
+                    return this.visitSatisfiesExpression(tree, p);
+                case tree_1.JS.Kind.ScopedVariableDeclarations:
+                    return this.visitScopedVariableDeclarations(tree, p);
+                case tree_1.JS.Kind.Shebang:
+                    return this.visitShebang(tree, p);
+                case tree_1.JS.Kind.Spread:
+                    return this.visitSpread(tree, p);
+                case tree_1.JS.Kind.StatementExpression:
+                    return this.visitStatementExpression(tree, p);
+                case tree_1.JS.Kind.TaggedTemplateExpression:
+                    return this.visitTaggedTemplateExpression(tree, p);
+                case tree_1.JS.Kind.TemplateExpression:
+                    return this.visitTemplateExpression(tree, p);
+                case tree_1.JS.Kind.TemplateExpressionSpan:
+                    return this.visitTemplateExpressionSpan(tree, p);
+                case tree_1.JS.Kind.Tuple:
+                    return this.visitTuple(tree, p);
+                case tree_1.JS.Kind.TypeDeclaration:
+                    return this.visitTypeDeclaration(tree, p);
+                case tree_1.JS.Kind.TypeOf:
+                    return this.visitTypeOf(tree, p);
+                case tree_1.JS.Kind.TypeTreeExpression:
+                    return this.visitTypeTreeExpression(tree, p);
+                case tree_1.JS.Kind.AssignmentOperation:
+                    return this.visitAssignmentOperationExtensions(tree, p);
+                case tree_1.JS.Kind.IndexedAccessType:
+                    return this.visitIndexedAccessType(tree, p);
+                case tree_1.JS.Kind.IndexType:
+                    return this.visitIndexedAccessTypeIndexType(tree, p);
+                case tree_1.JS.Kind.TypeQuery:
+                    return this.visitTypeQuery(tree, p);
+                case tree_1.JS.Kind.TypeInfo:
+                    return this.visitTypeInfo(tree, p);
+                case tree_1.JS.Kind.TypeOperator:
+                    return this.visitTypeOperator(tree, p);
+                case tree_1.JS.Kind.TypePredicate:
+                    return this.visitTypePredicate(tree, p);
+                case tree_1.JS.Kind.Union:
+                    return this.visitUnion(tree, p);
+                case tree_1.JS.Kind.Intersection:
+                    return this.visitIntersection(tree, p);
+                case tree_1.JS.Kind.Void:
+                    return this.visitVoid(tree, p);
+                case tree_1.JS.Kind.WithStatement:
+                    return this.visitWithStatement(tree, p);
+                case tree_1.JS.Kind.IndexSignatureDeclaration:
+                    return this.visitIndexSignatureDeclaration(tree, p);
+                case tree_1.JS.Kind.ComputedPropertyMethodDeclaration:
+                    return this.visitComputedPropertyMethodDeclaration(tree, p);
+                case tree_1.JS.Kind.ForOfLoop:
+                    return this.visitForOfLoop(tree, p);
+                case tree_1.JS.Kind.ForInLoop:
+                    return this.visitForInLoop(tree, p);
+                case tree_1.JS.Kind.NamespaceDeclaration:
+                    return this.visitNamespaceDeclaration(tree, p);
+                case tree_1.JS.Kind.TypeLiteral:
+                    return this.visitTypeLiteral(tree, p);
+                case tree_1.JS.Kind.ArrayBindingPattern:
+                    return this.visitArrayBindingPattern(tree, p);
+                case tree_1.JS.Kind.BindingElement:
+                    return this.visitBindingElement(tree, p);
+                case tree_1.JS.Kind.ExportDeclaration:
+                    return this.visitExportDeclaration(tree, p);
+                case tree_1.JS.Kind.ExportAssignment:
+                    return this.visitExportAssignment(tree, p);
+                case tree_1.JS.Kind.NamedExports:
+                    return this.visitNamedExports(tree, p);
+                case tree_1.JS.Kind.ExportSpecifier:
+                    return this.visitExportSpecifier(tree, p);
             }
-            return _super.accept.call(this, j, p);
-        });
+        }
+        return super.accept(j, p);
     }
 }
 exports.JavaScriptVisitor = JavaScriptVisitor;