@openrewrite/rewrite 8.72.2 → 8.72.3

package/dist/javascript/remove-import.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.RemoveImport = void 0;
 exports.maybeRemoveImport = maybeRemoveImport;
@@ -71,318 +62,308 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
      * first remaining element to maintain proper spacing. Also preserves trailing space
      * from the last element if it's removed.
      */
-    filterElementsWithPrefixPreservation(elements, shouldKeep, updatePrefix, _p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const filtered = [];
-            let removedPrefix;
-            // Track the trailing space of the original last element
-            const originalLastElement = elements[elements.length - 1];
-            const originalTrailingSpace = originalLastElement === null || originalLastElement === void 0 ? void 0 : originalLastElement.after;
-            for (const elem of elements) {
-                if (elem.element && shouldKeep(elem.element)) {
-                    // If we removed the previous element and this is the first kept element,
-                    // apply the removed element's prefix to maintain formatting
-                    if (removedPrefix && filtered.length === 0) {
-                        const updatedElement = yield updatePrefix(elem.element, removedPrefix);
-                        filtered.push(Object.assign(Object.assign({}, elem), { element: updatedElement }));
-                        removedPrefix = undefined;
-                    }
-                    else {
-                        filtered.push(elem);
-                    }
-                }
-                else if (elem.element) {
-                    // Store the prefix of the first removed element
-                    if (filtered.length === 0 && !removedPrefix) {
-                        removedPrefix = elem.element.prefix;
-                    }
+    async filterElementsWithPrefixPreservation(elements, shouldKeep, updatePrefix, _p) {
+        const filtered = [];
+        let removedPrefix;
+        // Track the trailing space of the original last element
+        const originalLastElement = elements[elements.length - 1];
+        const originalTrailingSpace = originalLastElement === null || originalLastElement === void 0 ? void 0 : originalLastElement.after;
+        for (const elem of elements) {
+            if (elem.element && shouldKeep(elem.element)) {
+                // If we removed the previous element and this is the first kept element,
+                // apply the removed element's prefix to maintain formatting
+                if (removedPrefix && filtered.length === 0) {
+                    const updatedElement = await updatePrefix(elem.element, removedPrefix);
+                    filtered.push(Object.assign(Object.assign({}, elem), { element: updatedElement }));
+                    removedPrefix = undefined;
                 }
                 else {
-                    // Keep non-element entries (shouldn't happen but be safe)
                     filtered.push(elem);
                 }
             }
-            // If the original last element was removed and we have remaining elements,
-            // transfer its trailing space to the new last element
-            if (filtered.length > 0 && (originalLastElement === null || originalLastElement === void 0 ? void 0 : originalLastElement.element) && !shouldKeep(originalLastElement.element)) {
-                const lastIdx = filtered.length - 1;
-                filtered[lastIdx] = Object.assign(Object.assign({}, filtered[lastIdx]), { after: originalTrailingSpace });
+            else if (elem.element) {
+                // Store the prefix of the first removed element
+                if (filtered.length === 0 && !removedPrefix) {
+                    removedPrefix = elem.element.prefix;
+                }
             }
-            return {
-                filtered,
-                allRemoved: filtered.length === 0
-            };
-        });
+            else {
+                // Keep non-element entries (shouldn't happen but be safe)
+                filtered.push(elem);
+            }
+        }
+        // If the original last element was removed and we have remaining elements,
+        // transfer its trailing space to the new last element
+        if (filtered.length > 0 && (originalLastElement === null || originalLastElement === void 0 ? void 0 : originalLastElement.element) && !shouldKeep(originalLastElement.element)) {
+            const lastIdx = filtered.length - 1;
+            filtered[lastIdx] = Object.assign(Object.assign({}, filtered[lastIdx]), { after: originalTrailingSpace });
+        }
+        return {
+            filtered,
+            allRemoved: filtered.length === 0
+        };
     }
     /**
      * Helper to update an import clause by removing specific bindings
      */
-    updateImportClause(jsImport, importClause, updateFn, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJavaScript(jsImport, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                if (draft.importClause) {
-                    draft.importClause = yield this.produceJavaScript(importClause, p, (clauseDraft) => __awaiter(this, void 0, void 0, function* () { return yield updateFn(clauseDraft); }));
-                }
-            }));
+    async updateImportClause(jsImport, importClause, updateFn, p) {
+        return this.produceJavaScript(jsImport, p, async (draft) => {
+            if (draft.importClause) {
+                draft.importClause = await this.produceJavaScript(importClause, p, async (clauseDraft) => await updateFn(clauseDraft));
+            }
         });
     }
-    visitJsCompilationUnit(compilationUnit, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // First, collect all used identifiers in the file
-            const usedIdentifiers = new Set();
-            const usedTypes = new Set();
-            // Traverse the AST to collect used identifiers
-            yield this.collectUsedIdentifiers(compilationUnit, usedIdentifiers, usedTypes);
-            // Now process imports with knowledge of what's used
-            return this.produceJavaScript(compilationUnit, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                const formatter = new java_2.ElementRemovalFormatter(true); // Preserve file headers from first import
-                draft.statements = yield (0, util_1.mapAsync)(compilationUnit.statements, (stmt) => __awaiter(this, void 0, void 0, function* () {
-                    const statement = stmt.element;
-                    // Handle ES6 imports
-                    if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
-                        const jsImport = statement;
-                        const result = yield this.processImport(jsImport, usedIdentifiers, usedTypes, p);
-                        if (result === undefined) {
-                            formatter.markRemoved(statement);
-                            return undefined;
-                        }
-                        const finalResult = formatter.processKept(result);
-                        return Object.assign(Object.assign({}, stmt), { element: finalResult });
-                    }
-                    // Handle CommonJS require statements
-                    // Note: const fs = require() comes as J.VariableDeclarations
-                    // Multi-variable declarations might come as JS.ScopedVariableDeclarations
-                    if ((statement === null || statement === void 0 ? void 0 : statement.kind) === java_1.J.Kind.VariableDeclarations) {
-                        const varDecl = statement;
-                        const result = yield this.processRequireFromVarDecls(varDecl, usedIdentifiers, p);
-                        if (result === undefined) {
-                            formatter.markRemoved(statement);
-                            return undefined;
-                        }
-                        const finalResult = formatter.processKept(result);
-                        return Object.assign(Object.assign({}, stmt), { element: finalResult });
-                    }
-                    // Handle JS.ScopedVariableDeclarations (multi-variable var/let/const)
-                    if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.ScopedVariableDeclarations) {
-                        const scopedVarDecl = statement;
-                        // Scoped variable declarations contain a variables array where each element is a single-variable J.VariableDeclarations
-                        const filteredVariables = [];
-                        let hasChanges = false;
-                        const varFormatter = new java_2.ElementRemovalFormatter(true); // Preserve file headers
-                        for (const v of scopedVarDecl.variables) {
-                            const varDecl = v.element;
-                            if ((varDecl === null || varDecl === void 0 ? void 0 : varDecl.kind) === java_1.J.Kind.VariableDeclarations) {
-                                const result = yield this.processRequireFromVarDecls(varDecl, usedIdentifiers, p);
-                                if (result === undefined) {
-                                    hasChanges = true;
-                                    varFormatter.markRemoved(varDecl);
-                                }
-                                else {
-                                    const formattedVarDecl = varFormatter.processKept(result);
-                                    filteredVariables.push(Object.assign(Object.assign({}, v), { element: formattedVarDecl }));
-                                }
+    async visitJsCompilationUnit(compilationUnit, p) {
+        // First, collect all used identifiers in the file
+        const usedIdentifiers = new Set();
+        const usedTypes = new Set();
+        // Traverse the AST to collect used identifiers
+        await this.collectUsedIdentifiers(compilationUnit, usedIdentifiers, usedTypes);
+        // Now process imports with knowledge of what's used
+        return this.produceJavaScript(compilationUnit, p, async (draft) => {
+            const formatter = new java_2.ElementRemovalFormatter(true); // Preserve file headers from first import
+            draft.statements = await (0, util_1.mapAsync)(compilationUnit.statements, async (stmt) => {
+                const statement = stmt.element;
+                // Handle ES6 imports
+                if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
+                    const jsImport = statement;
+                    const result = await this.processImport(jsImport, usedIdentifiers, usedTypes, p);
+                    if (result === undefined) {
+                        formatter.markRemoved(statement);
+                        return undefined;
+                    }
+                    const finalResult = formatter.processKept(result);
+                    return Object.assign(Object.assign({}, stmt), { element: finalResult });
+                }
+                // Handle CommonJS require statements
+                // Note: const fs = require() comes as J.VariableDeclarations
+                // Multi-variable declarations might come as JS.ScopedVariableDeclarations
+                if ((statement === null || statement === void 0 ? void 0 : statement.kind) === java_1.J.Kind.VariableDeclarations) {
+                    const varDecl = statement;
+                    const result = await this.processRequireFromVarDecls(varDecl, usedIdentifiers, p);
+                    if (result === undefined) {
+                        formatter.markRemoved(statement);
+                        return undefined;
+                    }
+                    const finalResult = formatter.processKept(result);
+                    return Object.assign(Object.assign({}, stmt), { element: finalResult });
+                }
+                // Handle JS.ScopedVariableDeclarations (multi-variable var/let/const)
+                if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.ScopedVariableDeclarations) {
+                    const scopedVarDecl = statement;
+                    // Scoped variable declarations contain a variables array where each element is a single-variable J.VariableDeclarations
+                    const filteredVariables = [];
+                    let hasChanges = false;
+                    const varFormatter = new java_2.ElementRemovalFormatter(true); // Preserve file headers
+                    for (const v of scopedVarDecl.variables) {
+                        const varDecl = v.element;
+                        if ((varDecl === null || varDecl === void 0 ? void 0 : varDecl.kind) === java_1.J.Kind.VariableDeclarations) {
+                            const result = await this.processRequireFromVarDecls(varDecl, usedIdentifiers, p);
+                            if (result === undefined) {
+                                hasChanges = true;
+                                varFormatter.markRemoved(varDecl);
                             }
                             else {
-                                filteredVariables.push(v);
+                                const formattedVarDecl = varFormatter.processKept(result);
+                                filteredVariables.push(Object.assign(Object.assign({}, v), { element: formattedVarDecl }));
                             }
                         }
-                        if (filteredVariables.length === 0) {
-                            formatter.markRemoved(statement);
-                            return undefined;
+                        else {
+                            filteredVariables.push(v);
                         }
-                        const finalElement = hasChanges
-                            ? formatter.processKept(Object.assign(Object.assign({}, scopedVarDecl), { variables: filteredVariables }))
-                            : formatter.processKept(statement);
-                        return Object.assign(Object.assign({}, stmt), { element: finalElement });
-                    }
-                    // For any other statement type, apply prefix from removed elements
-                    if (statement) {
-                        const finalStatement = formatter.processKept(statement);
-                        return Object.assign(Object.assign({}, stmt), { element: finalStatement });
                     }
-                    return stmt;
-                }));
-                // Filter out undefined (removed) statements
-                draft.statements = draft.statements.filter(s => s !== undefined);
-                draft.eof = yield this.visitSpace(compilationUnit.eof, p);
-            }));
+                    if (filteredVariables.length === 0) {
+                        formatter.markRemoved(statement);
+                        return undefined;
+                    }
+                    const finalElement = hasChanges
+                        ? formatter.processKept(Object.assign(Object.assign({}, scopedVarDecl), { variables: filteredVariables }))
+                        : formatter.processKept(statement);
+                    return Object.assign(Object.assign({}, stmt), { element: finalElement });
+                }
+                // For any other statement type, apply prefix from removed elements
+                if (statement) {
+                    const finalStatement = formatter.processKept(statement);
+                    return Object.assign(Object.assign({}, stmt), { element: finalStatement });
+                }
+                return stmt;
+            });
+            // Filter out undefined (removed) statements
+            draft.statements = draft.statements.filter(s => s !== undefined);
+            draft.eof = await this.visitSpace(compilationUnit.eof, p);
         });
     }
