@openrewrite/rewrite 8.91.0 → 8.91.2

package/dist/javascript/add-import.js

@@ -1,13 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddImport = exports.ImportStyle = void 0;
-exports.maybeAddImport = maybeAddImport;
+exports.RebindImport = exports.AddImport = exports.ImportStyle = void 0;
+exports.bindImport = bindImport;
+exports.memberName = memberName;
+exports.moduleScopeBindings = moduleScopeBindings;
+exports.requiredModuleOf = requiredModuleOf;
+exports.moduleNameOf = moduleNameOf;
+exports.existingImportBinding = existingImportBinding;
 const visitor_1 = require("./visitor");
 const java_1 = require("../java");
 const tree_1 = require("./tree");
 const uuid_1 = require("../uuid");
 const markers_1 = require("../markers");
 const style_1 = require("./style");
+const scope_1 = require("./scope");
+const mutative_1 = require("mutative");
 var ImportStyle;
 (function (ImportStyle) {
     ImportStyle[ImportStyle["ES6Named"] = 0] = "ES6Named";
@@ -16,96 +23,389 @@ var ImportStyle;
     ImportStyle[ImportStyle["CommonJS"] = 3] = "CommonJS"; // const x = require('module')
 })(ImportStyle || (exports.ImportStyle = ImportStyle = {}));
 /**
- * Register an AddImport visitor to add an import statement to a JavaScript/TypeScript file
- * @param visitor The visitor to add the import addition to
- * @param options Configuration options for the import to add
- *
- * @example
- * // Add a named import
- * maybeAddImport(visitor, { module: 'fs', member: 'readFile' });
- *
- * @example
- * // Add a default import using the 'default' member specifier
- * maybeAddImport(visitor, { module: 'react', member: 'default', alias: 'React' });
- *
- * @example
- * // Add a default import (legacy way, without specifying member)
- * maybeAddImport(visitor, { module: 'react', alias: 'React' });
- *
- * @example
- * // Add a namespace import
- * maybeAddImport(visitor, { module: 'crypto', member: '*', alias: 'crypto' });
- *
- * @example
- * // Add a side-effect import
- * maybeAddImport(visitor, { module: 'core-js/stable', sideEffectOnly: true });
+ * Ensures an import for `options.module` exists, queuing an `AddImport` edit where none already
+ * serves the request. `maybeBind`'s ESM/CommonJS lane is this function; its own JSDoc carries the
+ * return-value contract. `refuseCreate` answers `undefined` instead of queuing a new import,
+ * without affecting whether an existing binding answers the request first.
  */
