@mintlify/common 1.0.1268 → 1.0.1270

package/dist/mdx/plugins/remark/staticEvaluator.d.ts

@@ -0,0 +1,55 @@
+import type { Root } from 'mdast';
+export declare function nodeType(value: unknown): string | undefined;
+export type StaticValue = string | number | boolean | null | undefined | {
+    readonly [key: string]: StaticValue;
+} | readonly StaticValue[];
+export type StaticScope = Map<string, StaticValue>;
+export declare function isStaticObject(value: StaticValue): value is {
+    readonly [key: string]: StaticValue;
+};
+/**
+ * Caps a value's expanded size: its node count with shared references counted each time they
+ * appear, plus the length of every string and object key. Without it, `[a, a]` chains and string doubling stay
+ * cheap to evaluate but explode when serialized or inlined.
+ */
+export declare const MAX_STATIC_VALUE_WEIGHT = 100000;
+export declare function isNoOpSpreadValue(value: StaticValue): boolean;
+export declare function serializeStaticValue(value: StaticValue): string;
+export declare function identifierName(node: unknown): string | undefined;
+export type ComponentDef = {
+    params: unknown[];
+    body: unknown;
+};
+export type MarkdownComponentContext = {
+    defs: Map<string, ComponentDef>;
+    moduleScope: StaticScope;
+    /**
+     * Primitive `const` values built only from literals and other such values. No object is read to
+     * produce them, so no write the evaluator cannot see can make them stale.
+     */
+    literalScope: StaticScope;
+};
+export type EvalResult = {
+    ok: true;
+    value: StaticValue;
+} | {
+    ok: false;
+};
+export declare const EVAL_FAILED: EvalResult;
+export type EvalEnv = {
+    scope: StaticScope;
+    propsObjectName?: string;
+    failedProps?: ReadonlySet<string>;
+    restName?: string;
+    restFailedProps?: ReadonlySet<string>;
+};
+export declare function unbindPattern(pattern: unknown, env: EvalEnv): void;
+export declare function bindPattern(pattern: unknown, value: StaticValue, env: EvalEnv): void;
+export declare function evaluateStatic(node: unknown, env: EvalEnv): EvalResult;
+/**
+ * Collects a module's component definitions and its statically known values. Objects are only
+ * bound when the module never writes through any object: tracking which objects a write can reach
+ * is not worth the risk of publishing a stale value, while primitives are copied on read and stay
+ * known. A top-level write also invalidates the objects it may change for every later initializer.
+ */
+export declare function collectContextFromTree(tree: Root): MarkdownComponentContext;

package/dist/mdx/plugins/remark/staticEvaluator.js

