@openrewrite/rewrite 8.72.2 → 8.72.3

package/dist/javascript/templating/engine.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateApplier = exports.TemplateEngine = void 0;
 exports.setTemplateSourceFileCache = setTemplateSourceFileCache;
@@ -112,35 +103,33 @@ class TemplateCache {
     /**
      * Gets a cached compilation unit or creates and caches a new one.
      */
-    getOrParse(templateString, captures, contextStatements, dependencies) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const key = this.generateKey(templateString, captures, contextStatements, dependencies);
-            let cu = this.cache.get(key);
-            if (cu) {
-                return cu;
-            }
-            // Create workspace if dependencies are provided
-            // DependencyWorkspace has its own cache, so multiple templates with
-            // the same dependencies will automatically share the same workspace
-            let workspaceDir;
-            if (dependencies && Object.keys(dependencies).length > 0) {
-                workspaceDir = yield dependency_workspace_1.DependencyWorkspace.getOrCreateWorkspace({ dependencies });
-            }
-            // Prepend context statements for type attribution context
-            const fullTemplateString = contextStatements.length > 0
-                ? contextStatements.join('\n') + '\n' + templateString
-                : templateString;
-            // Parse and cache (workspace only needed during parsing)
-            // Use templateSourceFileCache if configured for ~3.2x speedup on dependency file parsing
-            const parser = new __2.JavaScriptParser({
-                relativeTo: workspaceDir,
-                sourceFileCache: templateSourceFileCache
-            });
-            const parseGenerator = parser.parse({ text: fullTemplateString, sourcePath: 'template.ts' });
-            cu = (yield parseGenerator.next()).value;
-            this.cache.set(key, cu);
+    async getOrParse(templateString, captures, contextStatements, dependencies) {
+        const key = this.generateKey(templateString, captures, contextStatements, dependencies);
+        let cu = this.cache.get(key);
+        if (cu) {
             return cu;
+        }
+        // Create workspace if dependencies are provided
+        // DependencyWorkspace has its own cache, so multiple templates with
+        // the same dependencies will automatically share the same workspace
+        let workspaceDir;
+        if (dependencies && Object.keys(dependencies).length > 0) {
+            workspaceDir = await dependency_workspace_1.DependencyWorkspace.getOrCreateWorkspace({ dependencies });
+        }
+        // Prepend context statements for type attribution context
+        const fullTemplateString = contextStatements.length > 0
+            ? contextStatements.join('\n') + '\n' + templateString
+            : templateString;
+        // Parse and cache (workspace only needed during parsing)
+        // Use templateSourceFileCache if configured for ~3.2x speedup on dependency file parsing
+        const parser = new __2.JavaScriptParser({
+            relativeTo: workspaceDir,
+            sourceFileCache: templateSourceFileCache
         });
+        const parseGenerator = parser.parse({ text: fullTemplateString, sourcePath: 'template.ts' });
+        cu = (await parseGenerator.next()).value;
+        this.cache.set(key, cu);
+        return cu;
     }
     /**
      * Clears the cache.
@@ -176,28 +165,26 @@ class TemplateEngine {
      * @param dependencies NPM dependencies for type attribution
      * @returns A Promise resolving to the extracted template AST
      */
-    static getTemplateTree(templateParts_1, parameters_1) {
-        return __awaiter(this, arguments, void 0, function* (templateParts, parameters, contextStatements = [], dependencies = {}) {
-            // Generate type preamble for captures/parameters with types
-            const preamble = TemplateEngine.generateTypePreamble(parameters);
-            // Build the template string with parameter placeholders
-            const templateString = TemplateEngine.buildTemplateString(templateParts, parameters);
-            // Add preamble to context statements (so they're skipped during extraction)
-            const contextWithPreamble = preamble.length > 0
-                ? [...contextStatements, ...preamble]
-                : contextStatements;
-            // Use cache to get or parse the compilation unit
-            const cu = yield templateCache.getOrParse(templateString, [], contextWithPreamble, dependencies);
-            // Check if there are any statements
-            if (!cu.statements || cu.statements.length === 0) {
-                throw new Error(`Failed to parse template code (no statements):\n${templateString}`);
-            }
-            // The template code is always the last statement (after context + preamble)
-            const lastStatement = cu.statements[cu.statements.length - 1].element;
-            // Extract from wrapper using shared utility
-            const extracted = utils_1.PlaceholderUtils.extractFromWrapper(lastStatement, 'Template');
-            return (0, mutative_1.create)(extracted, _ => { });
-        });
+    static async getTemplateTree(templateParts, parameters, contextStatements = [], dependencies = {}) {
+        // Generate type preamble for captures/parameters with types
+        const preamble = TemplateEngine.generateTypePreamble(parameters);
+        // Build the template string with parameter placeholders
+        const templateString = TemplateEngine.buildTemplateString(templateParts, parameters);
+        // Add preamble to context statements (so they're skipped during extraction)
+        const contextWithPreamble = preamble.length > 0
+            ? [...contextStatements, ...preamble]
+            : contextStatements;
+        // Use cache to get or parse the compilation unit
+        const cu = await templateCache.getOrParse(templateString, [], contextWithPreamble, dependencies);
+        // Check if there are any statements
+        if (!cu.statements || cu.statements.length === 0) {
+            throw new Error(`Failed to parse template code (no statements):\n${templateString}`);
+        }
+        // The template code is always the last statement (after context + preamble)
+        const lastStatement = cu.statements[cu.statements.length - 1].element;
+        // Extract from wrapper using shared utility
+        const extracted = utils_1.PlaceholderUtils.extractFromWrapper(lastStatement, 'Template');
+        return (0, mutative_1.create)(extracted, _ => { });
     }
     /**
      * Applies a template from a pre-parsed AST and returns the resulting AST.
@@ -211,20 +198,18 @@ class TemplateEngine {
      * @param wrappersMap Map of capture names to J.RightPadded wrappers (for preserving markers)
      * @returns A Promise resolving to the generated AST node
      */
-    static applyTemplateFromAst(ast_1, parameters_1, cursor_1, coordinates_1) {
-        return __awaiter(this, arguments, void 0, function* (ast, parameters, cursor, coordinates, values = new Map(), wrappersMap = new Map()) {
-            // Create substitutions map for placeholders
-            const substitutions = new Map();
-            for (let i = 0; i < parameters.length; i++) {
-                const placeholder = `${utils_1.PlaceholderUtils.PLACEHOLDER_PREFIX}${i}__`;
-                substitutions.set(placeholder, parameters[i]);
-            }
-            // Unsubstitute placeholders with actual parameter values and match results
-            const visitor = new placeholder_replacement_1.PlaceholderReplacementVisitor(substitutions, values, wrappersMap);
-            const unsubstitutedAst = (yield visitor.visit(ast, null));
-            // Apply the template to the current AST
-            return new TemplateApplier(cursor, coordinates, unsubstitutedAst).apply();
-        });
+    static async applyTemplateFromAst(ast, parameters, cursor, coordinates, values = new Map(), wrappersMap = new Map()) {
+        // Create substitutions map for placeholders
+        const substitutions = new Map();
+        for (let i = 0; i < parameters.length; i++) {
+            const placeholder = `${utils_1.PlaceholderUtils.PLACEHOLDER_PREFIX}${i}__`;
+            substitutions.set(placeholder, parameters[i]);
+        }
+        // Unsubstitute placeholders with actual parameter values and match results
+        const visitor = new placeholder_replacement_1.PlaceholderReplacementVisitor(substitutions, values, wrappersMap);
+        const unsubstitutedAst = (await visitor.visit(ast, null));
+        // Apply the template to the current AST
+        return new TemplateApplier(cursor, coordinates, unsubstitutedAst).apply();
     }
     /**
      * Generates type preamble declarations for captures/parameters with type annotations.
@@ -369,70 +354,68 @@ class TemplateEngine {
      * @param dependencies NPM dependencies for type attribution
      * @returns A Promise resolving to the extracted pattern AST with capture markers
      */
-    static getPatternTree(templateParts_1, captures_1) {
-        return __awaiter(this, arguments, void 0, function* (templateParts, captures, contextStatements = [], dependencies = {}) {
-            // Generate type preamble for captures with types (skip RawCode)
-            const preamble = [];
-            for (const capture of captures) {
-                // Skip raw code - it's not a capture
-                if (capture instanceof capture_1.RawCode || (capture && typeof capture === 'object' && capture[capture_1.RAW_CODE_SYMBOL])) {
-                    continue;
-                }
-                const captureName = capture[capture_1.CAPTURE_NAME_SYMBOL] || capture.getName();
-                const captureType = capture[capture_1.CAPTURE_TYPE_SYMBOL];
-                if (captureType) {
-                    // Convert Type to string if needed
-                    const typeString = typeof captureType === 'string'
-                        ? captureType
-                        : this.typeToString(captureType);
-                    // Only add preamble if we have a concrete type (not 'any')
-                    if (typeString !== 'any') {
-                        const placeholder = utils_1.PlaceholderUtils.createCapture(captureName, undefined);
-                        preamble.push(`let ${placeholder}: ${typeString};`);
-                    }
-                }
-                // Don't add preamble declarations without types - they don't provide type attribution
+    static async getPatternTree(templateParts, captures, contextStatements = [], dependencies = {}) {
+        // Generate type preamble for captures with types (skip RawCode)
+        const preamble = [];
+        for (const capture of captures) {
+            // Skip raw code - it's not a capture
+            if (capture instanceof capture_1.RawCode || (capture && typeof capture === 'object' && capture[capture_1.RAW_CODE_SYMBOL])) {
+                continue;
             }
-            // Build the template string with placeholders for captures and raw code
-            let result = '';
-            for (let i = 0; i < templateParts.length; i++) {
-                result += templateParts[i];
-                if (i < captures.length) {
-                    const capture = captures[i];
-                    // Check if this is a RawCode instance - splice directly
-                    if (capture instanceof capture_1.RawCode || (capture && typeof capture === 'object' && capture[capture_1.RAW_CODE_SYMBOL])) {
-                        result += capture.code;
-                    }
-                    else {
-                        // Use symbol to access capture name without triggering Proxy
-                        const captureName = capture[capture_1.CAPTURE_NAME_SYMBOL] || capture.getName();
-                        result += utils_1.PlaceholderUtils.createCapture(captureName, undefined);
-                    }
+            const captureName = capture[capture_1.CAPTURE_NAME_SYMBOL] || capture.getName();
+            const captureType = capture[capture_1.CAPTURE_TYPE_SYMBOL];
+            if (captureType) {
+                // Convert Type to string if needed
+                const typeString = typeof captureType === 'string'
+                    ? captureType
+                    : this.typeToString(captureType);
+                // Only add preamble if we have a concrete type (not 'any')
+                if (typeString !== 'any') {
+                    const placeholder = utils_1.PlaceholderUtils.createCapture(captureName, undefined);
+                    preamble.push(`let ${placeholder}: ${typeString};`);
                 }
             }
-            // Always wrap in function body - let the parser decide what it is,
-            // then we'll extract intelligently based on what was parsed
-            const templateString = `function ${utils_1.WRAPPER_FUNCTION_NAME}() { ${result} }`;
-            // Add preamble to context statements (so they're skipped during extraction)
-            const contextWithPreamble = preamble.length > 0
-                ? [...contextStatements, ...preamble]
-                : contextStatements;
-            // Filter out RawCode from captures for cache and marker attachment
-            const actualCaptures = captures.filter(c => !(c instanceof capture_1.RawCode || (c && typeof c === 'object' && c[capture_1.RAW_CODE_SYMBOL])));
-            // Use cache to get or parse the compilation unit
-            const cu = yield templateCache.getOrParse(templateString, actualCaptures, contextWithPreamble, dependencies);
-            // Check if there are any statements
-            if (!cu.statements || cu.statements.length === 0) {
-                throw new Error(`Failed to parse pattern code (no statements):\n${templateString}`);
+            // Don't add preamble declarations without types - they don't provide type attribution
+        }
+        // Build the template string with placeholders for captures and raw code
+        let result = '';
+        for (let i = 0; i < templateParts.length; i++) {
+            result += templateParts[i];
+            if (i < captures.length) {
+                const capture = captures[i];
+                // Check if this is a RawCode instance - splice directly
+                if (capture instanceof capture_1.RawCode || (capture && typeof capture === 'object' && capture[capture_1.RAW_CODE_SYMBOL])) {
+                    result += capture.code;
+                }
+                else {
+                    // Use symbol to access capture name without triggering Proxy
+                    const captureName = capture[capture_1.CAPTURE_NAME_SYMBOL] || capture.getName();
+                    result += utils_1.PlaceholderUtils.createCapture(captureName, undefined);
+                }
             }
-            // The pattern code is always the last statement (after context + preamble)
-            const lastStatement = cu.statements[cu.statements.length - 1].element;
-            // Extract from wrapper using shared utility
-            const extracted = utils_1.PlaceholderUtils.extractFromWrapper(lastStatement, 'Pattern');
-            // Attach CaptureMarkers to capture identifiers (only for actual captures, not raw code)
-            const visitor = new MarkerAttachmentVisitor(actualCaptures);
-            return (yield visitor.visit(extracted, undefined));
-        });
+        }
+        // Always wrap in function body - let the parser decide what it is,
+        // then we'll extract intelligently based on what was parsed
+        const templateString = `function ${utils_1.WRAPPER_FUNCTION_NAME}() { ${result} }`;
+        // Add preamble to context statements (so they're skipped during extraction)
+        const contextWithPreamble = preamble.length > 0
+            ? [...contextStatements, ...preamble]
+            : contextStatements;
+        // Filter out RawCode from captures for cache and marker attachment
+        const actualCaptures = captures.filter(c => !(c instanceof capture_1.RawCode || (c && typeof c === 'object' && c[capture_1.RAW_CODE_SYMBOL])));
+        // Use cache to get or parse the compilation unit
+        const cu = await templateCache.getOrParse(templateString, actualCaptures, contextWithPreamble, dependencies);
+        // Check if there are any statements
+        if (!cu.statements || cu.statements.length === 0) {
+            throw new Error(`Failed to parse pattern code (no statements):\n${templateString}`);
+        }
+        // The pattern code is always the last statement (after context + preamble)
+        const lastStatement = cu.statements[cu.statements.length - 1].element;
+        // Extract from wrapper using shared utility
+        const extracted = utils_1.PlaceholderUtils.extractFromWrapper(lastStatement, 'Pattern');
+        // Attach CaptureMarkers to capture identifiers (only for actual captures, not raw code)
+        const visitor = new MarkerAttachmentVisitor(actualCaptures);
+        return (await visitor.visit(extracted, undefined));
     }
 }
 exports.TemplateEngine = TemplateEngine;
@@ -449,82 +432,73 @@ class MarkerAttachmentVisitor extends __2.JavaScriptVisitor {
     /**
      * Attaches CaptureMarker to capture identifiers.
      */
-    visitIdentifier(ident, p) {
-        const _super = Object.create(null, {
-            visitIdentifier: { get: () => super.visitIdentifier }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            // First call parent to handle standard visitation
-            const visited = yield _super.visitIdentifier.call(this, ident, p);
-            if (!visited || visited.kind !== java_1.J.Kind.Identifier) {
-                return visited;
-            }
-            ident = visited;
-            // Check if this is a capture placeholder
-            if ((_a = ident.simpleName) === null || _a === void 0 ? void 0 : _a.startsWith(utils_1.PlaceholderUtils.CAPTURE_PREFIX)) {
-                const captureInfo = utils_1.PlaceholderUtils.parseCapture(ident.simpleName);
-                if (captureInfo) {
-                    // Find the original capture object to get variadic options and constraint
-                    const captureObj = this.captures.find(c => c.getName() === captureInfo.name);
-                    const variadicOptions = captureObj === null || captureObj === void 0 ? void 0 : captureObj.getVariadicOptions();
-                    const constraint = (_b = captureObj === null || captureObj === void 0 ? void 0 : captureObj.getConstraint) === null || _b === void 0 ? void 0 : _b.call(captureObj);
-                    // Add CaptureMarker to the Identifier with constraint
-                    const marker = new utils_1.CaptureMarker(captureInfo.name, variadicOptions, constraint);
-                    return (0, __1.updateIfChanged)(ident, {
-                        markers: Object.assign(Object.assign({}, ident.markers), { markers: [...ident.markers.markers, marker] })
-                    });
-                }
+    async visitIdentifier(ident, p) {
+        var _a, _b;
+        // First call parent to handle standard visitation
+        const visited = await super.visitIdentifier(ident, p);
+        if (!visited || visited.kind !== java_1.J.Kind.Identifier) {
+            return visited;
+        }
+        ident = visited;
+        // Check if this is a capture placeholder
+        if ((_a = ident.simpleName) === null || _a === void 0 ? void 0 : _a.startsWith(utils_1.PlaceholderUtils.CAPTURE_PREFIX)) {
+            const captureInfo = utils_1.PlaceholderUtils.parseCapture(ident.simpleName);
+            if (captureInfo) {
+                // Find the original capture object to get variadic options and constraint
+                const captureObj = this.captures.find(c => c.getName() === captureInfo.name);
+                const variadicOptions = captureObj === null || captureObj === void 0 ? void 0 : captureObj.getVariadicOptions();
+                const constraint = (_b = captureObj === null || captureObj === void 0 ? void 0 : captureObj.getConstraint) === null || _b === void 0 ? void 0 : _b.call(captureObj);
+                // Add CaptureMarker to the Identifier with constraint
+                const marker = new utils_1.CaptureMarker(captureInfo.name, variadicOptions, constraint);
+                return (0, __1.updateIfChanged)(ident, {
+                    markers: Object.assign(Object.assign({}, ident.markers), { markers: [...ident.markers.markers, marker] })
+                });
             }
-            return ident;
-        });
+        }
+        return ident;
     }
     /**
      * Propagates markers from element to RightPadded wrapper.
      */
-    visitRightPadded(right, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!(0, __1.isTree)(right.element)) {
-                return right;
-            }
-            const visitedElement = yield this.visit(right.element, p);
-            if (visitedElement && visitedElement !== right.element) {
-                const result = yield (0, __1.produceAsync)(right, (draft) => __awaiter(this, void 0, void 0, function* () {
-                    // Visit element first
-                    if (right.element && right.element.kind) {
-                        // Check if element has a CaptureMarker
-                        const elementMarker = utils_1.PlaceholderUtils.getCaptureMarker(visitedElement);
-                        if (elementMarker) {
-                            draft.markers.markers.push(elementMarker);
-                        }
-                        else {
-                            draft.element = visitedElement;
-                        }
-                    }
-                }));
-                return result;
-            }
+    async visitRightPadded(right, p) {
+        if (!(0, __1.isTree)(right.element)) {
             return right;
-        });
+        }
+        const visitedElement = await this.visit(right.element, p);
+        if (visitedElement && visitedElement !== right.element) {
+            const result = await (0, __1.produceAsync)(right, async (draft) => {
+                // Visit element first
+                if (right.element && right.element.kind) {
+                    // Check if element has a CaptureMarker
+                    const elementMarker = utils_1.PlaceholderUtils.getCaptureMarker(visitedElement);
+                    if (elementMarker) {
+                        draft.markers.markers.push(elementMarker);
+                    }
+                    else {
+                        draft.element = visitedElement;
+                    }
+                }
+            });
+            return result;
+        }
+        return right;
     }
     /**
      * Propagates markers from expression to ExpressionStatement.
      */
-    visitExpressionStatement(expressionStatement, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Visit the expression
-            const visitedExpression = yield this.visit(expressionStatement.expression, p);
-            // Check if expression has a CaptureMarker
-            const expressionMarker = utils_1.PlaceholderUtils.getCaptureMarker(visitedExpression);
-            if (expressionMarker) {
-                return (0, __1.updateIfChanged)(expressionStatement, {
-                    markers: Object.assign(Object.assign({}, expressionStatement.markers), { markers: [...expressionStatement.markers.markers, expressionMarker] }),
-                });
-            }
-            // No marker to move, just update with visited expression
+    async visitExpressionStatement(expressionStatement, p) {
+        // Visit the expression
+        const visitedExpression = await this.visit(expressionStatement.expression, p);
+        // Check if expression has a CaptureMarker
+        const expressionMarker = utils_1.PlaceholderUtils.getCaptureMarker(visitedExpression);
+        if (expressionMarker) {
             return (0, __1.updateIfChanged)(expressionStatement, {
-                expression: visitedExpression
+                markers: Object.assign(Object.assign({}, expressionStatement.markers), { markers: [...expressionStatement.markers.markers, expressionMarker] }),
             });
+        }
+        // No marker to move, just update with visited expression
+        return (0, __1.updateIfChanged)(expressionStatement, {
+            expression: visitedExpression
         });
     }
     /**
@@ -532,22 +506,20 @@ class MarkerAttachmentVisitor extends __2.JavaScriptVisitor {
      * This handles destructuring patterns like {${props}} where the capture marker
      * is on the identifier but needs to be on the BindingElement for container matching.
      */
-    visitBindingElement(bindingElement, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Visit the name
-            const visitedName = yield this.visit(bindingElement.name, p);
-            // Check if name has a CaptureMarker
-            const nameMarker = utils_1.PlaceholderUtils.getCaptureMarker(visitedName);
-            if (nameMarker) {
-                return (0, __1.updateIfChanged)(bindingElement, {
-                    name: visitedName,
-                    markers: Object.assign(Object.assign({}, bindingElement.markers), { markers: [...bindingElement.markers.markers, nameMarker] }),
-                });
-            }
-            // No marker to move, just update with visited name
+    async visitBindingElement(bindingElement, p) {
+        // Visit the name
+        const visitedName = await this.visit(bindingElement.name, p);
+        // Check if name has a CaptureMarker
+        const nameMarker = utils_1.PlaceholderUtils.getCaptureMarker(visitedName);
+        if (nameMarker) {
             return (0, __1.updateIfChanged)(bindingElement, {
-                name: visitedName
+                name: visitedName,
+                markers: Object.assign(Object.assign({}, bindingElement.markers), { markers: [...bindingElement.markers.markers, nameMarker] }),
             });
+        }
+        // No marker to move, just update with visited name
+        return (0, __1.updateIfChanged)(bindingElement, {
+            name: visitedName
         });
     }
 }
@@ -565,48 +537,42 @@ class TemplateApplier {
      *
      * @returns A Promise resolving to the modified AST
      */
-    apply() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { loc } = this.coordinates;
-            // Apply the template based on the location and mode
-            switch (loc || 'EXPRESSION_PREFIX') {
-                case 'EXPRESSION_PREFIX':
-                case 'STATEMENT_PREFIX':
-                case 'BLOCK_END':
-                    return this.applyInternal();
-                default:
-                    throw new Error(`Unsupported location: ${loc}`);
-            }
-        });
+    async apply() {
+        const { loc } = this.coordinates;
+        // Apply the template based on the location and mode
+        switch (loc || 'EXPRESSION_PREFIX') {
+            case 'EXPRESSION_PREFIX':
+            case 'STATEMENT_PREFIX':
+            case 'BLOCK_END':
+                return this.applyInternal();
+            default:
+                throw new Error(`Unsupported location: ${loc}`);
+        }
     }
     /**
      * Applies the template to an expression.
      *
      * @returns A Promise resolving to the modified AST
      */
-    applyInternal() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { tree } = this.coordinates;
-            if (!tree) {
-                return this.ast;
-            }
-            const originalTree = tree;
-            const resultToUse = this.wrapTree(originalTree, this.ast);
-            return this.format(resultToUse, originalTree);
-        });
+    async applyInternal() {
+        const { tree } = this.coordinates;
+        if (!tree) {
+            return this.ast;
+        }
+        const originalTree = tree;
+        const resultToUse = this.wrapTree(originalTree, this.ast);
+        return this.format(resultToUse, originalTree);
     }
-    format(resultToUse, originalTree) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            // Create a copy of the AST with the prefix from the target
-            const result = Object.assign(Object.assign({}, resultToUse), { 
-                // We temporarily set the ID so that the formatter can identify the tree
-                id: originalTree.id, prefix: originalTree.prefix });
-            // Apply auto-formatting to the result
-            const formatted = yield (0, format_1.maybeAutoFormat)(originalTree, result, null, undefined, (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.parent);
-            // Restore the original ID
-            return Object.assign(Object.assign({}, formatted), { id: resultToUse.id });
-        });
+    async format(resultToUse, originalTree) {
+        var _a;
+        // Create a copy of the AST with the prefix from the target
+        const result = Object.assign(Object.assign({}, resultToUse), { 
+            // We temporarily set the ID so that the formatter can identify the tree
+            id: originalTree.id, prefix: originalTree.prefix });
+        // Apply auto-formatting to the result
+        const formatted = await (0, format_1.maybeAutoFormat)(originalTree, result, null, undefined, (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.parent);
+        // Restore the original ID
+        return Object.assign(Object.assign({}, formatted), { id: resultToUse.id });
     }
     wrapTree(originalTree, resultToUse) {
         var _a, _b;