@mintlify/common 1.0.1269 → 1.0.1271

package/dist/mdx/estreeReferences.js

@@ -0,0 +1,963 @@
+import { isObject } from '../types/guards.js';
+export const NON_CODE_KEYS = new Set([
+    'loc',
+    'range',
+    'start',
+    'end',
+    'comments',
+    'leadingComments',
+    'trailingComments',
+]);
+const FUNCTION_NODE_TYPES = new Set([
+    'ArrowFunctionExpression',
+    'FunctionExpression',
+    'FunctionDeclaration',
+]);
+/** Collects the names a binding pattern declares (untyped estree records). */
+export function collectPatternNames(pattern, names) {
+    if (!isObject(pattern))
+        return;
+    const type = pattern.type;
+    if (type === 'Identifier') {
+        if (typeof pattern.name === 'string')
+            names.add(pattern.name);
+        return;
+    }
+    if (type === 'AssignmentPattern') {
+        collectPatternNames(pattern.left, names);
+        return;
+    }
+    if (type === 'RestElement') {
+        collectPatternNames(pattern.argument, names);
+        return;
+    }
+    if (type === 'ObjectPattern' && Array.isArray(pattern.properties)) {
+        for (const property of pattern.properties) {
+            if (!isObject(property))
+                continue;
+            if (property.type === 'RestElement')
+                collectPatternNames(property.argument, names);
+            else if (property.type === 'Property')
+                collectPatternNames(property.value, names);
+        }
+        return;
+    }
+    if (type === 'ArrayPattern' && Array.isArray(pattern.elements)) {
+        for (const element of pattern.elements)
+            collectPatternNames(element, names);
+    }
+}
+export function forEachCodeChild(node, callback) {
+    for (const [key, child] of Object.entries(node)) {
+        if (!NON_CODE_KEYS.has(key))
+            callback(child);
+    }
+}
+/** `var` declarations hoist to the enclosing function, so they shadow its whole body. */
+function collectVarNames(node, names) {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            collectVarNames(child, names);
+        return;
+    }
+    if (!isObject(node) || typeof node.type !== 'string')
+        return;
+    if (FUNCTION_NODE_TYPES.has(node.type) || node.type === 'ClassBody')
+        return;
+    if (node.type === 'VariableDeclaration' && node.kind === 'var') {
+        const declarations = Array.isArray(node.declarations) ? node.declarations : [];
+        for (const declarator of declarations) {
+            if (isObject(declarator))
+                collectPatternNames(declarator.id, names);
+        }
+    }
+    forEachCodeChild(node, (child) => collectVarNames(child, names));
+}
+/** Block-scoped declarations made directly in a statement list. */
+function collectLexicalNames(statements) {
+    const names = new Set();
+    for (const statement of statements) {
+        if (!isObject(statement))
+            continue;
+        if (statement.type === 'VariableDeclaration' && statement.kind !== 'var') {
+            const declarations = Array.isArray(statement.declarations) ? statement.declarations : [];
+            for (const declarator of declarations) {
+                if (isObject(declarator))
+                    collectPatternNames(declarator.id, names);
+            }
+        }
+        else if ((statement.type === 'FunctionDeclaration' || statement.type === 'ClassDeclaration') &&
+            isObject(statement.id) &&
+            typeof statement.id.name === 'string') {
+            names.add(statement.id.name);
+        }
+    }
+    return names;
+}
+function withNames(shadowed, names) {
+    const next = new Set(shadowed);
+    for (const name of names)
+        next.add(name);
+    return next;
+}
+function isJsxComponentName(name) {
+    return typeof name === 'string' && !/^[a-z]/.test(name) && !name.includes('-');
+}
+const MUTATING_METHODS = new Set([
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
+    'fill',
+    'copyWithin',
+    'set',
+    'add',
+    'delete',
+    'clear',
+    // Inherited by every object from `Object.prototype`
+    '__defineGetter__',
+    '__defineSetter__',
+]);
+const OBJECT_MUTATING_STATICS = new Set([
+    'assign',
+    'defineProperty',
+    'defineProperties',
+    'setPrototypeOf',
+]);
+const MUTATING_STATICS = new Map([
+    ['Object', OBJECT_MUTATING_STATICS],
+    ['Reflect', new Set(['set', 'defineProperty', 'deleteProperty', 'setPrototypeOf'])],
+]);
+/**
+ * Property names that reach `Object` or its mutating statics from any plain value, since every
+ * value's `constructor` chain leads to `Object` (or to `Function`, which compiles code).
+ */
+function isObjectReachingName(name) {
+    return name === 'constructor' || OBJECT_MUTATING_STATICS.has(name);
+}
+function propertyName(member) {
+    const property = member.property;
+    if (!isObject(property))
+        return undefined;
+    if (member.computed !== true && typeof property.name === 'string')
+        return property.name;
+    return property.type === 'Literal' && typeof property.value === 'string'
+        ? property.value
+        : undefined;
+}
+const GLOBAL_OBJECT_NAMES = new Set(['globalThis', 'window', 'self', 'global']);
+// Globals that change objects or run code without a traceable write, and the global object names
+// that expose them as properties
+const UNSAFE_GLOBAL_NAMES = new Set([
+    'Object',
+    'Reflect',
+    'Function',
+    'eval',
+    ...GLOBAL_OBJECT_NAMES,
+]);
+// Global object identifiers read through a static key that is not unsafe, such as
+// `window.location`. Any other use (aliases, computed keys, `window.Object`) can reach an unsafe
+// global without naming it.
+const SAFE_GLOBAL_OWNERS = new WeakSet();
+function hasDynamicKey(node, key) {
+    const literalKey = isObject(key) &&
+        key.type === 'Literal' &&
+        (typeof key.value === 'string' || typeof key.value === 'number');
+    return node.computed === true && !literalKey;
+}
+/**
+ * A call through a computed key that is not a literal, such as `value[key].assign(...)`, can reach
+ * `constructor` and from there `Object.assign`, so the key cannot be ruled out statically.
+ */
+function calleeHasDynamicKey(callee) {
+    let current = unwrapExpression(callee);
+    while (isObject(current) && current.type === 'MemberExpression') {
+        if (hasDynamicKey(current, current.property))
+            return true;
+        current = unwrapExpression(current.object);
+    }
+    return false;
+}
+/**
+ * A pattern key that may pull `constructor`, a mutating `Object` static, or an unsafe global such
+ * as `Function` out of a value.
+ */
+function visitPatternKeys(pattern, visit) {
+    var _a;
+    if (!isObject(pattern))
+        return;
+    switch (pattern.type) {
+        case 'AssignmentPattern':
+            visitPatternKeys(pattern.left, visit);
+            return;
+        case 'RestElement':
+            visitPatternKeys(pattern.argument, visit);
+            return;
+        case 'ArrayPattern':
+            if (Array.isArray(pattern.elements)) {
+                for (const element of pattern.elements)
+                    visitPatternKeys(element, visit);
+            }
+            return;
+        case 'ObjectPattern': {
+            const properties = Array.isArray(pattern.properties) ? pattern.properties : [];
+            for (const property of properties) {
+                if (!isObject(property))
+                    continue;
+                if (property.type === 'RestElement') {
+                    visitPatternKeys(property.argument, visit);
+                    continue;
+                }
+                const key = property.key;
+                const name = property.computed !== true && isObject(key) && typeof key.name === 'string'
+                    ? key.name
+                    : isObject(key) && key.type === 'Literal'
+                        ? String(key.value)
+                        : undefined;
+                if (hasDynamicKey(property, key) ||
+                    (name !== undefined && (isObjectReachingName(name) || UNSAFE_GLOBAL_NAMES.has(name)))) {
+                    (_a = visit.unknownWrite) === null || _a === void 0 ? void 0 : _a.call(visit);
+                }
+                visitPatternKeys(property.value, visit);
+            }
+            return;
+        }
+        default:
+            return;
+    }
+}
+// `Object` and `Reflect` identifiers used as `Object.method(...)` with a static method name. Any
+// other use (aliases, destructuring, `.call`, computed names) can reach a mutating static.
+const DIRECT_STATIC_OWNERS = new WeakSet();
+function markDirectStaticCall(call) {
+    const callee = call.callee;
+    if (!isObject(callee) || callee.type !== 'MemberExpression')
+        return;
+    const owner = callee.object;
+    if (propertyName(callee) !== undefined &&
+        isObject(owner) &&
+        owner.type === 'Identifier' &&
+        typeof owner.name === 'string' &&
+        MUTATING_STATICS.has(owner.name)) {
+        DIRECT_STATIC_OWNERS.add(owner);
+    }
+}
+/** The object a call changes in place, if the callee is a known mutating method. */
+function mutatedByCall(call) {
+    const callee = call.callee;
+    if (!isObject(callee) || callee.type !== 'MemberExpression')
+        return undefined;
+    const method = propertyName(callee);
+    if (method === undefined)
+        return undefined;
+    const owner = callee.object;
+    if (isObject(owner) && owner.type === 'Identifier' && typeof owner.name === 'string') {
+        const statics = MUTATING_STATICS.get(owner.name);
+        if (statics !== undefined) {
+            return statics.has(method) && Array.isArray(call.arguments) ? call.arguments[0] : undefined;
+        }
+    }
+    return MUTATING_METHODS.has(method) ? owner : undefined;
+}
+function visitIdentifier(identifier, shadowed, visit) {
+    var _a;
+    if (isObject(identifier) &&
+        typeof identifier.name === 'string' &&
+        !shadowed.has(identifier.name)) {
+        if (identifier.name === 'eval' ||
+            identifier.name === 'Function' ||
+            (GLOBAL_OBJECT_NAMES.has(identifier.name) && !SAFE_GLOBAL_OWNERS.has(identifier)) ||
+            (MUTATING_STATICS.has(identifier.name) && !DIRECT_STATIC_OWNERS.has(identifier))) {
+            (_a = visit.unknownWrite) === null || _a === void 0 ? void 0 : _a.call(visit);
+        }
+        visit.reference(identifier);
+    }
+}
+/** References made by a binding pattern: destructuring defaults and computed keys. */
+function visitPatternReferences(pattern, shadowed, visit) {
+    if (!isObject(pattern))
+        return;
+    switch (pattern.type) {
+        case 'AssignmentPattern':
+            visitPatternReferences(pattern.left, shadowed, visit);
+            visitReferences(pattern.right, shadowed, visit);
+            return;
+        case 'RestElement':
+            visitPatternReferences(pattern.argument, shadowed, visit);
+            return;
+        case 'ObjectPattern': {
+            const properties = Array.isArray(pattern.properties) ? pattern.properties : [];
+            for (const property of properties) {
+                if (!isObject(property))
+                    continue;
+                if (property.type === 'RestElement') {
+                    visitPatternReferences(property.argument, shadowed, visit);
+                    continue;
+                }
+                if (property.computed === true)
+                    visitReferences(property.key, shadowed, visit);
+                visitPatternReferences(property.value, shadowed, visit);
+            }
+            return;
+        }
+        case 'ArrayPattern': {
+            const elements = Array.isArray(pattern.elements) ? pattern.elements : [];
+            for (const element of elements)
+                visitPatternReferences(element, shadowed, visit);
+            return;
+        }
+        case 'MemberExpression':
+            visitReferences(pattern, shadowed, visit);
+            return;
+        default:
+            return;
+    }
+}
+/**
+ * Visits every identifier that refers to a module-level binding: function, block, catch, and
+ * loop bindings shadow their scopes, and property keys and intrinsic JSX tags are not references.
+ */
+export function visitReferences(node, shadowed, visit) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    if (Array.isArray(node)) {
+        for (const child of node)
+            visitReferences(child, shadowed, visit);
+        return;
+    }
+    if (!isObject(node) || typeof node.type !== 'string')
+        return;
+    const type = node.type;
+    if (FUNCTION_NODE_TYPES.has(type)) {
+        if (visit.eagerOnly === true)
+            return;
+        const params = Array.isArray(node.params) ? node.params : [];
+        const paramNames = new Set();
+        for (const param of params)
+            collectPatternNames(param, paramNames);
+        if (type === 'FunctionExpression' && isObject(node.id) && typeof node.id.name === 'string') {
+            paramNames.add(node.id.name);
+        }
+        // Parameter defaults see the parameters and the outer scope, never the body's declarations
+        const paramScope = withNames(shadowed, paramNames);
+        for (const param of params) {
+            visitPatternKeys(param, visit);
+            visitPatternReferences(param, paramScope, visit);
+        }
+        const bodyNames = new Set();
+        collectVarNames(node.body, bodyNames);
+        const body = node.body;
+        const blockBody = isObject(body) && Array.isArray(body.body) ? body.body : undefined;
+        if (blockBody !== undefined) {
+            for (const name of collectLexicalNames(blockBody))
+                bodyNames.add(name);
+        }
+        visitReferences(blockBody !== null && blockBody !== void 0 ? blockBody : body, withNames(paramScope, bodyNames), visit);
+        return;
+    }
+    switch (type) {
+        case 'Identifier':
+            visitIdentifier(node, shadowed, visit);
+            return;
+        case 'AssignmentExpression':
+            (_a = visit.write) === null || _a === void 0 ? void 0 : _a.call(visit, node.left, shadowed);
+            visitPatternKeys(node.left, visit);
+            visitReferences(node.left, shadowed, visit);
+            visitReferences(node.right, shadowed, visit);
+            return;
+        case 'UpdateExpression':
+            (_b = visit.write) === null || _b === void 0 ? void 0 : _b.call(visit, node.argument, shadowed);
+            visitReferences(node.argument, shadowed, visit);
+            return;
+        case 'UnaryExpression':
+            if (node.operator === 'delete') {
+                const deleted = unwrapExpression(node.argument);
+                if (isObject(deleted) && deleted.type === 'MemberExpression') {
+                    (_c = visit.mutate) === null || _c === void 0 ? void 0 : _c.call(visit, deleted.object, shadowed);
+                }
+            }
+            visitReferences(node.argument, shadowed, visit);
+            return;
+        case 'CallExpression': {
+            const mutated = mutatedByCall(node);
+            if (mutated !== undefined)
+                (_d = visit.mutate) === null || _d === void 0 ? void 0 : _d.call(visit, mutated, shadowed);
+            if (calleeHasDynamicKey(node.callee))
+                (_e = visit.unknownWrite) === null || _e === void 0 ? void 0 : _e.call(visit);
+            markDirectStaticCall(node);
+            forEachCodeChild(node, (child) => visitReferences(child, shadowed, visit));
+            return;
+        }
+        case 'NewExpression':
+        case 'TaggedTemplateExpression':
+            if (calleeHasDynamicKey(type === 'NewExpression' ? node.callee : node.tag)) {
+                (_f = visit.unknownWrite) === null || _f === void 0 ? void 0 : _f.call(visit);
+            }
+            forEachCodeChild(node, (child) => visitReferences(child, shadowed, visit));
+            return;
+        case 'ClassDeclaration':
+        case 'ClassExpression': {
+            visitReferences(node.superClass, shadowed, visit);
+            const ownName = type === 'ClassExpression' && isObject(node.id) && typeof node.id.name === 'string'
+                ? [node.id.name]
+                : [];
+            visitReferences(node.body, withNames(shadowed, ownName), visit);
+            return;
+        }
+        case 'BlockStatement':
+        case 'StaticBlock': {
+            const body = Array.isArray(node.body) ? node.body : [];
+            visitReferences(body, withNames(shadowed, collectLexicalNames(body)), visit);
+            return;
+        }
+        case 'SwitchStatement': {
+            visitReferences(node.discriminant, shadowed, visit);
+            const cases = Array.isArray(node.cases) ? node.cases : [];
+            const statements = cases.flatMap((switchCase) => isObject(switchCase) && Array.isArray(switchCase.consequent) ? switchCase.consequent : []);
+            visitReferences(cases, withNames(shadowed, collectLexicalNames(statements)), visit);
+            return;
+        }
+        case 'ForStatement': {
+            const inner = withNames(shadowed, collectLexicalNames([node.init]));
+            forEachCodeChild(node, (child) => visitReferences(child, inner, visit));
+            return;
+        }
+        case 'ForInStatement':
+        case 'ForOfStatement': {
+            const left = node.left;
+            const inner = withNames(shadowed, collectLexicalNames([left]));
+            // The iterable is evaluated before the loop bindings exist
+            visitReferences(node.right, shadowed, visit);
+            if (isObject(left) && left.type === 'VariableDeclaration') {
+                visitReferences(left, inner, visit);
+            }
+            else {
+                (_g = visit.write) === null || _g === void 0 ? void 0 : _g.call(visit, left, shadowed);
+                visitPatternKeys(left, visit);
+                visitReferences(left, shadowed, visit);
+            }
+            visitReferences(node.body, inner, visit);
+            return;
+        }
+        case 'CatchClause': {
+            const names = new Set();
+            collectPatternNames(node.param, names);
+            const inner = withNames(shadowed, names);
+            visitPatternKeys(node.param, visit);
+            visitPatternReferences(node.param, inner, visit);
+            visitReferences(node.body, inner, visit);
+            return;
+        }
+        case 'VariableDeclarator':
+            visitPatternKeys(node.id, visit);
+            visitPatternReferences(node.id, shadowed, visit);
+            visitReferences(node.init, shadowed, visit);
+            return;
+        case 'MemberExpression': {
+            // `value.constructor` reaches `Object` from any plain object, and its mutating statics can
+            // be read off whatever that was stored in. Direct `Object.assign(...)` calls are tracked.
+            const name = propertyName(node);
+            const owner = node.object;
+            const isDirectStatic = isObject(owner) &&
+                owner.type === 'Identifier' &&
+                typeof owner.name === 'string' &&
+                MUTATING_STATICS.has(owner.name);
+            if (name !== undefined && isObjectReachingName(name) && !isDirectStatic) {
+                (_h = visit.unknownWrite) === null || _h === void 0 ? void 0 : _h.call(visit);
+            }
+            if (name !== undefined && UNSAFE_GLOBAL_NAMES.has(name))
+                (_j = visit.unknownWrite) === null || _j === void 0 ? void 0 : _j.call(visit);
+            if (name !== undefined &&
+                !isObjectReachingName(name) &&
+                isObject(owner) &&
+                owner.type === 'Identifier' &&
+                typeof owner.name === 'string' &&
+                GLOBAL_OBJECT_NAMES.has(owner.name)) {
+                SAFE_GLOBAL_OWNERS.add(owner);
+            }
+            visitReferences(node.object, shadowed, visit);
+            if (node.computed === true)
+                visitReferences(node.property, shadowed, visit);
+            return;
+        }
+        case 'Property':
+        case 'PropertyDefinition':
+        case 'MethodDefinition':
+            if (node.computed === true)
+                visitReferences(node.key, shadowed, visit);
+            // Instance field initializers run per construction, not when the class is defined
+            if (visit.eagerOnly === true && type === 'PropertyDefinition' && node.static !== true)
+                return;
+            visitReferences(node.value, shadowed, visit);
+            return;
+        case 'LabeledStatement':
+            visitReferences(node.body, shadowed, visit);
+            return;
+        case 'WithStatement':
+            (_k = visit.unknownWrite) === null || _k === void 0 ? void 0 : _k.call(visit);
+            visitReferences(node.object, shadowed, visit);
+            visitReferences(node.body, shadowed, visit);
+            return;
+        case 'JSXOpeningElement':
+        case 'JSXClosingElement': {
+            const name = node.name;
+            if (isObject(name) && name.type === 'JSXIdentifier' && isJsxComponentName(name.name)) {
+                visitIdentifier(name, shadowed, visit);
+            }
+            else if (isObject(name) && name.type === 'JSXMemberExpression') {
+                visitReferences(name, shadowed, visit);
+            }
+            visitReferences(node.attributes, shadowed, visit);
+            return;
+        }
+        case 'JSXMemberExpression': {
+            const object = node.object;
+            if (isObject(object) && object.type === 'JSXIdentifier')
+                visitIdentifier(object, shadowed, visit);
+            else
+                visitReferences(object, shadowed, visit);
+            return;
+        }
+        case 'JSXAttribute':
+            visitReferences(node.value, shadowed, visit);
+            return;
+        case 'BreakStatement':
+        case 'ContinueStatement':
+        case 'MetaProperty':
+        case 'JSXIdentifier':
+        case 'JSXNamespacedName':
+            return;
+        default:
+            forEachCodeChild(node, (child) => visitReferences(child, shadowed, visit));
+    }
+}
+export function collectFreeReferences(node, eagerOnly = false) {
+    const references = new Set();
+    visitReferences(node, new Set(), {
+        reference: (identifier) => {
+            if (typeof identifier.name === 'string')
+                references.add(identifier.name);
+        },
+        eagerOnly,
+    });
+    return references;
+}
+/** Marks a write through an object that cannot be traced to particular module bindings. */
+export const UNKNOWN_WRITE_TARGET = '*';
+const WRAPPER_NODE_TYPES = new Set([
+    'ParenthesizedExpression',
+    'TSAsExpression',
+    'TSSatisfiesExpression',
+    'TSNonNullExpression',
+    'TSTypeAssertion',
+    'ChainExpression',
+]);
+/** A static property or index name, when the key cannot change at runtime. */
+function staticMemberKey(member) {
+    const property = member.property;
+    if (!isObject(property))
+        return undefined;
+    if (member.computed !== true)
+        return typeof property.name === 'string' ? property.name : undefined;
+    if (property.type === 'Literal' &&
+        (typeof property.value === 'string' || typeof property.value === 'number')) {
+        return String(property.value);
+    }
+    return undefined;
+}
+function propertyKeyName(property) {
+    if (property.computed === true) {
+        const key = property.key;
+        if (isObject(key) &&
+            key.type === 'Literal' &&
+            (typeof key.value === 'string' || typeof key.value === 'number')) {
+            return String(key.value);
+        }
+        return undefined;
+    }
+    const key = property.key;
+    if (isObject(key) && typeof key.name === 'string')
+        return key.name;
+    if (isObject(key) && key.type === 'Literal' && typeof key.value === 'string')
+        return key.value;
+    return undefined;
+}
+/**
+ * The value a member chain reads out of a fresh object or array. A spread or a key that is not
+ * static can hide a shared object, which the caller treats as an unknown write. A missing
+ * property is a write on the fresh wrapper itself.
+ */
+function readFreshMember(wrapper, member) {
+    const key = staticMemberKey(member);
+    if (key === undefined)
+        return 'unknown';
+    const node = unwrapExpression(wrapper);
+    if (!isObject(node))
+        return 'unknown';
+    if (node.type === 'ObjectExpression') {
+        const properties = Array.isArray(node.properties) ? node.properties : [];
+        let found = 'contained';
+        for (const property of properties) {
+            if (!isObject(property))
+                continue;
+            if (property.type === 'SpreadElement') {
+                found = 'unknown';
+                continue;
+            }
+            if (property.type !== 'Property')
+                continue;
+            const name = propertyKeyName(property);
+            if (name === undefined) {
+                found = 'unknown';
+                continue;
+            }
+            if (name === key)
+                found = property.value;
+        }
+        return found;
+    }
+    if (node.type === 'ArrayExpression') {
+        if (!/^\d+$/.test(key))
+            return 'contained';
+        const index = Number(key);
+        const elements = Array.isArray(node.elements) ? node.elements : [];
+        let cursor = 0;
+        for (const element of elements) {
+            if (isObject(element) && element.type === 'SpreadElement')
+                return 'unknown';
+            if (cursor === index)
+                return element !== null && element !== void 0 ? element : 'contained';
+            cursor += 1;
+        }
+        return 'contained';
+    }
+    return 'unknown';
+}
+/** The expression inside parentheses and type assertions, which do not change what is written. */
+function unwrapExpression(node) {
+    let current = node;
+    while (isObject(current) &&
+        typeof current.type === 'string' &&
+        WRAPPER_NODE_TYPES.has(current.type)) {
+        current = current.expression;
+    }
+    return current;
+}
+/** Names bound without an initializer: parameters, loop variables, and catch bindings. */
+function collectUntraceableBindingNames(node, names) {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            collectUntraceableBindingNames(child, names);
+        return;
+    }
+    if (!isObject(node) || typeof node.type !== 'string')
+        return;
+    if (FUNCTION_NODE_TYPES.has(node.type) && Array.isArray(node.params)) {
+        for (const param of node.params)
+            collectPatternNames(param, names);
+    }
+    if (node.type === 'CatchClause')
+        collectPatternNames(node.param, names);
+    if (node.type === 'VariableDeclarator' && node.init == null)
+        collectPatternNames(node.id, names);
+    if ((node.type === 'ForOfStatement' || node.type === 'ForInStatement') && isObject(node.left)) {
+        const left = node.left;
+        if (left.type === 'VariableDeclaration' && Array.isArray(left.declarations)) {
+            for (const declarator of left.declarations) {
+                if (isObject(declarator))
+                    collectPatternNames(declarator.id, names);
+            }
+        }
+    }
+    forEachCodeChild(node, (child) => collectUntraceableBindingNames(child, names));
+}
+/** Every declared local name mapped to the names its initializer references. */
+function collectLocalInitializers(node, initializers) {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            collectLocalInitializers(child, initializers);
+        return;
+    }
+    if (!isObject(node))
+        return;
+    const addSources = (target, value) => {
+        var _a;
+        const names = new Set();
+        collectPatternNames(target, names);
+        const references = collectFreeReferences(value);
+        for (const name of names) {
+            const existing = (_a = initializers.get(name)) !== null && _a !== void 0 ? _a : new Set();
+            for (const reference of references)
+                existing.add(reference);
+            initializers.set(name, existing);
+        }
+    };
+    if (node.type === 'VariableDeclarator')
+        addSources(node.id, node.init);
+    // A later assignment can make a local alias a module object too
+    if (node.type === 'AssignmentExpression')
+        addSources(unwrapExpression(node.left), node.right);
+    forEachCodeChild(node, (child) => collectLocalInitializers(child, initializers));
+}
+const CALL_NODE_TYPES = new Set(['CallExpression', 'NewExpression', 'TaggedTemplateExpression']);
+/**
+ * Whether `node` may evaluate to a value read through a computed key that is not a literal, or to
+ * a value derived from one: a tainted name, a member of one, or a wrapper holding one.
+ */
+function mayBeTainted(node, tainted) {
+    const value = unwrapExpression(node);
+    if (!isObject(value))
+        return false;
+    switch (value.type) {
+        case 'Identifier':
+            return typeof value.name === 'string' && tainted.has(value.name);
+        case 'MemberExpression':
+            return hasDynamicKey(value, value.property) || mayBeTainted(value.object, tainted);
+        case 'LogicalExpression':
+            return mayBeTainted(value.left, tainted) || mayBeTainted(value.right, tainted);
+        case 'ConditionalExpression':
+            return mayBeTainted(value.consequent, tainted) || mayBeTainted(value.alternate, tainted);
+        case 'SequenceExpression': {
+            const expressions = Array.isArray(value.expressions) ? value.expressions : [];
+            return mayBeTainted(expressions[expressions.length - 1], tainted);
+        }
+        case 'AwaitExpression':
+        case 'SpreadElement':
+            return mayBeTainted(value.argument, tainted);
+        case 'ArrayExpression':
+            return Array.isArray(value.elements)
+                ? value.elements.some((element) => mayBeTainted(element, tainted))
+                : false;
+        case 'ObjectExpression':
+            return Array.isArray(value.properties)
+                ? value.properties.some((property) => isObject(property) &&
+                    mayBeTainted(property.type === 'SpreadElement' ? property : property.value, tainted))
+                : false;
+        default:
+            return false;
+    }
+}
+/** Adds the names bound from a tainted value, such as `const C = value[key]` or `const D = C`. */
+function collectTaintedNames(node, tainted) {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            collectTaintedNames(child, tainted);
+        return;
+    }
+    if (!isObject(node))
+        return;
+    if (node.type === 'VariableDeclarator' && mayBeTainted(node.init, tainted)) {
+        collectPatternNames(node.id, tainted);
+    }
+    if (node.type === 'AssignmentExpression' && mayBeTainted(node.right, tainted)) {
+        collectPatternNames(unwrapExpression(node.left), tainted);
+    }
+    forEachCodeChild(node, (child) => collectTaintedNames(child, tainted));
+}
+const REFLECT_INVOKERS = new Set(['apply', 'construct']);
+/**
+ * Whether `node` calls a tainted value: directly, through a member such as `.call` or `[0]`, or
+ * through `Reflect.apply`. Such a value may be `Function` or an `Object` static, either of which
+ * can change objects without a traceable write.
+ */
+function callsTainted(node, tainted, eagerOnly) {
+    var _a;
+    if (Array.isArray(node))
+        return node.some((child) => callsTainted(child, tainted, eagerOnly));
+    if (!isObject(node) || typeof node.type !== 'string')
+        return false;
+    if (eagerOnly && FUNCTION_NODE_TYPES.has(node.type))
+        return false;
+    if (CALL_NODE_TYPES.has(node.type)) {
+        const callee = node.type === 'TaggedTemplateExpression' ? node.tag : node.callee;
+        if (mayBeTainted(callee, tainted))
+            return true;
+        const member = unwrapExpression(callee);
+        const args = Array.isArray(node.arguments) ? node.arguments : [];
+        if (isObject(member) &&
+            member.type === 'MemberExpression' &&
+            isObject(member.object) &&
+            member.object.type === 'Identifier' &&
+            member.object.name === 'Reflect' &&
+            REFLECT_INVOKERS.has((_a = propertyName(member)) !== null && _a !== void 0 ? _a : '') &&
+            mayBeTainted(args[0], tainted)) {
+            return true;
+        }
+    }
+    let found = false;
+    forEachCodeChild(node, (child) => {
+        found || (found = callsTainted(child, tainted, eagerOnly));
+    });
+    return found;
+}
+/** Whether `node` calls anything while it runs, outside function bodies. */
+export function hasEagerCall(node) {
+    if (Array.isArray(node))
+        return node.some(hasEagerCall);
+    if (!isObject(node) || typeof node.type !== 'string')
+        return false;
+    if (FUNCTION_NODE_TYPES.has(node.type))
+        return false;
+    if (CALL_NODE_TYPES.has(node.type))
+        return true;
+    if (node.type === 'PropertyDefinition' && node.static !== true) {
+        return node.computed === true && hasEagerCall(node.key);
+    }
+    let found = false;
+    forEachCodeChild(node, (child) => {
+        found || (found = hasEagerCall(child));
+    });
+    return found;
+}
+/**
+ * Module-level names reassigned, and names whose objects are written through, in `node`. A write
+ * through a local counts as a write to every name the local's initializer references, since the
+ * local may alias that object; a local initialized from fresh values passes nothing on.
+ */
+export function collectModuleWrites(node, eagerOnly = false) {
+    const writes = { reassigned: new Set(), mutated: new Set() };
+    const initializers = new Map();
+    collectLocalInitializers(node, initializers);
+    // Initializers are tracked by name, so a name also bound without one can never be traced
+    const untraceable = new Set();
+    collectUntraceableBindingNames(node, untraceable);
+    const tainted = new Set();
+    let taintedCount = -1;
+    while (tainted.size !== taintedCount) {
+        taintedCount = tainted.size;
+        collectTaintedNames(node, tainted);
+    }
+    if (callsTainted(node, tainted, eagerOnly))
+        writes.mutated.add(UNKNOWN_WRITE_TARGET);
+    const markObject = (root, shadowed, seen) => {
+        if (!shadowed.has(root)) {
+            writes.mutated.add(root);
+            return;
+        }
+        if (seen.has(root))
+            return;
+        seen.add(root);
+        // Parameters, loop variables, and catch bindings may hold any module object
+        const sources = initializers.get(root);
+        if (sources === undefined || untraceable.has(root)) {
+            writes.mutated.add(UNKNOWN_WRITE_TARGET);
+            return;
+        }
+        for (const source of sources)
+            markObject(source, new Set(), seen);
+    };
+    const mutate = (object, shadowed) => {
+        const members = [];
+        let root = unwrapExpression(object);
+        while (isObject(root) && root.type === 'MemberExpression') {
+            members.push(root);
+            root = unwrapExpression(root.object);
+        }
+        if (!isObject(root))
+            return;
+        if (root.type === 'ObjectExpression' || root.type === 'ArrayExpression') {
+            // Members were collected outer-first; the one next to the literal is last
+            let current = root;
+            for (let index = members.length - 1; index >= 0; index -= 1) {
+                const member = members[index];
+                if (member === undefined)
+                    return;
+                const read = readFreshMember(current, member);
+                if (read === 'contained')
+                    return;
+                if (read === 'unknown') {
+                    writes.mutated.add(UNKNOWN_WRITE_TARGET);
+                    return;
+                }
+                current = read;
+                const next = unwrapExpression(current);
+                if (!isObject(next) ||
+                    (next.type !== 'ObjectExpression' && next.type !== 'ArrayExpression')) {
+                    mutate(current, shadowed);
+                    return;
+                }
+                current = next;
+            }
+            return;
+        }
+        switch (root.type) {
+            case 'Identifier':
+                if (typeof root.name === 'string')
+                    markObject(root.name, shadowed, new Set());
+                return;
+            case 'ConditionalExpression':
+                mutate(root.consequent, shadowed);
+                mutate(root.alternate, shadowed);
+                return;
+            case 'LogicalExpression':
+                mutate(root.left, shadowed);
+                mutate(root.right, shadowed);
+                return;
+            case 'SequenceExpression': {
+                const expressions = Array.isArray(root.expressions) ? root.expressions : [];
+                mutate(expressions[expressions.length - 1], shadowed);
+                return;
+            }
+            // Fresh values and instances cannot be module objects
+            case 'ThisExpression':
+            case 'ObjectExpression':
+            case 'ArrayExpression':
+            case 'NewExpression':
+            case 'Literal':
+            case 'TemplateLiteral':
+                return;
+            default:
+                writes.mutated.add(UNKNOWN_WRITE_TARGET);
+        }
+    };
+    const write = (written, shadowed) => {
+        const target = unwrapExpression(written);
+        if (!isObject(target))
+            return;
+        switch (target.type) {
+            case 'Identifier':
+                if (typeof target.name === 'string' && !shadowed.has(target.name)) {
+                    writes.reassigned.add(target.name);
+                }
+                return;
+            case 'MemberExpression':
+                mutate(target.object, shadowed);
+                return;
+            case 'AssignmentPattern':
+                write(target.left, shadowed);
+                return;
+            case 'RestElement':
+                write(target.argument, shadowed);
+                return;
+            case 'ObjectPattern': {
+                const properties = Array.isArray(target.properties) ? target.properties : [];
+                for (const property of properties) {
+                    if (!isObject(property))
+                        continue;
+                    write(property.type === 'RestElement' ? property.argument : property.value, shadowed);
+                }
+                return;
+            }
+            case 'ArrayPattern': {
+                const elements = Array.isArray(target.elements) ? target.elements : [];
+                for (const element of elements)
+                    write(element, shadowed);
+                return;
+            }
+            default:
+                return;
+        }
+    };
+    visitReferences(node, new Set(), {
+        reference: () => undefined,
+        write,
+        mutate,
+        unknownWrite: () => {
+            writes.mutated.add(UNKNOWN_WRITE_TARGET);
+        },
+        eagerOnly,
+    });
+    return writes;
+}