-    processImport(jsImport, usedIdentifiers, usedTypes, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Handle import-equals-require syntax: import util = require("util");
-            if (jsImport.initializer) {
-                return this.processImportEqualsRequire(jsImport, usedIdentifiers, usedTypes, p);
-            }
-            // Check if this import is from the target module
-            if (!this.isTargetModule(jsImport)) {
-                return jsImport;
-            }
-            const importClause = jsImport.importClause;
-            if (!importClause) {
-                // Side-effect import like: import 'module'
-                if (this.member === '*') {
-                    return undefined; // Remove the entire import
+    async processImport(jsImport, usedIdentifiers, usedTypes, p) {
+        // Handle import-equals-require syntax: import util = require("util");
+        if (jsImport.initializer) {
+            return this.processImportEqualsRequire(jsImport, usedIdentifiers, usedTypes, p);
+        }
+        // Check if this import is from the target module
+        if (!this.isTargetModule(jsImport)) {
+            return jsImport;
+        }
+        const importClause = jsImport.importClause;
+        if (!importClause) {
+            // Side-effect import like: import 'module'
+            if (this.member === '*') {
+                return undefined; // Remove the entire import
+            }
+            return jsImport;
+        }
+        // Process default import
+        if (importClause.name) {
+            const defaultName = importClause.name.element;
+            if (defaultName && defaultName.kind === java_1.J.Kind.Identifier) {
+                const identifier = defaultName;
+                const name = identifier.simpleName;
+                // Check if we should remove this default import
+                let shouldRemove;
+                if (this.member === 'default') {
+                    // Special case: member 'default' means remove any default import from the target module if unused
+                    shouldRemove = !usedIdentifiers.has(name) && !usedTypes.has(name);
                 }
-                return jsImport;
-            }
-            // Process default import
-            if (importClause.name) {
-                const defaultName = importClause.name.element;
-                if (defaultName && defaultName.kind === java_1.J.Kind.Identifier) {
-                    const identifier = defaultName;
-                    const name = identifier.simpleName;
-                    // Check if we should remove this default import
-                    let shouldRemove;
-                    if (this.member === 'default') {
-                        // Special case: member 'default' means remove any default import from the target module if unused
-                        shouldRemove = !usedIdentifiers.has(name) && !usedTypes.has(name);
-                    }
-                    else {
-                        // Regular case: check if the import name matches the removal criteria
-                        shouldRemove = this.shouldRemoveImport(name, usedIdentifiers, usedTypes);
-                    }
-                    if (shouldRemove) {
-                        // If there are no named imports, remove the entire import
-                        if (!importClause.namedBindings) {
-                            return undefined;
+                else {
+                    // Regular case: check if the import name matches the removal criteria
+                    shouldRemove = this.shouldRemoveImport(name, usedIdentifiers, usedTypes);
+                }
+                if (shouldRemove) {
+                    // If there are no named imports, remove the entire import
+                    if (!importClause.namedBindings) {
+                        return undefined;
+                    }
+                    // Otherwise, just remove the default import and fix spacing
+                    return this.updateImportClause(jsImport, importClause, async (draft) => {
+                        var _a;
+                        draft.name = undefined;
+                        // When removing the default import, we need to transfer its prefix to namedBindings
+                        // to maintain proper spacing (the default import's prefix is typically empty)
+                        if (draft.namedBindings && ((_a = importClause.name) === null || _a === void 0 ? void 0 : _a.element)) {
+                            draft.namedBindings = await this.produceJava(draft.namedBindings, p, async (bindingsDraft) => {
+                                bindingsDraft.prefix = importClause.name.element.prefix;
+                            });
                         }
-                        // Otherwise, just remove the default import and fix spacing
-                        return this.updateImportClause(jsImport, importClause, (draft) => __awaiter(this, void 0, void 0, function* () {
-                            var _a;
-                            draft.name = undefined;
-                            // When removing the default import, we need to transfer its prefix to namedBindings
-                            // to maintain proper spacing (the default import's prefix is typically empty)
-                            if (draft.namedBindings && ((_a = importClause.name) === null || _a === void 0 ? void 0 : _a.element)) {
-                                draft.namedBindings = yield this.produceJava(draft.namedBindings, p, (bindingsDraft) => __awaiter(this, void 0, void 0, function* () {
-                                    bindingsDraft.prefix = importClause.name.element.prefix;
-                                }));
-                            }
-                        }), p);
-                    }
+                    }, p);
                 }
             }
-            // Process named imports
-            if (importClause.namedBindings) {
-                const namedBindings = importClause.namedBindings;
-                // Handle namespace import: import * as X from 'module'
-                if (namedBindings.kind === java_1.J.Kind.Identifier) {
-                    const identifier = namedBindings;
-                    const name = identifier.simpleName;
-                    // When removing a specific member from a namespace import,
-                    // we can only remove the entire namespace if it's not used
-                    if (this.member !== undefined) {
-                        // We're trying to remove a specific member from this namespace
-                        // Check if the namespace itself is used
-                        if (!usedIdentifiers.has(name) && !usedTypes.has(name)) {
-                            // Namespace is not used, remove the entire import
-                            if (!importClause.name) {
-                                return undefined;
-                            }
-                            return this.updateImportClause(jsImport, importClause, draft => {
-                                draft.namedBindings = undefined;
-                            }, p);
-                        }
-                        // Namespace is used, we can't remove individual members from it
-                    }
-                    else if (this.shouldRemoveImport(name, usedIdentifiers, usedTypes)) {
-                        // If there's no default import, remove the entire import
+        }
+        // Process named imports
+        if (importClause.namedBindings) {
+            const namedBindings = importClause.namedBindings;
+            // Handle namespace import: import * as X from 'module'
+            if (namedBindings.kind === java_1.J.Kind.Identifier) {
+                const identifier = namedBindings;
+                const name = identifier.simpleName;
+                // When removing a specific member from a namespace import,
+                // we can only remove the entire namespace if it's not used
+                if (this.member !== undefined) {
+                    // We're trying to remove a specific member from this namespace
+                    // Check if the namespace itself is used
+                    if (!usedIdentifiers.has(name) && !usedTypes.has(name)) {
+                        // Namespace is not used, remove the entire import
                         if (!importClause.name) {
                             return undefined;
                         }
-                        // Otherwise, just remove the namespace import
                         return this.updateImportClause(jsImport, importClause, draft => {
                             draft.namedBindings = undefined;
                         }, p);
                     }
-                }
-                else if (namedBindings.kind === tree_1.JS.Kind.Alias) {
-                    // Handle import * as X from 'module' - represented as Alias with propertyName = "*"
-                    const alias = namedBindings;
-                    const aliasName = alias.alias.simpleName;
-                    // When removing a specific member from a namespace import,
-                    // we can only remove the entire namespace if it's not used
-                    if (this.member !== undefined) {
-                        // We're trying to remove a specific member from this namespace
-                        // Check if the namespace itself is used
-                        if (!usedIdentifiers.has(aliasName) && !usedTypes.has(aliasName)) {
-                            // Namespace is not used, remove the entire import
-                            if (!importClause.name) {
-                                return undefined;
-                            }
-                            return this.updateImportClause(jsImport, importClause, draft => {
-                                draft.namedBindings = undefined;
-                            }, p);
-                        }
-                        // Namespace is used, we can't remove individual members from it
-                    }
-                    else if (this.shouldRemoveImport(aliasName, usedIdentifiers, usedTypes)) {
-                        // If there's no default import, remove the entire import
+                    // Namespace is used, we can't remove individual members from it
+                }
+                else if (this.shouldRemoveImport(name, usedIdentifiers, usedTypes)) {
+                    // If there's no default import, remove the entire import
+                    if (!importClause.name) {
+                        return undefined;
+                    }
+                    // Otherwise, just remove the namespace import
+                    return this.updateImportClause(jsImport, importClause, draft => {
+                        draft.namedBindings = undefined;
+                    }, p);
+                }
+            }
+            else if (namedBindings.kind === tree_1.JS.Kind.Alias) {
+                // Handle import * as X from 'module' - represented as Alias with propertyName = "*"
+                const alias = namedBindings;
+                const aliasName = alias.alias.simpleName;
+                // When removing a specific member from a namespace import,
+                // we can only remove the entire namespace if it's not used
+                if (this.member !== undefined) {
+                    // We're trying to remove a specific member from this namespace
+                    // Check if the namespace itself is used
+                    if (!usedIdentifiers.has(aliasName) && !usedTypes.has(aliasName)) {
+                        // Namespace is not used, remove the entire import
                         if (!importClause.name) {
                             return undefined;
                         }
-                        // Otherwise, just remove the namespace import
                         return this.updateImportClause(jsImport, importClause, draft => {
                             draft.namedBindings = undefined;
                         }, p);
                     }
+                    // Namespace is used, we can't remove individual members from it
                 }
-                // Handle named imports: import { a, b } from 'module'
-                if (namedBindings.kind === tree_1.JS.Kind.NamedImports) {
-                    const namedImports = namedBindings;
-                    const updatedImports = yield this.processNamedImports(namedImports, usedIdentifiers, usedTypes, p);
-                    if (updatedImports === undefined) {
-                        // All named imports were removed
-                        if (!importClause.name) {
-                            // No default import either, remove the entire import
-                            return undefined;
-                        }
-                        // Keep the import with just the default import
-                        return this.updateImportClause(jsImport, importClause, draft => {
-                            draft.namedBindings = undefined;
-                        }, p);
+                else if (this.shouldRemoveImport(aliasName, usedIdentifiers, usedTypes)) {
+                    // If there's no default import, remove the entire import
+                    if (!importClause.name) {
+                        return undefined;
                     }
-                    else if (updatedImports !== namedImports) {
-                        // Some named imports were removed
-                        return this.updateImportClause(jsImport, importClause, draft => {
-                            draft.namedBindings = updatedImports;
-                        }, p);
+                    // Otherwise, just remove the namespace import
+                    return this.updateImportClause(jsImport, importClause, draft => {
+                        draft.namedBindings = undefined;
+                    }, p);
+                }
+            }
+            // Handle named imports: import { a, b } from 'module'
+            if (namedBindings.kind === tree_1.JS.Kind.NamedImports) {
+                const namedImports = namedBindings;
+                const updatedImports = await this.processNamedImports(namedImports, usedIdentifiers, usedTypes, p);
+                if (updatedImports === undefined) {
+                    // All named imports were removed
+                    if (!importClause.name) {
+                        // No default import either, remove the entire import
+                        return undefined;
                     }
+                    // Keep the import with just the default import
+                    return this.updateImportClause(jsImport, importClause, draft => {
+                        draft.namedBindings = undefined;
+                    }, p);
+                }
+                else if (updatedImports !== namedImports) {
+                    // Some named imports were removed
+                    return this.updateImportClause(jsImport, importClause, draft => {
+                        draft.namedBindings = updatedImports;
+                    }, p);
                 }
             }
-            return jsImport;
-        });
+        }
+        return jsImport;
     }
     /**
      * Process TypeScript import-equals-require syntax: import util = require("util");
      * This is represented as a JS.Import with an initializer containing the require() call.
      */
-    processImportEqualsRequire(jsImport, usedIdentifiers, usedTypes, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const initializer = (_a = jsImport.initializer) === null || _a === void 0 ? void 0 : _a.element;
-            if (!initializer || !this.isRequireCall(initializer)) {
-                return jsImport;
-            }
-            const methodInv = initializer;
-            const moduleName = this.getModuleNameFromRequire(methodInv);
-            if (!moduleName || !this.matchesTargetModule(moduleName)) {
-                return jsImport;
-            }
-            // Get the import name from the importClause
-            const importClause = jsImport.importClause;
-            if (!importClause || !importClause.name) {
-                // No name, this is unusual for import-equals-require
-                return jsImport;
-            }
-            const importedName = importClause.name.element.simpleName;
-            // For import-equals-require, we can only remove the entire import since
-            // it imports the whole module as a single identifier
-            if (this.shouldRemoveIdentifier(importedName, usedIdentifiers, usedTypes)) {
-                return undefined;
-            }
+    async processImportEqualsRequire(jsImport, usedIdentifiers, usedTypes, p) {
+        var _a;
+        const initializer = (_a = jsImport.initializer) === null || _a === void 0 ? void 0 : _a.element;
+        if (!initializer || !this.isRequireCall(initializer)) {
             return jsImport;
-        });
+        }
+        const methodInv = initializer;
+        const moduleName = this.getModuleNameFromRequire(methodInv);
+        if (!moduleName || !this.matchesTargetModule(moduleName)) {
+            return jsImport;
+        }
+        // Get the import name from the importClause
+        const importClause = jsImport.importClause;
+        if (!importClause || !importClause.name) {
+            // No name, this is unusual for import-equals-require
+            return jsImport;
+        }
+        const importedName = importClause.name.element.simpleName;
+        // For import-equals-require, we can only remove the entire import since
+        // it imports the whole module as a single identifier
+        if (this.shouldRemoveIdentifier(importedName, usedIdentifiers, usedTypes)) {
+            return undefined;
+        }
+        return jsImport;
     }
     /**
      * Check if a node is a require() method invocation
@@ -411,100 +392,96 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
         // or we're checking if a specific binding is used)
         return !usedIdentifiers.has(name) && !usedTypes.has(name);
     }
-    processNamedImports(namedImports, usedIdentifiers, usedTypes, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { filtered, allRemoved } = yield this.filterElementsWithPrefixPreservation(namedImports.elements.elements, (elem) => {
-                if (elem.kind === tree_1.JS.Kind.ImportSpecifier) {
-                    const specifier = elem;
-                    const importName = this.getImportName(specifier);
-                    const aliasName = this.getImportAlias(specifier);
-                    // For aliased imports, check if the alias is used
-                    // For non-aliased imports, check if the import name is used
-                    const nameToCheck = aliasName || importName;
-                    // Check if we should remove this import
-                    if (this.member !== undefined) {
-                        // We're removing a specific member - check if this matches
-                        if (this.member === importName) {
-                            // This is the member we want to remove - check if it's used
-                            return usedIdentifiers.has(nameToCheck) || usedTypes.has(nameToCheck);
-                        }
-                        return true; // Keep imports that don't match the member
-                    }
-                    else {
-                        // We're removing based on the import name itself
-                        return !this.shouldRemoveImport(importName, usedIdentifiers, usedTypes);
-                    }
+    async processNamedImports(namedImports, usedIdentifiers, usedTypes, p) {
+        const { filtered, allRemoved } = await this.filterElementsWithPrefixPreservation(namedImports.elements.elements, (elem) => {
+            if (elem.kind === tree_1.JS.Kind.ImportSpecifier) {
+                const specifier = elem;
+                const importName = this.getImportName(specifier);
+                const aliasName = this.getImportAlias(specifier);
+                // For aliased imports, check if the alias is used
+                // For non-aliased imports, check if the import name is used
+                const nameToCheck = aliasName || importName;
+                // Check if we should remove this import
+                if (this.member !== undefined) {
+                    // We're removing a specific member - check if this matches
+                    if (this.member === importName) {
+                        // This is the member we want to remove - check if it's used
+                        return usedIdentifiers.has(nameToCheck) || usedTypes.has(nameToCheck);
+                    }
+                    return true; // Keep imports that don't match the member
                 }
-                return true; // Keep non-ImportSpecifier elements
-            }, (elem, prefix) => __awaiter(this, void 0, void 0, function* () {
-                if (elem.kind === tree_1.JS.Kind.ImportSpecifier) {
-                    return this.produceJavaScript(elem, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                        draft.prefix = prefix;
-                    }));
+                else {
+                    // We're removing based on the import name itself
+                    return !this.shouldRemoveImport(importName, usedIdentifiers, usedTypes);
                 }
-                return elem;
-            }), p);
-            if (allRemoved) {
-                return undefined;
-            }
-            if (filtered.length === namedImports.elements.elements.length) {
-                return namedImports; // No changes
-            }
-            // Create updated named imports with filtered elements
-            return this.produceJavaScript(namedImports, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.elements = Object.assign(Object.assign({}, namedImports.elements), { elements: filtered });
-            }));
+            }
+            return true; // Keep non-ImportSpecifier elements
+        }, async (elem, prefix) => {
+            if (elem.kind === tree_1.JS.Kind.ImportSpecifier) {
+                return this.produceJavaScript(elem, p, async (draft) => {
+                    draft.prefix = prefix;
+                });
+            }
+            return elem;
+        }, p);
+        if (allRemoved) {
+            return undefined;
+        }
+        if (filtered.length === namedImports.elements.elements.length) {
+            return namedImports; // No changes
+        }
+        // Create updated named imports with filtered elements
+        return this.produceJavaScript(namedImports, p, async (draft) => {
+            draft.elements = Object.assign(Object.assign({}, namedImports.elements), { elements: filtered });
         });
     }
-    processRequireFromVarDecls(varDecls, usedIdentifiers, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            // Check if this is a require() call
-            if (varDecls.variables.length !== 1) {
-                return varDecls;
-            }
-            const namedVar = varDecls.variables[0].element;
-            if (!namedVar) {
-                return varDecls;
-            }
-            const initializer = (_a = namedVar.initializer) === null || _a === void 0 ? void 0 : _a.element;
-            if (!initializer || !this.isRequireCall(initializer)) {
-                return varDecls;
-            }
-            const methodInv = initializer;
-            // This is a require() statement
-            const pattern = namedVar.name;
-            if (!pattern) {
-                return varDecls;
-            }
-            // Handle: const fs = require('fs')
-            if (pattern.kind === java_1.J.Kind.Identifier) {
-                const varName = pattern.simpleName;
-                // For require() statements, check the module name from the require call
-                const moduleName = this.getModuleNameFromRequire(methodInv);
-                if (moduleName && this.matchesTargetModule(moduleName) && !usedIdentifiers.has(varName)) {
-                    return undefined; // Remove the entire require statement
-                }
+    async processRequireFromVarDecls(varDecls, usedIdentifiers, p) {
+        var _a;
+        // Check if this is a require() call
+        if (varDecls.variables.length !== 1) {
+            return varDecls;
+        }
+        const namedVar = varDecls.variables[0].element;
+        if (!namedVar) {
+            return varDecls;
+        }
+        const initializer = (_a = namedVar.initializer) === null || _a === void 0 ? void 0 : _a.element;
+        if (!initializer || !this.isRequireCall(initializer)) {
+            return varDecls;
+        }
+        const methodInv = initializer;
+        // This is a require() statement
+        const pattern = namedVar.name;
+        if (!pattern) {
+            return varDecls;
+        }
+        // Handle: const fs = require('fs')
+        if (pattern.kind === java_1.J.Kind.Identifier) {
+            const varName = pattern.simpleName;
+            // For require() statements, check the module name from the require call
+            const moduleName = this.getModuleNameFromRequire(methodInv);
+            if (moduleName && this.matchesTargetModule(moduleName) && !usedIdentifiers.has(varName)) {
+                return undefined; // Remove the entire require statement
             }
-            // Handle: const { readFile } = require('fs')
-            if (pattern.kind === tree_1.JS.Kind.ObjectBindingPattern && this.member !== undefined) {
-                const objectPattern = pattern;
-                const updatedPattern = yield this.processObjectBindingPattern(objectPattern, usedIdentifiers, p);
-                if (updatedPattern === undefined) {
-                    return undefined; // Remove entire require
-                }
-                else if (updatedPattern !== objectPattern) {
-                    // Update with filtered bindings
-                    return this.produceJava(varDecls, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                        const updatedNamedVar = yield this.produceJava(namedVar, p, (namedDraft) => __awaiter(this, void 0, void 0, function* () {
-                            namedDraft.name = updatedPattern;
-                        }));
-                        draft.variables = [Object.assign(Object.assign({}, varDecls.variables[0]), { element: updatedNamedVar })];
-                    }));
-                }
+        }
+        // Handle: const { readFile } = require('fs')
+        if (pattern.kind === tree_1.JS.Kind.ObjectBindingPattern && this.member !== undefined) {
+            const objectPattern = pattern;
+            const updatedPattern = await this.processObjectBindingPattern(objectPattern, usedIdentifiers, p);
+            if (updatedPattern === undefined) {
+                return undefined; // Remove entire require
+            }
+            else if (updatedPattern !== objectPattern) {
+                // Update with filtered bindings
+                return this.produceJava(varDecls, p, async (draft) => {
+                    const updatedNamedVar = await this.produceJava(namedVar, p, async (namedDraft) => {
+                        namedDraft.name = updatedPattern;
+                    });
+                    draft.variables = [Object.assign(Object.assign({}, varDecls.variables[0]), { element: updatedNamedVar })];
+                });
             }
-            return varDecls;
-        });
+        }
+        return varDecls;
     }
     /**
      * Get the module name from a require() call
@@ -521,40 +498,38 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
         }
         return (_b = firstArg.value) === null || _b === void 0 ? void 0 : _b.toString();
     }
-    processObjectBindingPattern(pattern, usedIdentifiers, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { filtered, allRemoved } = yield this.filterElementsWithPrefixPreservation(pattern.bindings.elements, (elem) => {
-                if (elem.kind === tree_1.JS.Kind.BindingElement) {
-                    const name = this.getBindingElementName(elem);
-                    return !this.shouldRemoveImport(name, usedIdentifiers, new Set());
-                }
-                else if (elem.kind === java_1.J.Kind.Identifier) {
-                    const name = elem.simpleName;
-                    return !this.shouldRemoveImport(name, usedIdentifiers, new Set());
-                }
-                return true; // Keep other element types
-            }, (elem, prefix) => __awaiter(this, void 0, void 0, function* () {
-                if (elem.kind === java_1.J.Kind.Identifier) {
-                    return this.produceJava(elem, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                        draft.prefix = prefix;
-                    }));
-                }
-                else if (elem.kind === tree_1.JS.Kind.BindingElement) {
-                    return this.produceJavaScript(elem, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                        draft.prefix = prefix;
-                    }));
-                }
-                return elem;
-            }), p);
-            if (allRemoved) {
-                return undefined;
-            }
-            if (filtered.length === pattern.bindings.elements.length) {
-                return pattern;
-            }
-            return this.produceJavaScript(pattern, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.bindings = Object.assign(Object.assign({}, pattern.bindings), { elements: filtered });
-            }));
+    async processObjectBindingPattern(pattern, usedIdentifiers, p) {
+        const { filtered, allRemoved } = await this.filterElementsWithPrefixPreservation(pattern.bindings.elements, (elem) => {
+            if (elem.kind === tree_1.JS.Kind.BindingElement) {
+                const name = this.getBindingElementName(elem);
+                return !this.shouldRemoveImport(name, usedIdentifiers, new Set());
+            }
+            else if (elem.kind === java_1.J.Kind.Identifier) {
+                const name = elem.simpleName;
+                return !this.shouldRemoveImport(name, usedIdentifiers, new Set());
+            }
+            return true; // Keep other element types
+        }, async (elem, prefix) => {
+            if (elem.kind === java_1.J.Kind.Identifier) {
+                return this.produceJava(elem, p, async (draft) => {
+                    draft.prefix = prefix;
+                });
+            }
+            else if (elem.kind === tree_1.JS.Kind.BindingElement) {
+                return this.produceJavaScript(elem, p, async (draft) => {
+                    draft.prefix = prefix;
+                });
+            }
+            return elem;
+        }, p);
+        if (allRemoved) {
+            return undefined;
+        }
+        if (filtered.length === pattern.bindings.elements.length) {
+            return pattern;
+        }
+        return this.produceJavaScript(pattern, p, async (draft) => {
+            draft.bindings = Object.assign(Object.assign({}, pattern.bindings), { elements: filtered });
         });
     }
     getImportName(specifier) {
@@ -623,405 +598,395 @@ class RemoveImport extends visitor_1.JavaScriptVisitor {
     /**
      * Helper to traverse parameters from various node types
      */
-    traverseParameters(params, usedIdentifiers, usedTypes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!params || typeof params !== 'object')
-                return;
-            if (Array.isArray(params)) {
-                for (const p of params) {
-                    // Array elements might be RightPadded, so unwrap them
-                    const elem = p.element || p;
-                    yield this.collectUsedIdentifiers(elem, usedIdentifiers, usedTypes);
-                }
+    async traverseParameters(params, usedIdentifiers, usedTypes) {
+        if (!params || typeof params !== 'object')
+            return;
+        if (Array.isArray(params)) {
+            for (const p of params) {
+                // Array elements might be RightPadded, so unwrap them
+                const elem = p.element || p;
+                await this.collectUsedIdentifiers(elem, usedIdentifiers, usedTypes);
             }
-            else if (params.elements) {
-                for (const p of params.elements) {
-                    if (p.element) {
-                        yield this.collectUsedIdentifiers(p.element, usedIdentifiers, usedTypes);
-                    }
+        }
+        else if (params.elements) {
+            for (const p of params.elements) {
+                if (p.element) {
+                    await this.collectUsedIdentifiers(p.element, usedIdentifiers, usedTypes);
                 }
             }
-            else if (params.parameters) {
-                for (const p of params.parameters) {
-                    const elem = p.element || p;
-                    yield this.collectUsedIdentifiers(elem, usedIdentifiers, usedTypes);
-                }
+        }
+        else if (params.parameters) {
+            for (const p of params.parameters) {
+                const elem = p.element || p;
+                await this.collectUsedIdentifiers(elem, usedIdentifiers, usedTypes);
             }
-        });
+        }
     }
     /**
      * Helper to traverse statements from various node types
      */
-    traverseStatements(statements, usedIdentifiers, usedTypes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!statements)
-                return;
-            if (Array.isArray(statements)) {
-                for (const stmt of statements) {
-                    const element = stmt.element || stmt;
-                    if (element) {
-                        yield this.collectUsedIdentifiers(element, usedIdentifiers, usedTypes);
-                    }
+    async traverseStatements(statements, usedIdentifiers, usedTypes) {
+        if (!statements)
+            return;
+        if (Array.isArray(statements)) {
+            for (const stmt of statements) {
+                const element = stmt.element || stmt;
+                if (element) {
+                    await this.collectUsedIdentifiers(element, usedIdentifiers, usedTypes);
                 }
             }
-        });
+        }
     }
     /**
      * Helper to check for type expressions and collect type usage
      */
-    checkTypeExpression(node, usedTypes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (node.typeExpression) {
-                yield this.collectTypeUsage(node.typeExpression, usedTypes);
-            }
-        });
+    async checkTypeExpression(node, usedTypes) {
+        if (node.typeExpression) {
+            await this.collectTypeUsage(node.typeExpression, usedTypes);
+        }
     }
-    collectUsedIdentifiers(node, usedIdentifiers, usedTypes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // This is a simplified version - in a real implementation,
-            // we'd need to traverse the entire AST and collect all identifier usages
-            // For now, we'll implement a basic traversal
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _q, _r;
-            if (node.kind === java_1.J.Kind.Identifier) {
-                const identifier = node;
-                usedIdentifiers.add(identifier.simpleName);
-            }
-            else if (node.kind === java_1.J.Kind.VariableDeclarations) {
-                const varDecls = node;
-                // Check the type expression on the VariableDeclarations itself
-                yield this.checkTypeExpression(varDecls, usedTypes);
-                for (const v of varDecls.variables) {
-                    // Check the initializer
-                    if ((_a = v.element.initializer) === null || _a === void 0 ? void 0 : _a.element) {
-                        yield this.collectUsedIdentifiers(v.element.initializer.element, usedIdentifiers, usedTypes);
-                    }
+    async collectUsedIdentifiers(node, usedIdentifiers, usedTypes) {
+        // This is a simplified version - in a real implementation,
+        // we'd need to traverse the entire AST and collect all identifier usages
+        // For now, we'll implement a basic traversal
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _q, _r;
+        if (node.kind === java_1.J.Kind.Identifier) {
+            const identifier = node;
+            usedIdentifiers.add(identifier.simpleName);
+        }
+        else if (node.kind === java_1.J.Kind.VariableDeclarations) {
+            const varDecls = node;
+            // Check the type expression on the VariableDeclarations itself
+            await this.checkTypeExpression(varDecls, usedTypes);
+            for (const v of varDecls.variables) {
+                // Check the initializer
+                if ((_a = v.element.initializer) === null || _a === void 0 ? void 0 : _a.element) {
+                    await this.collectUsedIdentifiers(v.element.initializer.element, usedIdentifiers, usedTypes);
                 }
             }
-            else if (node.kind === java_1.J.Kind.MethodInvocation) {
-                const methodInv = node;
-                // Check if this is a member access pattern like fs.readFileSync
-                if (((_c = (_b = methodInv.select) === null || _b === void 0 ? void 0 : _b.element) === null || _c === void 0 ? void 0 : _c.kind) === java_1.J.Kind.FieldAccess) {
-                    const fieldAccess = methodInv.select.element;
-                    if (((_d = fieldAccess.target) === null || _d === void 0 ? void 0 : _d.kind) === java_1.J.Kind.Identifier) {
-                        usedIdentifiers.add(fieldAccess.target.simpleName);
-                    }
-                }
-                else if (((_f = (_e = methodInv.select) === null || _e === void 0 ? void 0 : _e.element) === null || _f === void 0 ? void 0 : _f.kind) === java_1.J.Kind.Identifier) {
-                    // Direct identifier like fs in fs.method() - though this is rare
-                    usedIdentifiers.add(methodInv.select.element.simpleName);
+        }
+        else if (node.kind === java_1.J.Kind.MethodInvocation) {
+            const methodInv = node;
+            // Check if this is a member access pattern like fs.readFileSync
+            if (((_c = (_b = methodInv.select) === null || _b === void 0 ? void 0 : _b.element) === null || _c === void 0 ? void 0 : _c.kind) === java_1.J.Kind.FieldAccess) {
+                const fieldAccess = methodInv.select.element;
+                if (((_d = fieldAccess.target) === null || _d === void 0 ? void 0 : _d.kind) === java_1.J.Kind.Identifier) {
+                    usedIdentifiers.add(fieldAccess.target.simpleName);
                 }
-                else if (!methodInv.select) {
-                    // No select means this is a direct function call like isArray()
-                    // Only in this case should we add the method name as a used identifier
-                    if (methodInv.name && methodInv.name.kind === java_1.J.Kind.Identifier) {
-                        usedIdentifiers.add(methodInv.name.simpleName);
-                    }
+            }
+            else if (((_f = (_e = methodInv.select) === null || _e === void 0 ? void 0 : _e.element) === null || _f === void 0 ? void 0 : _f.kind) === java_1.J.Kind.Identifier) {
+                // Direct identifier like fs in fs.method() - though this is rare
+                usedIdentifiers.add(methodInv.select.element.simpleName);
+            }
+            else if (!methodInv.select) {
+                // No select means this is a direct function call like isArray()
+                // Only in this case should we add the method name as a used identifier
+                if (methodInv.name && methodInv.name.kind === java_1.J.Kind.Identifier) {
+                    usedIdentifiers.add(methodInv.name.simpleName);
                 }
-                // Note: We don't add method names for calls like Array.isArray() or obj.method()
-                // because those are methods on objects, not standalone imported functions
-                // Recursively check arguments
-                if (methodInv.arguments) {
-                    for (const arg of methodInv.arguments.elements) {
-                        if (arg.element) {
-                            yield this.collectUsedIdentifiers(arg.element, usedIdentifiers, usedTypes);
-                        }
+            }
+            // Note: We don't add method names for calls like Array.isArray() or obj.method()
+            // because those are methods on objects, not standalone imported functions
+            // Recursively check arguments
+            if (methodInv.arguments) {
+                for (const arg of methodInv.arguments.elements) {
+                    if (arg.element) {
+                        await this.collectUsedIdentifiers(arg.element, usedIdentifiers, usedTypes);
                     }
                 }
-                // Check select (object being called on)
-                if ((_g = methodInv.select) === null || _g === void 0 ? void 0 : _g.element) {
-                    yield this.collectUsedIdentifiers(methodInv.select.element, usedIdentifiers, usedTypes);
-                }
             }
-            else if (node.kind === java_1.J.Kind.MemberReference) {
-                const memberRef = node;
-                if (memberRef.containing && ((_h = memberRef.containing.element) === null || _h === void 0 ? void 0 : _h.kind) === java_1.J.Kind.Identifier) {
-                    usedIdentifiers.add(memberRef.containing.element.simpleName);
-                }
+            // Check select (object being called on)
+            if ((_g = methodInv.select) === null || _g === void 0 ? void 0 : _g.element) {
+                await this.collectUsedIdentifiers(methodInv.select.element, usedIdentifiers, usedTypes);
             }
-            else if (node.kind === java_1.J.Kind.FieldAccess) {
-                // Handle field access like fs.readFileSync
-                const fieldAccess = node;
-                if (((_j = fieldAccess.target) === null || _j === void 0 ? void 0 : _j.kind) === java_1.J.Kind.Identifier) {
-                    usedIdentifiers.add(fieldAccess.target.simpleName);
-                }
-                // Recursively check the target
-                if (fieldAccess.target) {
-                    yield this.collectUsedIdentifiers(fieldAccess.target, usedIdentifiers, usedTypes);
-                }
+        }
+        else if (node.kind === java_1.J.Kind.MemberReference) {
+            const memberRef = node;
+            if (memberRef.containing && ((_h = memberRef.containing.element) === null || _h === void 0 ? void 0 : _h.kind) === java_1.J.Kind.Identifier) {
+                usedIdentifiers.add(memberRef.containing.element.simpleName);
+            }
+        }
+        else if (node.kind === java_1.J.Kind.FieldAccess) {
+            // Handle field access like fs.readFileSync
+            const fieldAccess = node;
+            if (((_j = fieldAccess.target) === null || _j === void 0 ? void 0 : _j.kind) === java_1.J.Kind.Identifier) {
+                usedIdentifiers.add(fieldAccess.target.simpleName);
             }
-            else if (node.kind === tree_1.JS.Kind.CompilationUnit) {
-                const cu = node;
-                for (const stmt of cu.statements) {
-                    if (stmt.element && stmt.element.kind !== tree_1.JS.Kind.Import) {
-                        // Skip require() statements at the top level
-                        if (stmt.element.kind === java_1.J.Kind.VariableDeclarations) {
-                            const varDecls = stmt.element;
-                            // Check if this is a require() statement
-                            let isRequire = false;
-                            for (const v of varDecls.variables) {
-                                const namedVar = v.element;
-                                if (((_l = (_k = namedVar === null || namedVar === void 0 ? void 0 : namedVar.initializer) === null || _k === void 0 ? void 0 : _k.element) === null || _l === void 0 ? void 0 : _l.kind) === java_1.J.Kind.MethodInvocation) {
-                                    const methodInv = namedVar.initializer.element;
-                                    if (((_m = methodInv.name) === null || _m === void 0 ? void 0 : _m.kind) === java_1.J.Kind.Identifier &&
-                                        methodInv.name.simpleName === 'require') {
-                                        isRequire = true;
-                                        break;
-                                    }
+            // Recursively check the target
+            if (fieldAccess.target) {
+                await this.collectUsedIdentifiers(fieldAccess.target, usedIdentifiers, usedTypes);
+            }
+        }
+        else if (node.kind === tree_1.JS.Kind.CompilationUnit) {
+            const cu = node;
+            for (const stmt of cu.statements) {
+                if (stmt.element && stmt.element.kind !== tree_1.JS.Kind.Import) {
+                    // Skip require() statements at the top level
+                    if (stmt.element.kind === java_1.J.Kind.VariableDeclarations) {
+                        const varDecls = stmt.element;
+                        // Check if this is a require() statement
+                        let isRequire = false;
+                        for (const v of varDecls.variables) {
+                            const namedVar = v.element;
+                            if (((_l = (_k = namedVar === null || namedVar === void 0 ? void 0 : namedVar.initializer) === null || _k === void 0 ? void 0 : _k.element) === null || _l === void 0 ? void 0 : _l.kind) === java_1.J.Kind.MethodInvocation) {
+                                const methodInv = namedVar.initializer.element;
+                                if (((_m = methodInv.name) === null || _m === void 0 ? void 0 : _m.kind) === java_1.J.Kind.Identifier &&
+                                    methodInv.name.simpleName === 'require') {
+                                    isRequire = true;
+                                    break;
                                 }
                             }
-                            if (!isRequire) {
-                                // Not a require statement, process normally
-                                yield this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
-                            }
                         }
-                        else if (stmt.element.kind !== tree_1.JS.Kind.ScopedVariableDeclarations) {
-                            // Process other non-import, non-require statements normally
-                            yield this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
+                        if (!isRequire) {
+                            // Not a require statement, process normally
+                            await this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
                         }
                     }
+                    else if (stmt.element.kind !== tree_1.JS.Kind.ScopedVariableDeclarations) {
+                        // Process other non-import, non-require statements normally
+                        await this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
+                    }
                 }
             }
-            else if (node.kind === java_1.J.Kind.Return) {
-                // Handle return statements
-                const returnStmt = node;
-                if (returnStmt.expression) {
-                    yield this.collectUsedIdentifiers(returnStmt.expression, usedIdentifiers, usedTypes);
-                }
+        }
+        else if (node.kind === java_1.J.Kind.Return) {
+            // Handle return statements
+            const returnStmt = node;
+            if (returnStmt.expression) {
+                await this.collectUsedIdentifiers(returnStmt.expression, usedIdentifiers, usedTypes);
             }
-            else if (node.kind === java_1.J.Kind.Block) {
-                const block = node;
-                for (const stmt of block.statements) {
-                    if (stmt.element) {
-                        yield this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
-                    }
+        }
+        else if (node.kind === java_1.J.Kind.Block) {
+            const block = node;
+            for (const stmt of block.statements) {
+                if (stmt.element) {
+                    await this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
                 }
             }
-            else if (node.kind === java_1.J.Kind.MethodDeclaration) {
-                const method = node;
-                // Check parameters for type usage
-                if (method.parameters) {
-                    for (const param of method.parameters.elements) {
-                        // Parameters can be various types, handle them recursively
-                        if (param.element) {
-                            yield this.collectUsedIdentifiers(param.element, usedIdentifiers, usedTypes);
-                        }
+        }
+        else if (node.kind === java_1.J.Kind.MethodDeclaration) {
+            const method = node;
+            // Check parameters for type usage
+            if (method.parameters) {
+                for (const param of method.parameters.elements) {
+                    // Parameters can be various types, handle them recursively
+                    if (param.element) {
+                        await this.collectUsedIdentifiers(param.element, usedIdentifiers, usedTypes);
                     }
                 }
-                // Check body
-                if (method.body) {
-                    yield this.collectUsedIdentifiers(method.body, usedIdentifiers, usedTypes);
-                }
             }
-            else if (node.kind === tree_1.JS.Kind.TypeOf) {
-                // Handle typeof expressions like: typeof util
-                const typeOf = node;
-                if (typeOf.expression) {
-                    yield this.collectUsedIdentifiers(typeOf.expression, usedIdentifiers, usedTypes);
-                }
+            // Check body
+            if (method.body) {
+                await this.collectUsedIdentifiers(method.body, usedIdentifiers, usedTypes);
             }
-            else if (node.kind === tree_1.JS.Kind.TypeQuery) {
-                // Handle typeof type queries like: const x: typeof util
-                const typeQuery = node;
-                if (typeQuery.typeExpression) {
-                    yield this.collectUsedIdentifiers(typeQuery.typeExpression, usedIdentifiers, usedTypes);
-                }
+        }
+        else if (node.kind === tree_1.JS.Kind.TypeOf) {
+            // Handle typeof expressions like: typeof util
+            const typeOf = node;
+            if (typeOf.expression) {
+                await this.collectUsedIdentifiers(typeOf.expression, usedIdentifiers, usedTypes);
             }
-            else if (node.typeExpression) {
-                // Handle nodes with type expressions (parameters, variables, etc.)
-                yield this.checkTypeExpression(node, usedTypes);
-                // Continue traversing other parts
-                if (node.name) {
-                    yield this.collectUsedIdentifiers(node.name, usedIdentifiers, usedTypes);
-                }
-                if (node.initializer) {
-                    yield this.collectUsedIdentifiers(node.initializer, usedIdentifiers, usedTypes);
-                }
+        }
+        else if (node.kind === tree_1.JS.Kind.TypeQuery) {
+            // Handle typeof type queries like: const x: typeof util
+            const typeQuery = node;
+            if (typeQuery.typeExpression) {
+                await this.collectUsedIdentifiers(typeQuery.typeExpression, usedIdentifiers, usedTypes);
             }
-            else if (node.kind === tree_1.JS.Kind.ArrowFunction || node.kind === java_1.J.Kind.Lambda) {
-                // Handle arrow functions and lambdas
-                const func = node;
-                if (func.parameters) {
-                    yield this.collectUsedIdentifiers(func.parameters, usedIdentifiers, usedTypes);
-                }
-                if (func.lambda) {
-                    yield this.collectUsedIdentifiers(func.lambda, usedIdentifiers, usedTypes);
-                }
-                if (func.body) {
-                    yield this.collectUsedIdentifiers(func.body, usedIdentifiers, usedTypes);
-                }
+        }
+        else if (node.typeExpression) {
+            // Handle nodes with type expressions (parameters, variables, etc.)
+            await this.checkTypeExpression(node, usedTypes);
+            // Continue traversing other parts
+            if (node.name) {
+                await this.collectUsedIdentifiers(node.name, usedIdentifiers, usedTypes);
             }
-            else if (node.kind === java_1.J.Kind.Lambda) {
-                const lambda = node;
-                if ((_o = lambda.parameters) === null || _o === void 0 ? void 0 : _o.parameters) {
-                    for (const param of lambda.parameters.parameters) {
-                        if (param.element) {
-                            yield this.collectUsedIdentifiers(param.element, usedIdentifiers, usedTypes);
-                        }
-                    }
-                }
-                if (lambda.body) {
-                    yield this.collectUsedIdentifiers(lambda.body, usedIdentifiers, usedTypes);
-                }
+            if (node.initializer) {
+                await this.collectUsedIdentifiers(node.initializer, usedIdentifiers, usedTypes);
             }
-            else if (node.kind === tree_1.JS.Kind.JsxTag) {
-                // Handle JSX tags like <div>content</div>
-                const jsxTag = node;
-                // Check attributes
-                if (jsxTag.attributes) {
-                    for (const attr of jsxTag.attributes) {
-                        if (attr.element) {
-                            yield this.collectUsedIdentifiers(attr.element, usedIdentifiers, usedTypes);
-                        }
-                    }
-                }
-                // Check children
-                if (jsxTag.children) {
-                    for (const child of jsxTag.children) {
-                        if (child) {
-                            yield this.collectUsedIdentifiers(child, usedIdentifiers, usedTypes);
-                        }
+        }
+        else if (node.kind === tree_1.JS.Kind.ArrowFunction || node.kind === java_1.J.Kind.Lambda) {
+            // Handle arrow functions and lambdas
+            const func = node;
+            if (func.parameters) {
+                await this.collectUsedIdentifiers(func.parameters, usedIdentifiers, usedTypes);
+            }
+            if (func.lambda) {
+                await this.collectUsedIdentifiers(func.lambda, usedIdentifiers, usedTypes);
+            }
+            if (func.body) {
+                await this.collectUsedIdentifiers(func.body, usedIdentifiers, usedTypes);
+            }
+        }
+        else if (node.kind === java_1.J.Kind.Lambda) {
+            const lambda = node;
+            if ((_o = lambda.parameters) === null || _o === void 0 ? void 0 : _o.parameters) {
+                for (const param of lambda.parameters.parameters) {
+                    if (param.element) {
+                        await this.collectUsedIdentifiers(param.element, usedIdentifiers, usedTypes);
                     }
                 }
             }
-            else if (node.kind === tree_1.JS.Kind.JsxEmbeddedExpression) {
-                // Handle JSX embedded expressions like {React.version}
-                const embedded = node;
-                // The expression is wrapped in RightPadded, so unwrap it
-                const expr = ((_q = embedded.expression) === null || _q === void 0 ? void 0 : _q.element) || embedded.expression;
-                if (expr) {
-                    yield this.collectUsedIdentifiers(expr, usedIdentifiers, usedTypes);
-                }
+            if (lambda.body) {
+                await this.collectUsedIdentifiers(lambda.body, usedIdentifiers, usedTypes);
             }
-            else if (node.kind === tree_1.JS.Kind.JsxAttribute) {
-                // Handle JSX attributes like onClick={handler}
-                const jsxAttr = node;
-                if (jsxAttr.value) {
-                    yield this.collectUsedIdentifiers(jsxAttr.value, usedIdentifiers, usedTypes);
+        }
+        else if (node.kind === tree_1.JS.Kind.JsxTag) {
+            // Handle JSX tags like <div>content</div>
+            const jsxTag = node;
+            // Check attributes
+            if (jsxTag.attributes) {
+                for (const attr of jsxTag.attributes) {
+                    if (attr.element) {
+                        await this.collectUsedIdentifiers(attr.element, usedIdentifiers, usedTypes);
+                    }
                 }
             }
-            else if (node.kind === tree_1.JS.Kind.TypeDeclaration) {
-                // Handle type alias declarations like: type Props = { children: React.ReactNode }
-                const typeDecl = node;
-                // The initializer contains the type expression (the right side of the =)
-                if ((_r = typeDecl.initializer) === null || _r === void 0 ? void 0 : _r.element) {
-                    yield this.collectTypeUsage(typeDecl.initializer.element, usedTypes);
+            // Check children
+            if (jsxTag.children) {
+                for (const child of jsxTag.children) {
+                    if (child) {
+                        await this.collectUsedIdentifiers(child, usedIdentifiers, usedTypes);
+                    }
                 }
             }
-            else if (node.statements) {
-                // Generic handler for nodes with statements
-                yield this.traverseStatements(node.statements, usedIdentifiers, usedTypes);
+        }
+        else if (node.kind === tree_1.JS.Kind.JsxEmbeddedExpression) {
+            // Handle JSX embedded expressions like {React.version}
+            const embedded = node;
+            // The expression is wrapped in RightPadded, so unwrap it
+            const expr = ((_q = embedded.expression) === null || _q === void 0 ? void 0 : _q.element) || embedded.expression;
+            if (expr) {
+                await this.collectUsedIdentifiers(expr, usedIdentifiers, usedTypes);
             }
-            else if (node.body) {
-                // Generic handler for nodes with body
-                yield this.collectUsedIdentifiers(node.body, usedIdentifiers, usedTypes);
+        }
+        else if (node.kind === tree_1.JS.Kind.JsxAttribute) {
+            // Handle JSX attributes like onClick={handler}
+            const jsxAttr = node;
+            if (jsxAttr.value) {
+                await this.collectUsedIdentifiers(jsxAttr.value, usedIdentifiers, usedTypes);
             }
-            else if (node.parameters) {
-                // Handle anything with parameters (functions, methods, etc.)
-                yield this.traverseParameters(node.parameters, usedIdentifiers, usedTypes);
-                // Continue with the body if it exists
-                if (node.body) {
-                    yield this.collectUsedIdentifiers(node.body, usedIdentifiers, usedTypes);
-                }
+        }
+        else if (node.kind === tree_1.JS.Kind.TypeDeclaration) {
+            // Handle type alias declarations like: type Props = { children: React.ReactNode }
+            const typeDecl = node;
+            // The initializer contains the type expression (the right side of the =)
+            if ((_r = typeDecl.initializer) === null || _r === void 0 ? void 0 : _r.element) {
+                await this.collectTypeUsage(typeDecl.initializer.element, usedTypes);
             }
-        });
+        }
+        else if (node.statements) {
+            // Generic handler for nodes with statements
+            await this.traverseStatements(node.statements, usedIdentifiers, usedTypes);
+        }
+        else if (node.body) {
+            // Generic handler for nodes with body
+            await this.collectUsedIdentifiers(node.body, usedIdentifiers, usedTypes);
+        }
+        else if (node.parameters) {
+            // Handle anything with parameters (functions, methods, etc.)
+            await this.traverseParameters(node.parameters, usedIdentifiers, usedTypes);
+            // Continue with the body if it exists
+            if (node.body) {
+                await this.collectUsedIdentifiers(node.body, usedIdentifiers, usedTypes);
+            }
+        }
     }
-    collectTypeUsage(typeExpr, usedTypes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (typeExpr.kind === java_1.J.Kind.Identifier) {
-                usedTypes.add(typeExpr.simpleName);
-            }
-            else if (typeExpr.kind === java_1.J.Kind.ParameterizedType) {
-                const paramType = typeExpr;
-                // First, collect usage from the base type (e.g., React.Ref from React.Ref<T>)
-                if (paramType.class) {
-                    yield this.collectTypeUsage(paramType.class, usedTypes);
-                }
-                // Then collect usage from type parameters (e.g., HTMLButtonElement from React.Ref<HTMLButtonElement>)
-                if (paramType.typeParameters) {
-                    for (const typeParam of paramType.typeParameters.elements) {
-                        if (typeParam.element) {
-                            yield this.collectTypeUsage(typeParam.element, usedTypes);
-                        }
+    async collectTypeUsage(typeExpr, usedTypes) {
+        var _a;
+        if (typeExpr.kind === java_1.J.Kind.Identifier) {
+            usedTypes.add(typeExpr.simpleName);
+        }
+        else if (typeExpr.kind === java_1.J.Kind.ParameterizedType) {
+            const paramType = typeExpr;
+            // First, collect usage from the base type (e.g., React.Ref from React.Ref<T>)
+            if (paramType.class) {
+                await this.collectTypeUsage(paramType.class, usedTypes);
+            }
+            // Then collect usage from type parameters (e.g., HTMLButtonElement from React.Ref<HTMLButtonElement>)
+            if (paramType.typeParameters) {
+                for (const typeParam of paramType.typeParameters.elements) {
+                    if (typeParam.element) {
+                        await this.collectTypeUsage(typeParam.element, usedTypes);
                     }
                 }
             }
-            else if (typeExpr.kind === java_1.J.Kind.FieldAccess) {
-                // Handle qualified names in type positions like React.Ref
-                const fieldAccess = typeExpr;
-                if (((_a = fieldAccess.target) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.Identifier) {
-                    usedTypes.add(fieldAccess.target.simpleName);
-                }
-                else if (fieldAccess.target) {
-                    // Recursively handle nested field accesses
-                    yield this.collectTypeUsage(fieldAccess.target, usedTypes);
-                }
+        }
+        else if (typeExpr.kind === java_1.J.Kind.FieldAccess) {
+            // Handle qualified names in type positions like React.Ref
+            const fieldAccess = typeExpr;
+            if (((_a = fieldAccess.target) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.Identifier) {
+                usedTypes.add(fieldAccess.target.simpleName);
             }
-            else if (typeExpr.kind === tree_1.JS.Kind.Intersection) {
-                // Handle intersection types like ButtonProps & { ref?: React.Ref<HTMLButtonElement> }
-                const intersection = typeExpr;
-                for (const typeElem of intersection.types) {
-                    if (typeElem.element) {
-                        yield this.collectTypeUsage(typeElem.element, usedTypes);
-                    }
-                }
+            else if (fieldAccess.target) {
+                // Recursively handle nested field accesses
+                await this.collectTypeUsage(fieldAccess.target, usedTypes);
             }
-            else if (typeExpr.kind === tree_1.JS.Kind.TypeLiteral) {
-                // Handle type literals like { ref?: React.Ref<HTMLButtonElement> }
-                const typeLiteral = typeExpr;
-                // TypeLiteral members are in a Block, which contains statements
-                for (const stmt of typeLiteral.members.statements) {
-                    if (stmt.element) {
-                        // Each statement is typically a VariableDeclarations representing a property
-                        yield this.collectUsedIdentifiers(stmt.element, new Set(), usedTypes);
-                    }
+        }
+        else if (typeExpr.kind === tree_1.JS.Kind.Intersection) {
+            // Handle intersection types like ButtonProps & { ref?: React.Ref<HTMLButtonElement> }
+            const intersection = typeExpr;
+            for (const typeElem of intersection.types) {
+                if (typeElem.element) {
+                    await this.collectTypeUsage(typeElem.element, usedTypes);
                 }
             }
-            else if (typeExpr.kind === tree_1.JS.Kind.TypeQuery) {
-                // Handle typeof type queries like: const x: typeof util
-                const typeQuery = typeExpr;
-                if (typeQuery.typeExpression) {
-                    yield this.collectTypeUsage(typeQuery.typeExpression, usedTypes);
+        }
+        else if (typeExpr.kind === tree_1.JS.Kind.TypeLiteral) {
+            // Handle type literals like { ref?: React.Ref<HTMLButtonElement> }
+            const typeLiteral = typeExpr;
+            // TypeLiteral members are in a Block, which contains statements
+            for (const stmt of typeLiteral.members.statements) {
+                if (stmt.element) {
+                    // Each statement is typically a VariableDeclarations representing a property
+                    await this.collectUsedIdentifiers(stmt.element, new Set(), usedTypes);
                 }
             }
-            else if (typeExpr.kind === tree_1.JS.Kind.TypeOf) {
-                // Handle typeof expressions in types
-                const typeOf = typeExpr;
-                if (typeOf.expression) {
-                    // For typeof expressions, the expression contains the identifier
-                    // Add it to usedTypes since it's used in a type context
-                    if (typeOf.expression.kind === java_1.J.Kind.Identifier) {
-                        usedTypes.add(typeOf.expression.simpleName);
-                    }
-                    else {
-                        yield this.collectTypeUsage(typeOf.expression, usedTypes);
-                    }
-                }
+        }
+        else if (typeExpr.kind === tree_1.JS.Kind.TypeQuery) {
+            // Handle typeof type queries like: const x: typeof util
+            const typeQuery = typeExpr;
+            if (typeQuery.typeExpression) {
+                await this.collectTypeUsage(typeQuery.typeExpression, usedTypes);
             }
-            else if (typeExpr.kind === tree_1.JS.Kind.TypeTreeExpression) {
-                // Handle TypeTreeExpression which wraps type identifiers
-                const typeTree = typeExpr;
-                if (typeTree.expression) {
-                    yield this.collectTypeUsage(typeTree.expression, usedTypes);
+        }
+        else if (typeExpr.kind === tree_1.JS.Kind.TypeOf) {
+            // Handle typeof expressions in types
+            const typeOf = typeExpr;
+            if (typeOf.expression) {
+                // For typeof expressions, the expression contains the identifier
+                // Add it to usedTypes since it's used in a type context
+                if (typeOf.expression.kind === java_1.J.Kind.Identifier) {
+                    usedTypes.add(typeOf.expression.simpleName);
                 }
-            }
-            else if (typeExpr.kind === tree_1.JS.Kind.TypeInfo) {
-                // Handle TypeInfo which contains type identifiers
-                const typeInfo = typeExpr;
-                if (typeInfo.typeIdentifier) {
-                    yield this.collectTypeUsage(typeInfo.typeIdentifier, usedTypes);
+                else {
+                    await this.collectTypeUsage(typeOf.expression, usedTypes);
                 }
             }
-            else if (typeExpr.expression) {
-                // Generic handler for nodes with expression property
-                yield this.collectTypeUsage(typeExpr.expression, usedTypes);
+        }
+        else if (typeExpr.kind === tree_1.JS.Kind.TypeTreeExpression) {
+            // Handle TypeTreeExpression which wraps type identifiers
+            const typeTree = typeExpr;
+            if (typeTree.expression) {
+                await this.collectTypeUsage(typeTree.expression, usedTypes);
             }
-            else if (typeExpr.typeIdentifier) {
-                // Generic handler for nodes with typeIdentifier property
-                yield this.collectTypeUsage(typeExpr.typeIdentifier, usedTypes);
+        }
+        else if (typeExpr.kind === tree_1.JS.Kind.TypeInfo) {
+            // Handle TypeInfo which contains type identifiers
+            const typeInfo = typeExpr;
+            if (typeInfo.typeIdentifier) {
+                await this.collectTypeUsage(typeInfo.typeIdentifier, usedTypes);
             }
-            // Add more type expression handlers as needed
-        });
+        }
+        else if (typeExpr.expression) {
+            // Generic handler for nodes with expression property
+            await this.collectTypeUsage(typeExpr.expression, usedTypes);
+        }
+        else if (typeExpr.typeIdentifier) {
+            // Generic handler for nodes with typeIdentifier property
+            await this.collectTypeUsage(typeExpr.typeIdentifier, usedTypes);
+        }
+        // Add more type expression handlers as needed
     }
 }
 exports.RemoveImport = RemoveImport;