@openrewrite/rewrite 8.91.1 → 8.91.2

package/dist/javascript/amd.js

@@ -0,0 +1,768 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveAmdDependency = exports.RebindAmdDependency = exports.AddAmdDependency = exports.DEFAULT_AMD_CALLEES = void 0;
+exports.amdBlockOf = amdBlockOf;
+exports.present = present;
+exports.elementsOf = elementsOf;
+exports.parametersOf = parametersOf;
+exports.dependencyNames = dependencyNames;
+exports.parameterNames = parameterNames;
+exports.identifierOf = identifierOf;
+exports.withDependency = withDependency;
+exports.withoutDependencyAt = withoutDependencyAt;
+exports.withDependencyModuleAt = withDependencyModuleAt;
+exports.calleesOf = calleesOf;
+exports.enclosingAmdBlock = enclosingAmdBlock;
+exports.lastSegment = lastSegment;
+exports.derivedBindingName = derivedBindingName;
+exports.bindAmd = bindAmd;
+exports.bodyOf = bodyOf;
+exports.references = references;
+exports.namesUsed = namesUsed;
+exports.removeNewlyUnusedAmdBindings = removeNewlyUnusedAmdBindings;
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const markers_1 = require("../markers");
+const uuid_1 = require("../uuid");
+const java_1 = require("../java");
+const tree_1 = require("./tree");
+const scope_1 = require("./scope");
+const visitor_1 = require("./visitor");
+const execution_1 = require("../execution");
+/** RequireJS and Dojo write `define`; UI5 namespaces it as `sap.ui.define`. */
+exports.DEFAULT_AMD_CALLEES = ["define", "require"];
+function amdBlockOf(call, callees = exports.DEFAULT_AMD_CALLEES) {
+    if (!isAmdCallee(call, callees)) {
+        return undefined;
+    }
+    const args = call.arguments.elements;
+    const dependenciesIndex = args.findIndex(arg => arg.element.kind === java_1.J.Kind.NewArray);
+    const factoryIndex = dependenciesIndex >= 0 ?
+        dependenciesIndex + 1 :
+        args.findIndex(arg => asFactory(arg.element) !== undefined);
+    const factory = factoryIndex >= 0 && factoryIndex < args.length ?
+        asFactory(args[factoryIndex].element) :
+        undefined;
+    if (factory === undefined) {
+        return undefined;
+    }
+    const dependencies = dependenciesIndex >= 0 ?
+        args[dependenciesIndex].element :
+        noDependencies();
+    return { dependenciesIndex, dependencies, factoryIndex, factory };
+}
+/** Stands in for the array a block written without one would have had. */
+function noDependencies() {
+    return {
+        kind: java_1.J.Kind.NewArray,
+        id: (0, uuid_1.randomId)(),
+        prefix: java_1.emptySpace,
+        markers: markers_1.emptyMarkers,
+        dimensions: [],
+        initializer: (0, java_1.emptyContainer)()
+    };
+}
+/**
+ * A callee written without a dot (`"define"`) matches by simple name on any receiver, so it
+ * also matches `foo.define(...)`; a dotted callee (`"sap.ui.define"`) requires the whole path.
+ */
+function isAmdCallee(call, callees) {
+    // The name check first: this runs for every call in a file, and almost none are these.
+    const simpleName = call.name.simpleName;
+    return callees.some(callee => {
+        const last = callee.substring(callee.lastIndexOf(".") + 1);
+        return simpleName === last && (callee === last || namespaceOf(call) === callee);
+    });
+}
+/** The dotted path a call is written under, `sap.ui.define` for `sap.ui.define(…)`. */
+function namespaceOf(call) {
+    var _a;
+    const segments = [call.name.simpleName];
+    let node = (_a = call.select) === null || _a === void 0 ? void 0 : _a.element;
+    while (node !== undefined) {
+        if (node.kind === java_1.J.Kind.FieldAccess) {
+            const access = node;
+            segments.unshift(access.name.element.simpleName);
+            node = access.target;
+        }
+        else if ((0, java_1.isIdentifier)(node)) {
+            segments.unshift(node.simpleName);
+            return segments.join(".");
+        }
+        else {
+            return undefined;
+        }
+    }
+    return segments.join(".");
+}
+/** A factory is written either as a function expression or as an arrow function. */
+function asFactory(argument) {
+    if (argument.kind === tree_1.JS.Kind.StatementExpression) {
+        const statement = argument.statement;
+        return statement.kind === java_1.J.Kind.MethodDeclaration ? statement : undefined;
+    }
+    return argument.kind === tree_1.JS.Kind.ArrowFunction ? argument.lambda : undefined;
+}
+/**
+ * The elements of a `[]` or `()`, which the parser fills with a single `J.Empty` when
+ * there are none.
+ */
+function present(elements) {
+    return elements.length === 1 && elements[0].element.kind === java_1.J.Kind.Empty ? [] : [...elements];
+}
+function elementsOf(block) {
+    var _a, _b;
+    return present((_b = (_a = block.dependencies.initializer) === null || _a === void 0 ? void 0 : _a.elements) !== null && _b !== void 0 ? _b : []);
+}
+function parametersOf(block) {
+    return present(block.factory.kind === java_1.J.Kind.MethodDeclaration ?
+        block.factory.parameters.elements :
+        normalizeArrowParameters(block.factory.parameters.parameters));
+}
+/**
+ * An arrow function's parameter list isn't built the way every other comma-separated list in
+ * the tree is: a trailing comma is an extra `J.Empty` entry rather than a `TrailingComma`
+ * marker, and a parameter's own trailing whitespace sits on the identifier's declaration
+ * rather than on the list entry that holds it. Folding both into the shape the rest of this
+ * module already handles lets append/remove treat every kind of factory alike.
+ */
+function normalizeArrowParameters(raw) {
+    if (raw.length === 1 && raw[0].element.kind === java_1.J.Kind.Empty) {
+        return [...raw];
+    }
+    const trailingEmpty = raw.length > 1 && raw[raw.length - 1].element.kind === java_1.J.Kind.Empty ?
+        raw[raw.length - 1] : undefined;
+    const real = (trailingEmpty === undefined ? raw : raw.slice(0, -1)).map(foldDeclarationTrailingSpace);
+    if (trailingEmpty === undefined) {
+        return real;
+    }
+    const last = real[real.length - 1];
+    const marker = { kind: java_1.J.Markers.TrailingComma, id: (0, uuid_1.randomId)(), suffix: trailingEmpty.after };
+    return [...real.slice(0, -1), Object.assign(Object.assign({}, last), { markers: Object.assign(Object.assign({}, last.markers), { markers: [...last.markers.markers, marker] }) })];
+}
+/** Moves a VariableDeclarations parameter's trailing whitespace from the identifier's own declaration up to the list entry, when the entry doesn't already carry any. */
+function foldDeclarationTrailingSpace(entry) {
+    if (entry.element.kind !== java_1.J.Kind.VariableDeclarations ||
+        entry.after.whitespace !== "" || entry.after.comments.length > 0) {
+        return entry;
+    }
+    const declaration = entry.element;
+    const variable = declaration.variables[0];
+    if (variable === undefined) {
+        return entry;
+    }
+    const folded = Object.assign(Object.assign({}, declaration), { variables: [Object.assign(Object.assign({}, variable), { after: java_1.emptySpace }), ...declaration.variables.slice(1)] });
+    return Object.assign(Object.assign({}, entry), { element: folded, after: variable.after });
+}
+function dependencyNames(block) {
+    return elementsOf(block).map(padded => {
+        const element = padded.element;
+        return (0, java_1.isLiteral)(element) && typeof element.value === "string" ? element.value : "";
+    });
+}
+function parameterNames(block) {
+    return parametersOf(block).map(padded => { var _a; return (_a = identifierOf(padded.element)) === null || _a === void 0 ? void 0 : _a.simpleName; });
+}
+function identifierOf(parameter) {
+    var _a;
+    if (parameter.kind === java_1.J.Kind.VariableDeclarations) {
+        const name = (_a = parameter.variables[0]) === null || _a === void 0 ? void 0 : _a.element.name;
+        return name !== undefined && (0, java_1.isIdentifier)(name) ? name : undefined;
+    }
+    return (0, java_1.isIdentifier)(parameter) ? parameter : undefined;
+}
+const dependencySlot = {
+    prefixOf: element => element.prefix,
+    withPrefix: (element, prefix) => (Object.assign(Object.assign({}, element), { prefix }))
+};
+const parameterSlot = {
+    prefixOf: element => { var _a, _b; return (_b = (_a = identifierOf(element)) === null || _a === void 0 ? void 0 : _a.prefix) !== null && _b !== void 0 ? _b : element.prefix; },
+    withPrefix: (element, prefix) => {
+        if (element.kind !== java_1.J.Kind.VariableDeclarations) {
+            return Object.assign(Object.assign({}, element), { prefix });
+        }
+        const declaration = element;
+        const variable = declaration.variables[0];
+        if (variable === undefined) {
+            return element;
+        }
+        return Object.assign(Object.assign({}, declaration), { variables: [
+                Object.assign(Object.assign({}, variable), { element: Object.assign(Object.assign({}, variable.element), { name: Object.assign(Object.assign({}, variable.element.name), { prefix }) }) }),
+                ...declaration.variables.slice(1)
+            ] });
+    }
+};
+/**
+ * A trailing comma is a marker on the entry it follows, so it has to travel to whichever
+ * entry ends up last. Left where it was, it prints as a second comma and the array gains a
+ * hole, which shifts every dependency after it out of step with its parameter.
+ */
+function moveTrailingComma(from, to) {
+    const trailing = (0, markers_1.findMarker)(from, java_1.J.Markers.TrailingComma);
+    if (trailing === undefined) {
+        return { from, to };
+    }
+    return {
+        from: Object.assign(Object.assign({}, from), { markers: Object.assign(Object.assign({}, from.markers), { markers: from.markers.markers.filter(m => m !== trailing) }) }),
+        to: Object.assign(Object.assign({}, to), { markers: Object.assign(Object.assign({}, to.markers), { markers: [...to.markers.markers, trailing] }) })
+    };
+}
+/**
+ * The whitespace that separates one entry from the next, taken from the entries already
+ * there so that a block listing its dependencies one per line keeps doing so.
+ */
+function separator(entries, slot) {
+    if (entries.length >= 2) {
+        return slot.prefixOf(entries[1].element);
+    }
+    const first = slot.prefixOf(entries[0].element);
+    return (0, java_1.spaceContainsNewline)(first) ? first : (0, java_1.space)(" ");
+}
+/**
+ * Appends `element`. The trailing entry's padding holds the whitespace before the closing
+ * bracket, so it has to move along with the position.
+ */
+function appendEntry(entries, element, slot) {
+    const last = entries[entries.length - 1];
+    if (last === undefined) {
+        return [(0, java_1.rightPadded)(element, java_1.emptySpace)];
+    }
+    const positioned = slot.withPrefix(element, separator(entries, slot));
+    const trailing = splitTrailingComments(last.after);
+    const moved = moveTrailingComma(Object.assign(Object.assign({}, last), { after: trailing.comments }), (0, java_1.rightPadded)(positioned, trailing.whitespace));
+    return [...entries.slice(0, -1), moved.from, moved.to];
+}
+/**
+ * Splits an entry's trailing padding when it stops being last. Plain whitespace only ever
+ * positioned the closing delimiter, so it travels to whichever entry becomes the new last. A
+ * comment documents the entry it follows and keeps its own trailing newline, so it stays put
+ * whole — a line comment with nothing left after it would otherwise swallow the comma the
+ * printer inserts right after this padding.
+ */
+function splitTrailingComments(after) {
+    return after.comments.length === 0 ?
+        { comments: Object.assign(Object.assign({}, after), { whitespace: "" }), whitespace: (0, java_1.space)(after.whitespace) } :
+        { comments: after, whitespace: java_1.emptySpace };
+}
+/**
+ * The plain-whitespace part of a leading prefix whose entry is about to be removed. A comment in
+ * that prefix documents the entry it precedes and is dropped along with it; the whitespace only
+ * ever positioned that entry after the opening bracket or a comma, so it's what travels to
+ * whichever entry takes its place.
+ */
+function leadingWhitespaceOf(prefix) {
+    return prefix.comments.length === 0 ? prefix.whitespace : "";
+}
+/**
+ * Removes the entry at `index`. The first entry carries no separating whitespace and the
+ * last carries the whitespace before the closing bracket, so removing either hands its
+ * padding to whichever entry takes its place.
+ */
+function removeEntry(entries, index, slot) {
+    if (index < 0 || index >= entries.length) {
+        return [...entries];
+    }
+    const remaining = [...entries];
+    const [removed] = remaining.splice(index, 1);
+    if (remaining.length === 0) {
+        return remaining;
+    }
+    if (index === 0) {
+        // Spread the survivor's own prefix rather than replacing it outright, so a comment it
+        // already carries survives; only its plain whitespace is replaced.
+        const whitespace = leadingWhitespaceOf(slot.prefixOf(removed.element));
+        const survivor = remaining[0];
+        remaining[0] = Object.assign(Object.assign({}, survivor), { element: slot.withPrefix(survivor.element, Object.assign(Object.assign({}, slot.prefixOf(survivor.element)), { whitespace })) });
+    }
+    else if (index === remaining.length) {
+        const last = Object.assign(Object.assign({}, remaining[index - 1]), { after: removed.after });
+        remaining[index - 1] = moveTrailingComma(removed, last).to;
+    }
+    return remaining;
+}
+function emptyExpression() {
+    return { kind: java_1.J.Kind.Empty, id: (0, uuid_1.randomId)(), prefix: java_1.emptySpace, markers: markers_1.emptyMarkers };
+}
+function withElements(dependencies, elements) {
+    const initializer = dependencies.initializer;
+    return Object.assign(Object.assign({}, dependencies), { initializer: Object.assign(Object.assign({}, initializer), { elements: elements.length === 0 ? [(0, java_1.rightPadded)(emptyExpression(), java_1.emptySpace)] : elements }) });
+}
+function withParameters(factory, parameters) {
+    const elements = parameters.length === 0 ? [(0, java_1.rightPadded)(emptyExpression(), java_1.emptySpace)] : parameters;
+    if (factory.kind === java_1.J.Kind.MethodDeclaration) {
+        const method = factory;
+        return Object.assign(Object.assign({}, method), { parameters: Object.assign(Object.assign({}, method.parameters), { elements: elements }) });
+    }
+    const lambda = factory;
+    // Unparenthesized arrow parameters are only valid JavaScript for exactly one parameter.
+    if (lambda.parameters.parenthesized || parameters.length === 1) {
+        return Object.assign(Object.assign({}, lambda), { parameters: Object.assign(Object.assign({}, lambda.parameters), { parameters: elements }) });
+    }
+    return parenthesize(lambda, elements);
+}
+/**
+ * A bare arrow parameter has no closing delimiter of its own — the space before `=>` sits on
+ * the parameter itself. Wrapping it in parens turns that into the space before the new `)`,
+ * so it has to move to `arrow` instead, where it will actually print before `=>` again.
+ */
+function parenthesize(lambda, elements) {
+    const last = elements[elements.length - 1];
+    const arrowSpace = last.after.whitespace === "" ? lambda.arrow : last.after;
+    return Object.assign(Object.assign({}, lambda), { parameters: Object.assign(Object.assign({}, lambda.parameters), { parenthesized: true, parameters: [...elements.slice(0, -1), Object.assign(Object.assign({}, last), { after: java_1.emptySpace })] }), arrow: arrowSpace });
+}
+function identifier(name) {
+    return {
+        kind: java_1.J.Kind.Identifier,
+        id: (0, uuid_1.randomId)(),
+        prefix: java_1.emptySpace,
+        markers: markers_1.emptyMarkers,
+        annotations: [],
+        simpleName: name,
+        type: undefined,
+        fieldType: undefined
+    };
+}
+function dependencyLiteral(module, quote) {
+    return {
+        kind: java_1.J.Kind.Literal,
+        id: (0, uuid_1.randomId)(),
+        prefix: java_1.emptySpace,
+        markers: markers_1.emptyMarkers,
+        value: module,
+        valueSource: `${quote}${module}${quote}`
+    };
+}
+/** The quote the block's own dependencies use, so a new one matches them. */
+function quoteOf(block) {
+    for (const padded of elementsOf(block)) {
+        const source = (0, java_1.isLiteral)(padded.element) ? padded.element.valueSource : undefined;
+        const quote = source === null || source === void 0 ? void 0 : source.charAt(0);
+        if (quote === '"' || quote === "'") {
+            return quote;
+        }
+    }
+    return '"';
+}
+function parameterDeclaration(name) {
+    return {
+        kind: java_1.J.Kind.VariableDeclarations,
+        id: (0, uuid_1.randomId)(),
+        prefix: java_1.emptySpace,
+        markers: markers_1.emptyMarkers,
+        leadingAnnotations: [],
+        modifiers: [],
+        variables: [(0, java_1.rightPadded)({
+                kind: java_1.J.Kind.NamedVariable,
+                id: (0, uuid_1.randomId)(),
+                prefix: java_1.emptySpace,
+                markers: markers_1.emptyMarkers,
+                name: identifier(name),
+                dimensionsAfterName: []
+            }, java_1.emptySpace)]
+    };
+}
+/**
+ * Adds a dependency and its binding, keeping the array and the parameter list index-aligned.
+ * Refuses (returns `undefined`) unless the two are already the same length: fewer parameters
+ * than dependencies would invent a binding for one an author left unbound on purpose, and more
+ * would pair the new dependency with an existing surplus parameter instead of a fresh one —
+ * either way corrupting the pairing this module exists to protect.
+ */
+function withDependency(call, block, module, binding) {
+    if (parametersOf(block).length !== elementsOf(block).length) {
+        return undefined;
+    }
+    const dependencies = withElements(block.dependencies, appendEntry(elementsOf(block), dependencyLiteral(module, quoteOf(block)), dependencySlot));
+    const factory = withParameters(block.factory, appendEntry(parametersOf(block), parameterDeclaration(binding), parameterSlot));
+    return withParts(call, block, dependencies, factory);
+}
+function withoutDependencyAt(call, block, index) {
+    const dependencies = withElements(block.dependencies, removeEntry(elementsOf(block), index, dependencySlot));
+    const parameters = parametersOf(block);
+    const factory = index >= parameters.length ?
+        block.factory :
+        withParameters(block.factory, removeEntry(parameters, index, parameterSlot));
+    return withParts(call, block, dependencies, factory);
+}
+/**
+ * Swaps the module the dependency at `index` names, leaving its parameter and every other
+ * entry's position untouched — simpler than a removal and a fresh append, which would shift
+ * every dependency after it and re-litigate the parameter pairing this module exists to protect.
+ */
+function withDependencyModuleAt(call, block, index, module) {
+    const quote = quoteOf(block);
+    const elements = [...elementsOf(block)];
+    const entry = elements[index];
+    const literal = entry.element;
+    const updated = Object.assign(Object.assign({}, literal), { value: module, valueSource: `${quote}${module}${quote}` });
+    elements[index] = Object.assign(Object.assign({}, entry), { element: updated });
+    const dependencies = withElements(block.dependencies, elements);
+    return withParts(call, block, dependencies, block.factory);
+}
+function withParts(call, block, dependencies, factory) {
+    var _a, _b;
+    const args = [...call.arguments.elements];
+    let factoryIndex = block.factoryIndex;
+    if (block.dependenciesIndex >= 0) {
+        args[block.dependenciesIndex] = Object.assign(Object.assign({}, args[block.dependenciesIndex]), { element: dependencies });
+    }
+    else if (present((_b = (_a = dependencies.initializer) === null || _a === void 0 ? void 0 : _a.elements) !== null && _b !== void 0 ? _b : []).length > 0) {
+        // The array takes the position the factory held, so it inherits what led up to it.
+        const leading = args[factoryIndex].element;
+        args[factoryIndex] = Object.assign(Object.assign({}, args[factoryIndex]), { element: Object.assign(Object.assign({}, leading), { prefix: (0, java_1.space)(" ") }) });
+        args.splice(factoryIndex, 0, (0, java_1.rightPadded)(Object.assign(Object.assign({}, dependencies), { prefix: leading.prefix }), java_1.emptySpace));
+        factoryIndex += 1;
+    }
+    args[factoryIndex] = Object.assign(Object.assign({}, args[factoryIndex]), { element: restoreFactory(args[factoryIndex].element, factory) });
+    return Object.assign(Object.assign({}, call), { arguments: Object.assign(Object.assign({}, call.arguments), { elements: args }) });
+}
+/** Puts the rewritten factory back into whichever wrapper the original was written as. */
+function restoreFactory(original, factory) {
+    if (original.kind === tree_1.JS.Kind.StatementExpression) {
+        const statementExpression = Object.assign(Object.assign({}, original), { statement: factory });
+        return statementExpression;
+    }
+    const arrowFunction = Object.assign(Object.assign({}, original), { lambda: factory });
+    return arrowFunction;
+}
+function calleesOf(options) {
+    const callee = options === null || options === void 0 ? void 0 : options.amdCallee;
+    return callee === undefined ? exports.DEFAULT_AMD_CALLEES : typeof callee === "string" ? [callee] : callee;
+}
+/** The nearest AMD block the cursor sits inside, which is the one a binding belongs to. */
+function enclosingAmdBlock(visitor, options) {
+    const callees = calleesOf(options);
+    let cursor = (0, scope_1.cursorOf)(visitor);
+    while (cursor !== undefined) {
+        const value = cursor.value;
+        if ((value === null || value === void 0 ? void 0 : value.kind) === java_1.J.Kind.MethodInvocation) {
+            const block = amdBlockOf(value, callees);
+            if (block !== undefined) {
+                return { call: value, block };
+            }
+        }
+        cursor = cursor.parent;
+    }
+    return undefined;
+}
+/** The conventional local name for a module: its last path segment. */
+function lastSegment(module) {
+    return module.substring(module.lastIndexOf("/") + 1);
+}
+// Always-reserved words, plus the strict-mode-only ones (module code is always strict) and
+// `await`/`yield`, contextual elsewhere but a trap to bind regardless of where they're legal.
+const RESERVED_WORDS = new Set([
+    "break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do",
+    "else", "enum", "export", "extends", "false", "finally", "for", "function", "if", "import",
+    "in", "instanceof", "new", "null", "return", "super", "switch", "this", "throw", "true", "try",
+    "typeof", "var", "void", "while", "with",
+    "await", "implements", "interface", "let", "package", "private", "protected", "public",
+    "static", "yield"
+]);
+/**
+ * `lastSegment(module)`, or `undefined` where that string cannot bind a name — a scoped
+ * package's `@scope/my-lib`, a subpath's `lodash.merge`, a `-`/`.`-bearing name, or a reserved
+ * word are all real module strings that are not legal identifiers. ASCII identifiers only —
+ * stricter than JavaScript itself, which allows Unicode, but refusing there is safe.
+ */
+function derivedBindingName(module) {
+    const segment = lastSegment(module);
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(segment) && !RESERVED_WORDS.has(segment) ? segment : undefined;
+}
+/** Queued reservations already targeting this block: the shared source for both dedup and deconfliction. */
+function queuedFor(visitor, blockId) {
+    return visitor.afterVisit.filter((v) => v instanceof AddAmdDependency && v.blockId === blockId);
+}
+/**
+ * A local binding for `module` on the AMD lane, creating one where the block does not already
+ * have it, or `undefined` where no safe binding exists.
+ *
+ * The name is decided from the cursor and returned at once; the edit that creates the binding
+ * is deferred onto `visitor.afterVisit`, as `bindImport`'s is.
+ */
+function bindAmd(visitor, amd, module, preferredName, callees, pinned = false) {
+    var _a;
+    const modules = dependencyNames(amd.block);
+    const bindings = parameterNames(amd.block);
+    const declared = module === "" ? -1 : modules.indexOf(module);
+    if (declared >= 0) {
+        return bindings[declared];
+    }
+    // Two calls naming the same module at the same block are the same request (ADR 0013),
+    // answered from whichever reservation is already queued rather than doubling the dependency.
+    const queued = queuedFor(visitor, amd.call.id);
+    const reserved = (_a = queued.find(v => v.module === module)) === null || _a === void 0 ? void 0 : _a.binding;
+    if (reserved !== undefined) {
+        return reserved;
+    }
+    // A parameter can only be appended at the end, so a block whose dependency and parameter
+    // counts already disagree would bind the new module against the wrong parameter either way.
+    if (bindings.length !== elementsOf(amd.block).length) {
+        return undefined;
+    }
+    if (preferredName === undefined && derivedBindingName(module) === undefined) {
+        return undefined;
+    }
+    // A parameter is in scope across the whole factory, and the queue hands this name to later
+    // requests at cursors inside it, so every name the factory declares is one it has to clear.
+    const taken = [...bindings, ...(0, scope_1.namesDeclaredWithin)(amd.block.factory), ...queued.map(v => v.binding)];
+    const requested = preferredName !== null && preferredName !== void 0 ? preferredName : derivedBindingName(module);
+    const binding = (0, scope_1.deconflict)(requested, candidate => taken.includes(candidate));
+    if (pinned && binding !== requested) {
+        // An alias is bound verbatim or not at all, since the caller may already have emitted
+        // code naming it, and a deconflicted spelling would leave that unbound.
+        return undefined;
+    }
+    visitor.afterVisit.push(new AddAmdDependency(amd.call.id, module, binding, callees));
+    return binding;
+}
+/** The factory's body: a `J.Block` for `function(){}` and most arrows, or the bare expression for `() => expr`. */
+function bodyOf(block) {
+    return block.factory.kind === java_1.J.Kind.MethodDeclaration ?
+        block.factory.body :
+        block.factory.body;
+}
+/**
+ * Whether the factory body references `name`. This counts any identifier of that name,
+ * including a member in a field access, since a stray dependency is fine where a shadowed one
+ * is not. `missingBodyAnswer` covers a body-less factory: `false` for an addition (nothing to
+ * conflict with), `true` for a removal (nothing to prove the binding unused).
+ */
+async function references(block, name, missingBodyAnswer) {
+    const body = bodyOf(block);
+    if (body === undefined) {
+        return missingBodyAnswer;
+    }
+    let found = false;
+    const finder = new class extends visitor_1.JavaScriptVisitor {
+        async visitIdentifier(id, c) {
+            if (id.simpleName === name) {
+                found = true;
+            }
+            return super.visitIdentifier(id, c);
+        }
+    };
+    await finder.visit(body, new execution_1.ExecutionContext());
+    return found;
+}
+/**
+ * Every name the factory body references, one walk for the whole block rather than one per
+ * name. `missingBodyAnswer` means what it means on `references`: the answer `.has` gives, for
+ * every name, when the factory has no body to walk.
+ */
+async function namesUsed(block, missingBodyAnswer) {
+    const body = bodyOf(block);
+    if (body === undefined) {
+        return { has: () => missingBodyAnswer };
+    }
+    const names = new Set();
+    const collector = new class extends visitor_1.JavaScriptVisitor {
+        async visitIdentifier(id, c) {
+            names.add(id.simpleName);
+            return super.visitIdentifier(id, c);
+        }
+    };
+    await collector.visit(body, new execution_1.ExecutionContext());
+    return names;
+}
+/**
+ * Applies the dependency a `maybeBind` call settled on. The block is found by id: its caller
+ * has already emitted a reference to the binding, so a block that cannot be found is an error
+ * rather than a skipped edit.
+ */
+class AddAmdDependency extends visitor_1.JavaScriptVisitor {
+    constructor(blockId, module, binding, callees) {
+        super();
+        this.blockId = blockId;
+        this.module = module;
+        this.binding = binding;
+        this.callees = callees;
+        this.applied = false;
+    }
+    async visitJsCompilationUnit(cu, p) {
+        const visited = await super.visitJsCompilationUnit(cu, p);
+        if (!this.applied) {
+            throw new Error(`No AMD block ${this.blockId} to declare '${this.module}' on, but '${this.binding}' was reported bound`);
+        }
+        return visited;
+    }
+    async visitMethodInvocation(m, p) {
+        const visited = await super.visitMethodInvocation(m, p);
+        if (visited.id !== this.blockId) {
+            return visited;
+        }
+        const block = amdBlockOf(visited, this.callees);
+        if (block === undefined) {
+            return visited;
+        }
+        this.applied = true;
+        if (!(await references(block, this.binding, false))) {
+            // Nothing referenced the binding, so the caller asked and then did not use the answer.
+            return visited;
+        }
+        // Another edit in the same visit can drop or add a factory parameter, reopening a count
+        // mismatch bindAmd's own check already cleared — an error here for the same reason a missing
+        // block is one.
+        const dependency = withDependency(visited, block, this.module, this.binding);
+        if (dependency === undefined) {
+            throw new Error(`AMD block ${this.blockId} no longer has matching dependency and parameter counts, ` +
+                `so '${this.module}' could not be declared for '${this.binding}', which was reported bound`);
+        }
+        return dependency;
+    }
+}
+exports.AddAmdDependency = AddAmdDependency;
+/**
+ * Applies a `maybeRebind` call's decision on the AMD lane: swaps the dependency's module in
+ * place, found by the block's tree id and the module it named when the caller asked.
+ */
+class RebindAmdDependency extends visitor_1.JavaScriptVisitor {
+    constructor(blockId, fromModule, toModule, callees) {
+        super();
+        this.blockId = blockId;
+        this.fromModule = fromModule;
+        this.toModule = toModule;
+        this.callees = callees;
+        this.applied = false;
+    }
+    async visitJsCompilationUnit(cu, p) {
+        const visited = await super.visitJsCompilationUnit(cu, p);
+        if (!this.applied) {
+            throw new Error(`No AMD block ${this.blockId} to rebind '${this.fromModule}' to '${this.toModule}' on`);
+        }
+        return visited;
+    }
+    async visitMethodInvocation(m, p) {
+        const visited = await super.visitMethodInvocation(m, p);
+        if (visited.id !== this.blockId) {
+            return visited;
+        }
+        const block = amdBlockOf(visited, this.callees);
+        if (block === undefined) {
+            return visited;
+        }
+        this.applied = true;
+        const index = this.fromModule === "" ? -1 : dependencyNames(block).indexOf(this.fromModule);
+        if (index < 0) {
+            throw new Error(`AMD block ${this.blockId} no longer has dependency '${this.fromModule}' to rebind to '${this.toModule}'`);
+        }
+        return withDependencyModuleAt(visited, block, index, this.toModule);
+    }
+}
+exports.RebindAmdDependency = RebindAmdDependency;
+/**
+ * The AMD counterpart to `RemoveImport`: drops a dependency the block's body no longer names,
+ * along with the parameter bound to it. A dependency the factory takes no parameter for is
+ * loaded for its side effects and stays, matching `bindAmd`'s own read of such a block. A
+ * `member`-scoped request is a no-op here — see `maybeUnbind`.
+ */
+class RemoveAmdDependency extends visitor_1.JavaScriptVisitor {
+    constructor(module, member, callees = exports.DEFAULT_AMD_CALLEES) {
+        super();
+        this.module = module;
+        this.member = member;
+        this.callees = callees;
+    }
+    async visitMethodInvocation(m, p) {
+        const visited = await super.visitMethodInvocation(m, p);
+        if (this.member !== undefined) {
+            return visited;
+        }
+        const block = amdBlockOf(visited, this.callees);
+        if (block === undefined) {
+            return visited;
+        }
+        const index = dependencyNames(block).indexOf(this.module);
+        if (index < 0) {
+            return visited;
+        }
+        const binding = parameterNames(block)[index];
+        if (binding === undefined || await references(block, binding, true)) {
+            return visited;
+        }
+        return withoutDependencyAt(visited, block, index);
+    }
+}
+exports.RemoveAmdDependency = RemoveAmdDependency;
+/**
+ * Drops AMD bindings a rewrite left unreferenced. One already unused beforehand stays: it is
+ * loaded for its side effects, so dropping it changes what the module loads. Needing the tree as
+ * it stood before the rewrite is why this takes both and does not defer. Blocks are matched by
+ * the call's id, so one a rewrite rebuilds rather than edits is left alone.
+ */
+async function removeNewlyUnusedAmdBindings(before, after, ctx, options) {
+    const callees = calleesOf(options);
+    const usedBeforeByBlock = new Map();
+    const collector = new class extends visitor_1.JavaScriptVisitor {
+        async visitMethodInvocation(m, c) {
+            const block = amdBlockOf(m, callees);
+            if (block !== undefined) {
+                usedBeforeByBlock.set(m.id, await usedBindings(block));
+            }
+            return super.visitMethodInvocation(m, c);
+        }
+    };
+    await collector.visit(before, ctx);
+    if (usedBeforeByBlock.size === 0) {
+        return after;
+    }
+    const sweeper = new class extends visitor_1.JavaScriptVisitor {
+        async visitMethodInvocation(m, c) {
+            let call = await super.visitMethodInvocation(m, c);
+            const usedBefore = usedBeforeByBlock.get(call.id);
+            let block = usedBefore === undefined ? undefined : amdBlockOf(call, callees);
+            if (usedBefore === undefined || block === undefined) {
+                return call;
+            }
+            // A block written `define(factory)` takes `require`, `exports` and `module` from the
+            // loader, so a parameter there is positional against arguments no dependency list names.
+            if (block.dependenciesIndex < 0 || parameterNames(block).length !== elementsOf(block).length) {
+                return call;
+            }
+            // withoutDependencyAt only edits the dependency array and parameter list, never the
+            // body, so which names it references can't change between removals.
+            const usedNow = await namesUsed(block, true);
+            for (;;) {
+                const bindings = parameterNames(block);
+                const goneIndex = bindings.findIndex(binding => binding !== undefined && usedBefore.has(binding) && !usedNow.has(binding));
+                if (goneIndex < 0) {
+                    return call;
+                }
+                call = withoutDependencyAt(call, block, goneIndex);
+                // A removal shifts the indices of the dependencies after it, so the block is
+                // re-derived from `call` rather than reused with stale offsets.
+                const next = amdBlockOf(call, callees);
+                if (next === undefined) {
+                    return call;
+                }
+                block = next;
+            }
+        }
+    };
+    return await sweeper.visit(after, ctx);
+}
+/** The block's parameter names that its body actually references, from a single walk of it. */
+async function usedBindings(block) {
+    const usedNames = await namesUsed(block, false);
+    const used = new Set();
+    for (const binding of parameterNames(block)) {
+        if (binding !== undefined && usedNames.has(binding)) {
+            used.add(binding);
+        }
+    }
+    return used;
+}
+//# sourceMappingURL=amd.js.map