@@ -0,0 +1,639 @@
+import { isObject } from '../../../types/guards.js';
+import { collectModuleWrites, collectPatternNames, hasEagerCall, } from '../../estreeReferences.js';
+export function nodeType(value) {
+    return isObject(value) && typeof value.type === 'string' ? value.type : undefined;
+}
+export function isStaticObject(value) {
+    return isObject(value);
+}
+/**
+ * Caps a value's expanded size: its node count with shared references counted each time they
+ * appear, plus the length of every string and object key. Without it, `[a, a]` chains and string doubling stay
+ * cheap to evaluate but explode when serialized or inlined.
+ */
+export const MAX_STATIC_VALUE_WEIGHT = 100000;
+const weights = new WeakMap();
+function weightOf(value) {
+    if (typeof value === 'string')
+        return 1 + value.length;
+    if (typeof value !== 'object' || value === null)
+        return 1;
+    const cached = weights.get(value);
+    if (cached !== undefined)
+        return cached;
+    let total = 1;
+    if (Array.isArray(value)) {
+        for (const child of value) {
+            total += weightOf(child);
+            if (total > MAX_STATIC_VALUE_WEIGHT)
+                break;
+        }
+    }
+    else {
+        for (const [key, child] of Object.entries(value)) {
+            total += key.length + weightOf(child);
+            if (total > MAX_STATIC_VALUE_WEIGHT)
+                break;
+        }
+    }
+    weights.set(value, total);
+    return total;
+}
+function withinBudget(value) {
+    return weightOf(value) > MAX_STATIC_VALUE_WEIGHT ? EVAL_FAILED : { ok: true, value };
+}
+export function isNoOpSpreadValue(value) {
+    return (value === null || value === undefined || typeof value === 'boolean' || typeof value === 'number');
+}
+// Self-contained literals: `Infinity` and `NaN` are shadowable identifiers, not keywords.
+function serializeNumber(value) {
+    if (Object.is(value, -0))
+        return '-0';
+    if (Number.isNaN(value))
+        return '0/0';
+    if (!Number.isFinite(value))
+        return value > 0 ? '1e999' : '-1e999';
+    return JSON.stringify(value);
+}
+export function serializeStaticValue(value) {
+    if (value === undefined)
+        return 'void 0';
+    if (value === null)
+        return 'null';
+    if (typeof value === 'number')
+        return serializeNumber(value);
+    if (typeof value === 'string' || typeof value === 'boolean')
+        return JSON.stringify(value);
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => serializeStaticValue(item)).join(',')}]`;
+    }
+    return `{${Object.entries(value)
+        .map(([key, item]) => {
+        const serializedKey = key === '__proto__' ? '["__proto__"]' : JSON.stringify(key);
+        return `${serializedKey}:${serializeStaticValue(item)}`;
+    })
+        .join(',')}}`;
+}
+function defineOwn(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true,
+    });
+}
+export function identifierName(node) {
+    if (nodeType(node) === 'Identifier' && isObject(node) && typeof node.name === 'string') {
+        return node.name;
+    }
+    return undefined;
+}
+function isPrimitiveValue(value) {
+    return value === null || typeof value !== 'object';
+}
+export const EVAL_FAILED = { ok: false };
+function unknowableMembers(name, env) {
+    if (name === undefined)
+        return undefined;
+    if (name === env.propsObjectName)
+        return env.failedProps;
+    if (name === env.restName)
+        return env.restFailedProps;
+    return undefined;
+}
+function isNullish(value) {
+    return value === null || value === undefined;
+}
+function isObjectValue(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isLooselyEqual(left, right) {
+    if (left === right)
+        return true;
+    if (isNullish(left) || isNullish(right))
+        return isNullish(left) && isNullish(right);
+    if (isObjectValue(left) || isObjectValue(right)) {
+        return isObjectValue(left) && isObjectValue(right) ? false : undefined;
+    }
+    if (typeof left === 'boolean' || typeof right === 'boolean') {
+        return Number(left) === Number(right);
+    }
+    if (typeof left === 'number' && typeof right === 'string')
+        return left === Number(right);
+    if (typeof left === 'string' && typeof right === 'number')
+        return Number(left) === right;
+    return false;
+}
+function readScope(name, env) {
+    if (!env.scope.has(name))
+        return EVAL_FAILED;
+    const bound = env.scope.get(name);
+    return { ok: true, value: bound === undefined ? undefined : bound };
+}
+function propertyKey(property, env) {
+    if (property.computed === true) {
+        const evaluatedKey = evaluateStatic(property.key, env);
+        return evaluatedKey.ok && typeof evaluatedKey.value === 'string'
+            ? evaluatedKey.value
+            : undefined;
+    }
+    const name = identifierName(property.key);
+    if (name !== undefined)
+        return name;
+    if (nodeType(property.key) === 'Literal' &&
+        isObject(property.key) &&
+        typeof property.key.value === 'string') {
+        return property.key.value;
+    }
+    return undefined;
+}
+function readMember(object, key) {
+    if (Array.isArray(object)) {
+        if (typeof key !== 'number' || !Number.isInteger(key) || key < 0)
+            return EVAL_FAILED;
+        if (key >= object.length)
+            return { ok: true, value: undefined };
+        return { ok: true, value: object[key] };
+    }
+    if (!isStaticObject(object) || typeof key !== 'string')
+        return EVAL_FAILED;
+    return { ok: true, value: Object.hasOwn(object, key) ? object[key] : undefined };
+}
+export function unbindPattern(pattern, env) {
+    const names = new Set();
+    collectPatternNames(pattern, names);
+    for (const name of names)
+        env.scope.delete(name);
+}
+export function bindPattern(pattern, value, env) {
+    const type = nodeType(pattern);
+    if (type === 'Identifier') {
+        const name = identifierName(pattern);
+        if (name !== undefined)
+            env.scope.set(name, value);
+        return;
+    }
+    if (type === 'AssignmentPattern' && isObject(pattern)) {
+        const resolved = value === undefined ? evaluateStatic(pattern.right, env) : { ok: true, value };
+        if (resolved.ok)
+            bindPattern(pattern.left, resolved.value, env);
+        else
+            unbindPattern(pattern.left, env);
+        return;
+    }
+    if (type === 'ObjectPattern' && isObject(pattern) && Array.isArray(pattern.properties)) {
+        if (!isStaticObject(value)) {
+            unbindPattern(pattern, env);
+            return;
+        }
+        const remaining = Object.assign({}, value);
+        let remainingKnown = true;
+        for (const property of pattern.properties) {
+            if (nodeType(property) === 'RestElement' && isObject(property)) {
+                if (remainingKnown)
+                    bindPattern(property.argument, remaining, env);
+                else
+                    unbindPattern(property.argument, env);
+                continue;
+            }
+            if (nodeType(property) !== 'Property' || !isObject(property))
+                continue;
+            const key = propertyKey(property, env);
+            if (key === undefined) {
+                remainingKnown = false;
+                unbindPattern(property.value, env);
+                continue;
+            }
+            delete remaining[key];
+            bindPattern(property.value, Object.hasOwn(value, key) ? value[key] : undefined, env);
+        }
+        return;
+    }
+    if (type === 'ArrayPattern' && isObject(pattern) && Array.isArray(pattern.elements)) {
+        if (!Array.isArray(value)) {
+            unbindPattern(pattern, env);
+            return;
+        }
+        for (let index = 0; index < pattern.elements.length; index++) {
+            const element = pattern.elements[index];
+            if (element === null || element === undefined)
+                continue;
+            if (nodeType(element) === 'RestElement' && isObject(element)) {
+                bindPattern(element.argument, value.slice(index), env);
+                break;
+            }
+            bindPattern(element, index < value.length ? value[index] : undefined, env);
+        }
+    }
+}
+export function evaluateStatic(node, env) {
+    var _a, _b;
+    if (!isObject(node))
+        return EVAL_FAILED;
+    switch (node.type) {
+        case 'Literal': {
+            const value = node.value;
+            if (typeof value === 'string' ||
+                typeof value === 'number' ||
+                typeof value === 'boolean' ||
+                value === null) {
+                return { ok: true, value };
+            }
+            return EVAL_FAILED;
+        }
+        case 'Identifier': {
+            if (typeof node.name !== 'string')
+                return EVAL_FAILED;
+            if (node.name === 'undefined' && !env.scope.has('undefined')) {
+                return { ok: true, value: undefined };
+            }
+            // Copying a props or rest object with unknowable keys would turn those keys
+            // into missing ones, so only member reads of known keys are allowed.
+            if (((_b = (_a = unknowableMembers(node.name, env)) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0) > 0)
+                return EVAL_FAILED;
+            return readScope(node.name, env);
+        }
+        case 'ParenthesizedExpression':
+            return evaluateStatic(node.expression, env);
+        case 'MemberExpression': {
+            const property = node.property;
+            const key = node.computed === true
+                ? evaluateStatic(property, env)
+                : { ok: true, value: identifierName(property) };
+            if (!key.ok || key.value === undefined)
+                return EVAL_FAILED;
+            const objectName = identifierName(node.object);
+            const unknowable = unknowableMembers(objectName, env);
+            if (unknowable !== undefined && objectName !== undefined) {
+                if (typeof key.value === 'string' && unknowable.has(key.value))
+                    return EVAL_FAILED;
+                const resolvedObject = readScope(objectName, env);
+                return resolvedObject.ok ? readMember(resolvedObject.value, key.value) : EVAL_FAILED;
+            }
+            const resolvedObject = evaluateStatic(node.object, env);
+            if (!resolvedObject.ok)
+                return EVAL_FAILED;
+            return readMember(resolvedObject.value, key.value);
+        }
+        case 'ObjectExpression': {
+            if (!Array.isArray(node.properties))
+                return EVAL_FAILED;
+            const result = {};
+            for (const property of node.properties) {
+                if (!isObject(property))
+                    return EVAL_FAILED;
+                if (property.type === 'SpreadElement') {
+                    const spread = evaluateStatic(property.argument, env);
+                    if (!spread.ok)
+                        return EVAL_FAILED;
+                    if (isNoOpSpreadValue(spread.value))
+                        continue;
+                    if (!isStaticObject(spread.value))
+                        return EVAL_FAILED;
+                    for (const [key, value] of Object.entries(spread.value))
+                        defineOwn(result, key, value);
+                    continue;
+                }
+                if (property.type !== 'Property')
+                    return EVAL_FAILED;
+                const key = propertyKey(property, env);
+                if (key === undefined)
+                    return EVAL_FAILED;
+                // A literal `__proto__:` key sets the prototype rather than an own property.
+                if (key === '__proto__' && property.computed !== true && property.shorthand !== true) {
+                    return EVAL_FAILED;
+                }
+                const value = evaluateStatic(property.value, env);
+                if (!value.ok)
+                    return EVAL_FAILED;
+                defineOwn(result, key, value.value);
+            }
+            return withinBudget(result);
+        }
+        case 'ArrayExpression': {
+            if (!Array.isArray(node.elements))
+                return EVAL_FAILED;
+            const result = [];
+            for (const element of node.elements) {
+                // A hole is not an `undefined` entry: iteration methods skip it
+                if (element === null)
+                    return EVAL_FAILED;
+                if (isObject(element) && element.type === 'SpreadElement') {
+                    const spread = evaluateStatic(element.argument, env);
+                    if (!spread.ok || !Array.isArray(spread.value))
+                        return EVAL_FAILED;
+                    if (result.length + spread.value.length > MAX_STATIC_VALUE_WEIGHT)
+                        return EVAL_FAILED;
+                    for (const item of spread.value)
+                        result.push(item);
+                    continue;
+                }
+                const value = evaluateStatic(element, env);
+                if (!value.ok)
+                    return EVAL_FAILED;
+                result.push(value.value);
+            }
+            return withinBudget(result);
+        }
+        case 'TemplateLiteral': {
+            const quasis = Array.isArray(node.quasis) ? node.quasis : [];
+            const expressions = Array.isArray(node.expressions) ? node.expressions : [];
+            let result = '';
+            for (let i = 0; i < quasis.length; i++) {
+                const quasi = quasis[i];
+                const cooked = isObject(quasi) && isObject(quasi.value) && typeof quasi.value.cooked === 'string'
+                    ? quasi.value.cooked
+                    : '';
+                result += cooked;
+                if (i < expressions.length) {
+                    const part = evaluateStatic(expressions[i], env);
+                    if (!part.ok)
+                        return EVAL_FAILED;
+                    if (typeof part.value === 'object' && part.value !== null)
+                        return EVAL_FAILED;
+                    result += String(part.value);
+                }
+                if (result.length > MAX_STATIC_VALUE_WEIGHT)
+                    return EVAL_FAILED;
+            }
+            return { ok: true, value: result };
+        }
+        case 'BinaryExpression': {
+            const left = evaluateStatic(node.left, env);
+            const right = evaluateStatic(node.right, env);
+            if (!left.ok || !right.ok)
+                return EVAL_FAILED;
+            switch (node.operator) {
+                case '+':
+                    if (isObjectValue(left.value) || isObjectValue(right.value))
+                        return EVAL_FAILED;
+                    if (typeof left.value === 'string' || typeof right.value === 'string') {
+                        const joined = `${String(left.value)}${String(right.value)}`;
+                        return joined.length > MAX_STATIC_VALUE_WEIGHT
+                            ? EVAL_FAILED
+                            : { ok: true, value: joined };
+                    }
+                    if (typeof left.value === 'number' && typeof right.value === 'number') {
+                        const sum = left.value + right.value;
+                        return Number.isNaN(sum) ? EVAL_FAILED : { ok: true, value: sum };
+                    }
+                    return EVAL_FAILED;
+                case '===':
+                    return { ok: true, value: left.value === right.value };
+                case '!==':
+                    return { ok: true, value: left.value !== right.value };
+                case '==':
+                case '!=': {
+                    const equal = isLooselyEqual(left.value, right.value);
+                    if (equal === undefined)
+                        return EVAL_FAILED;
+                    return { ok: true, value: node.operator === '==' ? equal : !equal };
+                }
+                default:
+                    return EVAL_FAILED;
+            }
+        }
+        case 'LogicalExpression': {
+            const left = evaluateStatic(node.left, env);
+            if (!left.ok)
+                return EVAL_FAILED;
+            const leftTruthy = Boolean(left.value);
+            if (node.operator === '&&')
+                return leftTruthy ? evaluateStatic(node.right, env) : left;
+            if (node.operator === '||')
+                return leftTruthy ? left : evaluateStatic(node.right, env);
+            if (node.operator === '??') {
+                return left.value === null || left.value === undefined
+                    ? evaluateStatic(node.right, env)
+                    : left;
+            }
+            return EVAL_FAILED;
+        }
+        case 'ConditionalExpression': {
+            const test = evaluateStatic(node.test, env);
+            if (!test.ok)
+                return EVAL_FAILED;
+            return evaluateStatic(test.value ? node.consequent : node.alternate, env);
+        }
+        case 'UnaryExpression': {
+            const argument = evaluateStatic(node.argument, env);
+            if (!argument.ok)
+                return EVAL_FAILED;
+            if (node.operator === 'void')
+                return { ok: true, value: undefined };
+            if (node.operator === '!')
+                return { ok: true, value: !argument.value };
+            if (node.operator === '-' || node.operator === '+') {
+                if (typeof argument.value === 'object' && argument.value !== null)
+                    return EVAL_FAILED;
+                const numeric = node.operator === '-' ? -Number(argument.value) : Number(argument.value);
+                if (Number.isNaN(numeric))
+                    return EVAL_FAILED;
+                return { ok: true, value: numeric };
+            }
+            return EVAL_FAILED;
+        }
+        default:
+            return EVAL_FAILED;
+    }
+}
+function isFunctionNode(value) {
+    const type = nodeType(value);
+    return (type === 'ArrowFunctionExpression' ||
+        type === 'FunctionExpression' ||
+        type === 'FunctionDeclaration');
+}
+function esmStatements(node) {
+    var _a;
+    if (node.type !== 'mdxjsEsm')
+        return [];
+    const estree = (_a = node.data) === null || _a === void 0 ? void 0 : _a.estree;
+    if (!isObject(estree) || !Array.isArray(estree.body))
+        return [];
+    return estree.body;
+}
+/** Every estree program or expression in the tree: ESM, `{expressions}`, and JSX attribute values. */
+function collectEstrees(node, estrees) {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            collectEstrees(child, estrees);
+        return;
+    }
+    if (!isObject(node))
+        return;
+    if (isObject(node.data) && node.data.estree !== undefined)
+        estrees.push(node.data.estree);
+    for (const [key, child] of Object.entries(node)) {
+        if (key !== 'data' && key !== 'position')
+            collectEstrees(child, estrees);
+    }
+}
+function dropObjectBindings(moduleScope) {
+    for (const [name, value] of moduleScope) {
+        if (typeof value === 'object' && value !== null)
+            moduleScope.delete(name);
+    }
+}
+/**
+ * Whether a top-level statement may write while it runs: directly, or through a call when the
+ * module has writes inside functions, since any call may run one of them.
+ */
+function writesEagerly(statement, moduleWrites) {
+    const { reassigned, mutated } = collectModuleWrites(statement, true);
+    if (reassigned.size > 0 || mutated.size > 0)
+        return true;
+    return moduleWrites && hasEagerCall(statement);
+}
+/**
+ * Collects a module's component definitions and its statically known values. Objects are only
+ * bound when the module never writes through any object: tracking which objects a write can reach
+ * is not worth the risk of publishing a stale value, while primitives are copied on read and stay
+ * known. A top-level write also invalidates the objects it may change for every later initializer.
+ */
+export function collectContextFromTree(tree) {
+    const defs = new Map();
+    const moduleScope = new Map();
+    const literalScope = new Map();
+    const aliases = [];
+    const statements = tree.children.flatMap(esmStatements);
+    const registerFunction = (name, fn) => {
+        const params = Array.isArray(fn.params) ? fn.params : [];
+        defs.set(name, { params, body: fn.body });
+    };
+    const registerDeclarator = (declarator, kind) => {
+        if (nodeType(declarator) !== 'VariableDeclarator' || !isObject(declarator))
+            return;
+        // A later declarator in the same statement runs after earlier ones, so only its own
+        // initializer should drop objects bound above it.
+        if (writesEagerly(declarator, moduleWrites))
+            dropObjectBindings(moduleScope);
+        const init = declarator.init;
+        const name = identifierName(declarator.id);
+        if (name !== undefined && isFunctionNode(init) && isObject(init)) {
+            registerFunction(name, init);
+            return;
+        }
+        if (kind !== 'const')
+            return;
+        const literal = evaluateStatic(init, { scope: literalScope });
+        if (literal.ok) {
+            // Defaults and computed keys in the pattern may read earlier literal values
+            const bound = new Map(literalScope);
+            bindPattern(declarator.id, literal.value, { scope: bound });
+            const declared = new Set();
+            collectPatternNames(declarator.id, declared);
+            for (const boundName of declared) {
+                if (!bound.has(boundName))
+                    continue;
+                const stored = bound.get(boundName);
+                const value = stored === undefined ? undefined : stored;
+                if (isPrimitiveValue(value))
+                    literalScope.set(boundName, value);
+            }
+        }
+        const evaluated = evaluateStatic(init, { scope: moduleScope });
+        if (!evaluated.ok)
+            return;
+        bindPattern(declarator.id, evaluated.value, { scope: moduleScope });
+    };
+    const estrees = [];
+    collectEstrees(tree, estrees);
+    const { reassigned, mutated } = collectModuleWrites(estrees);
+    const moduleWrites = reassigned.size > 0 || mutated.size > 0;
+    for (const statement of statements) {
+        if (!isObject(statement))
+            continue;
+        // A variable declaration writes from inside its declarators, which are checked one by one.
+        // Dropping here would hide objects from earlier declarators in the same statement.
+        const declaresVariables = statement.type === 'VariableDeclaration' ||
+            (statement.type === 'ExportNamedDeclaration' &&
+                isObject(statement.declaration) &&
+                statement.declaration.type === 'VariableDeclaration');
+        if (!declaresVariables && writesEagerly(statement, moduleWrites))
+            dropObjectBindings(moduleScope);
+        if (statement.type === 'VariableDeclaration') {
+            const declarations = Array.isArray(statement.declarations) ? statement.declarations : [];
+            for (const declarator of declarations)
+                registerDeclarator(declarator, statement.kind);
+            continue;
+        }
+        if (statement.type === 'FunctionDeclaration') {
+            const id = statement.id;
+            if (nodeType(id) === 'Identifier' && isObject(id) && typeof id.name === 'string') {
+                registerFunction(id.name, statement);
+            }
+            continue;
+        }
+        if (statement.type === 'ExportNamedDeclaration') {
+            const declaration = statement.declaration;
+            if (nodeType(declaration) === 'VariableDeclaration' && isObject(declaration)) {
+                const declarations = Array.isArray(declaration.declarations)
+                    ? declaration.declarations
+                    : [];
+                for (const declarator of declarations)
+                    registerDeclarator(declarator, declaration.kind);
+            }
+            if (nodeType(declaration) === 'FunctionDeclaration' && isObject(declaration)) {
+                const id = declaration.id;
+                if (nodeType(id) === 'Identifier' && isObject(id) && typeof id.name === 'string') {
+                    registerFunction(id.name, declaration);
+                }
+            }
+            // `export { a as b } from "./mod"` re-exports another module. Its local name is not a
+            // binding in this file, so copying a same-named local would publish the wrong value.
+            if (statement.source != null)
+                continue;
+            const specifiers = Array.isArray(statement.specifiers) ? statement.specifiers : [];
+            for (const specifier of specifiers) {
+                if (nodeType(specifier) !== 'ExportSpecifier' || !isObject(specifier))
+                    continue;
+                const local = specifier.local;
+                const exported = specifier.exported;
+                if (isObject(local) &&
+                    typeof local.name === 'string' &&
+                    isObject(exported) &&
+                    typeof exported.name === 'string') {
+                    aliases.push([local.name, exported.name]);
+                }
+            }
+        }
+        if (statement.type === 'ExportDefaultDeclaration') {
+            const declaration = statement.declaration;
+            if (isFunctionNode(declaration) && isObject(declaration)) {
+                const id = declaration.id;
+                if (nodeType(id) === 'Identifier' && isObject(id) && typeof id.name === 'string') {
+                    registerFunction(id.name, declaration);
+                }
+            }
+        }
+    }
+    for (const name of reassigned) {
+        moduleScope.delete(name);
+        literalScope.delete(name);
+        defs.delete(name);
+    }
+    if (mutated.size > 0)
+        dropObjectBindings(moduleScope);
+    let aliasChanged = true;
+    while (aliasChanged) {
+        aliasChanged = false;
+        for (const [local, exported] of aliases) {
+            const def = defs.get(local);
+            if (def && !defs.has(exported)) {
+                defs.set(exported, def);
+                aliasChanged = true;
+            }
+            if (moduleScope.has(local) && !moduleScope.has(exported)) {
+                const bound = moduleScope.get(local);
+                moduleScope.set(exported, bound === undefined ? undefined : bound);
+                aliasChanged = true;
+            }
+            if (literalScope.has(local) && !literalScope.has(exported)) {
+                const bound = literalScope.get(local);
+                literalScope.set(exported, bound === undefined ? undefined : bound);
+                aliasChanged = true;
+            }
+        }
+    }
+    return { defs, moduleScope, literalScope };
+}