rea-agents 6.3.0 → 6.4.0

package/dist/domain/javascript/javascriptSemanticMutationValues.js

@@ -19,43 +19,86 @@ export const invalidateSemanticEscapedPath = (value, path) => {
         ? { ...value, properties: value.properties.map(invalidateChild) }
         : { ...value, items: value.items.map(invalidateChild) };
 };
-/** Invalidate only slots that an explicit mutation can affect. */
-export const invalidateSemanticMutationPath = (value, path) => {
-    const [key, ...remaining] = path;
-    const unknown = {
-        status: "unknown",
-        reason: "This property may have been mutated.",
+/**
+ * Invalidate only slots that explicit mutations can affect, as if applying each
+ * path in order. Paths are grouped per slot so that many writes to one object
+ * cost one pass over its slots rather than one pass per write.
+ */
+export const invalidateSemanticMutationPaths = (value, paths) => {
+    if (paths.length === 0)
+        return value;
+    // An unknown key or a replaced value leaves nothing that a later path can
+    // restore, wherever it occurs in the sequence.
+    if ((value.status !== "object" && value.status !== "array") ||
+        paths.some(([key]) => key === undefined || key === null))
+        return {
+            status: "unknown",
+            reason: "This property may have been mutated.",
+        };
+    // Writing an array length discards every item known before it.
+    const reset = value.status === "array"
+        ? paths.findLastIndex(([key]) => key === "length")
+        : -1;
+    const base = reset < 0
+        ? value
+        : { status: "array", items: [], unknownItems: true, omittedItems: null };
+    const slots = base.status === "object" ? base.properties : base.items;
+    const slotsByName = new Map();
+    slots.forEach((property, index) => {
+        const indexes = slotsByName.get(property.name) ?? [];
+        indexes.push(index);
+        slotsByName.set(property.name, indexes);
+    });
+    const slotPaths = new Map();
+    const replacedSlots = new Set();
+    const select = (index, remaining) => {
+        const selected = slotPaths.get(index) ?? [];
+        selected.push(remaining);
+        slotPaths.set(index, selected);
+        if (remaining.length === 0)
+            replacedSlots.add(index);
     };
-    if (key === undefined || key === null)
-        return unknown;
-    if (value.status === "object" || value.status === "array") {
-        if (value.status === "array" && key === "length")
-            return {
-                status: "array",
-                items: [],
-                unknownItems: true,
-                omittedItems: null,
-            };
-        const slots = value.status === "object" ? value.properties : value.items;
-        const observed = slots.some((property) => semanticPropertyPathKeyMatches(key, property.name));
-        const properties = slots.map((property) => semanticPropertyPathKeyMatches(key, property.name)
-            ? {
+    // An added slot is already unknown, so later paths that select it are inert.
+    const added = new Set();
+    for (const [key, ...remaining] of paths.slice(reset + 1)) {
+        if (key === undefined || key === null)
+            continue;
+        if (typeof key === "object") {
+            slots.forEach((property, index) => {
+                if (semanticPropertyPathKeyMatches(key, property.name))
+                    select(index, remaining);
+            });
+            continue;
+        }
+        const indexes = slotsByName.get(String(key));
+        if (indexes === undefined)
+            added.add(String(key));
+        else
+            for (const index of indexes)
+                select(index, remaining);
+    }
+    const properties = slots.map((property, index) => {
+        const selected = slotPaths.get(index);
+        return selected === undefined
+            ? property
+            : {
                 ...property,
-                ...(remaining.length === 0
+                ...(replacedSlots.has(index)
                     ? { presence: "unknown-coverage" }
                     : {}),
-                value: invalidateSemanticMutationPath(property.value, remaining),
-            }
-            : property);
-        if (!observed && typeof key !== "object")
-            properties.push({
-                name: String(key),
-                value: unknown,
-                presence: "unknown-coverage",
-            });
-        return value.status === "object"
-            ? { ...value, properties }
-            : { ...value, items: properties };
-    }
-    return unknown;
+                value: invalidateSemanticMutationPaths(property.value, selected),
+            };
+    });
+    for (const name of added)
+        properties.push({
+            name,
+            value: {
+                status: "unknown",
+                reason: "This property may have been mutated.",
+            },
+            presence: "unknown-coverage",
+        });
+    return base.status === "object"
+        ? { ...base, properties }
+        : { ...base, items: properties };
 };

package/dist/domain/javascript/javascriptSemanticObjectReferences.js

@@ -0,0 +1,381 @@
+import * as t from "@babel/types";
+import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
+import { semanticCallableResultExpressions } from "./javascriptSemanticCallableResults.js";
+import { semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+import { semanticPropertyPathKeyMatches, } from "./javascriptSemanticPropertyPaths.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+export const semanticClassCandidates = (root, state) => {
+    const pending = [root];
+    const seenNodes = new Set();
+    const seenBindings = new Set();
+    const classes = [];
+    for (let cursor = 0; cursor < pending.length; cursor++) {
+        const node = pending[cursor];
+        if (node === undefined)
+            continue;
+        const expression = unwrapJavaScriptExpression(node).node;
+        if (seenNodes.has(expression))
+            continue;
+        seenNodes.add(expression);
+        if (t.isClass(expression)) {
+            classes.push(expression);
+        }
+        else if (t.isIdentifier(expression)) {
+            const binding = resolveSemanticBindingState(state, expression, expression.name);
+            if (binding === undefined || seenBindings.has(binding.bindingId))
+                continue;
+            seenBindings.add(binding.bindingId);
+            for (const initializer of binding.initializers)
+                pending.push(initializer.node);
+        }
+        else if (t.isConditionalExpression(expression) ||
+            t.isLogicalExpression(expression)) {
+            pending.push(t.isConditionalExpression(expression)
+                ? expression.consequent
+                : expression.left, t.isConditionalExpression(expression)
+                ? expression.alternate
+                : expression.right);
+        }
+        else if (t.isSequenceExpression(expression)) {
+            const last = expression.expressions.at(-1);
+            if (last !== undefined)
+                pending.push(last);
+        }
+    }
+    return classes;
+};
+const instanceFieldReferences = (root, propertyName, path, state) => {
+    const references = [];
+    const pending = [{ klass: root, excluded: new Set() }];
+    const selections = new Map();
+    let definiteNames;
+    for (let cursor = 0; cursor < pending.length; cursor++) {
+        const current = pending[cursor];
+        if (current === undefined)
+            continue;
+        const previous = selections.get(current.klass);
+        // A shared base can be reached through different derived classes. Only
+        // exclusions common to those paths can suppress a field in that base.
+        const excluded = previous === undefined
+            ? current.excluded
+            : new Set([...previous].filter((name) => current.excluded.has(name)));
+        if (previous !== undefined && previous.size === excluded.size)
+            continue;
+        selections.set(current.klass, excluded);
+        const shadowed = new Set(excluded);
+        for (const member of [...current.klass.body.body].reverse()) {
+            if (!t.isClassProperty(member) || member.static)
+                continue;
+            const key = semanticStaticPropertyKey(member.key, member.computed);
+            if (key !== null && shadowed.has(key))
+                continue;
+            if (key !== null)
+                shadowed.add(key);
+            if ((propertyName === null || key === null || key === propertyName) &&
+                member.value != null)
+                references.push({ node: member.value, path });
+        }
+        const bases = current.klass.superClass == null
+            ? []
+            : semanticClassCandidates(current.klass.superClass, state);
+        if (bases.length === 0)
+            definiteNames =
+                definiteNames === undefined
+                    ? shadowed
+                    : new Set([...definiteNames].filter((name) => shadowed.has(name)));
+        for (const klass of bases)
+            pending.push({ klass, excluded: shadowed });
+    }
+    return { references, definiteNames: definiteNames ?? new Set() };
+};
+const classPropertyDescriptors = (klass, propertyName, kind) => {
+    const isStatic = kind === "static";
+    const selectedGetters = [];
+    const fields = [];
+    const indexedMembers = [];
+    klass.body.body.forEach((member, index) => {
+        if ((t.isClassMethod(member) ||
+            (kind === "static" && t.isClassProperty(member))) &&
+            member.static === isStatic)
+            indexedMembers.push({
+                member,
+                index,
+                key: semanticStaticPropertyKey(member.key, member.computed),
+            });
+    });
+    const matchingMembers = propertyName === null
+        ? []
+        : indexedMembers.filter(({ key }) => key === propertyName);
+    const uncertainGetters = indexedMembers.filter((entry) => {
+        const { member, key } = entry;
+        return (t.isClassMethod(member) &&
+            member.kind === "get" &&
+            (propertyName === null || (member.computed && key === null)));
+    });
+    const getters = matchingMembers.filter((entry) => t.isClassMethod(entry.member) && entry.member.kind === "get");
+    const getter = getters.at(-1);
+    const getterIndex = getter?.index ?? -1;
+    const laterDataMember = matchingMembers.some(({ member, index }) => t.isClassProperty(member) ||
+        (t.isClassMethod(member) &&
+            member.kind === "method" &&
+            index > getterIndex));
+    const seenFields = new Set();
+    for (const { member, key } of [...indexedMembers].reverse()) {
+        if (!t.isClassProperty(member))
+            continue;
+        if (key !== null && seenFields.has(key))
+            continue;
+        if (key !== null)
+            seenFields.add(key);
+        if (propertyName === null || key === null || key === propertyName)
+            fields.push(member);
+    }
+    if (getters.length > 0 && !laterDataMember && getter !== undefined)
+        selectedGetters.push(getter.member);
+    for (const { member, index } of uncertainGetters)
+        if (!matchingMembers.some(({ member: matching, index: matchingIndex }) => (t.isClassProperty(matching) ||
+            (t.isClassMethod(matching) &&
+                (matching.kind === "method" || matching.kind === "get"))) &&
+            matchingIndex > index))
+            selectedGetters.push(member);
+    return {
+        getters: selectedGetters,
+        fields,
+        inherits: matchingMembers.length === 0,
+    };
+};
+export const semanticClassPropertyReferences = (lookup, selection, state, activeGetters = new Map()) => {
+    const root = lookup.owner;
+    const receiver = lookup.receiver ?? root;
+    const [key, ...path] = selection;
+    const propertyName = key == null || typeof key === "object" ? null : String(key);
+    const pending = [root];
+    const seen = new Set();
+    const possibleResults = [];
+    // Instance fields are own properties, including fields initialized by base
+    // constructors. They take precedence over every prototype descriptor.
+    let instanceFields = new Set();
+    if (lookup.kind === "instance") {
+        const fields = instanceFieldReferences(root, propertyName, path, state);
+        possibleResults.push(...fields.references);
+        instanceFields = fields.definiteNames;
+        if (propertyName !== null && instanceFields.has(propertyName))
+            return possibleResults;
+    }
+    for (let cursor = 0; cursor < pending.length; cursor++) {
+        const klass = pending[cursor];
+        if (klass === undefined || seen.has(klass))
+            continue;
+        seen.add(klass);
+        const descriptors = classPropertyDescriptors(klass, propertyName, lookup.kind);
+        for (const field of descriptors.fields)
+            if (field.value != null)
+                possibleResults.push({ node: field.value, path });
+        for (const getter of descriptors.getters) {
+            const key = semanticStaticPropertyKey(getter.key, getter.computed);
+            if (key !== null && instanceFields.has(key))
+                continue;
+            possibleResults.push(...getterResultReferences({ getter, owner: klass, receiver }, path, state, activeGetters));
+        }
+        // An exact own descriptor suppresses inherited lookup. Dynamic computed
+        // descriptors may or may not match, so retain possible superclass results.
+        if (descriptors.inherits &&
+            klass.superClass !== null &&
+            klass.superClass !== undefined)
+            pending.push(...semanticClassCandidates(klass.superClass, state));
+    }
+    return possibleResults;
+};
+const objectReceiverReference = (object, path, state) => {
+    // A literal's enclosing binding owns its slots. Returning the literal
+    // itself would bypass invalidation of that binding's observed properties.
+    let current = object;
+    const projection = [];
+    while (true) {
+        const parent = state.parentsByNode.get(current);
+        if (t.isVariableDeclarator(parent) &&
+            parent.init === current &&
+            t.isIdentifier(parent.id))
+            return [{ node: parent.id, path: [...projection, ...path] }];
+        if (t.isObjectProperty(parent) && parent.value === current) {
+            projection.unshift(semanticStaticPropertyKey(parent.key, parent.computed));
+            const container = state.parentsByNode.get(parent);
+            if (t.isObjectExpression(container)) {
+                current = container;
+                continue;
+            }
+        }
+        break;
+    }
+    return [{ node: object, path }];
+};
+const getterResultReferences = (invocation, path, state, activeGetters = new Map()) => {
+    const { getter, owner, receiver = owner } = invocation;
+    const previousLength = activeGetters.get(getter);
+    if (previousLength !== undefined && previousLength <= path.length)
+        return [];
+    // Repeated receiver reads may revisit a getter while consuming a finite
+    // path; recursive getters that preserve or grow that path cannot progress.
+    const active = new Map(activeGetters).set(getter, path.length);
+    const isStatic = t.isClassMethod(getter) && getter.static;
+    const resolve = (node, remaining) => {
+        const expression = unwrapJavaScriptExpression(node).node;
+        if (t.isThisExpression(expression)) {
+            if (t.isClass(receiver)) {
+                return semanticClassPropertyReferences({ owner: receiver, kind: isStatic ? "static" : "instance" }, remaining, state, active);
+            }
+            return objectReceiverReference(receiver, remaining, state);
+        }
+        if (t.isMemberExpression(expression) ||
+            t.isOptionalMemberExpression(expression)) {
+            if (t.isPrivateName(expression.property) &&
+                t.isThisExpression(expression.object) &&
+                t.isClass(owner)) {
+                const privateName = expression.property.id.name;
+                return owner.body.body.flatMap((member) => t.isClassPrivateProperty(member) &&
+                    member.static === isStatic &&
+                    member.key.id.name === privateName &&
+                    member.value != null
+                    ? [{ node: member.value, path: remaining }]
+                    : []);
+            }
+            const key = semanticStaticPropertyKey(expression.property, expression.computed);
+            if (t.isSuper(expression.object) &&
+                t.isClass(owner) &&
+                owner.superClass != null) {
+                return semanticClassCandidates(owner.superClass, state).flatMap((base) => semanticClassPropertyReferences({
+                    owner: base,
+                    receiver: t.isClass(receiver) ? receiver : owner,
+                    kind: isStatic ? "static" : "prototype",
+                }, [key, ...remaining], state, active));
+            }
+            return resolve(expression.object, [key, ...remaining]);
+        }
+        if (t.isConditionalExpression(expression))
+            return [
+                ...resolve(expression.consequent, remaining),
+                ...resolve(expression.alternate, remaining),
+            ];
+        if (t.isLogicalExpression(expression))
+            return [
+                ...resolve(expression.left, remaining),
+                ...resolve(expression.right, remaining),
+            ];
+        if (t.isSequenceExpression(expression)) {
+            const last = expression.expressions.at(-1);
+            return last === undefined ? [] : resolve(last, remaining);
+        }
+        return [{ node: expression, path: remaining }];
+    };
+    return semanticCallableResultExpressions(getter).flatMap(({ node }) => node === null ? [] : resolve(node, path));
+};
+export const semanticObjectPropertyReferences = (node, path, state) => {
+    const [key, ...remaining] = path;
+    const references = [];
+    const overwritten = new Set();
+    const dataOverwritten = new Set();
+    const accessorNames = new Set();
+    const getterNames = new Set();
+    const setterNames = new Set();
+    for (const property of [...node.properties].reverse()) {
+        if (t.isSpreadElement(property)) {
+            const selected = key ?? null;
+            if (typeof selected !== "object" && overwritten.has(String(selected)))
+                continue;
+            references.push({
+                node: property.argument,
+                path: [
+                    typeof selected === "object"
+                        ? {
+                            ...selected,
+                            excludedKeys: [
+                                ...new Set([
+                                    ...(selected?.excludedKeys ?? []),
+                                    ...overwritten,
+                                ]),
+                            ].sort(compareUnicodeCodePoints),
+                        }
+                        : selected,
+                    ...remaining,
+                ],
+            });
+            if (selected !== null &&
+                typeof selected !== "object" &&
+                t.isObjectExpression(property.argument) &&
+                objectExpressionDefinesKey(property.argument, String(selected))) {
+                overwritten.add(String(selected));
+                dataOverwritten.add(String(selected));
+            }
+            continue;
+        }
+        const name = semanticStaticPropertyKey(property.key, property.computed);
+        const isGetter = t.isObjectMethod(property) && property.kind === "get";
+        const isSetter = t.isObjectMethod(property) && property.kind === "set";
+        if (name !== null &&
+            (isGetter || isSetter
+                ? dataOverwritten.has(name) ||
+                    (isGetter ? getterNames.has(name) : setterNames.has(name))
+                : dataOverwritten.has(name) || accessorNames.has(name)))
+            continue;
+        if (name === null || semanticPropertyPathKeyMatches(key ?? null, name)) {
+            if (t.isObjectMethod(property) && property.kind === "get") {
+                references.push(...getterResultReferences({ getter: property, owner: node }, remaining, state));
+            }
+            else if (t.isObjectMethod(property) && property.kind === "set") {
+                // A setter contributes no readable reference. A paired getter is
+                // handled independently when it appears earlier in this object.
+            }
+            else {
+                references.push({
+                    node: t.isObjectProperty(property) ? property.value : property,
+                    path: remaining,
+                });
+            }
+        }
+        if (name !== null) {
+            if (isGetter) {
+                getterNames.add(name);
+                accessorNames.add(name);
+                overwritten.add(name);
+            }
+            else if (isSetter) {
+                setterNames.add(name);
+                accessorNames.add(name);
+                overwritten.add(name);
+            }
+            else if (!(t.isObjectProperty(property) &&
+                !property.computed &&
+                !property.shorthand &&
+                name === "__proto__")) {
+                overwritten.add(name);
+                dataOverwritten.add(name);
+            }
+        }
+    }
+    return references;
+};
+const objectExpressionDefinesKey = (root, key) => {
+    const pending = [root];
+    const seen = new Set();
+    for (let cursor = 0; cursor < pending.length; cursor++) {
+        const object = pending[cursor];
+        if (object === undefined || seen.has(object))
+            continue;
+        seen.add(object);
+        for (const property of object.properties) {
+            if (t.isSpreadElement(property)) {
+                if (t.isObjectExpression(property.argument))
+                    pending.push(property.argument);
+                continue;
+            }
+            const name = semanticStaticPropertyKey(property.key, property.computed);
+            if (name === key &&
+                !(t.isObjectProperty(property) &&
+                    !property.computed &&
+                    !property.shorthand &&
+                    name === "__proto__"))
+                return true;
+        }
+    }
+    return false;
+};

package/dist/domain/javascript/javascriptSemanticObjects.js

@@ -109,7 +109,13 @@ const collectDestructuring = (node, ownerCallableId, state, output) => {
 };
 const addObjectOperation = (input, state, output) => {
     output.push({
-        objectOperationId: `object:${input.kind}:${String(input.node.start ?? -1)}:${String(input.node.end ?? -1)}`,
+        // These high-volume IDs must not retain intermediate concatenations.
+        objectOperationId: [
+            "object",
+            input.kind,
+            String(input.node.start ?? -1),
+            String(input.node.end ?? -1),
+        ].join(":"),
         kind: input.kind,
         location: range(input.node),
         ownerCallableId: input.ownerCallableId,

package/dist/domain/javascript/javascriptSemanticProjection.js

@@ -2,7 +2,7 @@ import * as t from "@babel/types";
 import { resolveSemanticBindingState, semanticResolutionBlocked, isUnshadowedGlobal, } from "./javascriptSemanticState.js";
 import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
 import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
-import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { completeSemanticSteps, traverseJavaScriptAstSteps, } from "./javascriptSemanticTraversal.js";
 import { evaluateSemanticBinding, evaluateSemanticProvenance, } from "./javascriptSemanticValues.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 import { propertyName, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
@@ -62,11 +62,13 @@ export const collectSemanticModuleLink = (node, state) => {
         collectCommonJsExport(node, state);
 };
 /** Collect lexical references after definitions exist, optionally for one name. */
-export const collectSemanticReferences = (program, state, name) => {
+export const collectSemanticReferences = (program, state, name) => completeSemanticSteps(collectSemanticReferencesSteps(program, state, name));
+/** Collect lexical references in steps while preserving resolution and visit order. */
+export function* collectSemanticReferencesSteps(program, state, name) {
     const output = [];
     const seen = new Set();
     const patterns = [];
-    traverseJavaScriptAst(program, {
+    yield* traverseJavaScriptAstSteps(program, {
         enter: (node, parent, readAncestors) => {
             if (isPatternNode(node))
                 patterns.push(node);
@@ -111,7 +113,7 @@ export const collectSemanticReferences = (program, state, name) => {
         },
     });
     return output;
-};
+}
 /** Freeze collected scopes into deterministic IR order. */
 export const immutableSemanticScopes = (state) => state.scopes.map((scope) => ({
     scopeId: scope.scopeId,
@@ -258,17 +260,54 @@ const collectCommonJsExport = (node, state) => {
     const exportedName = commonJsExportName(node.left, state);
     if (exportedName === undefined)
         return;
-    const origin = semanticRequireOrigin(node.right, state);
+    const receiverEffect = isCommonJsModuleExports(node.left, state)
+        ? null
+        : commonJsExportReceiverEffect(node.right, state);
+    if (receiverEffect === "detached")
+        return;
+    // Simple assignment chains yield their rightmost assigned value. Compound
+    // and logical writes also depend on the previous value, so remain unknown.
+    let value = node.operator === "=" && receiverEffect !== "uncertain" ? node.right : null;
+    while (t.isAssignmentExpression(value, { operator: "=" }))
+        value = value.right;
+    const origin = value === null ? undefined : semanticRequireOrigin(value, state);
     addModuleLink(state, {
         kind: "commonjs-export",
         specifier: origin?.specifier ?? null,
         importedName: origin?.importedPath.at(-1) ?? null,
-        localName: t.isIdentifier(node.right) ? node.right.name : null,
+        localName: value !== null && t.isIdentifier(value) ? value.name : null,
         exportedName,
-        callableId: semanticCallableIdForNode(node.right),
+        callableId: value === null ? null : semanticCallableIdForNode(value),
         location: range(node),
     }, node);
 };
+/**
+ * An outer property assignment captures its receiver before evaluating the
+ * RHS. When that chain assigns a freshly created identity to `module.exports`,
+ * the outer write targets the old exports object and cannot define an export
+ * on the value ultimately returned by the CommonJS module. Reassignments from
+ * existing bindings may preserve identity, so this guard leaves them as
+ * export candidates.
+ */
+const commonJsExportReceiverEffect = (node, state) => {
+    let value = node;
+    while (t.isAssignmentExpression(value, { operator: "=" })) {
+        if (isCommonJsModuleExports(value.left, state))
+            return isFreshAssignmentResult(value.right) ? "detached" : "uncertain";
+        value = value.right;
+    }
+    return null;
+};
+const isFreshAssignmentResult = (node) => {
+    let value = node;
+    while (t.isAssignmentExpression(value, { operator: "=" }))
+        value = value.right;
+    return (t.isArrowFunctionExpression(value) ||
+        t.isFunctionExpression(value) ||
+        t.isClassExpression(value) ||
+        t.isObjectExpression(value) ||
+        t.isArrayExpression(value));
+};
 const addModuleLink = (state, link, referenceNode) => {
     const collected = { ...link, callableId: link.callableId ?? null };
     state.moduleLinks.push(collected);
@@ -457,8 +496,7 @@ const defaultDeclarationName = (declaration) => (t.isFunctionDeclaration(declara
     ? declaration.id.name
     : null;
 const commonJsExportName = (node, state) => {
-    if (isUnshadowedGlobal(node, state, "exports"))
-        return "default";
+    // Rebinding the CommonJS `exports` alias does not replace `module.exports`.
     if (!t.isMemberExpression(node) && !t.isOptionalMemberExpression(node))
         return undefined;
     const key = semanticStaticPropertyKey(node.property, node.computed);
@@ -468,12 +506,12 @@ const commonJsExportName = (node, state) => {
     if (isUnshadowedGlobal(node.object, state, "exports"))
         return key === null ? "*" : key || "*";
     if (t.isMemberExpression(node.object) &&
-        isUnshadowedGlobal(node.object.object, state, "module") &&
-        semanticStaticPropertyKey(node.object.property, node.object.computed) ===
-            "exports")
+        isCommonJsModuleExports(node.object, state))
         return key === null ? "*" : key || "default";
-    if (isUnshadowedGlobal(node.object, state, "module") &&
-        semanticStaticPropertyKey(node.property, node.computed) === "exports")
+    if (isCommonJsModuleExports(node, state))
         return "default";
     return undefined;
 };
+const isCommonJsModuleExports = (node, state) => (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) &&
+    isUnshadowedGlobal(node.object, state, "module") &&
+    semanticStaticPropertyKey(node.property, node.computed) === "exports";