-function maybeAddImport(visitor, options) {
+function bindImport(visitor, options, refuseCreate) {
     var _a, _b;
+    validate(options);
+    const module = moduleNameOf(options.module);
+    const sideEffectOnly = (_a = options.sideEffectOnly) !== null && _a !== void 0 ? _a : false;
+    const typeOnly = (_b = options.typeOnly) !== null && _b !== void 0 ? _b : false;
+    // A queued import binds the module as much as one already in the file, so it answers a later
+    // request the same way; a name a merged request never emits would be referenced but not bound.
     for (const v of visitor.afterVisit || []) {
-        if (v instanceof AddImport &&
-            v.module === options.module &&
-            v.member === options.member &&
-            v.alias === options.alias &&
-            v.sideEffectOnly === ((_a = options.sideEffectOnly) !== null && _a !== void 0 ? _a : false) &&
-            v.typeOnly === ((_b = options.typeOnly) !== null && _b !== void 0 ? _b : false)) {
-            return;
+        if (!(v instanceof AddImport) || v.module !== module ||
+            v.sideEffectOnly !== sideEffectOnly || v.typeOnly !== typeOnly) {
+            continue;
+        }
+        // How a specifier prints, or what name would be nice, does not say which binding is wanted.
+        // A pinned alias does: it asks for a binding of its own, which only the same request answers.
+        const answers = options.alias
+            ? v.alias === options.alias && v.member === options.member
+            : memberName(v.member) === memberName(options.member);
+        if (answers) {
+            return v.bindingName;
+        }
+    }
+    if (sideEffectOnly) {
+        if (refuseCreate) {
+            return undefined;
+        }
+        visitor.afterVisit.push(new AddImport(options));
+        return undefined;
+    }
+    // A pinned alias is the whole answer, so the file has no say and nothing below needs to read it.
+    if (options.alias) {
+        if (refuseCreate) {
+            return undefined;
+        }
+        visitor.afterVisit.push(new AddImport(options, options.alias));
+        return options.alias;
+    }
+    const derived = derivedName(options);
+    const cursor = (0, scope_1.cursorOf)(visitor);
+    const cu = cursor && (0, scope_1.compilationUnitOf)(cursor);
+    if (!cu) {
+        if (refuseCreate) {
+            return undefined;
+        }
+        visitor.afterVisit.push(new AddImport(options, derived));
+        return derived;
+    }
+    // An import already serving this request answers it; queuing one would, on the next cycle,
+    // derive a suffixed name from the binding this call just added. A caller that named a preference
+    // takes whatever comes back; one that did not assumes the name it derived, so a binding under
+    // any other name would leave the references it emits unbound.
+    for (const binding of moduleScopeBindings(cu)) {
+        if (binding.module === module && binding.member === memberName(options.member) &&
+            binding.typeOnly === typeOnly &&
+            (options.preferredName !== undefined || anyNameAnswers(options) ||
+                binding.name === derived)) {
+            return binding.name;
         }
     }
-    visitor.afterVisit.push(new AddImport(options));
+    if (refuseCreate) {
+        return undefined;
+    }
+    // Only the module scope answers for a name, but any scope in the file occupies one. The queue
+    // gives every later request for this module the name chosen here, so it has to clear the scopes
+    // those references will sit in, which are not known yet.
+    const taken = takenNames((0, scope_1.namesDeclaredIn)(cu), visitor);
+    const name = (0, scope_1.deconflict)(derived, candidate => taken.has(candidate));
+    visitor.afterVisit.push(new AddImport(options, name));
+    return name;
 }
-class AddImport extends visitor_1.JavaScriptVisitor {
-    constructor(options) {
+/** Rejects a request on its own terms, whatever the queue already holds. */
+function validate(options) {
+    // Validate that a name is provided when member is 'default'
+    if (options.member === 'default' && !options.alias && !options.preferredName) {
+        throw new Error("When member is 'default', the alias parameter is required");
+    }
+    // Validate that a name is provided when member is '*' (namespace import)
+    if (options.member === '*' && !options.alias && !options.preferredName) {
+        throw new Error("When member is '*', the alias parameter is required");
+    }
+    // Validate that sideEffectOnly is not combined with incompatible options
+    if (options.sideEffectOnly) {
+        if (options.member !== undefined) {
+            throw new Error("Cannot combine sideEffectOnly with member");
+        }
+        if (options.alias !== undefined) {
+            throw new Error("Cannot combine sideEffectOnly with alias");
+        }
+        if (options.preferredName !== undefined) {
+            throw new Error("Cannot combine sideEffectOnly with preferredName");
+        }
+        if (options.onlyIfReferenced !== undefined) {
+            throw new Error("Cannot combine sideEffectOnly with onlyIfReferenced");
+        }
+        if (options.typeOnly) {
+            throw new Error("Cannot combine sideEffectOnly with typeOnly");
+        }
+    }
+}
+/**
+ * A request that named no local name and asks for no member of the module. Having expressed no
+ * preference it has none to disappoint, so whatever the file already calls that module answers it.
+ */
+function anyNameAnswers(options) {
+    return !options.sideEffectOnly && memberName(options.member) === undefined &&
+        options.alias === undefined && options.preferredName === undefined;
+}
+/** The local name a request asks for, before the file has a say in it. */
+function derivedName(options) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = options.alias) !== null && _a !== void 0 ? _a : options.preferredName) !== null && _b !== void 0 ? _b : memberName(options.member)) !== null && _c !== void 0 ? _c : moduleNameOf(options.module);
+}
+/** `'default'` and an absent member both name a default import, which binds no member name of its own. */
+function memberName(member) {
+    return member === 'default' ? undefined : member;
+}
+/** What the file's imports and `require`s bind at module scope, and the module each name comes from. */
+function moduleScopeBindings(cu) {
+    const bindings = [];
+    const declaredByVariables = (varDecl) => {
         var _a, _b, _c;
-        super();
-        // Validate that alias is provided when member is 'default'
-        if (options.member === 'default' && !options.alias) {
-            throw new Error("When member is 'default', the alias parameter is required");
-        }
-        // Validate that alias is provided when member is '*' (namespace import)
-        if (options.member === '*' && !options.alias) {
-            throw new Error("When member is '*', the alias parameter is required");
-        }
-        // Validate that sideEffectOnly is not combined with incompatible options
-        if (options.sideEffectOnly) {
-            if (options.member !== undefined) {
-                throw new Error("Cannot combine sideEffectOnly with member");
+        for (const variable of varDecl.variables) {
+            const required = requiredModule((_b = (_a = variable.element) === null || _a === void 0 ? void 0 : _a.initializer) === null || _b === void 0 ? void 0 : _b.element);
+            if (required !== undefined) {
+                bindings.push(...requireBindings((_c = variable.element) === null || _c === void 0 ? void 0 : _c.name, required));
             }
-            if (options.alias !== undefined) {
-                throw new Error("Cannot combine sideEffectOnly with alias");
+        }
+    };
+    for (const stmt of cu.statements) {
+        const statement = stmt.element;
+        if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
+            bindings.push(...importBindings(statement));
+            continue;
+        }
+        for (const declaration of (0, scope_1.declarationsOf)(statement)) {
+            declaredByVariables(declaration);
+        }
+    }
+    return bindings;
+}
+/** The module a `require('...')` initializer names, `undefined` for an initializer that is anything else. */
+function requiredModule(initializer) {
+    return (initializer === null || initializer === void 0 ? void 0 : initializer.kind) === java_1.J.Kind.MethodInvocation
+        ? requiredModuleOf(initializer)
+        : undefined;
+}
+/** A `require(...)` call, whatever it is passed. `obj.require('x')` selects a method rather than loading a module. */
+function isRequireCall(methodInv) {
+    var _a;
+    return !methodInv.select && ((_a = methodInv.name) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.Identifier &&
+        methodInv.name.simpleName === 'require';
+}
+/**
+ * The module a `require(...)` call loads. `obj.require('x')` selects a method rather than loading a
+ * module, and a specifier that is not a string literal names none that can be read here.
+ */
+function requiredModuleOf(methodInv) {
+    var _a, _b;
+    if (!isRequireCall(methodInv)) {
+        return undefined;
+    }
+    const argument = (_b = (_a = methodInv.arguments) === null || _a === void 0 ? void 0 : _a.elements[0]) === null || _b === void 0 ? void 0 : _b.element;
+    return (argument === null || argument === void 0 ? void 0 : argument.kind) === java_1.J.Kind.Literal && typeof argument.value === 'string'
+        ? moduleNameOf(argument)
+        : undefined;
+}
+/** A `require` binds a module the way an import does, so the pool records it the same way. */
+function requireBindings(pattern, module) {
+    // A whole-module require binds no member, exactly as a default import does.
+    if ((pattern === null || pattern === void 0 ? void 0 : pattern.kind) === java_1.J.Kind.Identifier) {
+        return [{ name: pattern.simpleName, module, member: undefined, typeOnly: false }];
+    }
+    return (0, scope_1.bindingNames)(pattern).map(bound => bound.member === undefined
+        ? { name: bound.name }
+        : { name: bound.name, module, member: bound.member, typeOnly: false });
+}
+/** The member a specifier imports and the name it binds it under, which are the same absent an alias. */
+function specifierBinding(specifier) {
+    var _a, _b, _c, _d, _e;
+    if (((_a = specifier.specifier) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.Identifier) {
+        const name = specifier.specifier.simpleName;
+        return { name, member: name };
+    }
+    if (((_b = specifier.specifier) === null || _b === void 0 ? void 0 : _b.kind) !== tree_1.JS.Kind.Alias) {
+        return undefined;
+    }
+    const alias = specifier.specifier;
+    return ((_d = (_c = alias.propertyName) === null || _c === void 0 ? void 0 : _c.element) === null || _d === void 0 ? void 0 : _d.kind) === java_1.J.Kind.Identifier && ((_e = alias.alias) === null || _e === void 0 ? void 0 : _e.kind) === java_1.J.Kind.Identifier
+        ? { name: alias.alias.simpleName, member: alias.propertyName.element.simpleName }
+        : undefined;
+}
+function importBindings(jsImport) {
+    var _a, _b, _c, _d;
+    const moduleSpecifier = (_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element;
+    const module = (moduleSpecifier === null || moduleSpecifier === void 0 ? void 0 : moduleSpecifier.kind) === java_1.J.Kind.Literal
+        ? moduleNameOf(moduleSpecifier)
+        : undefined;
+    const importClause = jsImport.importClause;
+    if (!importClause) {
+        return [];
+    }
+    const typeOnly = importClause.typeOnly;
+    const bindings = [];
+    if (((_c = (_b = importClause.name) === null || _b === void 0 ? void 0 : _b.element) === null || _c === void 0 ? void 0 : _c.kind) === java_1.J.Kind.Identifier) {
+        bindings.push({ name: importClause.name.element.simpleName, module, member: undefined, typeOnly });
+    }
+    const namedBindings = importClause.namedBindings;
+    if ((namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) === java_1.J.Kind.Identifier) {
+        bindings.push({ name: namedBindings.simpleName, module, member: '*', typeOnly });
+    }
+    else if ((namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) === tree_1.JS.Kind.Alias) {
+        const alias = namedBindings.alias;
+        if ((alias === null || alias === void 0 ? void 0 : alias.kind) === java_1.J.Kind.Identifier) {
+            bindings.push({ name: alias.simpleName, module, member: '*', typeOnly });
+        }
+    }
+    else if ((namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) === tree_1.JS.Kind.NamedImports) {
+        for (const elem of namedBindings.elements.elements) {
+            const bound = ((_d = elem.element) === null || _d === void 0 ? void 0 : _d.kind) === tree_1.JS.Kind.ImportSpecifier
+                ? specifierBinding(elem.element)
+                : undefined;
+            if (bound) {
+                bindings.push(Object.assign(Object.assign({}, bound), { module, typeOnly }));
             }
-            if (options.onlyIfReferenced !== undefined) {
-                throw new Error("Cannot combine sideEffectOnly with onlyIfReferenced");
+        }
+    }
+    return bindings;
+}
+/**
+ * Names in scope, plus those pending `AddImport`s on the `afterVisit` queue have claimed. A queued
+ * `RemoveImport` does not free one: it removes only what the file leaves unused, and binding a name
+ * it keeps is an error, where an unnecessary suffix merely reads oddly.
+ */
+function takenNames(inScope, visitor) {
+    const taken = new Set(inScope);
+    for (const v of visitor.afterVisit || []) {
+        if (v instanceof AddImport && v.bindingName) {
+            taken.add(v.bindingName);
+        }
+    }
+    return taken;
+}
+/**
+ * The parser lifts surrogate pairs out of `valueSource` into `unicodeEscapes` and, when it does,
+ * sets `value` to the quoted source (`parser.ts` `mapLiteral`), so neither field alone is the
+ * module name. Reuniting them and stripping the quotes yields it for either shape of literal.
+ */
+function moduleNameOf(module) {
+    var _a;
+    if (typeof module === 'string') {
+        return module;
+    }
+    const source = module.valueSource;
+    if (source === undefined) {
+        return String(module.value);
+    }
+    let restored = '';
+    let cut = 0;
+    for (const escape of (_a = module.unicodeEscapes) !== null && _a !== void 0 ? _a : []) {
+        restored += source.slice(cut, escape.valueSourceIndex) + String.fromCharCode(parseInt(escape.codePoint, 16));
+        cut = escape.valueSourceIndex;
+    }
+    restored += source.slice(cut);
+    const quote = restored.charAt(0);
+    return (quote === "'" || quote === '"') && restored.endsWith(quote) && restored.length > 1
+        ? restored.slice(1, -1)
+        : restored;
+}
+function quoteOf(expression) {
+    if ((expression === null || expression === void 0 ? void 0 : expression.kind) !== java_1.J.Kind.Literal) {
+        return undefined;
+    }
+    const source = expression.valueSource;
+    const quote = source === null || source === void 0 ? void 0 : source.charAt(0);
+    // JsxText carries raw text as its `valueSource`, so a leading quote alone does not make a
+    // literal quote-delimited; requiring a matching pair keeps prose out of the tally.
+    return (quote === "'" || quote === '"') && source.length > 1 && source.endsWith(quote)
+        ? quote
+        : undefined;
+}
+/**
+ * Pick the quote character for a module specifier being added to `cu`, so that it agrees
+ * with the file it lands in. An existing specifier is the most direct precedent; a Prettier
+ * config states intent even where the file itself has not been formatted to match.
+ */
+async function detectQuote(cu) {
+    var _a, _b;
+    // Static imports are top-level, so the highest-ranked signal needs no traversal to find.
+    for (const statement of cu.statements) {
+        const element = statement.element;
+        const topLevelQuote = (element === null || element === void 0 ? void 0 : element.kind) === tree_1.JS.Kind.Import
+            ? quoteOf((_a = element.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element)
+            : (element === null || element === void 0 ? void 0 : element.kind) === tree_1.JS.Kind.ExportDeclaration
+                ? quoteOf((_b = element.moduleSpecifier) === null || _b === void 0 ? void 0 : _b.element)
+                : undefined;
+        if (topLevelQuote) {
+            return topLevelQuote;
+        }
+    }
+    let importQuote;
+    let requireQuote;
+    let single = 0;
+    let double = 0;
+    await new class extends visitor_1.JavaScriptVisitor {
+        async visitImportDeclaration(jsImport, p) {
+            var _a;
+            importQuote !== null && importQuote !== void 0 ? importQuote : (importQuote = quoteOf((_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element));
+            return super.visitImportDeclaration(jsImport, p);
+        }
+        async visitExportDeclaration(exportDeclaration, p) {
+            var _a;
+            importQuote !== null && importQuote !== void 0 ? importQuote : (importQuote = quoteOf((_a = exportDeclaration.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element));
+            return super.visitExportDeclaration(exportDeclaration, p);
+        }
+        async visitMethodInvocation(method, p) {
+            var _a, _b, _c;
+            if (!method.select && ((_a = method.name) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.Identifier &&
+                method.name.simpleName === 'require') {
+                requireQuote !== null && requireQuote !== void 0 ? requireQuote : (requireQuote = quoteOf((_c = (_b = method.arguments) === null || _b === void 0 ? void 0 : _b.elements[0]) === null || _c === void 0 ? void 0 : _c.element));
             }
-            if (options.typeOnly) {
-                throw new Error("Cannot combine sideEffectOnly with typeOnly");
+            return super.visitMethodInvocation(method, p);
+        }
+        async visitJsxAttribute(attribute, p) {
+            // JSX attribute quoting answers to Prettier's `jsxSingleQuote`, so it is no evidence
+            // about the quote style of ordinary strings.
+            return attribute;
+        }
+        async visitLiteral(literal, p) {
+            const quote = quoteOf(literal);
+            if (quote === "'") {
+                single++;
             }
+            else if (quote === '"') {
+                double++;
+            }
+            return super.visitLiteral(literal, p);
+        }
+    }().visit(cu, undefined);
+    // Imports outrank requires; that ordering is what makes the import-only scan above sound.
+    const specifierQuote = importQuote !== null && importQuote !== void 0 ? importQuote : requireQuote;
+    if (specifierQuote) {
+        return specifierQuote;
+    }
+    const prettier = (0, style_1.getStyle)(style_1.StyleKind.PrettierStyle, cu);
+    if ((prettier === null || prettier === void 0 ? void 0 : prettier.kind) === style_1.StyleKind.PrettierStyle && !prettier.ignored) {
+        const singleQuote = prettier.config.singleQuote;
+        if (typeof singleQuote === 'boolean') {
+            return singleQuote ? "'" : '"';
         }
-        this.module = options.module;
+    }
+    return double > single ? '"' : "'";
+}
+class AddImport extends visitor_1.JavaScriptVisitor {
+    constructor(options, bindingName) {
+        var _a, _b, _c;
+        super();
+        validate(options);
+        this.module = moduleNameOf(options.module);
+        this.moduleValueSource = typeof options.module === 'string' ? undefined : options.module.valueSource;
+        this.moduleUnicodeEscapes = typeof options.module === 'string' ? undefined : options.module.unicodeEscapes;
         this.member = options.member;
         this.alias = options.alias;
         this.onlyIfReferenced = (_a = options.onlyIfReferenced) !== null && _a !== void 0 ? _a : true;
         this.sideEffectOnly = (_b = options.sideEffectOnly) !== null && _b !== void 0 ? _b : false;
         this.typeOnly = (_c = options.typeOnly) !== null && _c !== void 0 ? _c : false;
         this.style = options.style;
+        this.quoteStyle = options.quoteStyle;
+        this.bindingName = this.sideEffectOnly ? undefined : bindingName !== null && bindingName !== void 0 ? bindingName : derivedName(options);
+        this.anyNameAnswers = anyNameAnswers(options);
     }
     /**
      * Extract module name from a module specifier literal
      */
     getModuleName(moduleSpecifier) {
-        var _a;
         if (moduleSpecifier.kind !== java_1.J.Kind.Literal) {
             return undefined;
         }
-        return (_a = moduleSpecifier.value) === null || _a === void 0 ? void 0 : _a.toString();
-    }
-    /**
-     * Check if a method invocation is a require() call
-     */
-    isRequireCall(methodInv) {
-        var _a;
-        return ((_a = methodInv.name) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.Identifier &&
-            methodInv.name.simpleName === 'require';
+        return moduleNameOf(moduleSpecifier);
     }
     /**
      * Determine the appropriate import style based on file type and existing imports
@@ -177,7 +477,7 @@ class AddImport extends visitor_1.JavaScriptVisitor {
                     const namedVar = varDecl.variables[0].element;
                     const initializer = (_a = namedVar === null || namedVar === void 0 ? void 0 : namedVar.initializer) === null || _a === void 0 ? void 0 : _a.element;
                     if ((initializer === null || initializer === void 0 ? void 0 : initializer.kind) === java_1.J.Kind.MethodInvocation &&
-                        this.isRequireCall(initializer)) {
+                        isRequireCall(initializer)) {
                         hasCommonJSRequires = true;
                     }
                 }
@@ -246,12 +546,8 @@ class AddImport extends visitor_1.JavaScriptVisitor {
                 if (varDecl.variables.length === 1) {
                     const namedVar = varDecl.variables[0].element;
                     const initializer = (_b = namedVar === null || namedVar === void 0 ? void 0 : namedVar.initializer) === null || _b === void 0 ? void 0 : _b.element;
-                    if ((initializer === null || initializer === void 0 ? void 0 : initializer.kind) === java_1.J.Kind.MethodInvocation &&
-                        this.isRequireCall(initializer)) {
-                        const moduleName = this.getModuleNameFromRequire(initializer);
-                        if (moduleName === this.module) {
-                            return ImportStyle.CommonJS;
-                        }
+                    if (requiredModule(initializer) === this.module) {
+                        return ImportStyle.CommonJS;
                     }
                 }
             }
@@ -382,11 +678,11 @@ class AddImport extends visitor_1.JavaScriptVisitor {
                         const namedImports = importClause.namedBindings;
                         const existingElements = namedImports.elements.elements;
                         // Find the correct insertion position (alphabetical, case-insensitive)
-                        const newName = (this.alias || this.member).toLowerCase();
+                        const newName = this.bindingName.toLowerCase();
                         let insertIndex = existingElements.findIndex(elem => {
-                            var _a;
+                            var _a, _b, _c;
                             if (((_a = elem.element) === null || _a === void 0 ? void 0 : _a.kind) === tree_1.JS.Kind.ImportSpecifier) {
-                                const name = this.getImportAlias(elem.element) || this.getImportName(elem.element);
+                                const name = (_c = (_b = specifierBinding(elem.element)) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : '';
                                 return newName.localeCompare(name.toLowerCase()) < 0;
                             }
                             return false;
@@ -511,135 +807,40 @@ class AddImport extends visitor_1.JavaScriptVisitor {
      * Check if the import matches what we're trying to add
      */
     isMatchingImport(jsImport) {
-        var _a, _b, _c, _d;
-        // Check module specifier
+        var _a;
         const moduleSpecifier = (_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element;
-        if (!moduleSpecifier) {
-            return false;
-        }
-        const moduleName = this.getModuleName(moduleSpecifier);
-        if (moduleName !== this.module) {
+        if (!moduleSpecifier || this.getModuleName(moduleSpecifier) !== this.module) {
             return false;
         }
+        // A side-effect import is the clause-less one, and no import carrying bindings stands in
+        // for it — nor it for them.
         const importClause = jsImport.importClause;
-        // Handle side-effect imports (no import clause)
-        if (!importClause) {
-            // If we're trying to add a side-effect import and one already exists, it's a match
-            return this.sideEffectOnly;
+        if (!importClause || this.sideEffectOnly) {
+            return !importClause && this.sideEffectOnly;
         }
-        // If we're adding a side-effect import but there's an existing import with bindings,
-        // it's not a match (side-effect import should be separate)
-        if (this.sideEffectOnly) {
-            return false;
-        }
-        // Check if the typeOnly flag matches - type-only and value imports are separate
-        if (importClause.typeOnly !== this.typeOnly) {
-            return false;
-        }
-        // Check if the specific member or default import already exists
-        if (this.member === '*') {
-            // We're adding a namespace import, check if one exists
-            const namedBindings = importClause.namedBindings;
-            if (!namedBindings) {
-                return false;
-            }
-            // Namespace imports can be represented as J.Identifier or JS.Alias
-            if (namedBindings.kind === java_1.J.Kind.Identifier) {
-                const identifier = namedBindings;
-                return identifier.simpleName === this.alias;
-            }
-            else if (namedBindings.kind === tree_1.JS.Kind.Alias) {
-                const alias = namedBindings;
-                if (((_b = alias.alias) === null || _b === void 0 ? void 0 : _b.kind) === java_1.J.Kind.Identifier) {
-                    return alias.alias.simpleName === this.alias;
-                }
-            }
-            return false;
-        }
-        else if (this.member === undefined || this.member === 'default') {
-            // We're adding a default import, check if one exists
-            // For member === 'default', also verify the alias matches if specified
-            if (importClause.name === undefined) {
-                return false;
-            }
-            // If we have an alias, check that it matches
-            if (this.alias && ((_c = importClause.name.element) === null || _c === void 0 ? void 0 : _c.kind) === java_1.J.Kind.Identifier) {
-                const existingName = importClause.name.element.simpleName;
-                return existingName === this.alias;
-            }
-            return true;
-        }
-        else {
-            // We're adding a named import, check if it exists
-            const namedBindings = importClause.namedBindings;
-            if (!namedBindings) {
-                return false;
-            }
-            if (namedBindings.kind === tree_1.JS.Kind.NamedImports) {
-                const namedImports = namedBindings;
-                for (const elem of namedImports.elements.elements) {
-                    if (((_d = elem.element) === null || _d === void 0 ? void 0 : _d.kind) === tree_1.JS.Kind.ImportSpecifier) {
-                        const specifier = elem.element;
-                        const importName = this.getImportName(specifier);
-                        const aliasName = this.getImportAlias(specifier);
-                        if (importName === this.member && aliasName === this.alias) {
-                            return true;
-                        }
-                    }
-                }
-            }
-        }
-        return false;
+        return importBindings(jsImport).some(binding => this.answeredBy(binding));
+    }
+    /** Whether a binding the file already has serves this request. */
+    answeredBy(binding) {
+        return binding.module === this.module &&
+            binding.member === memberName(this.member) &&
+            binding.typeOnly === this.typeOnly &&
+            (this.anyNameAnswers || binding.name === this.bindingName);
     }
     /**
      * Check if this is a matching CommonJS require statement
      */
     isMatchingRequire(varDecl) {
-        var _a, _b, _c;
+        var _a;
         if (varDecl.variables.length !== 1) {
             return false;
         }
         const namedVar = varDecl.variables[0].element;
-        if (!namedVar) {
+        const module = requiredModule((_a = namedVar === null || namedVar === void 0 ? void 0 : namedVar.initializer) === null || _a === void 0 ? void 0 : _a.element);
+        if (module !== this.module) {
             return false;
         }
-        const initializer = (_a = namedVar.initializer) === null || _a === void 0 ? void 0 : _a.element;
-        if (!initializer || initializer.kind !== java_1.J.Kind.MethodInvocation) {
-            return false;
-        }
-        const methodInv = initializer;
-        if (!this.isRequireCall(methodInv)) {
-            return false;
-        }
-        const moduleName = this.getModuleNameFromRequire(methodInv);
-        if (moduleName !== this.module) {
-            return false;
-        }
-        // Check if the variable name matches what we're trying to add
-        const pattern = namedVar.name;
-        if ((this.member === undefined || this.member === 'default') && (pattern === null || pattern === void 0 ? void 0 : pattern.kind) === java_1.J.Kind.Identifier) {
-            // Default import style: const fs = require('fs')
-            // For member === 'default', also check the alias matches if specified
-            if (this.alias) {
-                const varName = pattern.simpleName;
-                return varName === this.alias;
-            }
-            return true;
-        }
-        else if (this.member !== undefined && this.member !== 'default' && (pattern === null || pattern === void 0 ? void 0 : pattern.kind) === tree_1.JS.Kind.ObjectBindingPattern) {
-            // Destructured import: const { member } = require('module')
-            const objectPattern = pattern;
-            for (const elem of objectPattern.bindings.elements) {
-                if (((_b = elem.element) === null || _b === void 0 ? void 0 : _b.kind) === tree_1.JS.Kind.BindingElement) {
-                    const bindingElem = elem.element;
-                    const name = (_c = bindingElem.name) === null || _c === void 0 ? void 0 : _c.simpleName;
-                    if (name === (this.alias || this.member)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
+        return requireBindings(namedVar.name, module).some(binding => this.answeredBy(binding));
     }
     /**
      * Extract the module name from a class type by traversing the owningClass chain
@@ -754,7 +955,7 @@ class AddImport extends visitor_1.JavaScriptVisitor {
             }
         }
         // Step 2: Look for references that match
-        const targetName = this.alias || this.member;
+        const targetName = this.bindingName;
         const targetModule = this.module;
         let found = false;
         const self = this;
@@ -872,21 +1073,27 @@ class AddImport extends visitor_1.JavaScriptVisitor {
      * Create a new import statement
      */
     async createImportStatement(compilationUnit, insertionIndex, p) {
+        var _a;
         // Determine the appropriate prefix (spacing before the import)
         const prefix = this.determineImportPrefix(compilationUnit, insertionIndex);
         // Create the module specifier
         // For side-effect imports, use emptySpace since space comes from LeftPadded.before
         // For regular imports with import clause, use emptySpace since space comes from LeftPadded.before
         // However, the printer expects the space after 'from' in the literal's prefix
-        // Note: value contains the unquoted string, valueSource contains the quoted version for printing
+        // Note: value is the unquoted module name; valueSource and unicodeEscapes are its printed form
+        let valueSource = this.moduleValueSource;
+        if (valueSource === undefined) {
+            const quote = (_a = this.quoteStyle) !== null && _a !== void 0 ? _a : await detectQuote(compilationUnit);
+            valueSource = `${quote}${this.module}${quote}`;
+        }
         const moduleSpecifier = {
             id: (0, uuid_1.randomId)(),
             kind: java_1.J.Kind.Literal,
             prefix: this.sideEffectOnly ? java_1.emptySpace : java_1.singleSpace,
             markers: markers_1.emptyMarkers,
             value: this.module,
-            valueSource: `'${this.module}'`,
-            unicodeEscapes: [],
+            valueSource,
+            unicodeEscapes: this.moduleUnicodeEscapes,
             type: undefined
         };
         let importClause;
@@ -912,7 +1119,7 @@ class AddImport extends visitor_1.JavaScriptVisitor {
                 prefix: java_1.singleSpace,
                 markers: markers_1.emptyMarkers,
                 annotations: [],
-                simpleName: this.alias,
+                simpleName: this.bindingName,
                 type: undefined,
                 fieldType: undefined
             };
@@ -943,7 +1150,7 @@ class AddImport extends visitor_1.JavaScriptVisitor {
                 prefix: java_1.singleSpace,
                 markers: markers_1.emptyMarkers,
                 annotations: [],
-                simpleName: this.alias || this.module,
+                simpleName: this.bindingName,
                 type: undefined,
                 fieldType: undefined
             };
@@ -1010,7 +1217,8 @@ class AddImport extends visitor_1.JavaScriptVisitor {
      */
     createImportSpecifier() {
         let specifier;
-        if (this.alias) {
+        // An alias equal to the member says nothing `{member}` alone does not.
+        if (this.bindingName !== this.member) {
             // Aliased import: import { member as alias } from 'module'
             const propertyName = {
                 id: (0, uuid_1.randomId)(),
@@ -1028,7 +1236,7 @@ class AddImport extends visitor_1.JavaScriptVisitor {
                 prefix: java_1.singleSpace,
                 markers: markers_1.emptyMarkers,
                 annotations: [],
-                simpleName: this.alias,
+                simpleName: this.bindingName,
                 type: undefined,
                 fieldType: undefined
             };
@@ -1113,52 +1321,276 @@ class AddImport extends visitor_1.JavaScriptVisitor {
         // No imports found, insert at the beginning
         return 0;
     }
-    /**
-     * Get the module name from a require() call
-     */
-    getModuleNameFromRequire(methodInv) {
-        var _a, _b;
-        const args = (_a = methodInv.arguments) === null || _a === void 0 ? void 0 : _a.elements;
-        if (!args || args.length === 0) {
-            return undefined;
+}
+exports.AddImport = AddImport;
+/**
+ * The local name `jsImport` binds `member` of `module` to, or `undefined` where it binds
+ * something else. `'default'` and an absent `member` both mean the default import, matching
+ * {@link memberName}.
+ */
+function importBinds(jsImport, module, member) {
+    var _a, _b;
+    const specifier = (_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element;
+    if ((specifier === null || specifier === void 0 ? void 0 : specifier.kind) !== java_1.J.Kind.Literal || specifier.value !== module) {
+        return undefined;
+    }
+    const importClause = jsImport.importClause;
+    if (!importClause) {
+        return undefined;
+    }
+    const key = memberName(member);
+    if (key === undefined) {
+        const nameElem = (_b = importClause.name) === null || _b === void 0 ? void 0 : _b.element;
+        return nameElem && (0, java_1.isIdentifier)(nameElem) ? nameElem.simpleName : undefined;
+    }
+    if (key === '*') {
+        const namedBindings = importClause.namedBindings;
+        return (namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) === tree_1.JS.Kind.Alias && (0, java_1.isIdentifier)(namedBindings.alias)
+            ? namedBindings.alias.simpleName
+            : undefined;
+    }
+    const namedBindings = importClause.namedBindings;
+    if ((namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) !== tree_1.JS.Kind.NamedImports) {
+        return undefined;
+    }
+    for (const elem of namedBindings.elements.elements) {
+        const specifierNode = elem.element.specifier;
+        if (!namedSpecifierImports(specifierNode, key)) {
+            continue;
         }
-        const firstArg = args[0].element;
-        if (!firstArg || firstArg.kind !== java_1.J.Kind.Literal || typeof firstArg.value !== 'string') {
-            return undefined;
+        if ((0, java_1.isIdentifier)(specifierNode)) {
+            return specifierNode.simpleName;
+        }
+        const alias = specifierNode.alias;
+        if ((0, java_1.isIdentifier)(alias)) {
+            return alias.simpleName;
         }
-        return (_b = firstArg.value) === null || _b === void 0 ? void 0 : _b.toString();
     }
-    /**
-     * Get the import name from an import specifier
-     */
-    getImportName(specifier) {
-        const spec = specifier.specifier;
-        if ((spec === null || spec === void 0 ? void 0 : spec.kind) === tree_1.JS.Kind.Alias) {
-            const alias = spec;
-            const propertyName = alias.propertyName.element;
-            if ((propertyName === null || propertyName === void 0 ? void 0 : propertyName.kind) === java_1.J.Kind.Identifier) {
-                return propertyName.simpleName;
-            }
+    return undefined;
+}
+/** Whether `specifier` imports the member `key`, under whatever local name it binds it to. */
+function namedSpecifierImports(specifier, key) {
+    if ((0, java_1.isIdentifier)(specifier)) {
+        return specifier.simpleName === key;
+    }
+    if (specifier.kind === tree_1.JS.Kind.Alias) {
+        const propertyName = specifier.propertyName.element;
+        return (0, java_1.isIdentifier)(propertyName) && propertyName.simpleName === key;
+    }
+    return false;
+}
+/** Whether the named specifier binding `key` carries its own inline `type`, as in `{type a, b}`. */
+function namedSpecifierIsTypeOnly(imp, key) {
+    var _a;
+    const namedBindings = (_a = imp.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings;
+    if ((namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) !== tree_1.JS.Kind.NamedImports) {
+        return false;
+    }
+    for (const elem of namedBindings.elements.elements) {
+        if (namedSpecifierImports(elem.element.specifier, key)) {
+            return elem.element.importType.element;
         }
-        else if ((spec === null || spec === void 0 ? void 0 : spec.kind) === java_1.J.Kind.Identifier) {
-            return spec.simpleName;
+    }
+    return false;
+}
+/** How many named specifiers `jsImport` carries, `0` for a default, namespace or side-effect import. */
+function namedImportCount(jsImport) {
+    var _a;
+    const namedBindings = (_a = jsImport.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings;
+    return (namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) === tree_1.JS.Kind.NamedImports ? namedBindings.elements.elements.length : 0;
+}
+/**
+ * Whether `jsImport`'s clause binds exactly one thing — a default, a namespace, or one named
+ * specifier. That is the only shape a module-only move can rewrite in place: whichever binding
+ * `importBinds` already matched is this one, so nothing else the clause carries goes along with it.
+ */
+function isOnlyMember(jsImport) {
+    var _a;
+    const importClause = jsImport.importClause;
+    if (!importClause) {
+        return false;
+    }
+    const hasDefault = importClause.name !== undefined;
+    const hasNamespace = ((_a = importClause.namedBindings) === null || _a === void 0 ? void 0 : _a.kind) === tree_1.JS.Kind.Alias;
+    return (hasDefault ? 1 : 0) + (hasNamespace ? 1 : 0) + namedImportCount(jsImport) === 1;
+}
+/**
+ * The existing binding for `member` of `module`, read from `cu`'s own import statements — what
+ * `maybeRebind` reads before committing to a `RebindImport` edit.
+ */
+function existingImportBinding(cu, module, member) {
+    for (const stmt of cu.statements) {
+        const element = stmt.element;
+        if ((element === null || element === void 0 ? void 0 : element.kind) !== tree_1.JS.Kind.Import) {
+            continue;
+        }
+        const localName = importBinds(element, module, member);
+        if (localName !== undefined) {
+            return { localName, onlyMemberOfStatement: isOnlyMember(element) };
         }
-        return '';
     }
-    /**
-     * Get the import alias from an import specifier
-     */
-    getImportAlias(specifier) {
-        var _a;
-        const spec = specifier.specifier;
-        if ((spec === null || spec === void 0 ? void 0 : spec.kind) === tree_1.JS.Kind.Alias) {
-            const alias = spec;
-            if (((_a = alias.alias) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.Identifier) {
-                return alias.alias.simpleName;
-            }
+    return undefined;
+}
+/**
+ * Binds `member` under the name `local` already carries, so the file's references to it still
+ * resolve. `local` itself becomes the alias, keeping the type attribution it holds, and the alias
+ * takes its prefix: that whitespace separates the specifier from a `type` keyword before it.
+ */
+function aliasing(local, member) {
+    const propertyName = {
+        id: (0, uuid_1.randomId)(),
+        kind: java_1.J.Kind.Identifier,
+        prefix: java_1.emptySpace,
+        markers: markers_1.emptyMarkers,
+        annotations: [],
+        simpleName: member,
+        type: undefined,
+        fieldType: undefined
+    };
+    return {
+        id: (0, uuid_1.randomId)(),
+        kind: tree_1.JS.Kind.Alias,
+        prefix: local.prefix,
+        markers: markers_1.emptyMarkers,
+        propertyName: (0, java_1.rightPadded)(propertyName, java_1.singleSpace),
+        alias: Object.assign(Object.assign({}, local), { prefix: java_1.singleSpace })
+    };
+}
+/**
+ * Drops the binding for `member` from `jsImport`'s clause — the default, the namespace alias, or
+ * one entry of the named list, whichever `member` names — keeping everything else the clause
+ * binds. `ElementRemovalFormatter` carries the dropped binding's prefix onto whatever prints
+ * next, the same way `RemoveImport` keeps formatting sane when trimming a list.
+ */
+function removeBinding(jsImport, member) {
+    var _a;
+    const importClause = jsImport.importClause;
+    if (!importClause) {
+        return jsImport;
+    }
+    const key = memberName(member);
+    if (key === undefined) {
+        if (!importClause.name) {
+            return jsImport;
         }
-        return undefined;
+        const namedBindings = importClause.namedBindings;
+        if ((namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) === tree_1.JS.Kind.NamedImports) {
+            // `NamedImports` keeps the space before its own `{` on the container's `before`,
+            // not on its own prefix, so the removed default's prefix has to land there instead.
+            const namedImports = namedBindings;
+            const updated = Object.assign(Object.assign({}, namedImports), { elements: Object.assign(Object.assign({}, namedImports.elements), { before: importClause.name.element.prefix }) });
+            return Object.assign(Object.assign({}, jsImport), { importClause: Object.assign(Object.assign({}, importClause), { name: undefined, namedBindings: updated }) });
+        }
+        if (namedBindings) {
+            const formatter = new java_1.ElementRemovalFormatter();
+            formatter.markRemoved(importClause.name.element);
+            return Object.assign(Object.assign({}, jsImport), { importClause: Object.assign(Object.assign({}, importClause), { name: undefined, namedBindings: formatter.processKept(namedBindings) }) });
+        }
+        return Object.assign(Object.assign({}, jsImport), { importClause: Object.assign(Object.assign({}, importClause), { name: undefined }) });
+    }
+    if (key === '*') {
+        return Object.assign(Object.assign({}, jsImport), { importClause: Object.assign(Object.assign({}, importClause), { namedBindings: undefined }) });
     }
+    if (((_a = importClause.namedBindings) === null || _a === void 0 ? void 0 : _a.kind) !== tree_1.JS.Kind.NamedImports) {
+        return jsImport;
+    }
+    const namedImports = importClause.namedBindings;
+    const formatter = new java_1.ElementRemovalFormatter();
+    const kept = [];
+    for (const entry of namedImports.elements.elements) {
+        if (namedSpecifierImports(entry.element.specifier, key)) {
+            formatter.markRemoved(entry.element);
+        }
+        else {
+            kept.push(Object.assign(Object.assign({}, entry), { element: formatter.processKept(entry.element) }));
+        }
+    }
+    if (kept.length === 0) {
+        // An emptied brace list still prints, as `import D, {} from "m"`, so it goes with its
+        // last member; the caller drops the whole statement when no default remains either.
+        return Object.assign(Object.assign({}, jsImport), { importClause: Object.assign(Object.assign({}, importClause), { namedBindings: undefined }) });
+    }
+    const updatedNamedImports = Object.assign(Object.assign({}, namedImports), { elements: Object.assign(Object.assign({}, namedImports.elements), { elements: kept }) });
+    return Object.assign(Object.assign({}, jsImport), { importClause: Object.assign(Object.assign({}, importClause), { namedBindings: updatedNamedImports }) });
 }
-exports.AddImport = AddImport;
+/**
+ * Moves the binding `from` names to `to`, keeping the local name it already had. In place when
+ * the statement that carries it binds nothing else — module and member specifier rewritten there
+ * directly; otherwise the old specifier drops and {@link bindImport} queues the replacement,
+ * aliased to the preserved name.
+ *
+ * Not built on `RemoveImport`/`maybeUnbind`: those only drop a binding once nothing references
+ * it, but a rebind moves one that is still in use — removal here has to be unconditional.
+ */
+class RebindImport extends visitor_1.JavaScriptVisitor {
+    constructor(from, to, localName) {
+        super();
+        this.from = from;
+        this.to = to;
+        this.localName = localName;
+        this.transformedInPlace = false;
+        this.typeOnly = false;
+    }
+    async visitJsCompilationUnit(cu, p) {
+        const visited = await super.visitJsCompilationUnit(cu, p);
+        if (!this.transformedInPlace) {
+            bindImport(this, {
+                module: this.to.module,
+                member: this.to.member,
+                alias: this.localName,
+                typeOnly: this.typeOnly,
+                onlyIfReferenced: false
+            });
+        }
+        return visited;
+    }
+    async visitImportDeclaration(jsImport, p) {
+        var _a, _b;
+        const imp = await super.visitImportDeclaration(jsImport, p);
+        const key = memberName(this.from.member);
+        if (importBinds(imp, this.from.module, this.from.member) === undefined) {
+            return imp;
+        }
+        // A moved named specifier's own inline `type` marks it type-only even where the clause
+        // it's leaving is not — the replacement needs the same answer to stay type-safe.
+        this.typeOnly = ((_b = (_a = imp.importClause) === null || _a === void 0 ? void 0 : _a.typeOnly) !== null && _b !== void 0 ? _b : false) ||
+            (key !== undefined && key !== '*' && namedSpecifierIsTypeOnly(imp, key));
+        if (!isOnlyMember(imp)) {
+            return removeBinding(imp, this.from.member);
+        }
+        this.transformedInPlace = true;
+        return (0, mutative_1.create)(imp, draft => {
+            var _a;
+            const literal = draft.moduleSpecifier.element;
+            literal.value = this.to.module;
+            const originalSource = literal.valueSource || `"${this.from.module}"`;
+            const quoteChar = originalSource.startsWith("'") ? "'" : '"';
+            literal.valueSource = `${quoteChar}${this.to.module}${quoteChar}`;
+            // A named specifier's local name has to stay put in the source, since it is what the
+            // rest of the file already reads; default and namespace imports carry that name on
+            // the clause itself, which needs no edit for a module-only move.
+            const toKey = memberName(this.to.member);
+            if (key !== undefined && key !== '*' && toKey !== undefined && toKey !== key) {
+                const importClause = draft.importClause;
+                if (((_a = importClause === null || importClause === void 0 ? void 0 : importClause.namedBindings) === null || _a === void 0 ? void 0 : _a.kind) === tree_1.JS.Kind.NamedImports) {
+                    const namedImports = importClause.namedBindings;
+                    for (const elem of namedImports.elements.elements) {
+                        const specifier = elem.element;
+                        if (specifier.specifier.kind === java_1.J.Kind.Identifier && specifier.specifier.simpleName === key) {
+                            specifier.specifier = aliasing(specifier.specifier, toKey);
+                        }
+                        else if (specifier.specifier.kind === tree_1.JS.Kind.Alias) {
+                            const aliasNode = specifier.specifier;
+                            const propertyName = aliasNode.propertyName.element;
+                            if (propertyName.kind === java_1.J.Kind.Identifier && propertyName.simpleName === key) {
+                                propertyName.simpleName = toKey;
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
+}
+exports.RebindImport = RebindImport;
 //# sourceMappingURL=add-import.js.map